Term::Private Namespace Reference

Classes
class	BlockingQueue
class	Errno
class	ErrnoException
class	FileHandler
class	FileInitializer
class	Input
class	InputFileHandler
class	OutputFileHandler
class	Signals
class	Sigwinch
class	WindowsError
class	WindowsException

Enumerations
enum class	ExceptionDestination : std::uint8_t { MessageBox = 0 , StdErr }

Functions
std::uint8_t	utf8_decode_step (std::uint8_t state, std::uint8_t octet, std::uint32_t *cpp)
std::u32string	utf8_to_utf32 (const std::string &str)
bool	is_valid_utf8_code_unit (const std::string &str)
std::pair< bool, std::string >	getenv (const std::string &env)
	Value of an environment variables.
void	ExceptionHandler (const ExceptionDestination &destination=ExceptionDestination::StdErr) noexcept
std::string	ask (const std::string &str)
std::string	to_narrow (const std::wstring &wstr)
std::wstring	to_wide (const std::string &str)
std::string	utf32_to_utf8 (const char32_t &codepoint, const bool &exception=false)
	Encode a codepoint using UTF-8 std::string .
std::string	utf32_to_utf8 (const std::u32string &str, const bool &exception=false)
	Encode a std::u32string into UTF-8 std::string .

Variables
InputFileHandler &	in = reinterpret_cast<Term::Private::InputFileHandler&>(stdin_buffer)
OutputFileHandler &	out = reinterpret_cast<Term::Private::OutputFileHandler&>(stdout_buffer)
volatile std::sig_atomic_t	m_signalStatus {0}

Enumeration Type Documentation

ExceptionDestination

enum class Term::Private::ExceptionDestination : std::uint8_t

strong

Enumerator
MessageBox
StdErr

Definition at line 87 of file exception.hpp.

{
  MessageBox = 0,
  StdErr,
};

Function Documentation

ask()

std::string Term::Private::ask

(

const std::string &

str

)

Definition at line 182 of file file.cpp.

{
  Term::Private::out.write(str);
  std::string ret{Term::Private::in.read()};
  for(std::size_t i = 0; i != ret.size(); ++i) { Term::Private::out.write("\b \b"); }
  return ret;
}

ExceptionHandler()

void Term::Private::ExceptionHandler ( const ExceptionDestination & destination = ExceptionDestination::StdErr )

noexcept

Definition at line 175 of file exception.cpp.

{
  try
  {
    std::exception_ptr exception{std::current_exception()};
    if(exception != nullptr) { std::rethrow_exception(exception); }
  }
  catch(const Term::Exception& exception)
  {
    switch(destination)
    {
      case ExceptionDestination::MessageBox:
#if defined(_WIN32)
        MessageBoxW(nullptr, Term::Private::to_wide(exception.what()).c_str(), Term::Private::to_wide("cpp-terminal v" + Term::Version::string()).c_str(), MB_OK | MB_ICONERROR);
        break;
#endif
      case ExceptionDestination::StdErr:
#if defined(_WIN32)
        (void)(fputws(Term::Private::to_wide(std::string("cpp-terminal v" + Term::Version::string() + "\n" + exception.what() + "\n")).c_str(), stderr));
#else
        (void)(fputs(std::string("cpp-terminal v" + Term::Version::string() + "\n" + exception.what() + "\n").c_str(), stderr));
#endif
        break;
      default: break;
    }
  }
  catch(const std::exception& exception)
  {
    switch(destination)
    {
      case ExceptionDestination::MessageBox:
#if defined(_WIN32)
        MessageBoxW(nullptr, Term::Private::to_wide(exception.what()).c_str(), Term::Private::to_wide("cpp-terminal v" + Term::Version::string()).c_str(), MB_OK | MB_ICONERROR);
        break;
#endif
      case ExceptionDestination::StdErr:
#if defined(_WIN32)
        (void)(fputws(Term::Private::to_wide(std::string("cpp-terminal v" + Term::Version::string() + "\n" + exception.what() + "\n")).c_str(), stderr));
#else
        (void)(fputs(std::string("cpp-terminal v" + Term::Version::string() + "\n" + exception.what() + "\n").c_str(), stderr));
#endif
        break;
      default: break;
    }
  }
  catch(...)
  {
    switch(destination)
    {
      case ExceptionDestination::MessageBox:
#if defined(_WIN32)
        MessageBoxW(nullptr, Term::Private::to_wide("cpp-terminal v" + Term::Version::string() + "Unknown error").c_str(), Term::Private::to_wide("cpp-terminal v" + Term::Version::string()).c_str(), MB_OK | MB_ICONERROR);
        break;
#endif
      case ExceptionDestination::StdErr:
#if defined(_WIN32)
        (void)(fputws(Term::Private::to_wide("cpp-terminal v" + Term::Version::string() + ": Unknown error\n").c_str(), stderr));
#else
        (void)(fputs(("cpp-terminal v" + Term::Version::string() + ": Unknown error\n").c_str(), stderr));
#endif
      default: break;
    }
  }
  (void)(std::fflush(stderr));
  std::_Exit(Term::returnCode());
}

getenv()

std::pair< bool, std::string > Term::Private::getenv

(

const std::string &

env

)

Value of an environment variables.

Parameters

env	The environment variable.

Returns

std::pair<bool,std::string> with bool set to true if the environment variable is set and std::string set to the value of environment variable.

Warning

Internal use only.

Definition at line 14 of file env.cpp.

{
#if defined(_WIN32)
  std::size_t size{0};
  _wgetenv_s(&size, nullptr, 0, Term::Private::to_wide(key).c_str());
  std::wstring ret;
  if(size == 0 || size > ret.max_size()) return {false, std::string()};
  ret.reserve(size);
  _wgetenv_s(&size, &ret[0], size, Term::Private::to_wide(key).c_str());
  return {true, Term::Private::to_narrow(ret)};
#else
  if(std::getenv(key.c_str()) != nullptr) { return {true, static_cast<std::string>(std::getenv(key.c_str()))}; }
  return {false, std::string()};
#endif
}

is_valid_utf8_code_unit()

bool Term::Private::is_valid_utf8_code_unit

(

const std::string &

str

)

Definition at line 55 of file conversion.cpp.

{
  static const constexpr std::uint8_t b1OOOOOOO{128};
  static const constexpr std::uint8_t b11OOOOOO{192};
  static const constexpr std::uint8_t b111OOOOO{224};
  static const constexpr std::uint8_t b1111OOOO{240};
  static const constexpr std::uint8_t b11111OOO{248};
  switch(str.size())
  {
    case 1: return (static_cast<std::uint8_t>(str[0]) & b1OOOOOOO) == 0;
    case 2: return ((static_cast<std::uint8_t>(str[0]) & b111OOOOO) == b11OOOOOO) && ((static_cast<std::uint8_t>(str[1]) & b11OOOOOO) == b1OOOOOOO);
    case 3: return ((static_cast<std::uint8_t>(str[0]) & b1111OOOO) == b111OOOOO) && ((static_cast<std::uint8_t>(str[1]) & b11OOOOOO) == b1OOOOOOO) && ((static_cast<std::uint8_t>(str[2]) & b11OOOOOO) == b1OOOOOOO);
    case 4: return ((static_cast<std::uint8_t>(str[0]) & b11111OOO) == b1111OOOO) && ((static_cast<std::uint8_t>(str[1]) & b11OOOOOO) == b1OOOOOOO) && ((static_cast<std::uint8_t>(str[2]) & b11OOOOOO) == b1OOOOOOO) && ((static_cast<std::uint8_t>(str[3]) & b11OOOOOO) == b1OOOOOOO);
    default: return false;
  }
}

to_narrow()

std::string Term::Private::to_narrow

(

const std::wstring &

wstr

)

Definition at line 26 of file unicode.cpp.

{
  if(in.empty()) return std::string();
  static constexpr DWORD flag{WC_ERR_INVALID_CHARS};
  std::size_t            in_size{in.size()};
  if(in_size > static_cast<size_t>((std::numeric_limits<int>::max)())) throw Term::Exception("String size is to big " + std::to_string(in_size) + "/" + std::to_string((std::numeric_limits<int>::max)()));
  const int ret_size{::WideCharToMultiByte(CP_UTF8, flag, in.data(), static_cast<int>(in_size), nullptr, 0, nullptr, nullptr)};
  if(ret_size == 0) throw Term::Private::WindowsException(::GetLastError());
  std::string ret(static_cast<std::size_t>(ret_size), '\0');
  int         ret_error{::WideCharToMultiByte(CP_UTF8, flag, in.data(), static_cast<int>(in_size), &ret[0], ret_size, nullptr, nullptr)};
  if(ret_error == 0) throw Term::Private::WindowsException(::GetLastError());
  return ret;
}

to_wide()

std::wstring Term::Private::to_wide

(

const std::string &

str

)

Definition at line 40 of file unicode.cpp.

{
  if(in.empty()) return std::wstring();
  static constexpr DWORD flag{MB_ERR_INVALID_CHARS};
  std::size_t            in_size{in.size()};
  if(in_size > static_cast<size_t>((std::numeric_limits<int>::max)())) throw Term::Exception("String size is to big " + std::to_string(in_size) + "/" + std::to_string((std::numeric_limits<int>::max)()));
  const int ret_size{::MultiByteToWideChar(CP_UTF8, flag, in.data(), static_cast<int>(in_size), nullptr, 0)};
  if(ret_size == 0) throw Term::Private::WindowsException(::GetLastError());
  std::wstring ret(static_cast<std::size_t>(ret_size), '\0');
  int          ret_error{::MultiByteToWideChar(CP_UTF8, flag, in.data(), static_cast<int>(in_size), &ret[0], ret_size)};
  if(ret_error == 0) throw Term::Private::WindowsException(::GetLastError());
  return ret;
}

utf32_to_utf8() [1/2]

std::string Term::Private::utf32_to_utf8	(	const char32_t &	codepoint,
		const bool &	exception = false )

Encode a codepoint using UTF-8 std::string .

Parameters

codepoint	The codepoint ( char32_t ) on range [0,0x10FFFF] to convert.
exception	If true throw exception on error, otherwise change the out of range codepoint to "replacement character" � .

Returns

std::string the UTF-8 value.

Warning

Internal use only.

Definition at line 55 of file unicode.cpp.

{
  static const constexpr std::array<std::uint32_t, 4> size{0x7F, 0x07FF, 0xFFFF, 0x10FFFF};
  static const constexpr std::uint8_t                 mask{0x80};
  static const constexpr std::uint8_t                 add{0x3F};
  static const constexpr std::array<std::uint8_t, 3>  mask_first{0x1F, 0x0F, 0x07};
  static const constexpr std::array<std::uint8_t, 3>  add_first{0xC0, 0xE0, 0xF0};
  static const constexpr std::array<std::uint8_t, 4>  shift{0, 6, 12, 18};
  static const constexpr std::uint8_t                 max_size{4};
  std::string                                         ret;
  ret.reserve(max_size);
  if(codepoint <= size[0]) { ret = {static_cast<char>(codepoint)}; }  // Plain ASCII
  else if(codepoint <= size[1]) { ret = {static_cast<char>(((codepoint >> shift[1]) & mask_first[0]) | add_first[0]), static_cast<char>(((codepoint >> shift[0]) & add) | mask)}; }
  else if(codepoint <= size[2]) { ret = {static_cast<char>(((codepoint >> shift[2]) & mask_first[1]) | add_first[1]), static_cast<char>(((codepoint >> shift[1]) & add) | mask), static_cast<char>(((codepoint >> shift[0]) & add) | mask)}; }
  else if(codepoint <= size[3]) { ret = {static_cast<char>(((codepoint >> shift[3]) & mask_first[2]) | add_first[2]), static_cast<char>(((codepoint >> shift[2]) & add) | mask), static_cast<char>(((codepoint >> shift[1]) & add) | mask), static_cast<char>(((codepoint >> shift[0]) & add) | mask)}; }
  else if(exception) { throw Term::Exception("Invalid UTF32 codepoint."); }
  else { ret = "\xEF\xBF\xBD"; }
  return ret;
}

utf32_to_utf8() [2/2]

std::string Term::Private::utf32_to_utf8	(	const std::u32string &	str,
		const bool &	exception = false )

Encode a std::u32string into UTF-8 std::string .

Parameters

str	The std::u32string to convert.
exception	If true throw exception on error, otherwise change the out of range codepoint to "replacement character" � .

Returns

std::string encoded in UTF-8.

Warning

Internal use only.

Definition at line 75 of file unicode.cpp.

{
  std::string ret;
  for(const char32_t codepoint: str) { ret.append(utf32_to_utf8(codepoint, exception)); }
  return ret;
}

utf8_decode_step()

std::uint8_t Term::Private::utf8_decode_step	(	std::uint8_t	state,
		std::uint8_t	octet,
		std::uint32_t *	cpp )

Definition at line 25 of file conversion.cpp.

{
  static const constexpr std::array<std::uint32_t, 0x10> utf8ClassTab{0x88888888UL, 0x88888888UL, 0x99999999UL, 0x99999999UL, 0xaaaaaaaaUL, 0xaaaaaaaaUL, 0xaaaaaaaaUL, 0xaaaaaaaaUL, 0x222222ffUL, 0x22222222UL, 0x22222222UL, 0x22222222UL, 0x3333333bUL, 0x33433333UL, 0xfff5666cUL, 0xffffffffUL};
 
  static const constexpr std::array<std::uint32_t, 0x10> utf8StateTab{0xfffffff0UL, 0xffffffffUL, 0xfffffff1UL, 0xfffffff3UL, 0xfffffff4UL, 0xfffffff7UL, 0xfffffff6UL, 0xffffffffUL, 0x33f11f0fUL, 0xf3311f0fUL, 0xf33f110fUL, 0xfffffff2UL, 0xfffffff5UL, 0xffffffffUL, 0xffffffffUL, 0xffffffffUL};
 
  const std::uint8_t reject{static_cast<std::uint8_t>(state >> 3UL)};
  const std::uint8_t nonAscii{static_cast<std::uint8_t>(octet >> 7UL)};
  const std::uint8_t class_{static_cast<std::uint8_t>(!nonAscii ? 0 : (0xf & (utf8ClassTab[(octet >> 3) & 0xf] >> (4 * (octet & 7)))))};
 
  *cpp = (state == UTF8_ACCEPT ? (octet & (0xffU >> class_)) : ((octet & 0x3fU) | (*cpp << 6)));
 
  return (reject ? 0xf : (0xf & (utf8StateTab[class_] >> (4 * (state & 7)))));
}

utf8_to_utf32()

std::u32string Term::Private::utf8_to_utf32

(

const std::string &

str

)

Definition at line 40 of file conversion.cpp.

{
  std::uint32_t  codepoint{0};
  std::uint8_t   state{UTF8_ACCEPT};
  std::u32string ret;
  for(char idx: str)
  {
    state = utf8_decode_step(state, static_cast<std::uint8_t>(idx), &codepoint);
    if(state == UTF8_ACCEPT) { ret.push_back(codepoint); }
    else if(state == UTF8_REJECT) { throw Term::Exception("Invalid byte in UTF8 encoded string"); }
  }
  if(state != UTF8_ACCEPT) { throw Term::Exception("Expected more bytes in UTF8 encoded string"); }
  return ret;
}

Variable Documentation

in

Term::Private::InputFileHandler & Term::Private::in = reinterpret_cast<Term::Private::InputFileHandler&>(stdin_buffer)

extern

Definition at line 43 of file file.cpp.

m_signalStatus

volatile std::sig_atomic_t Term::Private::m_signalStatus {0}

Definition at line 28 of file sigwinch.cpp.

{0};

out

Term::Private::OutputFileHandler & Term::Private::out = reinterpret_cast<Term::Private::OutputFileHandler&>(stdout_buffer)

extern

Definition at line 44 of file file.cpp.