Skip to content

Commit

Permalink
Fixes (#337)
Browse files Browse the repository at this point in the history
  • Loading branch information
@flagarde
flagarde authored Dec 4, 2023
1 parent 5aa2580 commit 379f7f3
Show file tree
Hide file tree
Showing 15 changed files with 251 additions and 194 deletions.
21 changes: 17 additions & 4 deletions cpp-terminal/iostream_initializer.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -10,6 +10,7 @@
#include "cpp-terminal/iostream_initializer.hpp"

#include "cpp-terminal/iostream.hpp"
#include "cpp-terminal/private/exception.hpp"
#include "cpp-terminal/terminal.hpp"

Check warning on line 14 in cpp-terminal/iostream_initializer.cpp

View workflow job for this annotation

GitHub Actions / cpp-linter

/cpp-terminal/iostream_initializer.cpp:14:1 [misc-include-cleaner] 

included header terminal.hpp is not used directly
#include "cpp-terminal/terminal_initializer.hpp"
#include "cpp-terminal/tty.hpp"
Expand All @@ -19,9 +20,10 @@

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.
Expand All @@ -31,15 +33,26 @@ Term::IOStreamInitializer::IOStreamInitializer()
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);
}
4 changes: 2 additions & 2 deletions cpp-terminal/iostream_initializer.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand Down
2 changes: 1 addition & 1 deletion cpp-terminal/private/CMakeLists.txt
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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>)
Expand Down
4 changes: 2 additions & 2 deletions cpp-terminal/private/exception.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -84,7 +84,7 @@ Term::Private::WindowsException::WindowsException(const std::int64_t& error, con
{
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)
Expand All @@ -101,7 +101,7 @@ Term::Private::WindowsException::WindowsException(const std::int64_t& error, con

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);
}
Expand Down
124 changes: 72 additions & 52 deletions cpp-terminal/private/file.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -9,6 +9,8 @@

#include "cpp-terminal/private/file.hpp"

#include "cpp-terminal/private/exception.hpp"

#include <cstdio>
#include <new>

Expand All @@ -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

Expand All @@ -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');
Expand All @@ -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');
Expand All @@ -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);
}
35 changes: 19 additions & 16 deletions cpp-terminal/private/file.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -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};
Expand All @@ -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
Expand All @@ -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
Expand Down
Loading

1 comment on commit 379f7f3

@github-actions
Copy link

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Cpp-Linter Report ⚠️

Some files did not pass the configured checks!

clang-tidy reports: 153 concern(s)

  • cpp-terminal/iostream_initializer.cpp

    /cpp-terminal/iostream_initializer.cpp:14:1: warning: [misc-include-cleaner]

    included header terminal.hpp is not used directly

       14 | #include "cpp-terminal/terminal.hpp"
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   15 | #include "cpp-terminal/terminal_initializer.hpp"

    /cpp-terminal/iostream_initializer.cpp:30:22: warning: [misc-include-cleaner]

    no header providing "Term::TOstream" is directly included

       14 |     new(&Term::cout) TOstream(Term::Buffer::Type::FullBuffered, BUFSIZ);
      |                      ^

    /cpp-terminal/iostream_initializer.cpp:30:37: warning: [misc-include-cleaner]

    no header providing "Term::Buffer" is directly included

       12 |     new(&Term::cout) TOstream(Term::Buffer::Type::FullBuffered, BUFSIZ);
      |                                     ^

    /cpp-terminal/iostream_initializer.cpp:30:51: warning: [misc-include-cleaner]

    no header providing "Term::Buffer::Type::FullBuffered" is directly included

       12 |     new(&Term::cout) TOstream(Term::Buffer::Type::FullBuffered, BUFSIZ);
      |                                                   ^

    /cpp-terminal/iostream_initializer.cpp:30:65: warning: [misc-include-cleaner]

    no header providing "BUFSIZ" is directly included

       19 | #include <iostream>
   20 | 
   21 | std::size_t Term::IOStreamInitializer::m_counter{0};
   22 | 
   23 | Term::IOStreamInitializer::IOStreamInitializer() noexcept
   24 | try
   25 | {
   26 |   if(0 == m_counter)
   27 |   {
   28 |     static const std::ios_base::Init       iostreams_init;  // Init std::cout etc...
   29 |     static const Term::TerminalInitializer terminal_init;   // Make sure terminal is set up.
   30 |     new(&Term::cout) TOstream(Term::Buffer::Type::FullBuffered, BUFSIZ);
      |                                                                 ^

    /cpp-terminal/iostream_initializer.cpp:31:22: warning: [misc-include-cleaner]

    no header providing "Term::TOstream" is directly included

       14 |     new(&Term::clog) TOstream(Term::Buffer::Type::LineBuffered, BUFSIZ);
      |                      ^

    /cpp-terminal/iostream_initializer.cpp:31:37: warning: [misc-include-cleaner]

    no header providing "Term::Buffer" is directly included

       12 |     new(&Term::clog) TOstream(Term::Buffer::Type::LineBuffered, BUFSIZ);
      |                                     ^

    /cpp-terminal/iostream_initializer.cpp:31:51: warning: [misc-include-cleaner]

    no header providing "Term::Buffer::Type::LineBuffered" is directly included

       12 |     new(&Term::clog) TOstream(Term::Buffer::Type::LineBuffered, BUFSIZ);
      |                                                   ^

    /cpp-terminal/iostream_initializer.cpp:31:65: warning: [misc-include-cleaner]

    no header providing "BUFSIZ" is directly included

       19 | #include <iostream>
   20 | 
   21 | std::size_t Term::IOStreamInitializer::m_counter{0};
   22 | 
   23 | Term::IOStreamInitializer::IOStreamInitializer() noexcept
   24 | try
   25 | {
   26 |   if(0 == m_counter)
   27 |   {
   28 |     static const std::ios_base::Init       iostreams_init;  // Init std::cout etc...
   29 |     static const Term::TerminalInitializer terminal_init;   // Make sure terminal is set up.
   30 |     new(&Term::cout) TOstream(Term::Buffer::Type::FullBuffered, BUFSIZ);
   31 |     new(&Term::clog) TOstream(Term::Buffer::Type::LineBuffered, BUFSIZ);
      |                                                                 ^

    /cpp-terminal/iostream_initializer.cpp:32:22: warning: [misc-include-cleaner]

    no header providing "Term::TOstream" is directly included

       14 |     new(&Term::cerr) TOstream(Term::Buffer::Type::Unbuffered, 0);
      |                      ^

    /cpp-terminal/iostream_initializer.cpp:32:37: warning: [misc-include-cleaner]

    no header providing "Term::Buffer" is directly included

       12 |     new(&Term::cerr) TOstream(Term::Buffer::Type::Unbuffered, 0);
      |                                     ^

    /cpp-terminal/iostream_initializer.cpp:32:51: warning: [misc-include-cleaner]

    no header providing "Term::Buffer::Type::Unbuffered" is directly included

       12 |     new(&Term::cerr) TOstream(Term::Buffer::Type::Unbuffered, 0);
      |                                                   ^

    /cpp-terminal/iostream_initializer.cpp:33:21: warning: [misc-include-cleaner]

    no header providing "Term::TIstream" is directly included

       14 |     new(&Term::cin) TIstream(Term::Buffer::Type::FullBuffered, BUFSIZ);
      |                     ^

    /cpp-terminal/iostream_initializer.cpp:33:36: warning: [misc-include-cleaner]

    no header providing "Term::Buffer" is directly included

       12 |     new(&Term::cin) TIstream(Term::Buffer::Type::FullBuffered, BUFSIZ);
      |                                    ^

    /cpp-terminal/iostream_initializer.cpp:33:50: warning: [misc-include-cleaner]

    no header providing "Term::Buffer::Type::FullBuffered" is directly included

       12 |     new(&Term::cin) TIstream(Term::Buffer::Type::FullBuffered, BUFSIZ);
      |                                                  ^

    /cpp-terminal/iostream_initializer.cpp:33:64: warning: [misc-include-cleaner]

    no header providing "BUFSIZ" is directly included

       19 | #include <iostream>
   20 | 
   21 | std::size_t Term::IOStreamInitializer::m_counter{0};
   22 | 
   23 | Term::IOStreamInitializer::IOStreamInitializer() noexcept
   24 | try
   25 | {
   26 |   if(0 == m_counter)
   27 |   {
   28 |     static const std::ios_base::Init       iostreams_init;  // Init std::cout etc...
   29 |     static const Term::TerminalInitializer terminal_init;   // Make sure terminal is set up.
   30 |     new(&Term::cout) TOstream(Term::Buffer::Type::FullBuffered, BUFSIZ);
   31 |     new(&Term::clog) TOstream(Term::Buffer::Type::LineBuffered, BUFSIZ);
   32 |     new(&Term::cerr) TOstream(Term::Buffer::Type::Unbuffered, 0);
   33 |     new(&Term::cin) TIstream(Term::Buffer::Type::FullBuffered, BUFSIZ);
      |                                                                ^

    /cpp-terminal/iostream_initializer.cpp:49:21: warning: [misc-include-cleaner]

    no header providing "Term::TOstream" is directly included

       14 |     (&Term::cout)->~TOstream();
      |                     ^

    /cpp-terminal/iostream_initializer.cpp:50:21: warning: [misc-include-cleaner]

    no header providing "Term::TOstream" is directly included

       14 |     (&Term::cerr)->~TOstream();
      |                     ^

    /cpp-terminal/iostream_initializer.cpp:51:21: warning: [misc-include-cleaner]

    no header providing "Term::TOstream" is directly included

       14 |     (&Term::clog)->~TOstream();
      |                     ^

    /cpp-terminal/iostream_initializer.cpp:52:20: warning: [misc-include-cleaner]

    no header providing "Term::TIstream" is directly included

       14 |     (&Term::cin)->~TIstream();
      |                    ^

  • cpp-terminal/iostream_initializer.hpp

    /cpp-terminal/iostream_initializer.hpp:1:1: warning: [llvm-header-guard]

    header is missing header guard

        1 | /*
      | ^

  • cpp-terminal/private/exception.cpp

    /cpp-terminal/private/exception.cpp:16:1: warning: [misc-include-cleaner]

    included header atomic is not used directly

       16 | #include <atomic>
      | ^~~~~~~~~~~~~~~~~
   17 | #include <exception>

    /cpp-terminal/private/exception.cpp:28:3: warning: [misc-include-cleaner]

    included header cstring is not used directly

       28 |   #include <cstring>
      |   ^~~~~~~~~~~~~~~~~~
   29 | #endif

    /cpp-terminal/private/exception.cpp:37:39: warning: [misc-include-cleaner]

    no header providing "std::int64_t" is directly included

       17 | Term::Exception::Exception(const std::int64_t& code, const std::string& message) noexcept : m_code(code), m_message(message) {}
      |                                       ^

    /cpp-terminal/private/exception.cpp:45:6: warning: [misc-include-cleaner]

    no header providing "std::int64_t" is directly included

       17 | std::int64_t Term::Exception::code() const noexcept { return m_code; }
      |      ^

    /cpp-terminal/private/exception.cpp:51:39: warning: [misc-include-cleaner]

    no header providing "std::int64_t" is directly included

       17 | Term::Exception::Exception(const std::int64_t& code) noexcept : m_code(code) {}
      |                                       ^

    /cpp-terminal/private/exception.cpp:129:6: warning: [misc-include-cleaner]

    no header providing "std::int64_t" is directly included

       17 | std::int64_t Term::Private::Errno::error() const noexcept { return m_errno; }
      |      ^

    /cpp-terminal/private/exception.cpp:139:30: warning: [misc-include-cleaner]

    no header providing "std::uint32_t" is directly included

       17 |   m_errno = static_cast<std::uint32_t>(errno);  //NOSONAR
      |                              ^

    /cpp-terminal/private/exception.cpp:150:58: warning: [misc-include-cleaner]

    no header providing "std::int64_t" is directly included

       17 | Term::Private::ErrnoException::ErrnoException(const std::int64_t& error, const std::string& context) : Term::Exception(error)
      |                                                          ^

    /cpp-terminal/private/exception.cpp:159:15: warning: [misc-include-cleaner]

    no header providing "strerror_r" is directly included

       18 |   message = ::strerror_r(static_cast<std::int32_t>(error), &message[0], message.size());  // NOLINT(readability-container-data-pointer)
      |               ^

    /cpp-terminal/private/exception.cpp:159:43: warning: [misc-include-cleaner]

    no header providing "std::int32_t" is directly included

       17 |   message = ::strerror_r(static_cast<std::int32_t>(error), &message[0], message.size());  // NOLINT(readability-container-data-pointer)
      |                                           ^

    /cpp-terminal/private/exception.cpp:175:5: warning: [misc-const-correctness]

    variable 'exception' of type 'std::exception_ptr' can be declared 'const'

      175 |     std::exception_ptr exception{std::current_exception()};
      |     ^
      |                        const

    /cpp-terminal/private/exception.cpp:235:8: warning: [misc-include-cleaner]

    no header providing "std::_Exit" is directly included

       17 |   std::_Exit(Term::returnCode());
      |        ^

  • cpp-terminal/private/file.cpp

    /cpp-terminal/private/file.cpp:15:1: warning: [misc-include-cleaner]

    included header new is not used directly

       15 | #include <new>
      | ^~~~~~~~~~~~~~
   16 |

    /cpp-terminal/private/file.cpp:25:1: warning: [misc-include-cleaner]

    included header unicode.hpp is not used directly

       25 | #include "cpp-terminal/private/unicode.hpp"
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   26 |

    /cpp-terminal/private/file.cpp:38:50: warning: [readability-identifier-length]

    variable name 'in' is too short, expected at least 3 characters

       38 | Term::Private::InputFileHandler&  Term::Private::in  = reinterpret_cast<Term::Private::InputFileHandler&>(stdin_buffer);
      |                                                  ^

    /cpp-terminal/private/file.cpp:38:56: warning: [cppcoreguidelines-pro-type-reinterpret-cast]

    do not use reinterpret_cast

       38 | Term::Private::InputFileHandler&  Term::Private::in  = reinterpret_cast<Term::Private::InputFileHandler&>(stdin_buffer);
      |                                                        ^

    /cpp-terminal/private/file.cpp:39:56: warning: [cppcoreguidelines-pro-type-reinterpret-cast]

    do not use reinterpret_cast

       39 | Term::Private::OutputFileHandler& Term::Private::out = reinterpret_cast<Term::Private::OutputFileHandler&>(stdout_buffer);
      |                                                        ^

    /cpp-terminal/private/file.cpp:43:46: warning: [misc-include-cleaner]

    no header providing "std::recursive_mutex" is directly included

       15 | Term::Private::FileHandler::FileHandler(std::recursive_mutex& mutex, const std::string& file, const std::string& mode) noexcept
      |                                              ^

    /cpp-terminal/private/file.cpp:43:81: warning: [misc-include-cleaner]

    no header providing "std::string" is directly included

       16 | Term::Private::FileHandler::FileHandler(std::recursive_mutex& mutex, const std::string& file, const std::string& mode) noexcept
      |                                                                                 ^

    /cpp-terminal/private/file.cpp:43:106: warning: [misc-include-cleaner]

    no header providing "std::string" is directly included

       16 | Term::Private::FileHandler::FileHandler(std::recursive_mutex& mutex, const std::string& file, const std::string& mode) noexcept
      |                                                                                                          ^

    /cpp-terminal/private/file.cpp:57:11: warning: [hicpp-signed-bitwise]

    use of a signed integer operand with a binary bitwise operator

       57 |   flag &= ~O_NONBLOCK;
      |        ~~ ^~~~~~~~~~~

    /cpp-terminal/private/file.cpp:58:29: warning: [misc-include-cleaner]

    no header providing "std::string" is directly included

       16 |   if(mode.find('r') != std::string::npos) { flag |= O_RDONLY; }       //NOLINT(abseil-string-find-str-contains)
      |                             ^

    /cpp-terminal/private/file.cpp:59:34: warning: [misc-include-cleaner]

    no header providing "std::string" is directly included

       16 |   else if(mode.find('w') != std::string::npos) { flag |= O_WRONLY; }  //NOLINT(abseil-string-find-str-contains)
      |                                  ^

    /cpp-terminal/private/file.cpp:67:58: warning: [misc-include-cleaner]

    no header providing "fdopen" is directly included

       16 |   Term::Private::Errno().check_if(nullptr == (m_file = ::fdopen(m_fd, mode.c_str()))).throw_exception("::fdopen(m_fd, mode.c_str())");
      |                                                          ^

    /cpp-terminal/private/file.cpp:92:6: warning: [misc-include-cleaner]

    no header providing "std::int32_t" is directly included

       14 | std::int32_t Term::Private::FileHandler::fd() const noexcept { return m_fd; }
      |      ^

    /cpp-terminal/private/file.cpp:96:64: warning: [misc-include-cleaner]

    no header providing "std::string" is directly included

       16 | std::size_t Term::Private::OutputFileHandler::write(const std::string& str) const
      |                                                                ^

    /cpp-terminal/private/file.cpp:103:3: warning: [misc-include-cleaner]

    no header providing "ssize_t" is directly included

       16 |   ssize_t written{0};
      |   ^

    /cpp-terminal/private/file.cpp:116:3: warning: [misc-include-cleaner]

    no header providing "ssize_t" is directly included

       16 |   ssize_t written{0};
      |   ^

    /cpp-terminal/private/file.cpp:122:6: warning: [misc-include-cleaner]

    no header providing "std::string" is directly included

       16 | std::string Term::Private::InputFileHandler::read()
      |      ^

    /cpp-terminal/private/file.cpp:122:46: warning: [readability-convert-member-functions-to-static]

    method 'read' can be made static

      122 | std::string Term::Private::InputFileHandler::read()
      |                                              ^

    /cpp-terminal/private/file.cpp:132:29: warning: [misc-include-cleaner]

    no header providing "FIONREAD" is directly included

       14 |   ::ioctl(Private::in.fd(), FIONREAD, &nread);  //NOLINT(cppcoreguidelines-pro-type-vararg,hicpp-vararg)
      |                             ^

    /cpp-terminal/private/file.cpp:135:10: warning: [misc-include-cleaner]

    no header providing "std::string" is directly included

       16 |     std::string ret(nread, '\0');
      |          ^

    /cpp-terminal/private/file.cpp:136:5: warning: [misc-include-cleaner]

    no header providing "errno" is directly included

       14 |     errno = 0;
      |     ^

    /cpp-terminal/private/file.cpp:137:5: warning: [misc-const-correctness]

    variable 'nnread' of type '::ssize_t' (aka 'long') can be declared 'const'

      137 |     ::ssize_t nnread{::read(Private::in.fd(), &ret[0], ret.size())};
      |     ^
      |               const

    /cpp-terminal/private/file.cpp:137:7: warning: [misc-include-cleaner]

    no header providing "ssize_t" is directly included

       16 |     ::ssize_t nnread{::read(Private::in.fd(), &ret[0], ret.size())};
      |       ^

    /cpp-terminal/private/file.cpp:137:47: warning: [readability-container-data-pointer]

    'data' should be used for accessing the data pointer instead of taking the address of the 0-th element

      137 |     ::ssize_t nnread{::read(Private::in.fd(), &ret[0], ret.size())};
      |                                               ^~~~~~~
      |                                               ret.data()

    /cpp-terminal/private/file.cpp:138:24: warning: [misc-include-cleaner]

    no header providing "errno" is directly included

       14 |     if(nnread == -1 && errno != EAGAIN) { throw Term::Exception("read() failed"); }
      |                        ^

    /cpp-terminal/private/file.cpp:138:33: warning: [misc-include-cleaner]

    no header providing "EAGAIN" is directly included

       14 |     if(nnread == -1 && errno != EAGAIN) { throw Term::Exception("read() failed"); }
      |                                 ^

    /cpp-terminal/private/file.cpp:138:55: warning: [misc-include-cleaner]

    no header providing "Term::Exception" is directly included

       12 |     if(nnread == -1 && errno != EAGAIN) { throw Term::Exception("read() failed"); }
      |                                                       ^

    /cpp-terminal/private/file.cpp:139:12: warning: [readability-redundant-string-cstr]

    redundant call to 'c_str'

      139 |     return ret.c_str();
      |            ^~~~~~~~~~~
      |            ret

    /cpp-terminal/private/file.cpp:150:58: warning: [misc-include-cleaner]

    no header providing "std::recursive_mutex" is directly included

       15 | Term::Private::OutputFileHandler::OutputFileHandler(std::recursive_mutex& io_mutex) noexcept
      |                                                          ^

    /cpp-terminal/private/file.cpp:160:56: warning: [misc-include-cleaner]

    no header providing "std::recursive_mutex" is directly included

       15 | Term::Private::InputFileHandler::InputFileHandler(std::recursive_mutex& io_mutex) noexcept
      |                                                        ^

  • cpp-terminal/private/file.hpp

    /cpp-terminal/private/file.hpp:1:1: warning: [llvm-header-guard]

    header is missing header guard

        1 | /*
      | ^

    /cpp-terminal/private/file.hpp:31:18: warning: [misc-include-cleaner]

    no header providing "FILE" is directly included

       16 | #include <mutex>
   17 | #include <string>
   18 | 
   19 | namespace Term
   20 | {
   21 | 
   22 | namespace Private
   23 | {
   24 | 
   25 | class FileHandler
   26 | {
   27 | public:
   28 | #if defined(_WIN32)
   29 |   using Handle = void*;
   30 | #else
   31 |   using Handle = FILE*;
      |                  ^

    /cpp-terminal/private/file.hpp:41:3: warning: [misc-include-cleaner]

    no header providing "FILE" is directly included

       16 |   FILE*        file() const noexcept;
      |   ^

    /cpp-terminal/private/file.hpp:52:3: warning: [misc-include-cleaner]

    no header providing "FILE" is directly included

       16 |   FILE*                 m_file{nullptr};
      |   ^

    /cpp-terminal/private/file.hpp:93:30: warning: [readability-identifier-length]

    variable name 'in' is too short, expected at least 3 characters

       93 | extern InputFileHandler&     in;
      |                              ^

    /cpp-terminal/private/file.hpp:95:1: warning: [fuchsia-statically-constructed-objects]

    static objects are disallowed; if possible, use a constexpr constructor instead

       95 | static const FileInitializer file_initializer;
      | ^

  • cpp-terminal/private/file_initializer.cpp

    /cpp-terminal/private/file_initializer.cpp:29:6: warning: [misc-include-cleaner]

    no header providing "std::size_t" is directly included

       14 | 
   15 | #if defined(_WIN32)
   16 |   #include "cpp-terminal/private/unicode.hpp"
   17 | 
   18 |   #include <io.h>
   19 |   #include <windows.h>
   20 |   #if defined(MessageBox)
   21 |     #undef MessageBox
   22 |   #endif
   23 | #else
   24 |   #include <sys/stat.h>
   25 | #endif
   26 | 
   27 | bool Term::Private::FileInitializer::m_consoleCreated = {false};
   28 | 
   29 | std::size_t Term::Private::FileInitializer::m_counter = {0};
      |      ^

    /cpp-terminal/private/file_initializer.cpp:74:15: warning: [misc-include-cleaner]

    no header providing "std::recursive_mutex" is directly included

       14 |   static std::recursive_mutex ioMutex;
      |               ^

    /cpp-terminal/private/file_initializer.cpp:79:84: warning: [misc-include-cleaner]

    no header providing "Term::Exception" is directly included

       12 |     if(nullptr == new(&Term::Private::in) InputFileHandler(ioMutex)) { throw Term::Exception("new(&Term::Private::in) InputFileHandler(ioMutex)"); }
      |                                                                                    ^

    /cpp-terminal/private/file_initializer.cpp:80:86: warning: [misc-include-cleaner]

    no header providing "Term::Exception" is directly included

       12 |     if(nullptr == new(&Term::Private::out) OutputFileHandler(ioMutex)) { throw Term::Exception("new(&Term::Private::out) OutputFileHandler(ioMutex)"); }
      |                                                                                      ^

    /cpp-terminal/private/file_initializer.cpp:115:8: warning: [misc-include-cleaner]

    no header providing "fileno" is directly included

       14 |   if(::fileno(stderr) < 0) { Term::Private::Errno().check_if(nullptr == std::freopen("/dev/tty", "w", stderr)).throw_exception(R"(std::freopen("/dev/tty", "w", stderr))"); }  //NOLINT(cppcoreguidelines-owning-memory)
      |        ^

    /cpp-terminal/private/file_initializer.cpp:115:15: warning: [misc-include-cleaner]

    no header providing "stderr" is directly included

       14 |   if(::fileno(stderr) < 0) { Term::Private::Errno().check_if(nullptr == std::freopen("/dev/tty", "w", stderr)).throw_exception(R"(std::freopen("/dev/tty", "w", stderr))"); }  //NOLINT(cppcoreguidelines-owning-memory)
      |               ^

    /cpp-terminal/private/file_initializer.cpp:115:78: warning: [misc-include-cleaner]

    no header providing "std::freopen" is directly included

       14 |   if(::fileno(stderr) < 0) { Term::Private::Errno().check_if(nullptr == std::freopen("/dev/tty", "w", stderr)).throw_exception(R"(std::freopen("/dev/tty", "w", stderr))"); }  //NOLINT(cppcoreguidelines-owning-memory)
      |                                                                              ^

    /cpp-terminal/private/file_initializer.cpp:115:103: warning: [misc-include-cleaner]

    no header providing "stderr" is directly included

       14 |   if(::fileno(stderr) < 0) { Term::Private::Errno().check_if(nullptr == std::freopen("/dev/tty", "w", stderr)).throw_exception(R"(std::freopen("/dev/tty", "w", stderr))"); }  //NOLINT(cppcoreguidelines-owning-memory)
      |                                                                                                       ^

    /cpp-terminal/private/file_initializer.cpp:116:8: warning: [misc-include-cleaner]

    no header providing "fileno" is directly included

       14 |   if(::fileno(stdout) < 0) { Term::Private::Errno().check_if(nullptr == std::freopen("/dev/tty", "w", stdout)).throw_exception(R"(std::freopen("/dev/tty", "w", stdout))"); }  //NOLINT(cppcoreguidelines-owning-memory)
      |        ^

    /cpp-terminal/private/file_initializer.cpp:116:15: warning: [misc-include-cleaner]

    no header providing "stdout" is directly included

       14 |   if(::fileno(stdout) < 0) { Term::Private::Errno().check_if(nullptr == std::freopen("/dev/tty", "w", stdout)).throw_exception(R"(std::freopen("/dev/tty", "w", stdout))"); }  //NOLINT(cppcoreguidelines-owning-memory)
      |               ^

    /cpp-terminal/private/file_initializer.cpp:116:78: warning: [misc-include-cleaner]

    no header providing "std::freopen" is directly included

       14 |   if(::fileno(stdout) < 0) { Term::Private::Errno().check_if(nullptr == std::freopen("/dev/tty", "w", stdout)).throw_exception(R"(std::freopen("/dev/tty", "w", stdout))"); }  //NOLINT(cppcoreguidelines-owning-memory)
      |                                                                              ^

    /cpp-terminal/private/file_initializer.cpp:116:103: warning: [misc-include-cleaner]

    no header providing "stdout" is directly included

       14 |   if(::fileno(stdout) < 0) { Term::Private::Errno().check_if(nullptr == std::freopen("/dev/tty", "w", stdout)).throw_exception(R"(std::freopen("/dev/tty", "w", stdout))"); }  //NOLINT(cppcoreguidelines-owning-memory)
      |                                                                                                       ^

    /cpp-terminal/private/file_initializer.cpp:117:8: warning: [misc-include-cleaner]

    no header providing "fileno" is directly included

       14 |   if(::fileno(stdin) < 0) { Term::Private::Errno().check_if(nullptr == std::freopen("/dev/tty", "r", stdin)).throw_exception(R"(std::freopen("/dev/tty", "r", stdin))"); }     //NOLINT(cppcoreguidelines-owning-memory)
      |        ^

    /cpp-terminal/private/file_initializer.cpp:117:15: warning: [misc-include-cleaner]

    no header providing "stdin" is directly included

       14 |   if(::fileno(stdin) < 0) { Term::Private::Errno().check_if(nullptr == std::freopen("/dev/tty", "r", stdin)).throw_exception(R"(std::freopen("/dev/tty", "r", stdin))"); }     //NOLINT(cppcoreguidelines-owning-memory)
      |               ^

    /cpp-terminal/private/file_initializer.cpp:117:77: warning: [misc-include-cleaner]

    no header providing "std::freopen" is directly included

       14 |   if(::fileno(stdin) < 0) { Term::Private::Errno().check_if(nullptr == std::freopen("/dev/tty", "r", stdin)).throw_exception(R"(std::freopen("/dev/tty", "r", stdin))"); }     //NOLINT(cppcoreguidelines-owning-memory)
      |                                                                             ^

    /cpp-terminal/private/file_initializer.cpp:117:102: warning: [misc-include-cleaner]

    no header providing "stdin" is directly included

       14 |   if(::fileno(stdin) < 0) { Term::Private::Errno().check_if(nullptr == std::freopen("/dev/tty", "r", stdin)).throw_exception(R"(std::freopen("/dev/tty", "r", stdin))"); }     //NOLINT(cppcoreguidelines-owning-memory)
      |                                                                                                      ^

    /cpp-terminal/private/file_initializer.cpp:120:14: warning: [misc-include-cleaner]

    no header providing "std::size_t" is directly included

       14 |   const std::size_t bestSize{static_cast<std::size_t>(stats.st_blksize) > 0 ? static_cast<std::size_t>(stats.st_blksize) : BUFSIZ};  //NOSONAR(S1774)
      |              ^

    /cpp-terminal/private/file_initializer.cpp:120:47: warning: [misc-include-cleaner]

    no header providing "std::size_t" is directly included

       14 |   const std::size_t bestSize{static_cast<std::size_t>(stats.st_blksize) > 0 ? static_cast<std::size_t>(stats.st_blksize) : BUFSIZ};  //NOSONAR(S1774)
      |                                               ^

    /cpp-terminal/private/file_initializer.cpp:120:96: warning: [misc-include-cleaner]

    no header providing "std::size_t" is directly included

       14 |   const std::size_t bestSize{static_cast<std::size_t>(stats.st_blksize) > 0 ? static_cast<std::size_t>(stats.st_blksize) : BUFSIZ};  //NOSONAR(S1774)
      |                                                                                                ^

    /cpp-terminal/private/file_initializer.cpp:120:124: warning: [misc-include-cleaner]

    no header providing "BUFSIZ" is directly included

       14 |   const std::size_t bestSize{static_cast<std::size_t>(stats.st_blksize) > 0 ? static_cast<std::size_t>(stats.st_blksize) : BUFSIZ};  //NOSONAR(S1774)
      |                                                                                                                            ^

    /cpp-terminal/private/file_initializer.cpp:122:40: warning: [misc-include-cleaner]

    no header providing "std::setvbuf" is directly included

       14 |   Term::Private::Errno().check_if(std::setvbuf(stderr, nullptr, _IONBF, 0) != 0).throw_exception("std::setvbuf(stderr, nullptr, _IONBF, 0)");
      |                                        ^

    /cpp-terminal/private/file_initializer.cpp:122:48: warning: [misc-include-cleaner]

    no header providing "stderr" is directly included

       14 |   Term::Private::Errno().check_if(std::setvbuf(stderr, nullptr, _IONBF, 0) != 0).throw_exception("std::setvbuf(stderr, nullptr, _IONBF, 0)");
      |                                                ^

    /cpp-terminal/private/file_initializer.cpp:122:65: warning: [misc-include-cleaner]

    no header providing "_IONBF" is directly included

       14 |   Term::Private::Errno().check_if(std::setvbuf(stderr, nullptr, _IONBF, 0) != 0).throw_exception("std::setvbuf(stderr, nullptr, _IONBF, 0)");
      |                                                                 ^

    /cpp-terminal/private/file_initializer.cpp:123:40: warning: [misc-include-cleaner]

    no header providing "std::setvbuf" is directly included

       14 |   Term::Private::Errno().check_if(std::setvbuf(stdout, nullptr, _IOLBF, bestSize) != 0).throw_exception("std::setvbuf(stdout, nullptr, _IOLBF, bestSize)");
      |                                        ^

    /cpp-terminal/private/file_initializer.cpp:123:48: warning: [misc-include-cleaner]

    no header providing "stdout" is directly included

       14 |   Term::Private::Errno().check_if(std::setvbuf(stdout, nullptr, _IOLBF, bestSize) != 0).throw_exception("std::setvbuf(stdout, nullptr, _IOLBF, bestSize)");
      |                                                ^

    /cpp-terminal/private/file_initializer.cpp:123:65: warning: [misc-include-cleaner]

    no header providing "_IOLBF" is directly included

       14 |   Term::Private::Errno().check_if(std::setvbuf(stdout, nullptr, _IOLBF, bestSize) != 0).throw_exception("std::setvbuf(stdout, nullptr, _IOLBF, bestSize)");
      |                                                                 ^

    /cpp-terminal/private/file_initializer.cpp:124:40: warning: [misc-include-cleaner]

    no header providing "std::setvbuf" is directly included

       14 |   Term::Private::Errno().check_if(std::setvbuf(stdin, nullptr, _IOLBF, bestSize) != 0).throw_exception("std::setvbuf(stdin, nullptr, _IOLBF, bestSize)");
      |                                        ^

    /cpp-terminal/private/file_initializer.cpp:124:48: warning: [misc-include-cleaner]

    no header providing "stdin" is directly included

       14 |   Term::Private::Errno().check_if(std::setvbuf(stdin, nullptr, _IOLBF, bestSize) != 0).throw_exception("std::setvbuf(stdin, nullptr, _IOLBF, bestSize)");
      |                                                ^

    /cpp-terminal/private/file_initializer.cpp:124:64: warning: [misc-include-cleaner]

    no header providing "_IOLBF" is directly included

       14 |   Term::Private::Errno().check_if(std::setvbuf(stdin, nullptr, _IOLBF, bestSize) != 0).throw_exception("std::setvbuf(stdin, nullptr, _IOLBF, bestSize)");
      |                                                                ^

  • cpp-terminal/private/file_initializer.hpp

    /cpp-terminal/private/file_initializer.hpp:1:1: warning: [llvm-header-guard]

    header is missing header guard

        1 | /*
      | ^

  • cpp-terminal/private/sigwinch.cpp

    /cpp-terminal/private/sigwinch.cpp:15:3: warning: [misc-include-cleaner]

    included header csignal is not used directly

       15 |   #include <csignal>
      |   ^~~~~~~~~~~~~~~~~~
   16 |   #include <unistd.h>

    /cpp-terminal/private/sigwinch.cpp:38:6: warning: [misc-include-cleaner]

    no header providing "std::int32_t" is directly included

       13 | std::int32_t Term::Private::Sigwinch::get() noexcept
      |      ^

    /cpp-terminal/private/sigwinch.cpp:47:6: warning: [misc-include-cleaner]

    no header providing "std::int32_t" is directly included

       13 | std::int32_t Term::Private::Sigwinch::m_fd{-1};
      |      ^

    /cpp-terminal/private/sigwinch.cpp:58:5: warning: [misc-include-cleaner]

    no header providing "sigset_t" is directly included

       13 |   ::sigset_t windows_event = {};
      |     ^

    /cpp-terminal/private/sigwinch.cpp:59:35: warning: [misc-include-cleaner]

    no header providing "sigemptyset" is directly included

       13 |   Term::Private::Errno().check_if(sigemptyset(&windows_event) != 0).throw_exception("sigemptyset(&windows_event)");
      |                                   ^

    /cpp-terminal/private/sigwinch.cpp:60:35: warning: [misc-include-cleaner]

    no header providing "sigaddset" is directly included

       13 |   Term::Private::Errno().check_if(sigaddset(&windows_event, SIGWINCH) != 0).throw_exception("sigaddset(&windows_event, SIGWINCH)");
      |                                   ^

    /cpp-terminal/private/sigwinch.cpp:60:61: warning: [misc-include-cleaner]

    no header providing "SIGWINCH" is directly included

       13 |   Term::Private::Errno().check_if(sigaddset(&windows_event, SIGWINCH) != 0).throw_exception("sigaddset(&windows_event, SIGWINCH)");
      |                                                             ^

    /cpp-terminal/private/sigwinch.cpp:68:5: warning: [misc-include-cleaner]

    no header providing "sigset_t" is directly included

       13 |   ::sigset_t windows_event = {};
      |     ^

    /cpp-terminal/private/sigwinch.cpp:69:35: warning: [misc-include-cleaner]

    no header providing "sigemptyset" is directly included

       13 |   Term::Private::Errno().check_if(sigemptyset(&windows_event) != 0).throw_exception("sigemptyset(&windows_event)");
      |                                   ^

    /cpp-terminal/private/sigwinch.cpp:70:35: warning: [misc-include-cleaner]

    no header providing "sigaddset" is directly included

       13 |   Term::Private::Errno().check_if(sigaddset(&windows_event, SIGWINCH) != 0).throw_exception("sigaddset(&windows_event, SIGWINCH)");
      |                                   ^

    /cpp-terminal/private/sigwinch.cpp:70:61: warning: [misc-include-cleaner]

    no header providing "SIGWINCH" is directly included

       13 |   Term::Private::Errno().check_if(sigaddset(&windows_event, SIGWINCH) != 0).throw_exception("sigaddset(&windows_event, SIGWINCH)");
      |                                                             ^

    /cpp-terminal/private/sigwinch.cpp:71:37: warning: [misc-include-cleaner]

    no header providing "pthread_sigmask" is directly included

       13 |   Term::Private::Errno().check_if(::pthread_sigmask(SIG_BLOCK, &windows_event, nullptr) != 0).throw_exception("::pthread_sigmask(SIG_BLOCK, &windows_event, nullptr)");
      |                                     ^

    /cpp-terminal/private/sigwinch.cpp:71:53: warning: [misc-include-cleaner]

    no header providing "SIG_BLOCK" is directly included

       13 |   Term::Private::Errno().check_if(::pthread_sigmask(SIG_BLOCK, &windows_event, nullptr) != 0).throw_exception("::pthread_sigmask(SIG_BLOCK, &windows_event, nullptr)");
      |                                                     ^

    /cpp-terminal/private/sigwinch.cpp:78:5: warning: [misc-include-cleaner]

    no header providing "sigset_t" is directly included

       13 |   ::sigset_t windows_event = {};
      |     ^

    /cpp-terminal/private/sigwinch.cpp:79:35: warning: [misc-include-cleaner]

    no header providing "sigemptyset" is directly included

       13 |   Term::Private::Errno().check_if(sigemptyset(&windows_event) != 0).throw_exception("sigemptyset(&windows_event)");
      |                                   ^

    /cpp-terminal/private/sigwinch.cpp:80:35: warning: [misc-include-cleaner]

    no header providing "sigaddset" is directly included

       13 |   Term::Private::Errno().check_if(sigaddset(&windows_event, SIGWINCH) != 0).throw_exception("sigaddset(&windows_event, SIGWINCH)");
      |                                   ^

    /cpp-terminal/private/sigwinch.cpp:80:61: warning: [misc-include-cleaner]

    no header providing "SIGWINCH" is directly included

       13 |   Term::Private::Errno().check_if(sigaddset(&windows_event, SIGWINCH) != 0).throw_exception("sigaddset(&windows_event, SIGWINCH)");
      |                                                             ^

    /cpp-terminal/private/sigwinch.cpp:81:37: warning: [misc-include-cleaner]

    no header providing "pthread_sigmask" is directly included

       13 |   Term::Private::Errno().check_if(::pthread_sigmask(SIG_UNBLOCK, &windows_event, nullptr) != 0).throw_exception("::pthread_sigmask(SIG_UNBLOCK, &windows_event, nullptr)");
      |                                     ^

    /cpp-terminal/private/sigwinch.cpp:81:53: warning: [misc-include-cleaner]

    no header providing "SIG_UNBLOCK" is directly included

       13 |   Term::Private::Errno().check_if(::pthread_sigmask(SIG_UNBLOCK, &windows_event, nullptr) != 0).throw_exception("::pthread_sigmask(SIG_UNBLOCK, &windows_event, nullptr)");
      |                                                     ^

    /cpp-terminal/private/sigwinch.cpp:85:53: warning: [misc-include-cleaner]

    no header providing "std::int32_t" is directly included

       13 | bool Term::Private::Sigwinch::isSigwinch(const std::int32_t& file_descriptor) noexcept
      |                                                     ^

  • cpp-terminal/private/sigwinch.hpp

    /cpp-terminal/private/sigwinch.hpp:1:1: warning: [llvm-header-guard]

    header is missing header guard

        1 | /*
      | ^

  • cpp-terminal/private/terminal_impl.cpp

    /cpp-terminal/private/terminal_impl.cpp:10:1: warning: [misc-include-cleaner]

    included header env.hpp is not used directly

       10 | #include "cpp-terminal/private/env.hpp"
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   11 | #include "cpp-terminal/private/exception.hpp"

    /cpp-terminal/private/terminal_impl.cpp:13:1: warning: [misc-include-cleaner]

    included header terminal.hpp is not used directly

       13 | #include "cpp-terminal/terminal.hpp"
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   14 |

    /cpp-terminal/private/terminal_impl.cpp:31:12: warning: [misc-include-cleaner]

    no header providing "Term::Terminal" is directly included

       10 | void Term::Terminal::set_unset_utf8()
      |            ^

    /cpp-terminal/private/terminal_impl.cpp:64:12: warning: [misc-include-cleaner]

    no header providing "Term::Terminal" is directly included

       10 | void Term::Terminal::store_and_restore() noexcept
      |            ^

    /cpp-terminal/private/terminal_impl.cpp:64:22: warning: [readability-convert-member-functions-to-static]

    method 'store_and_restore' can be made static

       64 | void Term::Terminal::store_and_restore() noexcept
      |                      ^

    /cpp-terminal/private/terminal_impl.cpp:111:6: warning: [misc-include-cleaner]

    no header providing "std::size_t" is directly included

       14 | std::size_t Term::Terminal::setMouseEvents()
      |      ^

    /cpp-terminal/private/terminal_impl.cpp:111:19: warning: [misc-include-cleaner]

    no header providing "Term::Terminal" is directly included

       10 | std::size_t Term::Terminal::setMouseEvents()
      |                   ^

    /cpp-terminal/private/terminal_impl.cpp:120:6: warning: [misc-include-cleaner]

    no header providing "std::size_t" is directly included

       14 | std::size_t Term::Terminal::unsetMouseEvents()
      |      ^

    /cpp-terminal/private/terminal_impl.cpp:120:19: warning: [misc-include-cleaner]

    no header providing "Term::Terminal" is directly included

       10 | std::size_t Term::Terminal::unsetMouseEvents()
      |                   ^

    /cpp-terminal/private/terminal_impl.cpp:129:6: warning: [misc-include-cleaner]

    no header providing "std::size_t" is directly included

       14 | std::size_t Term::Terminal::setFocusEvents()
      |      ^

    /cpp-terminal/private/terminal_impl.cpp:129:19: warning: [misc-include-cleaner]

    no header providing "Term::Terminal" is directly included

       10 | std::size_t Term::Terminal::setFocusEvents()
      |                   ^

    /cpp-terminal/private/terminal_impl.cpp:138:6: warning: [misc-include-cleaner]

    no header providing "std::size_t" is directly included

       14 | std::size_t Term::Terminal::unsetFocusEvents()
      |      ^

    /cpp-terminal/private/terminal_impl.cpp:138:19: warning: [misc-include-cleaner]

    no header providing "Term::Terminal" is directly included

       10 | std::size_t Term::Terminal::unsetFocusEvents()
      |                   ^

    /cpp-terminal/private/terminal_impl.cpp:147:12: warning: [misc-include-cleaner]

    no header providing "Term::Terminal" is directly included

       10 | void Term::Terminal::setMode()
      |            ^

    /cpp-terminal/private/terminal_impl.cpp:185:22: warning: [misc-include-cleaner]

    no header providing "Term::Option" is directly included

       10 |     if(m_options.has(Option::Raw))
      |                      ^

    /cpp-terminal/private/terminal_impl.cpp:185:30: warning: [misc-include-cleaner]

    no header providing "Term::Option::Raw" is directly included

       10 |     if(m_options.has(Option::Raw))
      |                              ^

    /cpp-terminal/private/terminal_impl.cpp:188:41: warning: [misc-include-cleaner]

    no header providing "std::size_t" is directly included

       14 |       send.c_iflag &= ~static_cast<std::size_t>(BRKINT | ICRNL | INPCK | ISTRIP | IXON);
      |                                         ^

    /cpp-terminal/private/terminal_impl.cpp:193:41: warning: [misc-include-cleaner]

    no header providing "std::size_t" is directly included

       14 |       send.c_lflag &= ~static_cast<std::size_t>(ECHO | ICANON | IEXTEN);
      |                                         ^

    /cpp-terminal/private/terminal_impl.cpp:199:27: warning: [misc-include-cleaner]

    no header providing "Term::Option" is directly included

       10 |     else if(m_options.has(Option::Cooked))
      |                           ^

    /cpp-terminal/private/terminal_impl.cpp:199:35: warning: [misc-include-cleaner]

    no header providing "Term::Option::Cooked" is directly included

       10 |     else if(m_options.has(Option::Cooked))
      |                                   ^

    /cpp-terminal/private/terminal_impl.cpp:205:22: warning: [misc-include-cleaner]

    no header providing "Term::Option" is directly included

       10 |     if(m_options.has(Option::NoSignalKeys)) { send.c_lflag &= ~static_cast<std::size_t>(ISIG); }  //FIXME need others flags !
      |                      ^

    /cpp-terminal/private/terminal_impl.cpp:205:30: warning: [misc-include-cleaner]

    no header providing "Term::Option::NoSignalKeys" is directly included

       10 |     if(m_options.has(Option::NoSignalKeys)) { send.c_lflag &= ~static_cast<std::size_t>(ISIG); }  //FIXME need others flags !
      |                              ^

    /cpp-terminal/private/terminal_impl.cpp:205:81: warning: [misc-include-cleaner]

    no header providing "std::size_t" is directly included

       14 |     if(m_options.has(Option::NoSignalKeys)) { send.c_lflag &= ~static_cast<std::size_t>(ISIG); }  //FIXME need others flags !
      |                                                                                 ^

    /cpp-terminal/private/terminal_impl.cpp:206:27: warning: [misc-include-cleaner]

    no header providing "Term::Option" is directly included

       10 |     else if(m_options.has(Option::NoSignalKeys)) { send.c_lflag |= ISIG; }
      |                           ^

    /cpp-terminal/private/terminal_impl.cpp:206:35: warning: [misc-include-cleaner]

    no header providing "Term::Option::NoSignalKeys" is directly included

       10 |     else if(m_options.has(Option::NoSignalKeys)) { send.c_lflag |= ISIG; }
      |                                   ^

  • cpp-terminal/terminal_impl.cpp

    /cpp-terminal/terminal_impl.cpp:16:1: warning: [misc-include-cleaner]

    included header return_code.hpp is not used directly

       16 | #include "cpp-terminal/private/return_code.hpp"
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   17 | #include "cpp-terminal/private/sigwinch.hpp"

  • cpp-terminal/terminal_impl.hpp

    /cpp-terminal/terminal_impl.hpp:1:1: warning: [llvm-header-guard]

    header is missing header guard

        1 | /*
      | ^

    /cpp-terminal/terminal_impl.hpp:13:1: warning: [misc-include-cleaner]

    included header terminal_initializer.hpp is not used directly

       13 | #include "cpp-terminal/terminal_initializer.hpp"
      | ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   14 | #include "cpp-terminal/terminfo.hpp"

  • cpp-terminal/terminal_initializer.cpp

    /cpp-terminal/terminal_initializer.cpp:16:1: warning: [misc-include-cleaner]

    included header new is not used directly

       16 | #include <new>
      | ^~~~~~~~~~~~~~
   17 |

    /cpp-terminal/terminal_initializer.cpp:18:6: warning: [misc-include-cleaner]

    no header providing "std::size_t" is directly included

       16 | #include <new>
   17 | 
   18 | std::size_t Term::TerminalInitializer::m_counter{0};
      |      ^

    /cpp-terminal/terminal_initializer.cpp:26:26: warning: [misc-include-cleaner]

    no header providing "Term::Terminal" is directly included

       15 | 
   16 | #include <new>
   17 | 
   18 | std::size_t Term::TerminalInitializer::m_counter{0};
   19 | 
   20 | Term::TerminalInitializer::TerminalInitializer() noexcept
   21 | try
   22 | {
   23 |   if(0 == m_counter)
   24 |   {
   25 |     static const Private::FileInitializer files_init;
   26 |     new(&Term::terminal) Terminal();
      |                          ^

    /cpp-terminal/terminal_initializer.cpp:39:44: warning: [misc-include-cleaner]

    no header providing "Term::Terminal" is directly included

       15 |   if(0 == m_counter) { (&Term::terminal)->~Terminal(); }
      |                                            ^

  • cpp-terminal/terminal_initializer.hpp

    /cpp-terminal/terminal_initializer.hpp:1:1: warning: [llvm-header-guard]

    header is missing header guard

        1 | /*
      | ^

Have any feedback or feature suggestions? Share it here.

Please sign in to comment.