[FEAT] Frontend: Add `try` syntax, frontend nsan (Nectar Sanitizer) checks added. And installer updates.

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

6 files changed, 15 insertions, 928 deletions

diff --git a/src/CompilerKit/src/Frontends/NectarCompiler+AMD64.cpp b/src/CompilerKit/src/Frontends/NectarCompiler+AMD64.cpp
index 5936e27..742575b 100644
--- a/src/CompilerKit/src/Frontends/NectarCompiler+AMD64.cpp
+++ b/src/CompilerKit/src/Frontends/NectarCompiler+AMD64.cpp
@@ -675,6 +675,9 @@ CompilerKit::SyntaxLeafList::SyntaxLeaf CompilerFrontendNectarAMD64::Compile(
           arg += ch;
         }
 
+        if (keyword.first.fKeywordKind == CompilerKit::KeywordKind::kKeywordKindAccessChecked)
+          syntax_tree.fUserValue += "call __nsan__begin\n";
+
         if (!nectar_get_variable_ref(nameVar).empty()) {
           if (!kNasmOutput) {
             syntax_tree.fUserValue += buf;
@@ -706,6 +709,9 @@ CompilerKit::SyntaxLeafList::SyntaxLeaf CompilerFrontendNectarAMD64::Compile(
           res += syntax_rem_buffer;
 
           syntax_tree.fUserValue += res;
+
+          if (keyword.first.fKeywordKind == CompilerKit::KeywordKind::kKeywordKindAccessChecked)
+            syntax_tree.fUserValue += "call __nsan_end\n";
         }
 
         break;
diff --git a/src/CompilerKit/src/Frontends/NectarCompiler+PTX.cpp b/src/CompilerKit/src/Frontends/NectarCompiler+PTX.cpp
index 1584661..7edc493 100644
--- a/src/CompilerKit/src/Frontends/NectarCompiler+PTX.cpp
+++ b/src/CompilerKit/src/Frontends/NectarCompiler+PTX.cpp
@@ -1623,8 +1623,7 @@ NECTAR_MODULE(CompilerNectarPTX) {
         continue;
       }
 
-      if (strcmp(argv[index], "--help") == 0 || 
-        strcmp(argv[index], "-h") == 0) {
+      if (strcmp(argv[index], "--help") == 0 || strcmp(argv[index], "-h") == 0) {
         std::cout << "====================================================\n";
         std::cout << "NECTAR PTX FRONTEND:\n";
         std::cout << "====================================================\n";
diff --git a/src/CompilerKit/src/Generators/DynamicLinker64+MachO.cpp b/src/CompilerKit/src/Generators/DynamicLinker64+MachO.cpp
index 42f5112..72c8284 100644
--- a/src/CompilerKit/src/Generators/DynamicLinker64+MachO.cpp
+++ b/src/CompilerKit/src/Generators/DynamicLinker64+MachO.cpp
@@ -29,10 +29,7 @@
 
 #define kLinkerSplash() kStdOut << kLinkerVersionStr << kStdEndl
 
-#define kConsoleOut        \
-  (std::cout << kRed \
-             << "ld: "  \
-             << kReset)
+#define kConsoleOut (std::cout << kRed << "ld: " << kReset)
 
 static CompilerKit::STLString kOutput              = kMachODefaultOutput;
 static cpu_type_t             kCpuType             = CPU_TYPE_X86_64;
@@ -132,8 +129,7 @@ NECTAR_MODULE(DynamicLinker64MachO) {
    * @brief parse flags and trigger options.
    */
   for (size_t linker_arg{1}; linker_arg < argc; ++linker_arg) {
-    if (std::strcmp(argv[linker_arg], "--help") == 0 ||
-   std::strcmp(argv[linker_arg], "-h") == 0) {
+    if (std::strcmp(argv[linker_arg], "--help") == 0 || std::strcmp(argv[linker_arg], "-h") == 0) {
       kLinkerSplash();
 
       kConsoleOut << "--version: Show linker version.\n";
@@ -148,7 +144,7 @@ NECTAR_MODULE(DynamicLinker64MachO) {
 
       return NECTAR_SUCCESS;
     } else if (std::strcmp(argv[linker_arg], "--version") == 0 ||
-  std::strcmp(argv[linker_arg], "-v") == 0) {
+               std::strcmp(argv[linker_arg], "-v") == 0) {
       kLinkerSplash();
 
       return NECTAR_SUCCESS;
diff --git a/src/CompilerKit/src/Generators/DynamicLinker64+PEF.cpp b/src/CompilerKit/src/Generators/DynamicLinker64+PEF.cpp
index 650b4ab..b3a152a 100644
--- a/src/CompilerKit/src/Generators/DynamicLinker64+PEF.cpp
+++ b/src/CompilerKit/src/Generators/DynamicLinker64+PEF.cpp
@@ -37,10 +37,7 @@
 /// @brief PEF stack size symbol.
 #define kLinkerStackSizeSymbol "__PEFSizeOfReserveStack"
 
-#define kConsoleOut        \
-  (std::cout << kRed \
-             << "ld: "  \
-             << kReset)
+#define kConsoleOut (std::cout << kRed << "ld: " << kReset)
 
 enum struct ABIType : Int32 {
   kABITypeNull    = 0,
@@ -79,8 +76,7 @@ NECTAR_MODULE(DynamicLinker64PEF) {
    * @brief parse flags and trigger options.
    */
   for (size_t linker_arg = 1; linker_arg < argc; ++linker_arg) {
-    if (std::strcmp(argv[linker_arg], "--help") == 0 ||
-  std::strcmp(argv[linker_arg], "-h") == 0) {
+    if (std::strcmp(argv[linker_arg], "--help") == 0 || std::strcmp(argv[linker_arg], "-h") == 0) {
       kLinkerSplash();
 
       kConsoleOut << "--version: Show linker version.\n";
@@ -98,7 +94,7 @@ NECTAR_MODULE(DynamicLinker64PEF) {
 
       return NECTAR_SUCCESS;
     } else if (std::strcmp(argv[linker_arg], "--version") == 0 ||
-  std::strcmp(argv[linker_arg], "-v") == 0) {
+               std::strcmp(argv[linker_arg], "-v") == 0) {
       kLinkerSplash();
 
       return NECTAR_SUCCESS;
diff --git a/src/CompilerKit/src/Preprocess/Preprocessor+Generic.cpp b/src/CompilerKit/src/Preprocess/Preprocessor+Generic.cpp
deleted file mode 100644
index 555ea8b..0000000
--- a/src/CompilerKit/src/Preprocess/Preprocessor+Generic.cpp
+++ /dev/null
@@ -1,910 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-// Copyright 2024-2026, Amlal El Mahrouss (amlal@nekernel.org)
-// Licensed under the Apache License, Version 2.0 (See accompanying
-// file LICENSE or copy at http://www.apache.org/licenses/LICENSE-2.0)
-// Official repository: https://github.com/ne-foss-org/nectar
-
-/// BUGS: 0
-
-#include <CompilerKit/AST.h>
-#include <CompilerKit/ErrorID.h>
-#include <algorithm>
-#include <filesystem>
-#include <fstream>
-#include <iostream>
-#include <stdexcept>
-#include <vector>
-
-#define kMacroPrefix '#'
-
-/// @author Amlal El Mahrouss (amlal@nekernel.org)
-/// @file Preprocessor+Generic.cpp
-/// @brief Nectar Preprocessor.
-
-using pp_parser_fn_t = Int32 (*)(CompilerKit::STLString&, std::ifstream&, std::ofstream&);
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-// @brief Preprocessor internal types.
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-namespace Detail {
-enum PPOperatorType : Int32 {
-  kInvalid = 0,
-  kEqual   = 100,
-  kGreaterEqThan,
-  kLesserEqThan,
-  kGreaterThan,
-  kLesserThan,
-  kNotEqual,
-  kCount = 6,
-};
-
-struct pp_macro_condition final {
-  int32_t                fType;
-  CompilerKit::STLString fTypeName;
-
-  void Print() {
-    std::cout << "type: " << fType << "\n";
-    std::cout << "type_name: " << fTypeName << "\n";
-  }
-};
-
-struct pp_macro final {
-  std::vector<CompilerKit::STLString> fArgs;
-  CompilerKit::STLString              fName;
-  CompilerKit::STLString              fValue;
-
-  void Print() {
-    std::cout << "name: " << fName << "\n";
-    std::cout << "value: " << fValue << "\n";
-
-    for (auto& arg : fArgs) {
-      std::cout << "arg: " << arg << "\n";
-    }
-  }
-};
-}  // namespace Detail
-
-static std::vector<CompilerKit::STLString> kFiles;
-static std::vector<Detail::pp_macro>       kMacros;
-static std::vector<CompilerKit::STLString> kIncludes;
-
-static CompilerKit::STLString kWorkingDir = "";
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-// @name pp_parse_if_condition
-// @brief parse #if condition
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-int32_t pp_parse_if_condition(Detail::pp_macro_condition& cond, Detail::pp_macro& macro,
-                              bool& inactive_code, bool& defined,
-                              CompilerKit::STLString& macro_str) {
-  if (cond.fType == Detail::PPOperatorType::kEqual) {
-    auto pos = macro_str.find(macro.fName);
-    if (pos == CompilerKit::STLString::npos) return 0;
-
-    auto substr_macro = macro_str.substr(pos + macro.fName.size());
-
-    if (substr_macro.find(macro.fValue) != CompilerKit::STLString::npos) {
-      if (macro.fValue == "0") {
-        defined       = false;
-        inactive_code = true;
-
-        return 1;
-      }
-
-      defined       = true;
-      inactive_code = false;
-
-      return 1;
-    }
-  } else if (cond.fType == Detail::kNotEqual) {
-    auto pos = macro_str.find(macro.fName);
-    if (pos == CompilerKit::STLString::npos) return 0;
-
-    auto substr_macro = macro_str.substr(pos + macro.fName.size());
-
-    if (substr_macro.find(macro.fName) != CompilerKit::STLString::npos) {
-      if (substr_macro.find(macro.fValue) != CompilerKit::STLString::npos) {
-        defined       = false;
-        inactive_code = true;
-
-        return 1;
-      }
-
-      defined       = true;
-      inactive_code = false;
-
-      return 1;
-    }
-
-    return 0;
-  }
-
-  auto pos = macro_str.find(macro.fName);
-  if (pos == CompilerKit::STLString::npos) return 0;
-
-  auto substr_macro = macro_str.substr(pos + macro.fName.size());
-
-  CompilerKit::STLString number;
-
-  for (auto& macro_num : kMacros) {
-    if (substr_macro.find(macro_num.fName) != CompilerKit::STLString::npos) {
-      for (size_t i = 0; i < macro_num.fValue.size(); ++i) {
-        if (isdigit(macro_num.fValue[i])) {
-          number += macro_num.fValue[i];
-        } else {
-          number.clear();
-          break;
-        }
-      }
-
-      break;
-    }
-  }
-
-  size_t y = 2;
-
-  /* last try */
-  for (; y < macro_str.size(); y++) {
-    if (isdigit(macro_str[y])) {
-      for (size_t x = y; x < macro_str.size(); x++) {
-        if (macro_str[x] == ' ') break;
-
-        number += macro_str[x];
-      }
-
-      break;
-    }
-  }
-
-  size_t rhs = atol(macro.fValue.c_str());
-  size_t lhs = atol(number.c_str());
-
-  if (lhs == 0) {
-    number.clear();
-    ++y;
-
-    for (; y < macro_str.size(); y++) {
-      if (isdigit(macro_str[y])) {
-        for (size_t x = y; x < macro_str.size(); x++) {
-          if (macro_str[x] == ' ') break;
-
-          number += macro_str[x];
-        }
-
-        break;
-      }
-    }
-
-    lhs = atol(number.c_str());
-  }
-
-  if (cond.fType == Detail::PPOperatorType::kGreaterThan) {
-    if (lhs > rhs) {
-      defined       = true;
-      inactive_code = false;
-
-      return 1;
-    }
-
-    return 0;
-  }
-
-  if (cond.fType == Detail::PPOperatorType::kGreaterEqThan) {
-    if (lhs >= rhs) {
-      defined       = true;
-      inactive_code = false;
-
-      return 1;
-    }
-
-    return 0;
-  }
-
-  if (cond.fType == Detail::PPOperatorType::kLesserEqThan) {
-    if (lhs <= rhs) {
-      defined       = true;
-      inactive_code = false;
-
-      return 1;
-    }
-
-    return 0;
-  }
-
-  if (cond.fType == Detail::PPOperatorType::kLesserThan) {
-    if (lhs < rhs) {
-      defined       = true;
-      inactive_code = false;
-
-      return 1;
-    }
-
-    return 0;
-  }
-
-  return 0;
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-// @brief stores every included file here.
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-std::vector<CompilerKit::STLString> kAllIncludes;
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-// @name pp_parse_file
-// @brief parse file to preprocess it.
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-void pp_parse_file(std::ifstream& hdr_file, std::ofstream& pp_out) {
-  CompilerKit::STLString hdr_line;
-  CompilerKit::STLString line_after_include;
-
-  bool inactive_code = false;
-  bool defined       = false;
-
-  try {
-    while (std::getline(hdr_file, hdr_line)) {
-      if (inactive_code) {
-        if (hdr_line.find("#endif") == CompilerKit::STLString::npos) {
-          continue;
-        } else if (hdr_line[0] == '#' && hdr_line.find("#endif") != CompilerKit::STLString::npos) {
-          inactive_code = false;
-        }
-      }
-
-      if (hdr_line.find("*/") != CompilerKit::STLString::npos) {
-        hdr_line.erase(hdr_line.find("*/"), strlen("*/"));
-      }
-
-      if (hdr_line.find("/*") != CompilerKit::STLString::npos) {
-        inactive_code = true;
-
-        // get rid of comment.
-        hdr_line.erase(hdr_line.find("/*"));
-      }
-
-      if (hdr_line[0] == '#' && hdr_line.find("endif") != CompilerKit::STLString::npos) {
-        if (!defined && inactive_code) {
-          inactive_code = false;
-          defined       = false;
-
-          continue;
-        }
-
-        continue;
-      }
-
-      if (!defined && inactive_code) {
-        continue;
-      }
-
-      if (defined && inactive_code) {
-        continue;
-      }
-
-      for (auto macro : kMacros) {
-        if (CompilerKit::ast_find_needle(hdr_line, macro.fName)) {
-          auto macro_pos = hdr_line.find(macro.fName);
-          if (macro_pos == CompilerKit::STLString::npos) continue;
-
-          if (hdr_line.substr(macro_pos).find(macro.fName + '(') != CompilerKit::STLString::npos) {
-            if (!macro.fArgs.empty()) {
-              CompilerKit::STLString              symbol_val = macro.fValue;
-              std::vector<CompilerKit::STLString> args;
-
-              size_t x_arg_indx = 0;
-
-              CompilerKit::STLString line_after_define = hdr_line;
-              CompilerKit::STLString str_arg;
-
-              if (line_after_define.find("(") != CompilerKit::STLString::npos) {
-                line_after_define.erase(0, line_after_define.find("(") + 1);
-
-                for (auto& subc : line_after_define) {
-                  if (subc == ' ' || subc == '\t') continue;
-
-                  if (subc == ',' || subc == ')') {
-                    if (str_arg.empty()) continue;
-
-                    args.push_back(str_arg);
-
-                    str_arg.clear();
-
-                    continue;
-                  }
-
-                  str_arg.push_back(subc);
-                }
-              }
-
-              for (auto arg : macro.fArgs) {
-                if (symbol_val.find(macro.fArgs[x_arg_indx]) != CompilerKit::STLString::npos) {
-                  symbol_val.replace(symbol_val.find(macro.fArgs[x_arg_indx]),
-                                     macro.fArgs[x_arg_indx].size(), args[x_arg_indx]);
-                  ++x_arg_indx;
-                } else {
-                  throw std::runtime_error("cppdrv: Internal error.");
-                }
-              }
-
-              auto len = macro.fName.size();
-              len += symbol_val.size();
-              len += 2;  // ( and )
-
-              auto paren_pos = hdr_line.find(")");
-              if (paren_pos != CompilerKit::STLString::npos) {
-                hdr_line.erase(paren_pos, 1);
-              }
-
-              auto macro_call_pos = hdr_line.find(macro.fName + '(');
-              if (macro_call_pos != CompilerKit::STLString::npos) {
-                hdr_line.replace(macro_call_pos, len, symbol_val);
-              }
-            } else {
-              auto value = macro.fValue;
-
-              hdr_line.replace(hdr_line.find(macro.fName), macro.fName.size(), value);
-            }
-          }
-        }
-      }
-
-      if (hdr_line[0] == '#' && hdr_line.find("define") != CompilerKit::STLString::npos) {
-        auto define_pos = hdr_line.find("define");
-        if (define_pos == CompilerKit::STLString::npos) continue;
-
-        auto line_after_define = hdr_line.substr(define_pos + strlen("define"));
-
-        CompilerKit::STLString macro_value;
-        CompilerKit::STLString macro_key;
-
-        std::size_t pos = 0UL;
-
-        std::vector<CompilerKit::STLString> args;
-        bool                                on_args = false;
-
-        for (auto& ch : line_after_define) {
-          ++pos;
-
-          if (ch == '(') {
-            on_args = true;
-            continue;
-          }
-
-          if (ch == ')') {
-            on_args = false;
-            continue;
-          }
-
-          if (ch == '\\') continue;
-
-          if (on_args) continue;
-
-          if (ch == ' ') {
-            for (size_t i = pos; i < line_after_define.size(); i++) {
-              macro_value += line_after_define[i];
-            }
-
-            break;
-          }
-
-          macro_key += ch;
-        }
-
-        CompilerKit::STLString str;
-
-        if (line_after_define.find("(") != CompilerKit::STLString::npos) {
-          line_after_define.erase(0, line_after_define.find("(") + 1);
-
-          for (auto& subc : line_after_define) {
-            if (subc == ',' || subc == ')') {
-              if (str.empty()) continue;
-
-              args.push_back(str);
-
-              str.clear();
-
-              continue;
-            }
-
-            str.push_back(subc);
-          }
-        }
-
-        Detail::pp_macro macro;
-
-        macro.fArgs  = args;
-        macro.fName  = macro_key;
-        macro.fValue = macro_value;
-
-        kMacros.emplace_back(macro);
-
-        continue;
-      }
-
-      if (hdr_line[0] != kMacroPrefix) {
-        if (inactive_code) {
-          continue;
-        }
-
-        pp_out << hdr_line << std::endl;
-
-        continue;
-      }
-
-      if (hdr_line[0] == kMacroPrefix && hdr_line.find("ifndef") != CompilerKit::STLString::npos) {
-        auto ifndef_pos = hdr_line.find("ifndef");
-        if (ifndef_pos == CompilerKit::STLString::npos) continue;
-
-        auto line_after_ifndef = hdr_line.substr(ifndef_pos + strlen("ifndef") + 1);
-        CompilerKit::STLString macro;
-
-        for (auto& ch : line_after_ifndef) {
-          if (ch == ' ') {
-            break;
-          }
-
-          macro += ch;
-        }
-
-        if (macro == "0") {
-          defined       = true;
-          inactive_code = false;
-          continue;
-        }
-
-        if (macro == "1") {
-          defined       = false;
-          inactive_code = true;
-
-          continue;
-        }
-
-        bool found = false;
-
-        defined       = true;
-        inactive_code = false;
-
-        for (auto& macro_ref : kMacros) {
-          if (hdr_line.find(macro_ref.fName) != CompilerKit::STLString::npos) {
-            found = true;
-            break;
-          }
-        }
-
-        if (found) {
-          defined       = false;
-          inactive_code = true;
-
-          continue;
-        }
-      } else if (hdr_line[0] == '#' && hdr_line.find("else") != CompilerKit::STLString::npos) {
-        if (!defined && inactive_code) {
-          inactive_code = false;
-          defined       = true;
-
-          continue;
-        } else {
-          defined       = false;
-          inactive_code = true;
-
-          continue;
-        }
-      } else if (hdr_line[0] == '#' && hdr_line.find("ifdef") != CompilerKit::STLString::npos) {
-        auto ifdef_pos = hdr_line.find("ifdef");
-        if (ifdef_pos == CompilerKit::STLString::npos) continue;
-
-        auto                   line_after_ifdef = hdr_line.substr(ifdef_pos + strlen("ifdef") + 1);
-        CompilerKit::STLString macro;
-
-        for (auto& ch : line_after_ifdef) {
-          if (ch == ' ') {
-            break;
-          }
-
-          macro += ch;
-        }
-
-        if (macro == "0") {
-          defined       = false;
-          inactive_code = true;
-
-          continue;
-        }
-
-        if (macro == "1") {
-          defined       = true;
-          inactive_code = false;
-
-          continue;
-        }
-
-        defined       = false;
-        inactive_code = true;
-
-        for (auto& macro_ref : kMacros) {
-          if (hdr_line.find(macro_ref.fName) != CompilerKit::STLString::npos) {
-            defined       = true;
-            inactive_code = false;
-
-            break;
-          }
-        }
-      } else if (hdr_line[0] == '#' && hdr_line.find("if") != CompilerKit::STLString::npos) {
-        inactive_code = true;
-
-        std::vector<Detail::pp_macro_condition> pp_macro_condition_list = {
-            {
-                .fType     = Detail::PPOperatorType::kEqual,
-                .fTypeName = "==",
-            },
-            {
-                .fType     = Detail::PPOperatorType::kNotEqual,
-                .fTypeName = "!=",
-            },
-            {
-                .fType     = Detail::PPOperatorType::kLesserThan,
-                .fTypeName = "<",
-            },
-            {
-                .fType     = Detail::PPOperatorType::kGreaterThan,
-                .fTypeName = ">",
-            },
-            {
-                .fType     = Detail::PPOperatorType::kLesserEqThan,
-                .fTypeName = "<=",
-            },
-            {
-                .fType     = Detail::PPOperatorType::kGreaterEqThan,
-                .fTypeName = ">=",
-            },
-        };
-
-        int32_t good_to_go = 0;
-
-        for (auto& macro_condition : pp_macro_condition_list) {
-          if (hdr_line.find(macro_condition.fTypeName) != CompilerKit::STLString::npos) {
-            for (auto& found_macro : kMacros) {
-              if (hdr_line.find(found_macro.fName) != CompilerKit::STLString::npos) {
-                good_to_go = pp_parse_if_condition(macro_condition, found_macro, inactive_code,
-                                                   defined, hdr_line);
-
-                break;
-              }
-            }
-          }
-        }
-
-        if (good_to_go) continue;
-
-        auto if_pos = hdr_line.find("if");
-        if (if_pos == CompilerKit::STLString::npos) continue;
-
-        auto                   line_after_if = hdr_line.substr(if_pos + strlen("if") + 1);
-        CompilerKit::STLString macro;
-
-        for (auto& ch : line_after_if) {
-          if (ch == ' ') {
-            break;
-          }
-
-          macro += ch;
-        }
-
-        if (macro == "0") {
-          defined       = false;
-          inactive_code = true;
-          continue;
-        }
-
-        if (macro == "1") {
-          defined       = true;
-          inactive_code = false;
-
-          continue;
-        }
-
-        // last try, is it defined to be one?
-        for (auto& macro_ref : kMacros) {
-          if (macro_ref.fName.find(macro) != CompilerKit::STLString::npos &&
-              macro_ref.fValue == "1") {
-            inactive_code = false;
-            defined       = true;
-
-            break;
-          }
-        }
-      } else if (hdr_line[0] == '#' && hdr_line.find("warning") != CompilerKit::STLString::npos) {
-        auto warning_pos = hdr_line.find("warning");
-        if (warning_pos == CompilerKit::STLString::npos) continue;
-
-        auto line_after_warning = hdr_line.substr(warning_pos + strlen("warning") + 1);
-        CompilerKit::STLString message;
-
-        for (auto& ch : line_after_warning) {
-          if (ch == '\r' || ch == '\n') {
-            break;
-          }
-
-          message += ch;
-        }
-
-        std::cerr << "warn: " << message << std::endl;
-      } else if (hdr_line[0] == '#' && hdr_line.find("error") != CompilerKit::STLString::npos) {
-        auto error_pos = hdr_line.find("error");
-        if (error_pos == CompilerKit::STLString::npos) continue;
-
-        auto line_after_warning = hdr_line.substr(error_pos + strlen("error") + 1);
-        CompilerKit::STLString message;
-
-        for (auto& ch : line_after_warning) {
-          if (ch == '\r' || ch == '\n') {
-            break;
-          }
-
-          message += ch;
-        }
-
-        throw std::runtime_error("error: " + message);
-      } else if (hdr_line[0] == '#' && hdr_line.find("include ") != CompilerKit::STLString::npos) {
-        auto include_pos = hdr_line.find("include ");
-        if (include_pos == CompilerKit::STLString::npos) continue;
-
-        line_after_include = hdr_line.substr(include_pos + strlen("include "));
-
-      kIncludeFile:
-        auto it = std::find(kAllIncludes.cbegin(), kAllIncludes.cend(), line_after_include);
-
-        if (it != kAllIncludes.cend()) {
-          continue;
-        }
-
-        CompilerKit::STLString path;
-
-        kAllIncludes.push_back(line_after_include);
-
-        bool enable    = false;
-        bool not_local = false;
-
-        for (auto& ch : line_after_include) {
-          if (ch == ' ') continue;
-
-          if (ch == '<') {
-            not_local = true;
-            enable    = true;
-
-            continue;
-          }
-
-          if (ch == '\"') {
-            not_local = false;
-            enable    = true;
-            continue;
-          }
-
-          if (enable) {
-            path += ch;
-          }
-        }
-
-        if (not_local) {
-          bool open = false;
-
-          if (path.ends_with('>')) {
-            path.erase(path.find('>'));
-          }
-
-          if (path.ends_with('"')) {
-            path.erase(path.find('"'));
-          }
-
-          for (auto& include : kIncludes) {
-            CompilerKit::STLString header_path = include;
-            header_path.push_back('/');
-            header_path += path;
-
-            std::ifstream header(header_path);
-
-            if (!header.is_open()) continue;
-
-            open = true;
-
-            pp_parse_file(header, pp_out);
-
-            break;
-          }
-
-          if (!open) {
-            throw std::runtime_error("cppdrv: no such include file: " + path);
-          }
-        } else {
-          std::ifstream header(path);
-
-          if (!header.is_open()) throw std::runtime_error("cppdrv: no such include file: " + path);
-
-          pp_parse_file(header, pp_out);
-        }
-      } else {
-        std::cerr << ("cppdrv: unknown pre-processor directive, " + hdr_line) << "\n";
-        continue;
-      }
-    }
-  } catch (const std::out_of_range& oor) {
-    return;
-  }
-}
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-// @brief main entrypoint of app.
-
-/////////////////////////////////////////////////////////////////////////////////////////
-
-NECTAR_MODULE(GenericPreprocessorMain) {
-  try {
-    bool skip        = false;
-    bool double_skip = false;
-
-    Detail::pp_macro macro_1;
-
-    macro_1.fName  = "__true";
-    macro_1.fValue = "1";
-
-    kMacros.push_back(macro_1);
-
-    Detail::pp_macro macro_unreachable;
-
-    macro_unreachable.fName  = "__unreachable";
-    macro_unreachable.fValue = "__compilerkit_unreachable";
-
-    kMacros.push_back(macro_unreachable);
-
-    Detail::pp_macro macro_unused;
-
-    macro_unused.fName  = "__unused";
-    macro_unused.fValue = "__compilerkit_unused";
-
-    kMacros.push_back(macro_unused);
-
-    Detail::pp_macro macro_0;
-
-    macro_0.fName  = "__false";
-    macro_0.fValue = "0";
-
-    kMacros.push_back(macro_0);
-
-    Detail::pp_macro macro_nectar;
-
-    macro_nectar.fName  = "__NECTAR__";
-    macro_nectar.fValue = "1";
-
-    kMacros.push_back(macro_nectar);
-
-    Detail::pp_macro macro_lang;
-
-    macro_lang.fName  = "__ncpp";
-    macro_lang.fValue = "202601L";
-
-    kMacros.push_back(macro_lang);
-
-    Detail::pp_macro macro_nil;
-
-    macro_nil.fName  = "nil";
-    macro_nil.fValue = "0";
-
-    kMacros.push_back(macro_nil);
-
-    for (auto index = 1UL; index < argc; ++index) {
-      if (skip) {
-        skip = false;
-        continue;
-      }
-
-      if (double_skip) {
-        ++index;
-        double_skip = false;
-        continue;
-      }
-
-      if (argv[index][0] == '-') {
-        if (strcmp(argv[index], "-cpp-ver") == 0) {
-          printf("%s\n",
-                 "Nectar Preprocessor Driver v1.11, (c) Amlal El Mahrouss 2024-2026 all rights "
-                 "reserved.");
-
-          return NECTAR_SUCCESS;
-        }
-
-        if (strcmp(argv[index], "-cpp-help") == 0) {
-          printf("%s\n",
-                 "Nectar Preprocessor Driver v1.11, (c) Amlal El Mahrouss 2024-2026 all rights "
-                 "reserved.");
-          printf("%s\n", "-cpp-working-dir <path>: set directory to working path.");
-          printf("%s\n", "-cpp-include-dir <path>: add directory to include path.");
-          printf("%s\n", "-cpp-def <name> <value>: define a macro.");
-          printf("%s\n", "-cpp-ver: print the version.");
-          printf("%s\n", "-cpp-help: show help (this current command).");
-
-          return NECTAR_SUCCESS;
-        }
-
-        if (strcmp(argv[index], "-cpp-include-dir") == 0) {
-          CompilerKit::STLString inc = argv[index + 1];
-
-          skip = true;
-
-          kIncludes.push_back(inc);
-        }
-
-        if (strcmp(argv[index], "-cpp-working-dir") == 0) {
-          CompilerKit::STLString inc = argv[index + 1];
-          skip                       = true;
-          kWorkingDir                = inc;
-        }
-
-        if (strcmp(argv[index], "-cpp-def") == 0 && argv[index + 1] != nullptr &&
-            argv[index + 2] != nullptr) {
-          CompilerKit::STLString macro_key = argv[index + 1];
-
-          CompilerKit::STLString macro_value;
-          bool                   is_string = false;
-
-          for (int argv_find_len = 0; argv_find_len < strlen(argv[index + 2]); ++argv_find_len) {
-            if (!isdigit(argv[index + 2][argv_find_len])) {
-              is_string = true;
-              macro_value += "\"";
-
-              break;
-            }
-          }
-
-          macro_value += argv[index + 2];
-
-          if (is_string) macro_value += "\"";
-
-          Detail::pp_macro macro;
-          macro.fName  = macro_key;
-          macro.fValue = macro_value;
-
-          kMacros.push_back(macro);
-
-          double_skip = true;
-        }
-
-        continue;
-      }
-
-      kFiles.emplace_back(argv[index]);
-    }
-
-    if (kFiles.empty()) return NECTAR_EXEC_ERROR;
-
-    for (auto& file : kFiles) {
-      if (!std::filesystem::exists(file)) continue;
-
-      std::ifstream file_descriptor(file);
-      std::ofstream file_descriptor_pp(file + ".pp");
-
-      pp_parse_file(file_descriptor, file_descriptor_pp);
-    }
-
-    return NECTAR_SUCCESS;
-  } catch (const std::runtime_error& e) {
-    std::cout << e.what() << '\n';
-  }
-
-  return NECTAR_EXEC_ERROR;
-}
-
-// Last rev 8-1-24
diff --git a/src/DebuggerKit/src/NeSystem.cpp b/src/DebuggerKit/src/NeSystem.cpp
index 381d2db..287a50a 100644
--- a/src/DebuggerKit/src/NeSystem.cpp
+++ b/src/DebuggerKit/src/NeSystem.cpp
@@ -18,8 +18,8 @@ using namespace DebuggerKit::NeKernel;
 NeSystemDebugger::NeSystemDebugger()  = default;
 NeSystemDebugger::~NeSystemDebugger() = default;
 
-bool NeSystemDebugger::Attach(const CompilerKit::STLString& path, const CompilerKit::STLString& argv,
-                              ProcessID& pid) noexcept {
+bool NeSystemDebugger::Attach(const CompilerKit::STLString& path,
+                              const CompilerKit::STLString& argv, ProcessID& pid) noexcept {
   if (path.empty() || argv.empty()) return NO;
 
   m_socket = ::socket(AF_INET, SOCK_STREAM, 0);