feat: `shared_runner` for `run_after_build` in nebuild.

Signed-off-by: Amlal El Mahrouss <amlal@nekernel.org>

3 files changed, 359 insertions, 390 deletions

diff --git a/dev/src/JSONManifestBuilder.cc b/dev/src/JSONManifestBuilder.cc
index 33d7f62..f64dba4 100644
--- a/dev/src/JSONManifestBuilder.cc
+++ b/dev/src/JSONManifestBuilder.cc
@@ -4,6 +4,7 @@
 // ============================================================= //
 
 #include <BuildKit/JSONManifestBuilder.h>
+#include <dlfcn.h>
 
 using JSON = nlohmann::json;
 
@@ -99,12 +100,24 @@ bool JSONManifestBuilder::BuildTarget(const std::string& argv_val, const bool dr
 
     try {
       if (json_obj["run_after_build"].get<bool>()) {
-        if (target.ends_with(".so")) {
-          NeBuild::Logger::info()
-              << "error: can't open dynamic library, it mayn't have an entrypoint" << std::endl;
+        if (target.ends_with(".so") || target.ends_with(".dylib")) {
+#if defined(NEBUILD_POSIX)
+          auto dll = dlopen(target.c_str(), RTLD_LAZY);
 
-          return true;
-        } else if (target.ends_with(".dylib") || target.ends_with(".dll")) {
+          if (dll) {
+            int (*entrypoint)(void) = nullptr;
+            entrypoint = (decltype(entrypoint))dlsym(dll, "shared_runner");
+
+            if (entrypoint) entrypoint();
+
+            dlclose(dll);
+
+            return true;
+          }
+#endif
+
+          return false;
+        } else {
           std::ifstream     file = std::ifstream(target);
           std::stringstream ss;
 
@@ -119,17 +132,8 @@ bool JSONManifestBuilder::BuildTarget(const std::string& argv_val, const bool dr
             NeBuild::Logger::info()
                 << "error: can't open FEP dynamic library, it mayn't contain an entrypoint"
                 << std::endl;
-          else if (ss.str()[0] == 'M' && ss.str()[1] == 'Z')
-            NeBuild::Logger::info()
-                << "error: can't open MZ dynamic library, it mayn't contain an entrypoint"
-                << std::endl;
-          else if (ss.str()[0] == 0x7F && ss.str()[1] == 'E') {
-            NeBuild::Logger::info()
-                << "error: can't open ELF dynamic library, it mayn't contain an entrypoint"
-                << std::endl;
-          }
 
-          return true;
+          return false;
         }
 
 #if defined(NEBUILD_WINDOWS)
diff --git a/vendor/json/json_fwd.h b/vendor/json/json_fwd.h
index a1c70f3..4edbdce 100644
--- a/vendor/json/json_fwd.h
+++ b/vendor/json/json_fwd.h
@@ -102,8 +102,8 @@
 #endif
 
 #ifndef NLOHMANN_JSON_NAMESPACE_END
-#define NLOHMANN_JSON_NAMESPACE_END                                  \
-  } /* namespace (inline namespace) NOLINT(readability/namespace) */ \
+#define NLOHMANN_JSON_NAMESPACE_END                                   \
+  }  /* namespace (inline namespace) NOLINT(readability/namespace) */ \
   }  // namespace nlohmann
 #endif
 
diff --git a/vendor/rang/rang.h b/vendor/rang/rang.h
index 204ab1d..5d1c68e 100644
--- a/vendor/rang/rang.h
+++ b/vendor/rang/rang.h
@@ -17,14 +17,14 @@
 #elif defined(OS_WIN)
 
 #if defined(_WIN32_WINNT) && (_WIN32_WINNT < 0x0600)
-#error                                                                         \
-  "Please include rang.hpp before any windows system headers or set _WIN32_WINNT at least to _WIN32_WINNT_VISTA"
+#error \
+    "Please include rang.hpp before any windows system headers or set _WIN32_WINNT at least to _WIN32_WINNT_VISTA"
 #elif !defined(_WIN32_WINNT)
 #define _WIN32_WINNT _WIN32_WINNT_VISTA
 #endif
 
-#include <windows.h>
 #include <io.h>
+#include <windows.h>
 #include <memory>
 
 // Only defined in windows 10 onwards, redefining in lower windows since it
@@ -49,448 +49,413 @@ namespace rang {
  * Note that on Windows terminals bold style is same as fgB color.
  */
 enum class style {
-    reset     = 0,
-    bold      = 1,
-    dim       = 2,
-    italic    = 3,
-    underline = 4,
-    blink     = 5,
-    rblink    = 6,
-    reversed  = 7,
-    conceal   = 8,
-    crossed   = 9
+  reset     = 0,
+  bold      = 1,
+  dim       = 2,
+  italic    = 3,
+  underline = 4,
+  blink     = 5,
+  rblink    = 6,
+  reversed  = 7,
+  conceal   = 8,
+  crossed   = 9
 };
 
 enum class fg {
-    black   = 30,
-    red     = 31,
-    green   = 32,
-    yellow  = 33,
-    blue    = 34,
-    magenta = 35,
-    cyan    = 36,
-    gray    = 37,
-    reset   = 39
+  black   = 30,
+  red     = 31,
+  green   = 32,
+  yellow  = 33,
+  blue    = 34,
+  magenta = 35,
+  cyan    = 36,
+  gray    = 37,
+  reset   = 39
 };
 
 enum class bg {
-    black   = 40,
-    red     = 41,
-    green   = 42,
-    yellow  = 43,
-    blue    = 44,
-    magenta = 45,
-    cyan    = 46,
-    gray    = 47,
-    reset   = 49
+  black   = 40,
+  red     = 41,
+  green   = 42,
+  yellow  = 43,
+  blue    = 44,
+  magenta = 45,
+  cyan    = 46,
+  gray    = 47,
+  reset   = 49
 };
 
 enum class fgB {
-    black   = 90,
-    red     = 91,
-    green   = 92,
-    yellow  = 93,
-    blue    = 94,
-    magenta = 95,
-    cyan    = 96,
-    gray    = 97
+  black   = 90,
+  red     = 91,
+  green   = 92,
+  yellow  = 93,
+  blue    = 94,
+  magenta = 95,
+  cyan    = 96,
+  gray    = 97
 };
 
 enum class bgB {
-    black   = 100,
-    red     = 101,
-    green   = 102,
-    yellow  = 103,
-    blue    = 104,
-    magenta = 105,
-    cyan    = 106,
-    gray    = 107
+  black   = 100,
+  red     = 101,
+  green   = 102,
+  yellow  = 103,
+  blue    = 104,
+  magenta = 105,
+  cyan    = 106,
+  gray    = 107
 };
 
 enum class control {  // Behaviour of rang function calls
-    Off   = 0,  // toggle off rang style/color calls
-    Auto  = 1,  // (Default) autodect terminal and colorize if needed
-    Force = 2  // force ansi color output to non terminal streams
+  Off   = 0,          // toggle off rang style/color calls
+  Auto  = 1,          // (Default) autodect terminal and colorize if needed
+  Force = 2           // force ansi color output to non terminal streams
 };
 // Use rang::setControlMode to set rang control mode
 
 enum class winTerm {  // Windows Terminal Mode
-    Auto   = 0,  // (Default) automatically detects wheter Ansi or Native API
-    Ansi   = 1,  // Force use Ansi API
-    Native = 2  // Force use Native API
+  Auto   = 0,         // (Default) automatically detects wheter Ansi or Native API
+  Ansi   = 1,         // Force use Ansi API
+  Native = 2          // Force use Native API
 };
 // Use rang::setWinTermMode to explicitly set terminal API for Windows
 // Calling rang::setWinTermMode have no effect on other OS
 
 namespace rang_implementation {
 
-    inline std::atomic<control> &controlMode() noexcept
-    {
-        static std::atomic<control> value(control::Auto);
-        return value;
-    }
+  inline std::atomic<control>& controlMode() noexcept {
+    static std::atomic<control> value(control::Auto);
+    return value;
+  }
 
-    inline std::atomic<winTerm> &winTermMode() noexcept
-    {
-        static std::atomic<winTerm> termMode(winTerm::Auto);
-        return termMode;
-    }
+  inline std::atomic<winTerm>& winTermMode() noexcept {
+    static std::atomic<winTerm> termMode(winTerm::Auto);
+    return termMode;
+  }
 
-    inline bool supportsColor() noexcept
-    {
+  inline bool supportsColor() noexcept {
 #if defined(OS_LINUX) || defined(OS_MAC)
 
-        static const bool result = [] {
-            const char *Terms[]
-              = { "ansi",    "color",  "console", "cygwin", "gnome",
-                  "konsole", "kterm",  "linux",   "msys",   "putty",
-                  "rxvt",    "screen", "vt100",   "xterm" };
-
-            const char *env_p = std::getenv("TERM");
-            if (env_p == nullptr) {
-                return false;
-            }
-            return std::any_of(std::begin(Terms), std::end(Terms),
-                               [&](const char *term) {
-                                   return std::strstr(env_p, term) != nullptr;
-                               });
-        }();
+    static const bool result = [] {
+      const char* Terms[] = {"ansi",  "color", "console", "cygwin", "gnome",  "konsole", "kterm",
+                             "linux", "msys",  "putty",   "rxvt",   "screen", "vt100",   "xterm"};
+
+      const char* env_p = std::getenv("TERM");
+      if (env_p == nullptr) {
+        return false;
+      }
+      return std::any_of(std::begin(Terms), std::end(Terms),
+                         [&](const char* term) { return std::strstr(env_p, term) != nullptr; });
+    }();
 
 #elif defined(OS_WIN)
-        // All windows versions support colors through native console methods
-        static constexpr bool result = true;
+    // All windows versions support colors through native console methods
+    static constexpr bool result = true;
 #endif
-        return result;
-    }
+    return result;
+  }
 
 #ifdef OS_WIN
 
-
-    inline bool isMsysPty(int fd) noexcept
-    {
-        // Dynamic load for binary compability with old Windows
-        const auto ptrGetFileInformationByHandleEx
-          = reinterpret_cast<decltype(&GetFileInformationByHandleEx)>(
-            GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")),
-                           "GetFileInformationByHandleEx"));
-        if (!ptrGetFileInformationByHandleEx) {
-            return false;
-        }
-
-        HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
-        if (h == INVALID_HANDLE_VALUE) {
-            return false;
-        }
-
-        // Check that it's a pipe:
-        if (GetFileType(h) != FILE_TYPE_PIPE) {
-            return false;
-        }
-
-        // POD type is binary compatible with FILE_NAME_INFO from WinBase.h
-        // It have the same alignment and used to avoid UB in caller code
-        struct MY_FILE_NAME_INFO {
-            DWORD FileNameLength;
-            WCHAR FileName[MAX_PATH];
-        };
-
-        auto pNameInfo = std::unique_ptr<MY_FILE_NAME_INFO>(
-          new (std::nothrow) MY_FILE_NAME_INFO());
-        if (!pNameInfo) {
-            return false;
-        }
-
-        // Check pipe name is template of
-        // {"cygwin-","msys-"}XXXXXXXXXXXXXXX-ptyX-XX
-        if (!ptrGetFileInformationByHandleEx(h, FileNameInfo, pNameInfo.get(),
-                                             sizeof(MY_FILE_NAME_INFO))) {
-            return false;
-        }
-        std::wstring name(pNameInfo->FileName, pNameInfo->FileNameLength / sizeof(WCHAR));
-        if ((name.find(L"msys-") == std::wstring::npos
-             && name.find(L"cygwin-") == std::wstring::npos)
-            || name.find(L"-pty") == std::wstring::npos) {
-            return false;
-        }
-
-        return true;
+  inline bool isMsysPty(int fd) noexcept {
+    // Dynamic load for binary compability with old Windows
+    const auto ptrGetFileInformationByHandleEx =
+        reinterpret_cast<decltype(&GetFileInformationByHandleEx)>(
+            GetProcAddress(GetModuleHandle(TEXT("kernel32.dll")), "GetFileInformationByHandleEx"));
+    if (!ptrGetFileInformationByHandleEx) {
+      return false;
     }
 
-#endif
+    HANDLE h = reinterpret_cast<HANDLE>(_get_osfhandle(fd));
+    if (h == INVALID_HANDLE_VALUE) {
+      return false;
+    }
 
-    inline bool isTerminal(const std::streambuf *osbuf) noexcept
-    {
-        using std::cerr;
-        using std::clog;
-        using std::cout;
-#if defined(OS_LINUX) || defined(OS_MAC)
-        if (osbuf == cout.rdbuf()) {
-            static const bool cout_term = isatty(fileno(stdout)) != 0;
-            return cout_term;
-        } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
-            static const bool cerr_term = isatty(fileno(stderr)) != 0;
-            return cerr_term;
-        }
-#elif defined(OS_WIN)
-        if (osbuf == cout.rdbuf()) {
-            static const bool cout_term
-              = (_isatty(_fileno(stdout)) || isMsysPty(_fileno(stdout)));
-            return cout_term;
-        } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
-            static const bool cerr_term
-              = (_isatty(_fileno(stderr)) || isMsysPty(_fileno(stderr)));
-            return cerr_term;
-        }
-#endif
-        return false;
+    // Check that it's a pipe:
+    if (GetFileType(h) != FILE_TYPE_PIPE) {
+      return false;
     }
 
-    template <typename T>
-    using enableStd = typename std::enable_if<
-      std::is_same<T, rang::style>::value || std::is_same<T, rang::fg>::value
-        || std::is_same<T, rang::bg>::value || std::is_same<T, rang::fgB>::value
-        || std::is_same<T, rang::bgB>::value,
-      std::ostream &>::type;
+    // POD type is binary compatible with FILE_NAME_INFO from WinBase.h
+    // It have the same alignment and used to avoid UB in caller code
+    struct MY_FILE_NAME_INFO {
+      DWORD FileNameLength;
+      WCHAR FileName[MAX_PATH];
+    };
 
+    auto pNameInfo = std::unique_ptr<MY_FILE_NAME_INFO>(new (std::nothrow) MY_FILE_NAME_INFO());
+    if (!pNameInfo) {
+      return false;
+    }
 
-#ifdef OS_WIN
+    // Check pipe name is template of
+    // {"cygwin-","msys-"}XXXXXXXXXXXXXXX-ptyX-XX
+    if (!ptrGetFileInformationByHandleEx(h, FileNameInfo, pNameInfo.get(),
+                                         sizeof(MY_FILE_NAME_INFO))) {
+      return false;
+    }
+    std::wstring name(pNameInfo->FileName, pNameInfo->FileNameLength / sizeof(WCHAR));
+    if ((name.find(L"msys-") == std::wstring::npos &&
+         name.find(L"cygwin-") == std::wstring::npos) ||
+        name.find(L"-pty") == std::wstring::npos) {
+      return false;
+    }
 
-    struct SGR {  // Select Graphic Rendition parameters for Windows console
-        BYTE fgColor;  // foreground color (0-15) lower 3 rgb bits + intense bit
-        BYTE bgColor;  // background color (0-15) lower 3 rgb bits + intense bit
-        BYTE bold;  // emulated as FOREGROUND_INTENSITY bit
-        BYTE underline;  // emulated as BACKGROUND_INTENSITY bit
-        BOOLEAN inverse;  // swap foreground/bold & background/underline
-        BOOLEAN conceal;  // set foreground/bold to background/underline
-    };
+    return true;
+  }
 
-    enum class AttrColor : BYTE {  // Color attributes for console screen buffer
-        black   = 0,
-        red     = 4,
-        green   = 2,
-        yellow  = 6,
-        blue    = 1,
-        magenta = 5,
-        cyan    = 3,
-        gray    = 7
-    };
+#endif
 
-    inline HANDLE getConsoleHandle(const std::streambuf *osbuf) noexcept
-    {
-        if (osbuf == std::cout.rdbuf()) {
-            static const HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
-            return hStdout;
-        } else if (osbuf == std::cerr.rdbuf() || osbuf == std::clog.rdbuf()) {
-            static const HANDLE hStderr = GetStdHandle(STD_ERROR_HANDLE);
-            return hStderr;
-        }
-        return INVALID_HANDLE_VALUE;
+  inline bool isTerminal(const std::streambuf* osbuf) noexcept {
+    using std::cerr;
+    using std::clog;
+    using std::cout;
+#if defined(OS_LINUX) || defined(OS_MAC)
+    if (osbuf == cout.rdbuf()) {
+      static const bool cout_term = isatty(fileno(stdout)) != 0;
+      return cout_term;
+    } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
+      static const bool cerr_term = isatty(fileno(stderr)) != 0;
+      return cerr_term;
     }
-
-    inline bool setWinTermAnsiColors(const std::streambuf *osbuf) noexcept
-    {
-        HANDLE h = getConsoleHandle(osbuf);
-        if (h == INVALID_HANDLE_VALUE) {
-            return false;
-        }
-        DWORD dwMode = 0;
-        if (!GetConsoleMode(h, &dwMode)) {
-            return false;
-        }
-        dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
-        if (!SetConsoleMode(h, dwMode)) {
-            return false;
-        }
-        return true;
+#elif defined(OS_WIN)
+    if (osbuf == cout.rdbuf()) {
+      static const bool cout_term = (_isatty(_fileno(stdout)) || isMsysPty(_fileno(stdout)));
+      return cout_term;
+    } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
+      static const bool cerr_term = (_isatty(_fileno(stderr)) || isMsysPty(_fileno(stderr)));
+      return cerr_term;
     }
+#endif
+    return false;
+  }
 
-    inline bool supportsAnsi(const std::streambuf *osbuf) noexcept
-    {
-        using std::cerr;
-        using std::clog;
-        using std::cout;
-        if (osbuf == cout.rdbuf()) {
-            static const bool cout_ansi
-              = (isMsysPty(_fileno(stdout)) || setWinTermAnsiColors(osbuf));
-            return cout_ansi;
-        } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
-            static const bool cerr_ansi
-              = (isMsysPty(_fileno(stderr)) || setWinTermAnsiColors(osbuf));
-            return cerr_ansi;
-        }
-        return false;
-    }
+  template <typename T>
+  using enableStd = typename std::enable_if<
+      std::is_same<T, rang::style>::value || std::is_same<T, rang::fg>::value ||
+          std::is_same<T, rang::bg>::value || std::is_same<T, rang::fgB>::value ||
+          std::is_same<T, rang::bgB>::value,
+      std::ostream&>::type;
 
-    inline const SGR &defaultState() noexcept
-    {
-        static const SGR defaultSgr = []() -> SGR {
-            CONSOLE_SCREEN_BUFFER_INFO info;
-            WORD attrib = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
-            if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE),
-                                           &info)
-                || GetConsoleScreenBufferInfo(GetStdHandle(STD_ERROR_HANDLE),
-                                              &info)) {
-                attrib = info.wAttributes;
-            }
-            SGR sgr     = { 0, 0, 0, 0, FALSE, FALSE };
-            sgr.fgColor = attrib & 0x0F;
-            sgr.bgColor = (attrib & 0xF0) >> 4;
-            return sgr;
-        }();
-        return defaultSgr;
-    }
+#ifdef OS_WIN
 
-    inline BYTE ansi2attr(BYTE rgb) noexcept
-    {
-        static const AttrColor rev[8]
-          = { AttrColor::black,  AttrColor::red,  AttrColor::green,
-              AttrColor::yellow, AttrColor::blue, AttrColor::magenta,
-              AttrColor::cyan,   AttrColor::gray };
-        return static_cast<BYTE>(rev[rgb]);
+  struct SGR {          // Select Graphic Rendition parameters for Windows console
+    BYTE    fgColor;    // foreground color (0-15) lower 3 rgb bits + intense bit
+    BYTE    bgColor;    // background color (0-15) lower 3 rgb bits + intense bit
+    BYTE    bold;       // emulated as FOREGROUND_INTENSITY bit
+    BYTE    underline;  // emulated as BACKGROUND_INTENSITY bit
+    BOOLEAN inverse;    // swap foreground/bold & background/underline
+    BOOLEAN conceal;    // set foreground/bold to background/underline
+  };
+
+  enum class AttrColor : BYTE {  // Color attributes for console screen buffer
+    black   = 0,
+    red     = 4,
+    green   = 2,
+    yellow  = 6,
+    blue    = 1,
+    magenta = 5,
+    cyan    = 3,
+    gray    = 7
+  };
+
+  inline HANDLE getConsoleHandle(const std::streambuf* osbuf) noexcept {
+    if (osbuf == std::cout.rdbuf()) {
+      static const HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE);
+      return hStdout;
+    } else if (osbuf == std::cerr.rdbuf() || osbuf == std::clog.rdbuf()) {
+      static const HANDLE hStderr = GetStdHandle(STD_ERROR_HANDLE);
+      return hStderr;
     }
+    return INVALID_HANDLE_VALUE;
+  }
 
-    inline void setWinSGR(rang::bg col, SGR &state) noexcept
-    {
-        if (col != rang::bg::reset) {
-            state.bgColor = ansi2attr(static_cast<BYTE>(col) - 40);
-        } else {
-            state.bgColor = defaultState().bgColor;
-        }
+  inline bool setWinTermAnsiColors(const std::streambuf* osbuf) noexcept {
+    HANDLE h = getConsoleHandle(osbuf);
+    if (h == INVALID_HANDLE_VALUE) {
+      return false;
     }
-
-    inline void setWinSGR(rang::fg col, SGR &state) noexcept
-    {
-        if (col != rang::fg::reset) {
-            state.fgColor = ansi2attr(static_cast<BYTE>(col) - 30);
-        } else {
-            state.fgColor = defaultState().fgColor;
-        }
+    DWORD dwMode = 0;
+    if (!GetConsoleMode(h, &dwMode)) {
+      return false;
     }
-
-    inline void setWinSGR(rang::bgB col, SGR &state) noexcept
-    {
-        state.bgColor = (BACKGROUND_INTENSITY >> 4)
-          | ansi2attr(static_cast<BYTE>(col) - 100);
+    dwMode |= ENABLE_VIRTUAL_TERMINAL_PROCESSING;
+    if (!SetConsoleMode(h, dwMode)) {
+      return false;
     }
-
-    inline void setWinSGR(rang::fgB col, SGR &state) noexcept
-    {
-        state.fgColor
-          = FOREGROUND_INTENSITY | ansi2attr(static_cast<BYTE>(col) - 90);
+    return true;
+  }
+
+  inline bool supportsAnsi(const std::streambuf* osbuf) noexcept {
+    using std::cerr;
+    using std::clog;
+    using std::cout;
+    if (osbuf == cout.rdbuf()) {
+      static const bool cout_ansi = (isMsysPty(_fileno(stdout)) || setWinTermAnsiColors(osbuf));
+      return cout_ansi;
+    } else if (osbuf == cerr.rdbuf() || osbuf == clog.rdbuf()) {
+      static const bool cerr_ansi = (isMsysPty(_fileno(stderr)) || setWinTermAnsiColors(osbuf));
+      return cerr_ansi;
     }
-
-    inline void setWinSGR(rang::style style, SGR &state) noexcept
-    {
-        switch (style) {
-            case rang::style::reset: state = defaultState(); break;
-            case rang::style::bold: state.bold = FOREGROUND_INTENSITY; break;
-            case rang::style::underline:
-            case rang::style::blink:
-                state.underline = BACKGROUND_INTENSITY;
-                break;
-            case rang::style::reversed: state.inverse = TRUE; break;
-            case rang::style::conceal: state.conceal = TRUE; break;
-            default: break;
-        }
+    return false;
+  }
+
+  inline const SGR& defaultState() noexcept {
+    static const SGR defaultSgr = []() -> SGR {
+      CONSOLE_SCREEN_BUFFER_INFO info;
+      WORD                       attrib = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE;
+      if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &info) ||
+          GetConsoleScreenBufferInfo(GetStdHandle(STD_ERROR_HANDLE), &info)) {
+        attrib = info.wAttributes;
+      }
+      SGR sgr     = {0, 0, 0, 0, FALSE, FALSE};
+      sgr.fgColor = attrib & 0x0F;
+      sgr.bgColor = (attrib & 0xF0) >> 4;
+      return sgr;
+    }();
+    return defaultSgr;
+  }
+
+  inline BYTE ansi2attr(BYTE rgb) noexcept {
+    static const AttrColor rev[8] = {AttrColor::black,  AttrColor::red,  AttrColor::green,
+                                     AttrColor::yellow, AttrColor::blue, AttrColor::magenta,
+                                     AttrColor::cyan,   AttrColor::gray};
+    return static_cast<BYTE>(rev[rgb]);
+  }
+
+  inline void setWinSGR(rang::bg col, SGR& state) noexcept {
+    if (col != rang::bg::reset) {
+      state.bgColor = ansi2attr(static_cast<BYTE>(col) - 40);
+    } else {
+      state.bgColor = defaultState().bgColor;
     }
+  }
 
-    inline SGR &current_state() noexcept
-    {
-        static SGR state = defaultState();
-        return state;
+  inline void setWinSGR(rang::fg col, SGR& state) noexcept {
+    if (col != rang::fg::reset) {
+      state.fgColor = ansi2attr(static_cast<BYTE>(col) - 30);
+    } else {
+      state.fgColor = defaultState().fgColor;
     }
-
-    inline WORD SGR2Attr(const SGR &state) noexcept
-    {
-        WORD attrib = 0;
-        if (state.conceal) {
-            if (state.inverse) {
-                attrib = (state.fgColor << 4) | state.fgColor;
-                if (state.bold)
-                    attrib |= FOREGROUND_INTENSITY | BACKGROUND_INTENSITY;
-            } else {
-                attrib = (state.bgColor << 4) | state.bgColor;
-                if (state.underline)
-                    attrib |= FOREGROUND_INTENSITY | BACKGROUND_INTENSITY;
-            }
-        } else if (state.inverse) {
-            attrib = (state.fgColor << 4) | state.bgColor;
-            if (state.bold) attrib |= BACKGROUND_INTENSITY;
-            if (state.underline) attrib |= FOREGROUND_INTENSITY;
-        } else {
-            attrib = state.fgColor | (state.bgColor << 4) | state.bold
-              | state.underline;
-        }
-        return attrib;
+  }
+
+  inline void setWinSGR(rang::bgB col, SGR& state) noexcept {
+    state.bgColor = (BACKGROUND_INTENSITY >> 4) | ansi2attr(static_cast<BYTE>(col) - 100);
+  }
+
+  inline void setWinSGR(rang::fgB col, SGR& state) noexcept {
+    state.fgColor = FOREGROUND_INTENSITY | ansi2attr(static_cast<BYTE>(col) - 90);
+  }
+
+  inline void setWinSGR(rang::style style, SGR& state) noexcept {
+    switch (style) {
+      case rang::style::reset:
+        state = defaultState();
+        break;
+      case rang::style::bold:
+        state.bold = FOREGROUND_INTENSITY;
+        break;
+      case rang::style::underline:
+      case rang::style::blink:
+        state.underline = BACKGROUND_INTENSITY;
+        break;
+      case rang::style::reversed:
+        state.inverse = TRUE;
+        break;
+      case rang::style::conceal:
+        state.conceal = TRUE;
+        break;
+      default:
+        break;
     }
-
-    template <typename T>
-    inline void setWinColorAnsi(std::ostream &os, T const value)
-    {
-        os << "\033[" << static_cast<int>(value) << "m";
+  }
+
+  inline SGR& current_state() noexcept {
+    static SGR state = defaultState();
+    return state;
+  }
+
+  inline WORD SGR2Attr(const SGR& state) noexcept {
+    WORD attrib = 0;
+    if (state.conceal) {
+      if (state.inverse) {
+        attrib = (state.fgColor << 4) | state.fgColor;
+        if (state.bold) attrib |= FOREGROUND_INTENSITY | BACKGROUND_INTENSITY;
+      } else {
+        attrib = (state.bgColor << 4) | state.bgColor;
+        if (state.underline) attrib |= FOREGROUND_INTENSITY | BACKGROUND_INTENSITY;
+      }
+    } else if (state.inverse) {
+      attrib = (state.fgColor << 4) | state.bgColor;
+      if (state.bold) attrib |= BACKGROUND_INTENSITY;
+      if (state.underline) attrib |= FOREGROUND_INTENSITY;
+    } else {
+      attrib = state.fgColor | (state.bgColor << 4) | state.bold | state.underline;
     }
-
-    template <typename T>
-    inline void setWinColorNative(std::ostream &os, T const value)
-    {
-        const HANDLE h = getConsoleHandle(os.rdbuf());
-        if (h != INVALID_HANDLE_VALUE) {
-            setWinSGR(value, current_state());
-            // Out all buffered text to console with previous settings:
-            os.flush();
-            SetConsoleTextAttribute(h, SGR2Attr(current_state()));
-        }
+    return attrib;
+  }
+
+  template <typename T>
+  inline void setWinColorAnsi(std::ostream& os, T const value) {
+    os << "\033[" << static_cast<int>(value) << "m";
+  }
+
+  template <typename T>
+  inline void setWinColorNative(std::ostream& os, T const value) {
+    const HANDLE h = getConsoleHandle(os.rdbuf());
+    if (h != INVALID_HANDLE_VALUE) {
+      setWinSGR(value, current_state());
+      // Out all buffered text to console with previous settings:
+      os.flush();
+      SetConsoleTextAttribute(h, SGR2Attr(current_state()));
     }
-
-    template <typename T>
-    inline enableStd<T> setColor(std::ostream &os, T const value)
-    {
-        if (winTermMode() == winTerm::Auto) {
-            if (supportsAnsi(os.rdbuf())) {
-                setWinColorAnsi(os, value);
-            } else {
-                setWinColorNative(os, value);
-            }
-        } else if (winTermMode() == winTerm::Ansi) {
-            setWinColorAnsi(os, value);
-        } else {
-            setWinColorNative(os, value);
-        }
-        return os;
+  }
+
+  template <typename T>
+  inline enableStd<T> setColor(std::ostream& os, T const value) {
+    if (winTermMode() == winTerm::Auto) {
+      if (supportsAnsi(os.rdbuf())) {
+        setWinColorAnsi(os, value);
+      } else {
+        setWinColorNative(os, value);
+      }
+    } else if (winTermMode() == winTerm::Ansi) {
+      setWinColorAnsi(os, value);
+    } else {
+      setWinColorNative(os, value);
     }
+    return os;
+  }
 #else
-    template <typename T>
-    inline enableStd<T> setColor(std::ostream &os, T const value)
-    {
-        return os << "\033[" << static_cast<int>(value) << "m";
-    }
+  template <typename T>
+  inline enableStd<T> setColor(std::ostream& os, T const value) {
+    return os << "\033[" << static_cast<int>(value) << "m";
+  }
 #endif
 }  // namespace rang_implementation
 
 template <typename T>
-inline rang_implementation::enableStd<T> operator<<(std::ostream &os,
-                                                    const T value)
-{
-    const control option = rang_implementation::controlMode();
-    switch (option) {
-        case control::Auto:
-            return rang_implementation::supportsColor()
-                && rang_implementation::isTerminal(os.rdbuf())
-              ? rang_implementation::setColor(os, value)
-              : os;
-        case control::Force: return rang_implementation::setColor(os, value);
-        default: return os;
-    }
+inline rang_implementation::enableStd<T> operator<<(std::ostream& os, const T value) {
+  const control option = rang_implementation::controlMode();
+  switch (option) {
+    case control::Auto:
+      return rang_implementation::supportsColor() && rang_implementation::isTerminal(os.rdbuf())
+                 ? rang_implementation::setColor(os, value)
+                 : os;
+    case control::Force:
+      return rang_implementation::setColor(os, value);
+    default:
+      return os;
+  }
 }
 
-inline void setWinTermMode(const rang::winTerm value) noexcept
-{
-    rang_implementation::winTermMode() = value;
+inline void setWinTermMode(const rang::winTerm value) noexcept {
+  rang_implementation::winTermMode() = value;
 }
 
-inline void setControlMode(const control value) noexcept
-{
-    rang_implementation::controlMode() = value;
+inline void setControlMode(const control value) noexcept {
+  rang_implementation::controlMode() = value;
 }
 
 }  // namespace rang