Fixes

cpp-terminal/iostream_initializer.cpp

@@ -10,7 +10,8 @@
 #include "cpp-terminal/iostream_initializer.hpp"
 
 #include "cpp-terminal/iostream.hpp"
+#include "cpp-terminal/private/exception.hpp"
 #include "cpp-terminal/terminal.hpp"
 #include "cpp-terminal/terminal_initializer.hpp"
 #include "cpp-terminal/tty.hpp"
 
@@ -19,27 +20,39 @@
 
 std::size_t Term::IOStreamInitializer::m_counter{0};
 
-Term::IOStreamInitializer::IOStreamInitializer()
+Term::IOStreamInitializer::IOStreamInitializer() noexcept
+try
 {
-  if(0 == m_counter++)
+  if(0 == m_counter)
   {
     static const std::ios_base::Init       iostreams_init;  // Init std::cout etc...
     static const Term::TerminalInitializer terminal_init;   // Make sure terminal is set up.
     new(&Term::cout) TOstream(Term::Buffer::Type::FullBuffered, BUFSIZ);
     new(&Term::clog) TOstream(Term::Buffer::Type::LineBuffered, BUFSIZ);
     new(&Term::cerr) TOstream(Term::Buffer::Type::Unbuffered, 0);
     new(&Term::cin) TIstream(Term::Buffer::Type::FullBuffered, BUFSIZ);
     if(is_stdin_a_tty()) { std::cin.rdbuf(Term::cin.rdbuf()); }
   }
+  ++m_counter;
+}
+catch(...)
+{
+  ExceptionHandler(Private::ExceptionDestination::StdErr);
 }
 
-Term::IOStreamInitializer::~IOStreamInitializer()
+Term::IOStreamInitializer::~IOStreamInitializer() noexcept
+try
 {
-  if(0 == --m_counter)
+  --m_counter;
+  if(0 == m_counter)
   {
     (&Term::cout)->~TOstream();
     (&Term::cerr)->~TOstream();
     (&Term::clog)->~TOstream();
     (&Term::cin)->~TIstream();
   }
 }
+catch(...)
+{
+  ExceptionHandler(Private::ExceptionDestination::StdErr);
+}

cpp-terminal/iostream_initializer.hpp

@@ -17,8 +17,8 @@ namespace Term
 class IOStreamInitializer
 {
 public:
-  ~IOStreamInitializer();
-  IOStreamInitializer();
+  ~IOStreamInitializer() noexcept;
+  IOStreamInitializer() noexcept;
   IOStreamInitializer(const IOStreamInitializer&)            = delete;
   IOStreamInitializer(IOStreamInitializer&&)                 = delete;
   IOStreamInitializer& operator=(IOStreamInitializer&&)      = delete;

cpp-terminal/private/CMakeLists.txt

@@ -4,7 +4,7 @@ find_package(Threads)
 # configure version information
 configure_file(version.cpp.in version.cpp)
 
-add_library(cpp-terminal-private STATIC "${CMAKE_CURRENT_BINARY_DIR}/version.cpp" return_code.cpp file_initializer.cpp exception.cpp unicode.cpp conversion.cpp args.cpp terminal.cpp tty.cpp terminfo.cpp input.cpp screen.cpp cursor.cpp file.cpp env.cpp blocking_queue.cpp sigwinch.cpp)
+add_library(cpp-terminal-private STATIC "${CMAKE_CURRENT_BINARY_DIR}/version.cpp" return_code.cpp file_initializer.cpp exception.cpp unicode.cpp conversion.cpp args.cpp terminal_impl.cpp tty.cpp terminfo.cpp input.cpp screen.cpp cursor.cpp file.cpp env.cpp blocking_queue.cpp sigwinch.cpp)
 target_link_libraries(cpp-terminal-private PRIVATE Warnings::Warnings PUBLIC Threads::Threads)
 target_compile_options(cpp-terminal-private PRIVATE $<$<CXX_COMPILER_ID:MSVC>:/utf-8 /wd4668 /wd4514>)
 target_include_directories(cpp-terminal-private PRIVATE $<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}> $<BUILD_INTERFACE:${PROJECT_SOURCE_DIR}> $<BUILD_INTERFACE:${PROJECT_BINARY_DIR}> $<INSTALL_INTERFACE:include>)

cpp-terminal/private/exception.cpp

@@ -84,7 +84,7 @@
 {
   setContext(context);
   wchar_t*    ptr{nullptr};
-  const DWORD cchMsg{FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_ALLOCATE_BUFFER, nullptr, static_cast<uint32_t>(code()), 0, reinterpret_cast<wchar_t*>(&ptr), 0, nullptr)};
+  const DWORD cchMsg{FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_ALLOCATE_BUFFER, nullptr, static_cast<uint32_t>(code()), MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), reinterpret_cast<wchar_t*>(&ptr), 0, nullptr)};
   if(cchMsg > 0)
   {
     auto deleter = [](void* p)
@@ -101,7 +101,7 @@
 
 void Term::Private::WindowsException::build_what() const noexcept
 {
-  std::string what{"windows error " + std::to_string(code()) + ": " + message()};
+  std::string what{std::string("windows error ") + std::to_string(code()) + std::string(": ") + message().c_str()};
   if(!context().empty()) what += " [" + context() + "]";
   setWhat(what);
 }
@@ -152,7 +152,7 @@
   setContext(context);
 #if defined(_WIN32)
   std::wstring message(m_maxSize, L'\0');
   message = _wcserror_s(&message[0], message.size(), static_cast<int>(error));
   setMessage(Term::Private::to_narrow(message.c_str()));
 #else
   std::string message(m_maxSize, '\0');
@@ -228,7 +228,7 @@
 #else
         (void)(fputs(("cpp-terminal v" + Term::Version::string() + ": Unknown error\n").c_str(), stderr));
 #endif
       default: break;
     }
   }
   (void)(std::fflush(stderr));

cpp-terminal/private/file.cpp

@@ -9,6 +9,8 @@
 
 #include "cpp-terminal/private/file.hpp"
 
+#include "cpp-terminal/private/exception.hpp"
+
 #include <cstdio>
 #include <new>
 
@@ -20,12 +22,10 @@
   #include <unistd.h>
 #endif
 
-#include "cpp-terminal/private/exception.hpp"
 #include "cpp-terminal/private/unicode.hpp"
 
 #include <array>
 #include <fcntl.h>
-#include <iostream>
 
 //FIXME Move this to other file
 
@@ -40,86 +40,87 @@ Term::Private::OutputFileHandler& Term::Private::out = reinterpret_cast<Term::Pr
 
 //
 
-Term::Private::FileHandler::FileHandler(std::recursive_mutex& mutex, const std::string& filename, const std::string& mode) : m_mutex(mutex)
+Term::Private::FileHandler::FileHandler(std::recursive_mutex& mutex, const std::string& file, const std::string& mode) noexcept
+try : m_mutex(mutex)
 {
 #if defined(_WIN32)
-  m_handle = CreateFile(filename.c_str(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
+  m_handle = {CreateFile(file.c_str(), GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr)};
   if(m_handle == INVALID_HANDLE_VALUE)
   {
-    m_handle = CreateFile("NUL", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr);
-    if(m_handle != INVALID_HANDLE_VALUE) m_null = true;
-  }
-  if(m_handle != INVALID_HANDLE_VALUE)
-  {
-    m_fd   = _open_osfhandle(reinterpret_cast<intptr_t>(m_handle), _O_RDWR);
-    m_file = _fdopen(m_fd, mode.c_str());
+    Term::Private::WindowsError().check_if((m_handle = CreateFile("NUL", GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, nullptr)) == INVALID_HANDLE_VALUE).throw_exception("Problem opening NUL");
+    m_null = true;
   }
+  Term::Private::Errno().check_if((m_fd = _open_osfhandle(reinterpret_cast<intptr_t>(m_handle), _O_RDWR)) == -1).throw_exception("_open_osfhandle(reinterpret_cast<intptr_t>(m_handle), _O_RDWR)");
+  Term::Private::Errno().check_if(nullptr == (m_file = _fdopen(m_fd, mode.c_str()))).throw_exception("_fdopen(m_fd, mode.c_str())");
 #else
   std::size_t flag{O_ASYNC | O_DSYNC | O_NOCTTY | O_SYNC | O_NDELAY};
-  if(mode.find('r') != std::string::npos) flag |= O_RDONLY;
-  else if(mode.find('w') != std::string::npos)
-    flag |= O_WRONLY;
-  else
-    flag |= O_RDWR;
-  m_fd = {::open(filename.c_str(), flag)};
+  flag &= ~O_NONBLOCK;
+  if(mode.find('r') != std::string::npos) { flag |= O_RDONLY; }       //NOLINT(abseil-string-find-str-contains)
+  else if(mode.find('w') != std::string::npos) { flag |= O_WRONLY; }  //NOLINT(abseil-string-find-str-contains)
+  else { flag |= O_RDWR; }
+  m_fd = {::open(file.c_str(), static_cast<int>(flag))};  //NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
   if(m_fd == -1)
   {
-    m_fd = {::open("/dev/null", flag)};
-    if(m_fd != -1) m_null = true;
-  }
-  if(m_fd != -1)
-  {
-    m_file   = fdopen(m_fd, mode.c_str());
-    m_handle = m_file;
+    Term::Private::Errno().check_if((m_fd = ::open("/dev/null", static_cast<int>(flag))) == -1).throw_exception(R"(::open("/dev/null", flag))");  //NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
+    m_null = true;
   }
+  Term::Private::Errno().check_if(nullptr == (m_file = ::fdopen(m_fd, mode.c_str()))).throw_exception("::fdopen(m_fd, mode.c_str())");
+  m_handle = m_file;
 #endif
-  setvbuf(m_file, nullptr, _IONBF, 0);
+  Term::Private::Errno().check_if(std::setvbuf(m_file, nullptr, _IONBF, 0) != 0).throw_exception("std::setvbuf(m_file, nullptr, _IONBF, 0)");
+}
+catch(...)
+{
+  ExceptionHandler(ExceptionDestination::StdErr);
 }
 
-Term::Private::FileHandler::~FileHandler()
+Term::Private::FileHandler::~FileHandler() noexcept
+try
+{
+  flush();
+  Term::Private::Errno().check_if(0 != std::fclose(m_file)).throw_exception("std::fclose(m_file)");  //NOLINT(cppcoreguidelines-owning-memory)
+}
+catch(...)
 {
-  std::fflush(m_file);
-  std::fclose(m_file);
+  ExceptionHandler(ExceptionDestination::StdErr);
 }
 
-bool Term::Private::FileHandler::null() const { return m_null; }
+bool Term::Private::FileHandler::null() const noexcept { return m_null; }
 
-FILE* Term::Private::FileHandler::file() { return m_file; }
+FILE* Term::Private::FileHandler::file() const noexcept { return m_file; }
 
-std::int32_t Term::Private::FileHandler::fd() const { return m_fd; }
+std::int32_t Term::Private::FileHandler::fd() const noexcept { return m_fd; }
 
-Term::Private::FileHandler::Handle Term::Private::FileHandler::handle() { return m_handle; }
+Term::Private::FileHandler::Handle Term::Private::FileHandler::handle() const noexcept { return m_handle; }
 
-std::size_t Term::Private::OutputFileHandler::write(const std::string& str)
+std::size_t Term::Private::OutputFileHandler::write(const std::string& str) const
 {
-  if(str.empty()) { return 0; }
-  //std::lock_guard<std::mutex> lock(m_mut);
 #if defined(_WIN32)
-  DWORD dwCount{0};
-  if(WriteConsole(handle(), &str[0], static_cast<DWORD>(str.size()), &dwCount, nullptr) == 0) return -1;
-  else
-    return static_cast<int>(dwCount);
+  DWORD written{0};
+  if(!str.empty()) { Term::Private::WindowsError().check_if(0 == WriteConsole(handle(), &str[0], static_cast<DWORD>(str.size()), &written, nullptr)).throw_exception("WriteConsole(handle(), &str[0], static_cast<DWORD>(str.size()), &written, nullptr)"); }
+  return static_cast<std::size_t>(written);
 #else
-  return ::write(fd(), &str[0], str.size());
+  ssize_t written{0};
+  if(!str.empty()) { Term::Private::Errno().check_if((written = ::write(fd(), str.data(), str.size())) == -1).throw_exception("::write(fd(), str.data(), str.size())"); }
+  return static_cast<std::size_t>(written);
 #endif
 }
 
-std::size_t Term::Private::OutputFileHandler::write(const char& ch)
+std::size_t Term::Private::OutputFileHandler::write(const char& character) const
 {
-  //std::lock_guard<std::mutex> lock(m_mut);
 #if defined(_WIN32)
-  DWORD dwCount{0};
-  if(WriteConsole(handle(), &ch, 1, &dwCount, nullptr) == 0) return -1;
-  else
-    return static_cast<int>(dwCount);
+  DWORD written{0};
+  Term::Private::WindowsError().check_if(0 == WriteConsole(handle(), &character, 1, &written, nullptr)).throw_exception("WriteConsole(handle(), &character, 1, &written, nullptr)");
+  return static_cast<std::size_t>(written);
 #else
-  return ::write(fd(), &ch, 1);
+  ssize_t written{0};
+  Term::Private::Errno().check_if((written = ::write(fd(), &character, 1)) == -1).throw_exception("::write(fd(), &character, 1)");
+  return static_cast<std::size_t>(written);
 #endif
 }
 
 std::string Term::Private::InputFileHandler::read()
 {
-  //std::lock_guard<std::mutex> lock(m_mut);
 #if defined(_WIN32)
   DWORD       nread{0};
   std::string ret(4096, '\0');
@@ -128,7 +129,7 @@ std::string Term::Private::InputFileHandler::read()
   return ret.c_str();
 #else
   std::size_t nread{0};
-  ::ioctl(Private::in.fd(), FIONREAD, &nread);
+  ::ioctl(Private::in.fd(), FIONREAD, &nread);  //NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
   if(nread != 0)
   {
     std::string ret(nread, '\0');
@@ -137,12 +138,31 @@ std::string Term::Private::InputFileHandler::read()
     if(nnread == -1 && errno != EAGAIN) { throw Term::Exception("read() failed"); }
     return ret.c_str();
   }
-  else
-    return std::string();
+  return {};
 #endif
 }
 
-void Term::Private::FileHandler::flush() { std::fflush(m_file); }
+void Term::Private::FileHandler::flush() { Term::Private::Errno().check_if(0 != std::fflush(m_file)).throw_exception("std::fflush(m_file)"); }
 
 void Term::Private::FileHandler::lockIO() { m_mutex.lock(); }
 void Term::Private::FileHandler::unlockIO() { m_mutex.unlock(); }
+
+Term::Private::OutputFileHandler::OutputFileHandler(std::recursive_mutex& io_mutex) noexcept
+try : FileHandler(io_mutex, m_file, "w")
+{
+  //noop
+}
+catch(...)
+{
+  ExceptionHandler(ExceptionDestination::StdErr);
+}
+
+Term::Private::InputFileHandler::InputFileHandler(std::recursive_mutex& io_mutex) noexcept
+try : FileHandler(io_mutex, m_file, "r")
+{
+  //noop
+}
+catch(...)
+{
+  ExceptionHandler(ExceptionDestination::StdErr);
+}

cpp-terminal/private/file.hpp

@@ -30,22 +30,23 @@ class FileHandler
 #else
   using Handle = FILE*;
 #endif
-  FileHandler(std::recursive_mutex& mutex, const std::string& file, const std::string& mode);
+  FileHandler(std::recursive_mutex& mutex, const std::string& file, const std::string& mode) noexcept;
   FileHandler(const FileHandler&)            = delete;
   FileHandler(FileHandler&&)                 = delete;
   FileHandler& operator=(const FileHandler&) = delete;
   FileHandler& operator=(FileHandler&&)      = delete;
-  virtual ~FileHandler();
-  Handle       handle();
-  bool         null() const;
-  FILE*        file();
-  std::int32_t fd() const;
+  virtual ~FileHandler() noexcept;
+  Handle       handle() const noexcept;
+  bool         null() const noexcept;
+  FILE*        file() const noexcept;
+  std::int32_t fd() const noexcept;
   void         lockIO();
   void         unlockIO();
   void         flush();
 
 private:
-  std::recursive_mutex& m_mutex;  // should be static but MacOS don't want it (crash at runtime)
+  // should be static but MacOS don't want it (crash at runtime)
+  std::recursive_mutex& m_mutex;  //NOLINT(cppcoreguidelines-avoid-const-or-ref-data-members)
   bool                  m_null{false};
   Handle                m_handle{nullptr};
   FILE*                 m_file{nullptr};
@@ -55,14 +56,15 @@ class FileHandler
 class OutputFileHandler : public FileHandler
 {
 public:
-  explicit OutputFileHandler(std::recursive_mutex& IOmutex) : FileHandler(IOmutex, m_file, "w") {}
-  std::size_t write(const std::string& str);
-  std::size_t write(const char& character);
+  explicit OutputFileHandler(std::recursive_mutex& io_mutex) noexcept;
   OutputFileHandler(const OutputFileHandler& other)          = delete;
-  OutputFileHandler& operator=(const OutputFileHandler& rhs) = delete;
   OutputFileHandler(OutputFileHandler&& other)               = delete;
   OutputFileHandler& operator=(OutputFileHandler&& rhs)      = delete;
-  virtual ~OutputFileHandler()                               = default;
+  OutputFileHandler& operator=(const OutputFileHandler& rhs) = delete;
+  ~OutputFileHandler() override                              = default;
+
+  std::size_t write(const std::string& str) const;
+  std::size_t write(const char& character) const;
 #if defined(_WIN32)
   static const constexpr char* m_file{"CONOUT$"};
 #else
@@ -73,13 +75,14 @@ class OutputFileHandler : public FileHandler
 class InputFileHandler : public FileHandler
 {
 public:
-  explicit InputFileHandler(std::recursive_mutex& IOmutex) : FileHandler(IOmutex, m_file, "r") {}
-  std::string read();
+  explicit InputFileHandler(std::recursive_mutex& io_mutex) noexcept;
   InputFileHandler(const InputFileHandler&)            = delete;
-  InputFileHandler& operator=(const InputFileHandler&) = delete;
   InputFileHandler(InputFileHandler&&)                 = delete;
   InputFileHandler& operator=(InputFileHandler&&)      = delete;
-  virtual ~InputFileHandler()                          = default;
+  InputFileHandler& operator=(const InputFileHandler&) = delete;
+  ~InputFileHandler() override                         = default;
+
+  std::string read();
 #if defined(_WIN32)
   static const constexpr char* m_file{"CONIN$"};
 #else