From 1e8b22f34ce423b23d1b4c4ea59ed16aa29842d8 Mon Sep 17 00:00:00 2001
From: Amlal <amlal@nekernel.org>
Date: Thu, 1 May 2025 11:59:48 +0200
Subject: tooling, fs: Improve tooling and clean up HeFS filesystem code.

Signed-off-by: Amlal <amlal@nekernel.org>
---
 dev/boot/BootKit/BootKit.h        |   1 +
 dev/boot/src/HEL/AMD64/BootEFI.cc |  17 +-
 dev/kernel/src/FS/HeFS.cc         |   9 -
 tooling/mk_fwrk.py                |  16 +-
 tooling/mk_img.py                 |   6 +-
 tooling/mkfs.h                    |  36 +++
 tooling/mkfs.hefs.cc              |  62 ++---
 tooling/rang.h                    | 502 ++++++++++++++++++++++++++++++++++++++
 8 files changed, 586 insertions(+), 63 deletions(-)
 create mode 100644 tooling/mkfs.h
 create mode 100644 tooling/rang.h

diff --git a/dev/boot/BootKit/BootKit.h b/dev/boot/BootKit/BootKit.h
index 5f4a65c4..3f871b9a 100644
--- a/dev/boot/BootKit/BootKit.h
+++ b/dev/boot/BootKit/BootKit.h
@@ -148,6 +148,7 @@ class BootFileReader final {
 
 typedef UInt8* BlobType;
 
+/// @brief Bootloader Version String.
 class BVersionString final {
  public:
   static const CharacterTypeUTF8* The() { return BOOTLOADER_VERSION; }
diff --git a/dev/boot/src/HEL/AMD64/BootEFI.cc b/dev/boot/src/HEL/AMD64/BootEFI.cc
index ffc3c692..260d7c00 100644
--- a/dev/boot/src/HEL/AMD64/BootEFI.cc
+++ b/dev/boot/src/HEL/AMD64/BootEFI.cc
@@ -199,15 +199,15 @@ EFI_EXTERN_C EFI_API Int32 BootloaderMain(EfiHandlePtr image_handle, EfiSystemTa
   // Assign to global 'kHandoverHeader'.
 
   WideChar kernel_path[256U] = L"krnl.efi";
-  UInt32   kernel_path_sz    = 256U;
+  UInt32   kernel_path_sz    = StrLen("krnl.efi");
 
-  if (ST->RuntimeServices->GetVariable(L"/props/boot_path", kEfiGlobalNamespaceVarGUID, nullptr,
+  if (ST->RuntimeServices->GetVariable(L"/props/kernel_path", kEfiGlobalNamespaceVarGUID, nullptr,
                                        &kernel_path_sz, kernel_path) != kEfiOk) {
     /// access attributes (in order)
     /// EFI_VARIABLE_NON_VOLATILE | EFI_VARIABLE_BOOTSERVICE_ACCESS | EFI_VARIABLE_RUNTIME_ACCESS
     UInt32 attr = 0x00000001 | 0x00000002 | 0x00000004;
 
-    ST->RuntimeServices->SetVariable(L"/props/boot_path", kEfiGlobalNamespaceVarGUID, &attr,
+    ST->RuntimeServices->SetVariable(L"/props/kernel_path", kEfiGlobalNamespaceVarGUID, &attr,
                                      &kernel_path_sz, kernel_path);
   }
 
@@ -217,17 +217,18 @@ EFI_EXTERN_C EFI_API Int32 BootloaderMain(EfiHandlePtr image_handle, EfiSystemTa
   ST->RuntimeServices->GetVariable(L"/props/kern_ver", kEfiGlobalNamespaceVarGUID, nullptr, &sz_ver,
                                    &ver);
 
-  if (ver != KERNEL_VERSION_BCD) {
+  if (ver < KERNEL_VERSION_BCD) {
     ver = KERNEL_VERSION_BCD;
 
     ST->RuntimeServices->SetVariable(L"/props/kern_ver", kEfiGlobalNamespaceVarGUID, nullptr,
                                      &sz_ver, &ver);
-    writer.Write("BootZ: version has been updated: ").Write(ver).Write("\r");
-  }
 
-  writer.Write("BootZ: version: ").Write(ver).Write("\r");
+    writer.Write("BootZ: Version has been updated: ").Write(ver).Write("\r");
+  } else {
+    writer.Write("BootZ: Version: ").Write(ver).Write("\r");
+  }
 
-  // boot to kernel, if not netboot this.
+  // boot to kernel, if not bootnet this.
 
   Boot::BootFileReader reader_kernel(kernel_path, image_handle);
 
diff --git a/dev/kernel/src/FS/HeFS.cc b/dev/kernel/src/FS/HeFS.cc
index 2f5bb55d..89415ee5 100644
--- a/dev/kernel/src/FS/HeFS.cc
+++ b/dev/kernel/src/FS/HeFS.cc
@@ -825,8 +825,6 @@ _Output Bool HeFileSystemParser::CreateDirectory(_Input DriveTrait* drive, _Inpu
                                                  const Utf8Char* dir) {
   HEFS_BOOT_NODE* root = (HEFS_BOOT_NODE*) mm_new_heap(sizeof(HEFS_BOOT_NODE), Yes, No);
 
-  kout << "CreateDirectory...\r";
-
   rt_copy_memory((VoidPtr) "fs/hefs-packet", drive->fPacket.fPacketMime,
                  rt_string_len("fs/hefs-packet"));
 
@@ -870,16 +868,9 @@ _Output Bool HeFileSystemParser::CreateDirectory(_Input DriveTrait* drive, _Inpu
 /// @return If it was sucessful, see err_local_get().
 _Output Bool HeFileSystemParser::CreateFile(_Input DriveTrait* drive, _Input const Int32 flags,
                                             const Utf8Char* dir, const Utf8Char* name) {
-  NE_UNUSED(drive);
-  NE_UNUSED(flags);
-  NE_UNUSED(dir);
-  NE_UNUSED(name);
-
   HEFS_INDEX_NODE* node = (HEFS_INDEX_NODE*) RTL_ALLOCA(sizeof(HEFS_INDEX_NODE));
   HEFS_BOOT_NODE*  root = (HEFS_BOOT_NODE*) RTL_ALLOCA(sizeof(HEFS_BOOT_NODE));
 
-  kout << "CreateFile...\r";
-
   rt_copy_memory((VoidPtr) "fs/hefs-packet", drive->fPacket.fPacketMime,
                  rt_string_len("fs/hefs-packet"));
 
diff --git a/tooling/mk_fwrk.py b/tooling/mk_fwrk.py
index 5f519237..e0302754 100755
--- a/tooling/mk_fwrk.py
+++ b/tooling/mk_fwrk.py
@@ -9,6 +9,9 @@ def create_directory_structure(base_path, project_name):
     # Define the directory structure
     structure = {
         project_name: {
+            "dist": {
+                ".keep": None
+            },
             "src": {
                 ".keep": None
             },
@@ -39,7 +42,7 @@ def create_directory_structure(base_path, project_name):
     # Create the JSON file
     diutil_json_path = os.path.join(base_path, project_name, f"{project_name}.json")
     manifest = {
-        "compiler_path": "g++",
+        "compiler_path": "clang++",
         "compiler_std": "c++20",
         "headers_path": ["./", "../../../dev/kernel", "../../../public/frameworks/", "../../../dev/", "./"],
         "sources_path": [
@@ -47,9 +50,9 @@ def create_directory_structure(base_path, project_name):
         ],
         "output_name": f"./dist/{project_name}",
         "cpp_macros": [
-            "kSampleVersion=0x0100",
-            "kSampleVersionHighest=0x0100",
-            "kSampleVersionLowest=0x0100",
+            "kSampleFWVersion=0x0100",
+            "kSampleFWVersionHighest=0x0100",
+            "kSampleFWVersionLowest=0x0100",
             "__NE_SDK__"
         ]
     }
@@ -60,8 +63,9 @@ def create_directory_structure(base_path, project_name):
 if __name__ == "__main__":
     if len(sys.argv) != 2:
         print("Usage: mk_fwrk.py <project_name>")
-        sys.exit(1)
+        sys.exit(os.EX_CONFIG)
 
     base_path = os.getcwd()  # Use the current working directory as the base path
     create_directory_structure(base_path, sys.argv[1])
-    print("Ne application created successfully.")
\ No newline at end of file
+    
+    print("NeKernel framework created successfully.")
diff --git a/tooling/mk_img.py b/tooling/mk_img.py
index 4a663bc0..8227a217 100755
--- a/tooling/mk_img.py
+++ b/tooling/mk_img.py
@@ -33,7 +33,7 @@ def copy_to_fat(image_path, source_dir):
         print(f"Error: mcopy failed with error code {e.returncode}.")
         sys.exit(1)
     except Exception as e:
-        print(f"Error: mcopy: {e}")
+        print(f"Error: failed: {e}")
         sys.exit(1)
 
 if __name__ == "__main__":
@@ -44,4 +44,6 @@ if __name__ == "__main__":
     image_path = sys.argv[1]
     source_dir = sys.argv[2]
 
-    copy_to_fat(image_path, source_dir)
\ No newline at end of file
+    copy_to_fat(image_path, source_dir)
+
+    print("NeKernel image created successfully.")
diff --git a/tooling/mkfs.h b/tooling/mkfs.h
new file mode 100644
index 00000000..650261db
--- /dev/null
+++ b/tooling/mkfs.h
@@ -0,0 +1,36 @@
+/* -------------------------------------------
+
+  Copyright (C) 2025, Amlal El Mahrouss, all rights reserved.
+
+------------------------------------------- */
+
+#pragma once
+
+#include <iostream>
+#include <string>
+#include <tooling/rang.h>
+
+/// @internal
+namespace mkfs {
+/// @brief Helper function to get the option value from command line arguments.
+template <typename CharType>
+inline std::basic_string<CharType> get_option(const std::basic_string<CharType>& args,
+                                              const std::basic_string<CharType>& option) {
+  size_t pos = args.find(option + CharType('='));
+
+  if (pos != std::string::npos) {
+    size_t start = pos + option.length() + 1;
+    size_t end   = args.find(' ', start);
+    return args.substr(start, end - start);
+  }
+
+  return std::basic_string<CharType>{};
+}
+
+inline auto console_out() -> std::ostream& {
+    std::ostream& conout = std::cout;
+    conout << rang::fg::red << "mkfs: " << rang::style::reset;
+
+    return conout;
+}
+}  // namespace mkfs
\ No newline at end of file
diff --git a/tooling/mkfs.hefs.cc b/tooling/mkfs.hefs.cc
index f19f1571..d9928858 100644
--- a/tooling/mkfs.hefs.cc
+++ b/tooling/mkfs.hefs.cc
@@ -5,28 +5,9 @@
 ------------------------------------------- */
 
 #include <tooling/hefs.h>
+#include <tooling/mkfs.h>
 #include <cstdlib>
 #include <fstream>
-#include <iostream>
-#include <string>
-
-/// @internal
-namespace mkfs::detail {
-/// @brief Helper function to get the option value from command line arguments.
-template <typename CharType>
-static std::basic_string<CharType> get_option(const std::basic_string<CharType>& args,
-                                              const std::basic_string<CharType>& option) {
-  size_t pos = args.find(option + CharType('='));
-
-  if (pos != std::string::npos) {
-    size_t start = pos + option.length() + 1;
-    size_t end   = args.find(' ', start);
-    return args.substr(start, end - start);
-  }
-
-  return std::basic_string<CharType>{};
-}
-}  // namespace mkfs::detail
 
 static size_t        kDiskSize   = 1024 * 1024 * 1024 * 4UL;
 static uint16_t      kVersion    = kHeFSVersion;
@@ -35,10 +16,11 @@ static size_t        kSectorSize = 512;
 
 int main(int argc, char** argv) {
   if (argc < 2) {
-    std::cerr << "mkfs.hefs: Error: Missing required arguments." << std::endl;
-    std::cerr << "mkfs.hefs: Usage: mkfs.hefs -L <label> -s <sector_size> -p <part_start> -e "
-                 "<part_end> -S <disk_size> -o <output_device>"
-              << std::endl;
+    mkfs::console_out() << 
+        "hefs: Usage: mkfs.hefs -L <label> -s <sector_size> -p <part_start> -e " <<
+        "<part_end> -S <disk_size> -o <output_device>"
+        << std::endl;
+
     return EXIT_FAILURE;
   }
 
@@ -58,18 +40,19 @@ int main(int argc, char** argv) {
     args_wide += u8" ";
   }
 
-  auto output_device = mkfs::detail::get_option<char>(args, "-o");
+  auto output_device = mkfs::get_option<char>(args, "-o");
 
-  kSectorSize = std::strtol(mkfs::detail::get_option<char>(args, "-s").data(), nullptr, 10);
-  kLabel      = mkfs::detail::get_option<char8_t>(args_wide, u8"-L");
+  kSectorSize = std::strtol(mkfs::get_option<char>(args, "-s").data(), nullptr, 10);
+  kLabel      = mkfs::get_option<char8_t>(args_wide, u8"-L");
 
   if (kLabel.empty()) kLabel = kHeFSDefaultVoluneName;
 
-  kDiskSize = std::strtol(mkfs::detail::get_option<char>(args, "-S").data(), nullptr, 10) * 1024 *
-              1024 * 1024;
+  kDiskSize =
+      std::strtol(mkfs::get_option<char>(args, "-S").data(), nullptr, 10) * 1024 * 1024 * 1024;
 
   if (kDiskSize == 0) {
-    std::cerr << "mkfs.hefs: Error: Invalid size specified." << std::endl;
+    mkfs::console_out() << "hefs: Error: Unable to deduce future disk size for output_device: " << output_device
+    << std::endl;
     return EXIT_FAILURE;
   }
 
@@ -77,17 +60,19 @@ int main(int argc, char** argv) {
   std::ofstream filesystem(output_device, std::ios::binary);
 
   if (!filesystem.good()) {
-    std::cerr << "mkfs.hefs: Error: Unable to open output_device " << output_device << std::endl;
+    mkfs::console_out() << "hefs: Info: Unable to open output_device: " << output_device
+    << std::endl;
     return EXIT_FAILURE;
   }
 
   // create a boot node, and then allocate a index node directory tree.
   mkfs::hefs::BootNode bootNode{{}, {}, 0, 0, 0, 0, 0, 0, 0, 0};
 
-  auto start_ind = std::strtol(mkfs::detail::get_option<char>(args, "-p").data(), nullptr, 10);
+  auto start_ind = std::strtol(mkfs::get_option<char>(args, "-p").data(), nullptr, 10);
+
   start_ind += sizeof(mkfs::hefs::BootNode);
 
-  auto end_ind = std::strtol(mkfs::detail::get_option<char>(args, "-e").data(), nullptr, 10);
+  auto end_ind = std::strtol(mkfs::get_option<char>(args, "-e").data(), nullptr, 10);
 
   bootNode.version    = kVersion;
   bootNode.diskKind   = mkfs::hefs::kHeFSHardDrive;
@@ -102,13 +87,13 @@ int main(int argc, char** argv) {
   std::memcpy(bootNode.magic, kHeFSMagic, kHeFSMagicLen - 1);
   std::memcpy(bootNode.volumeName, kLabel.data(), kLabel.size() * sizeof(char16_t));
 
-  filesystem.seekp(std::strtol(mkfs::detail::get_option<char>(args, "-p").data(), nullptr, 10));
+  filesystem.seekp(std::strtol(mkfs::get_option<char>(args, "-p").data(), nullptr, 10));
   filesystem.write(reinterpret_cast<const char*>(&bootNode), sizeof(mkfs::hefs::BootNode));
 
   if (!filesystem.good()) {
-    std::cerr << "mkfs.hefs: Error: Unable to write to output_device " << output_device
-              << std::endl;
-    return 1;
+    mkfs::console_out() << "hefs: Error: Unable to write FS to output_device: " << output_device
+                      << std::endl;
+    return EXIT_FAILURE;
   }
 
   filesystem.seekp(bootNode.startIND);
@@ -116,7 +101,8 @@ int main(int argc, char** argv) {
   filesystem.flush();
   filesystem.close();
 
-  std::cout << "mkfs.hefs: HeFS filesystem created in output_device " << output_device << std::endl;
+  mkfs::console_out() << "hefs: Info: Wrote FS to output_device: " << output_device
+  << std::endl;
 
   return EXIT_SUCCESS;
 }
\ No newline at end of file
diff --git a/tooling/rang.h b/tooling/rang.h
new file mode 100644
index 00000000..204ab1dc
--- /dev/null
+++ b/tooling/rang.h
@@ -0,0 +1,502 @@
+#ifndef RANG_DOT_HPP
+#define RANG_DOT_HPP
+
+#if defined(__unix__) || defined(__unix) || defined(__linux__)
+#define OS_LINUX
+#elif defined(WIN32) || defined(_WIN32) || defined(_WIN64)
+#define OS_WIN
+#elif defined(__APPLE__) || defined(__MACH__)
+#define OS_MAC
+#else
+#error Unknown Platform
+#endif
+
+#if defined(OS_LINUX) || defined(OS_MAC)
+#include <unistd.h>
+
+#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"
+#elif !defined(_WIN32_WINNT)
+#define _WIN32_WINNT _WIN32_WINNT_VISTA
+#endif
+
+#include <windows.h>
+#include <io.h>
+#include <memory>
+
+// Only defined in windows 10 onwards, redefining in lower windows since it
+// doesn't gets used in lower versions
+// https://docs.microsoft.com/en-us/windows/console/getconsolemode
+#ifndef ENABLE_VIRTUAL_TERMINAL_PROCESSING
+#define ENABLE_VIRTUAL_TERMINAL_PROCESSING 0x0004
+#endif
+
+#endif
+
+#include <algorithm>
+#include <atomic>
+#include <cstdlib>
+#include <cstring>
+#include <iostream>
+
+namespace rang {
+
+/* For better compability with most of terminals do not use any style settings
+ * except of reset, bold and reversed.
+ * 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
+};
+
+enum class fg {
+    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
+};
+
+enum class fgB {
+    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
+};
+
+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
+};
+// 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
+};
+// 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<winTerm> &winTermMode() noexcept
+    {
+        static std::atomic<winTerm> termMode(winTerm::Auto);
+        return termMode;
+    }
+
+    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;
+                               });
+        }();
+
+#elif defined(OS_WIN)
+        // All windows versions support colors through native console methods
+        static constexpr bool result = true;
+#endif
+        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;
+    }
+
+#endif
+
+    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;
+    }
+
+    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;
+
+
+#ifdef OS_WIN
+
+    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 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;
+    }
+
+    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;
+    }
+
+    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 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 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;
+        }
+    }
+
+    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;
+        }
+        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;
+    }
+#else
+    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 void setWinTermMode(const rang::winTerm value) noexcept
+{
+    rang_implementation::winTermMode() = value;
+}
+
+inline void setControlMode(const control value) noexcept
+{
+    rang_implementation::controlMode() = value;
+}
+
+}  // namespace rang
+
+#undef OS_LINUX
+#undef OS_WIN
+#undef OS_MAC
+
+#endif /* ifndef RANG_DOT_HPP */
\ No newline at end of file
-- 
cgit v1.2.3