feat: codebase improvements of Nectar.

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

9 files changed, 124 insertions, 151 deletions

diff --git a/src/CompilerKit/src/Assemblers/Assembler+64x0.cc b/src/CompilerKit/src/Assemblers/Assembler+64x0.cc
index 5067c23..911fd27 100644
--- a/src/CompilerKit/src/Assemblers/Assembler+64x0.cc
+++ b/src/CompilerKit/src/Assemblers/Assembler+64x0.cc
@@ -25,11 +25,6 @@
 #include <CompilerKit/Detail/64x0.h>
 #include <CompilerKit/PEF.h>
 #include <CompilerKit/Utilities/Compiler.h>
-#include <algorithm>
-#include <filesystem>
-#include <fstream>
-#include <iostream>
-#include <vector>
 
 /////////////////////
 
diff --git a/src/CompilerKit/src/Assemblers/Assembler+AMD64.cc b/src/CompilerKit/src/Assemblers/Assembler+AMD64.cc
index ade375c..f1736cc 100644
--- a/src/CompilerKit/src/Assemblers/Assembler+AMD64.cc
+++ b/src/CompilerKit/src/Assemblers/Assembler+AMD64.cc
@@ -31,13 +31,6 @@
 #include <CompilerKit/AST.h>
 #include <CompilerKit/Detail/AMD64.h>
 #include <CompilerKit/PEF.h>
-#include <algorithm>
-#include <cstdlib>
-#include <filesystem>
-#include <fstream>
-#include <iostream>
-#include <vector>
-
 /////////////////////
 
 // ANSI ESCAPE CODES
diff --git a/src/CompilerKit/src/Assemblers/Assembler+ARM64.cc b/src/CompilerKit/src/Assemblers/Assembler+ARM64.cc
index fa1d3b5..fd06d4e 100644
--- a/src/CompilerKit/src/Assemblers/Assembler+ARM64.cc
+++ b/src/CompilerKit/src/Assemblers/Assembler+ARM64.cc
@@ -25,11 +25,6 @@
 #include <CompilerKit/ErrorID.h>
 #include <CompilerKit/PEF.h>
 #include <CompilerKit/Utilities/Assembler.h>
-#include <algorithm>
-#include <filesystem>
-#include <fstream>
-#include <iostream>
-#include <vector>
 
 /////////////////////
 
diff --git a/src/CompilerKit/src/Assemblers/Assembler+PowerPC.cc b/src/CompilerKit/src/Assemblers/Assembler+PowerPC.cc
index 830fba1..8f6119c 100644
--- a/src/CompilerKit/src/Assemblers/Assembler+PowerPC.cc
+++ b/src/CompilerKit/src/Assemblers/Assembler+PowerPC.cc
@@ -25,11 +25,6 @@
 #include <CompilerKit/ErrorID.h>
 #include <CompilerKit/PEF.h>
 #include <CompilerKit/Utilities/Assembler.h>
-#include <algorithm>
-#include <filesystem>
-#include <fstream>
-#include <iostream>
-#include <vector>
 
 /////////////////////
 
diff --git a/src/CompilerKit/src/CodeGenerator+AssemblyFactory.cc b/src/CompilerKit/src/CodeGenerator+AssemblyFactory.cc
index 2e95bd0..1a9067b 100644
--- a/src/CompilerKit/src/CodeGenerator+AssemblyFactory.cc
+++ b/src/CompilerKit/src/CodeGenerator+AssemblyFactory.cc
@@ -8,7 +8,7 @@
 /**
  * @file AssemblyFactory.cc
  * @author Amlal El Mahrouss (amlal@nekernel.org)
- * @brief Nectar Assembly API
+ * @brief Nectar Code Generation API
  * @version 0.0.3
  * @copyright Copyright (c) 2024-2025 Amlal El Mahrouss
  *
diff --git a/src/CompilerKit/src/Compilers/NectarCompiler+AMD64.cc b/src/CompilerKit/src/Compilers/NectarCompiler+AMD64.cc
index 9dbb4f6..720fdee 100644
--- a/src/CompilerKit/src/Compilers/NectarCompiler+AMD64.cc
+++ b/src/CompilerKit/src/Compilers/NectarCompiler+AMD64.cc
@@ -22,10 +22,6 @@
 #include <CompilerKit/PEF.h>
 #include <CompilerKit/UUID.h>
 #include <CompilerKit/Utilities/Compiler.h>
-#include <csignal>
-#include <cstdlib>
-#include <filesystem>
-#include <set>
 
 /* NeKernel NECTAR Compiler Driver. */
 /* This is part of the CompilerKit. */
diff --git a/src/CompilerKit/src/Linkers/DynamicLinker64+MachO.cc b/src/CompilerKit/src/Linkers/DynamicLinker64+MachO.cc
index 9b9d8ad..f87e2fc 100644
--- a/src/CompilerKit/src/Linkers/DynamicLinker64+MachO.cc
+++ b/src/CompilerKit/src/Linkers/DynamicLinker64+MachO.cc
@@ -16,8 +16,6 @@
 #include <CompilerKit/PEF.h>
 #include <CompilerKit/UUID.h>
 #include <CompilerKit/Utilities/Compiler.h>
-#include <filesystem>
-#include <map>
 
 #define kMachODefaultOutput \
   { "a.out" }
@@ -40,7 +38,7 @@ static bool                   kDuplicateSymbols    = false;
 static bool                   kIsDylib             = false;
 static Int64                  kMachODefaultStackSz = 0;
 
-static CompilerKit::STLString kLinkerStart = "_main";
+static CompilerKit::STLString kLinkerStart = "__ImageStart";
 
 /* object code and list. */
 static std::vector<CompilerKit::STLString>    kObjectList;
@@ -49,16 +47,16 @@ static std::vector<CompilerKit::Detail::Blob> kDataBytes;
 
 /* symbol table */
 static std::vector<nlist_64>                      kSymbolTable;
-static std::vector<char>                          kStringTable;
-static std::map<CompilerKit::STLString, uint64_t> kSymbolOffsets;
+static std::vector<Char>                          kStringTable;
+static std::map<CompilerKit::STLString, UInt64> kSymbolOffsets;
 
 /// @brief Structure to hold section information from AE records
 struct SectionInfo {
   CompilerKit::STLString name;
-  uint32_t               kind;
-  std::vector<char>      bytes;
-  uint64_t               address;
-  uint64_t               size;
+  UInt32               kind;
+  std::vector<Char>      bytes;
+  UInt64               address;
+  UInt64               size;
 };
 
 /// @brief Extract clean symbol name from AE record name
@@ -67,7 +65,7 @@ static CompilerKit::STLString ExtractSymbolName(const CompilerKit::STLString& ae
   CompilerKit::STLString name = aeName;
 
   // Remove section prefixes/suffixes
-  const char* sections[] = {".code64", ".data64", ".zero64", "$"};
+  const Char* sections[] = {".code64", ".data64", ".zero64", "$"};
 
   for (const auto& sec : sections) {
     size_t pos;
@@ -88,16 +86,16 @@ static CompilerKit::STLString ExtractSymbolName(const CompilerKit::STLString& ae
 }
 
 /// @brief Add a symbol to the symbol table
-static uint32_t AddSymbol(const CompilerKit::STLString& name, uint8_t type, uint8_t sect,
-                          uint64_t value) {
+static UInt32 AddSymbol(const CompilerKit::STLString& name, uint8_t type, uint8_t sect,
+                          UInt64 value) {
   // Add name to string table (offset 0 is reserved for empty string)
   if (kStringTable.empty()) {
     kStringTable.push_back('\0');  // First byte is null
   }
 
-  uint32_t strOffset = static_cast<uint32_t>(kStringTable.size());
+  UInt32 strOffset = static_cast<UInt32>(kStringTable.size());
 
-  for (char c : name) {
+  for (Char c : name) {
     kStringTable.push_back(c);
   }
   kStringTable.push_back('\0');
@@ -113,7 +111,7 @@ static uint32_t AddSymbol(const CompilerKit::STLString& name, uint8_t type, uint
   kSymbolTable.push_back(sym);
   kSymbolOffsets[name] = value;
 
-  return static_cast<uint32_t>(kSymbolTable.size() - 1);
+  return static_cast<UInt32>(kSymbolTable.size() - 1);
 }
 
 ///	@brief Nectar 64-bit Mach-O Linker.
@@ -293,7 +291,7 @@ NECTAR_MODULE(DynamicLinker64MachO) {
       delete[] raw_ae_records;
 
       // Read the actual code bytes
-      std::vector<char> bytes;
+      std::vector<Char> bytes;
       bytes.resize(hdr.fCodeSize);
 
       reader_protocol.fFilePtr.seekg(std::streamsize(hdr.fStartCode));
@@ -323,8 +321,8 @@ NECTAR_MODULE(DynamicLinker64MachO) {
   }
 
   // Calculate sizes
-  uint64_t textSize = 0;
-  uint64_t dataSize = 0;
+  UInt64 textSize = 0;
+  UInt64 dataSize = 0;
 
   for (auto& blob : kTextBytes) {
     textSize += blob.mBlob.size();
@@ -346,29 +344,29 @@ NECTAR_MODULE(DynamicLinker64MachO) {
 
   using namespace CompilerKit::MachO;
 
-  uint32_t numCommands = 8;  // __PAGEZERO, LC_BUILD_VERSION, __TEXT, __LINKEDIT, LC_LOAD_DYLINKER,
+  UInt32 numCommands = 8;  // __PAGEZERO, LC_BUILD_VERSION, __TEXT, __LINKEDIT, LC_LOAD_DYLINKER,
                              // LC_UUID, LC_SYMTAB, LC_DYSYMTAB
 
   if (!kIsDylib) {
     numCommands += 1;  // LC_MAIN
   }
 
-  uint32_t dataSegCmdSize =
+  UInt32 dataSegCmdSize =
       kDataBytes.size() > 0 ? sizeof(segment_command_64) + sizeof(section_64) : 0;
 
   if (dataSegCmdSize > 0) ++numCommands;  // __DATA segment
 
-  uint32_t sizeOfCmds      = 0;
-  uint32_t headerSize      = sizeof(mach_header_64);
-  uint32_t pageZeroSize    = sizeof(segment_command_64);
-  uint32_t textSegCmdSize  = sizeof(segment_command_64) + sizeof(section_64);
-  uint32_t buildCmdSize    = sizeof(build_version_command);
-  uint32_t mainCmdSize     = sizeof(entry_point_command);
-  uint32_t uuidCmdSize     = sizeof(uuid_command);
-  uint32_t symtabCmdSize   = sizeof(symtab_command);
-  uint32_t dysymtabCmdSize = sizeof(dysymtab_command);
-  uint32_t linkeditCmdSize = sizeof(segment_command_64);  // No sections
-  uint32_t dylinkerCmdSize =
+  UInt32 sizeOfCmds      = 0;
+  UInt32 headerSize      = sizeof(mach_header_64);
+  UInt32 pageZeroSize    = sizeof(segment_command_64);
+  UInt32 textSegCmdSize  = sizeof(segment_command_64) + sizeof(section_64);
+  UInt32 buildCmdSize    = sizeof(build_version_command);
+  UInt32 mainCmdSize     = sizeof(entry_point_command);
+  UInt32 uuidCmdSize     = sizeof(uuid_command);
+  UInt32 symtabCmdSize   = sizeof(symtab_command);
+  UInt32 dysymtabCmdSize = sizeof(dysymtab_command);
+  UInt32 linkeditCmdSize = sizeof(segment_command_64);  // No sections
+  UInt32 dylinkerCmdSize =
       (sizeof(dylinker_command) + 13 + 1 + 7) & ~7;  // "/usr/lib/dyld" + padding to 8-byte align
 
   sizeOfCmds = pageZeroSize + textSegCmdSize + dataSegCmdSize + buildCmdSize + uuidCmdSize +
@@ -376,25 +374,25 @@ NECTAR_MODULE(DynamicLinker64MachO) {
 
   if (!kIsDylib) sizeOfCmds += mainCmdSize;
 
-  uint64_t headerAndCmdsSize = headerSize + sizeOfCmds;
-  uint64_t textFileOffset    = AlignToPage(headerAndCmdsSize);
-  uint64_t textVMAddr        = kDefaultBaseAddress;
-  uint64_t textSegmentSize   = AlignToPage(textSize > 0 ? textSize : kPageSize);
-  uint64_t textVMSize        = textFileOffset + textSegmentSize;  // __TEXT includes header
+  UInt64 headerAndCmdsSize = headerSize + sizeOfCmds;
+  UInt64 textFileOffset    = AlignToPage(headerAndCmdsSize);
+  UInt64 textVMAddr        = kDefaultBaseAddress;
+  UInt64 textSegmentSize   = AlignToPage(textSize > 0 ? textSize : kPageSize);
+  UInt64 textVMSize        = textFileOffset + textSegmentSize;  // __TEXT includes header
 
-  uint64_t dataFileOffset  = textFileOffset + textSegmentSize;
-  uint64_t dataVMAddr      = textVMAddr + textVMSize;
-  uint64_t dataSegmentSize = dataSize > 0 ? AlignToPage(dataSize) : 0;  // 0 if no data
+  UInt64 dataFileOffset  = textFileOffset + textSegmentSize;
+  UInt64 dataVMAddr      = textVMAddr + textVMSize;
+  UInt64 dataSegmentSize = dataSize > 0 ? AlignToPage(dataSize) : 0;  // 0 if no data
 
   // __LINKEDIT segment comes after data segment (or __TEXT if no data)
-  uint64_t linkeditFileOffset =
+  UInt64 linkeditFileOffset =
       dataSegmentSize > 0 ? dataFileOffset + dataSegmentSize : textFileOffset + textSegmentSize;
-  uint64_t linkeditVMAddr =
+  UInt64 linkeditVMAddr =
       dataSegmentSize > 0 ? dataVMAddr + dataSegmentSize : textVMAddr + textVMSize;
-  uint64_t symtabFileOffset = linkeditFileOffset;
-  uint64_t strtabFileOffset = symtabFileOffset + (kSymbolTable.size() * sizeof(nlist_64));
-  uint64_t linkeditFileSize = (kSymbolTable.size() * sizeof(nlist_64)) + kStringTable.size();
-  uint64_t linkeditVMSize   = AlignToPage(linkeditFileSize > 0 ? linkeditFileSize : 1);
+  UInt64 symtabFileOffset = linkeditFileOffset;
+  UInt64 strtabFileOffset = symtabFileOffset + (kSymbolTable.size() * sizeof(nlist_64));
+  UInt64 linkeditFileSize = (kSymbolTable.size() * sizeof(nlist_64)) + kStringTable.size();
+  UInt64 linkeditVMSize   = AlignToPage(linkeditFileSize > 0 ? linkeditFileSize : 1);
 
   // Write Mach-O header
   mach_header_64 header{};
@@ -408,7 +406,7 @@ NECTAR_MODULE(DynamicLinker64MachO) {
   header.flags      = MH_NOUNDEFS | MH_DYLDLINK | MH_TWOLEVEL | MH_PIE;
   header.reserved   = 0;
 
-  output_fc.write(reinterpret_cast<const char*>(&header), sizeof(header));
+  output_fc.write(reinterpret_cast<const Char*>(&header), sizeof(header));
 
   if (kVerbose) {
     kConsoleOut << "Wrote Mach-O header, ncmds: " << numCommands << "\n";
@@ -427,7 +425,7 @@ NECTAR_MODULE(DynamicLinker64MachO) {
   pageZeroSegment.nsects   = 0;
   pageZeroSegment.flags    = 0;
 
-  output_fc.write(reinterpret_cast<const char*>(&pageZeroSegment), sizeof(pageZeroSegment));
+  output_fc.write(reinterpret_cast<const Char*>(&pageZeroSegment), sizeof(pageZeroSegment));
 
   build_version_command build = {.cmd      = LC_BUILD_VERSION,
                                  .cmdsize  = sizeof(build_version_command),
@@ -436,7 +434,7 @@ NECTAR_MODULE(DynamicLinker64MachO) {
                                  .sdk      = (11 << 16),  // macOS 11.0
                                  .ntools   = 0};
 
-  output_fc.write(reinterpret_cast<const char*>(&build), sizeof(build));
+  output_fc.write(reinterpret_cast<const Char*>(&build), sizeof(build));
 
   if (kVerbose) {
     kConsoleOut << "Wrote LC_BUILD_VERSION, platform: macOS, minos: 11.0, sdk: 11.0\n";
@@ -457,7 +455,7 @@ NECTAR_MODULE(DynamicLinker64MachO) {
   textSegment.nsects   = 1;
   textSegment.flags    = 0;
 
-  output_fc.write(reinterpret_cast<const char*>(&textSegment), sizeof(textSegment));
+  output_fc.write(reinterpret_cast<const Char*>(&textSegment), sizeof(textSegment));
 
   // Write __text section header
   section_64 textSection{};
@@ -465,7 +463,7 @@ NECTAR_MODULE(DynamicLinker64MachO) {
   CopySegmentName(textSection.segname, kSegmentText);
   textSection.addr      = textVMAddr + textFileOffset;  // Section is at offset within segment
   textSection.size      = textSize;
-  textSection.offset    = static_cast<uint32_t>(textFileOffset);
+  textSection.offset    = static_cast<UInt32>(textFileOffset);
   textSection.align     = kSectionAlign;
   textSection.reloff    = 0;
   textSection.nreloc    = 0;
@@ -474,7 +472,7 @@ NECTAR_MODULE(DynamicLinker64MachO) {
   textSection.reserved2 = 0;
   textSection.reserved3 = 0;
 
-  output_fc.write(reinterpret_cast<const char*>(&textSection), sizeof(textSection));
+  output_fc.write(reinterpret_cast<const Char*>(&textSection), sizeof(textSection));
 
   if (kVerbose) {
     kConsoleOut << "Wrote __TEXT segment, vmaddr: 0x" << std::hex << textVMAddr << std::dec << "\n";
@@ -496,7 +494,7 @@ NECTAR_MODULE(DynamicLinker64MachO) {
   dataSegment.flags    = 0;
 
   if (dataSegCmdSize > 0)
-    output_fc.write(reinterpret_cast<const char*>(&dataSegment), sizeof(dataSegment));
+    output_fc.write(reinterpret_cast<const Char*>(&dataSegment), sizeof(dataSegment));
 
   // Write __data section header
   section_64 dataSection{};
@@ -504,7 +502,7 @@ NECTAR_MODULE(DynamicLinker64MachO) {
   CopySegmentName(dataSection.segname, kSegmentData);
   dataSection.addr      = dataVMAddr;
   dataSection.size      = dataSize;
-  dataSection.offset    = static_cast<uint32_t>(dataFileOffset);
+  dataSection.offset    = static_cast<UInt32>(dataFileOffset);
   dataSection.align     = kSectionAlign;
   dataSection.reloff    = 0;
   dataSection.nreloc    = 0;
@@ -514,7 +512,7 @@ NECTAR_MODULE(DynamicLinker64MachO) {
   dataSection.reserved3 = 0;
 
   if (dataSegCmdSize > 0)
-    output_fc.write(reinterpret_cast<const char*>(&dataSection), sizeof(dataSection));
+    output_fc.write(reinterpret_cast<const Char*>(&dataSection), sizeof(dataSection));
 
   if (kVerbose) {
     kConsoleOut << "Wrote __DATA segment, vmaddr: 0x" << std::hex << dataVMAddr << std::dec << "\n";
@@ -535,7 +533,7 @@ NECTAR_MODULE(DynamicLinker64MachO) {
   linkeditSegment.nsects   = 0;
   linkeditSegment.flags    = 0;
 
-  output_fc.write(reinterpret_cast<const char*>(&linkeditSegment), sizeof(linkeditSegment));
+  output_fc.write(reinterpret_cast<const Char*>(&linkeditSegment), sizeof(linkeditSegment));
 
   if (kVerbose) {
     kConsoleOut << "Wrote __LINKEDIT segment, vmaddr: 0x" << std::hex << linkeditVMAddr << std::dec
@@ -544,8 +542,8 @@ NECTAR_MODULE(DynamicLinker64MachO) {
   }
 
   // Write LC_LOAD_DYLINKER command
-  const char*       dyldPath = "/usr/lib/dyld";
-  std::vector<char> dylinkerCmd(dylinkerCmdSize, 0);
+  const Char*       dyldPath = "/usr/lib/dyld";
+  std::vector<Char> dylinkerCmd(dylinkerCmdSize, 0);
   dylinker_command* dylinker = reinterpret_cast<dylinker_command*>(dylinkerCmd.data());
   dylinker->cmd              = LC_LOAD_DYLINKER;
   dylinker->cmdsize          = dylinkerCmdSize;
@@ -565,7 +563,7 @@ NECTAR_MODULE(DynamicLinker64MachO) {
     // entryoff is relative to __TEXT segment file offset
     entryCommand.entryoff = textFileOffset + entryCommand.entryoff;
 
-    output_fc.write(reinterpret_cast<const char*>(&entryCommand), sizeof(entryCommand));
+    output_fc.write(reinterpret_cast<const Char*>(&entryCommand), sizeof(entryCommand));
 
     if (kVerbose) {
       kConsoleOut << "Wrote LC_MAIN, entryoff: 0x" << std::hex << entryCommand.entryoff << std::dec
@@ -586,7 +584,7 @@ NECTAR_MODULE(DynamicLinker64MachO) {
   auto                         uuidBytes     = generatedUuid.as_bytes();
   std::memcpy(uuidCmd.uuid, uuidBytes.data(), 16);
 
-  output_fc.write(reinterpret_cast<const char*>(&uuidCmd), sizeof(uuidCmd));
+  output_fc.write(reinterpret_cast<const Char*>(&uuidCmd), sizeof(uuidCmd));
 
   if (kVerbose) {
     kConsoleOut << "Wrote LC_UUID\n";
@@ -596,12 +594,12 @@ NECTAR_MODULE(DynamicLinker64MachO) {
   symtab_command symtabCmd{};
   symtabCmd.cmd     = LC_SYMTAB;
   symtabCmd.cmdsize = sizeof(symtab_command);
-  symtabCmd.symoff  = static_cast<uint32_t>(symtabFileOffset);
-  symtabCmd.nsyms   = static_cast<uint32_t>(kSymbolTable.size());
-  symtabCmd.stroff  = static_cast<uint32_t>(strtabFileOffset);
-  symtabCmd.strsize = static_cast<uint32_t>(kStringTable.size());
+  symtabCmd.symoff  = static_cast<UInt32>(symtabFileOffset);
+  symtabCmd.nsyms   = static_cast<UInt32>(kSymbolTable.size());
+  symtabCmd.stroff  = static_cast<UInt32>(strtabFileOffset);
+  symtabCmd.strsize = static_cast<UInt32>(kStringTable.size());
 
-  output_fc.write(reinterpret_cast<const char*>(&symtabCmd), sizeof(symtabCmd));
+  output_fc.write(reinterpret_cast<const Char*>(&symtabCmd), sizeof(symtabCmd));
 
   if (kVerbose) {
     kConsoleOut << "Wrote LC_SYMTAB, nsyms: " << symtabCmd.nsyms
@@ -616,28 +614,28 @@ NECTAR_MODULE(DynamicLinker64MachO) {
 
   // All symbols are local for now
   dysymtabCmd.ilocalsym = 0;
-  dysymtabCmd.nlocalsym = static_cast<uint32_t>(kSymbolTable.size());
+  dysymtabCmd.nlocalsym = static_cast<UInt32>(kSymbolTable.size());
 
   // External symbols start after locals
-  dysymtabCmd.iextdefsym = static_cast<uint32_t>(kSymbolTable.size());
+  dysymtabCmd.iextdefsym = static_cast<UInt32>(kSymbolTable.size());
   dysymtabCmd.nextdefsym = 0;
 
   // Undefined symbols
-  dysymtabCmd.iundefsym = static_cast<uint32_t>(kSymbolTable.size());
+  dysymtabCmd.iundefsym = static_cast<UInt32>(kSymbolTable.size());
   dysymtabCmd.nundefsym = 0;
 
-  output_fc.write(reinterpret_cast<const char*>(&dysymtabCmd), sizeof(dysymtabCmd));
+  output_fc.write(reinterpret_cast<const Char*>(&dysymtabCmd), sizeof(dysymtabCmd));
 
   if (kVerbose) {
     kConsoleOut << "Wrote LC_DYSYMTAB\n";
   }
 
   // Pad to text section offset
-  uint64_t currentPos = output_fc.tellp();
-  uint64_t padding    = textFileOffset - currentPos;
+  UInt64 currentPos = output_fc.tellp();
+  UInt64 padding    = textFileOffset - currentPos;
 
   if (padding > 0) {
-    std::vector<char> zeros(padding, 0);
+    std::vector<Char> zeros(padding, 0);
     output_fc.write(zeros.data(), zeros.size());
   }
 
@@ -651,7 +649,7 @@ NECTAR_MODULE(DynamicLinker64MachO) {
   padding    = dataFileOffset - currentPos;
 
   if (padding > 0) {
-    std::vector<char> zeros(padding, 0);
+    std::vector<Char> zeros(padding, 0);
     output_fc.write(zeros.data(), zeros.size());
   }
 
@@ -665,13 +663,13 @@ NECTAR_MODULE(DynamicLinker64MachO) {
   padding    = symtabFileOffset - currentPos;
 
   if (padding > 0) {
-    std::vector<char> zeros(padding, 0);
+    std::vector<Char> zeros(padding, 0);
     output_fc.write(zeros.data(), zeros.size());
   }
 
   // Write symbol table (nlist_64 entries)
   for (auto& sym : kSymbolTable) {
-    output_fc.write(reinterpret_cast<const char*>(&sym), sizeof(nlist_64));
+    output_fc.write(reinterpret_cast<const Char*>(&sym), sizeof(nlist_64));
   }
 
   if (kVerbose) {
diff --git a/src/CompilerKit/src/Linkers/DynamicLinker64+PEF.cc b/src/CompilerKit/src/Linkers/DynamicLinker64+PEF.cc
index 0729d7b..ea513c5 100644
--- a/src/CompilerKit/src/Linkers/DynamicLinker64+PEF.cc
+++ b/src/CompilerKit/src/Linkers/DynamicLinker64+PEF.cc
@@ -16,17 +16,18 @@
 #include <CompilerKit/PEF.h>
 #include <CompilerKit/UUID.h>
 #include <CompilerKit/Utilities/Compiler.h>
-#include <filesystem>
 
-#define kPefNoCpu (0U)
-#define kPefNoSubCpu (0U)
-#define kPefDefaultOutput \
+#define kLinkerPefNoCpu (0U)
+#define kLinkerPefNoSubCpu (0U)
+#define kLinkerPefDefaultOutput \
   { "a" kPefExt }
 
-#define kLinkerVersionStr "Nectar 64-Bit Linker (Preferred Executable Format)"
+#define kLinkerVersionStr "Nectar 64-Bit Linker (NeKernel PEF)"
 
 #define kLinkerDefaultOrigin kPefBaseOrigin
+
 #define kLinkerId (0x5046FF)
+
 #define kLinkerAbiContainer "__PEFContainer:ABI:"
 #define kLinkerGuidContainer "__PEFContainer:GUID:"
 
@@ -40,24 +41,24 @@
              << "ld64: "   \
              << "\e[0;97m")
 
-enum {
+enum struct ABIType : Int32 {
   kABITypeNull    = 0,
   kABITypeStart   = 0x1010, /* The start of ABI list. */
   kABITypeNE      = 0x5046, /* PF (NeKernel.org's PEF ABI) */
   kABITypeInvalid = 0xFFFF,
 };
 
-static CompilerKit::STLString kOutput           = kPefDefaultOutput;
-static Int32                  kAbi              = kABITypeNE;
-static Int32                  kSubArch          = kPefNoSubCpu;
+static CompilerKit::STLString kOutput           = kLinkerPefDefaultOutput;
+static ABIType                kAbi              = ABIType::kABITypeNE;
+static Int32                  kSubArch          = kLinkerPefNoSubCpu;
 static Int32                  kArch             = CompilerKit::kPefArchInvalid;
 static bool                   kFatBinaryEnable  = false;
 static bool                   kStartFound       = false;
 static bool                   kDuplicateSymbols = false;
 
 /* ld64 is to be found, mld is to be found at runtime. */
-static const Char* kLdDefineSymbol = ":UndefinedSymbol:";
-static const Char* kLdDynamicSym   = ":RuntimeSymbol:";
+static const Char* kLinkerDefineSymbol = ":UndefinedSymbol:";
+static const Char* kLinkerDynamicSym   = ":RuntimeSymbol:";
 
 static CompilerKit::STLString kLinkerStart = kPefStart;
 
@@ -202,7 +203,7 @@ NECTAR_MODULE(DynamicLinker64PEF) {
   pef_container.Kind     = is_executable ? CompilerKit::kPefKindExec : CompilerKit::kPefKindDylib;
   pef_container.SubCpu   = kSubArch;
   pef_container.Linker   = kLinkerId;  // Amlal El Mahrouss Linker
-  pef_container.Abi      = kAbi;       // Multi-Processor UX ABI
+  pef_container.Abi      = static_cast<Int32>(kAbi);       // Multi-Processor UX ABI
   pef_container.Magic[0] = kPefMagic[kFatBinaryEnable ? 2 : 0];
   pef_container.Magic[1] = kPefMagic[1];
   pef_container.Magic[2] = kPefMagic[kFatBinaryEnable ? 0 : 2];
@@ -292,7 +293,7 @@ NECTAR_MODULE(DynamicLinker64PEF) {
             cmd_hdr_name.find(kPefZero64) == CompilerKit::STLString::npos) {
           if (cmd_hdr_name.find(kLinkerStart) == CompilerKit::STLString::npos &&
               *command_header.Name == 0) {
-            if (cmd_hdr_name.find(kLdDefineSymbol) != CompilerKit::STLString::npos) {
+            if (cmd_hdr_name.find(kLinkerDefineSymbol) != CompilerKit::STLString::npos) {
               goto ld_mark_header;
             } else {
               continue;
@@ -327,7 +328,7 @@ NECTAR_MODULE(DynamicLinker64PEF) {
       delete[] raw_ae_records;
       raw_ae_records = nullptr;
 
-      std::vector<char> bytes;
+      std::vector<Char> bytes;
       bytes.resize(hdr.fCodeSize);
 
       reader_protocol.fFilePtr.seekg(std::streamsize(hdr.fStartCode));
@@ -367,9 +368,9 @@ NECTAR_MODULE(DynamicLinker64PEF) {
 
   for (auto& command_hdr : command_headers) {
     // check if this symbol needs to be resolved.
-    if (CompilerKit::STLString(command_hdr.Name).find(kLdDefineSymbol) !=
+    if (CompilerKit::STLString(command_hdr.Name).find(kLinkerDefineSymbol) !=
             CompilerKit::STLString::npos &&
-        CompilerKit::STLString(command_hdr.Name).find(kLdDynamicSym) ==
+        CompilerKit::STLString(command_hdr.Name).find(kLinkerDynamicSym) ==
             CompilerKit::STLString::npos) {
       if (kVerbose) kConsoleOut << "Found undefined symbol: " << command_hdr.Name << "\n";
 
@@ -392,10 +393,10 @@ NECTAR_MODULE(DynamicLinker64PEF) {
         it != not_found.end()) {
       CompilerKit::STLString symbol_imp = *it;
 
-      if (symbol_imp.find(kLdDefineSymbol) == CompilerKit::STLString::npos) continue;
+      if (symbol_imp.find(kLinkerDefineSymbol) == CompilerKit::STLString::npos) continue;
 
       // erase the lookup prefix.
-      symbol_imp.erase(0, symbol_imp.find(kLdDefineSymbol) + strlen(kLdDefineSymbol));
+      symbol_imp.erase(0, symbol_imp.find(kLinkerDefineSymbol) + strlen(kLinkerDefineSymbol));
 
       // demangle everything.
       while (symbol_imp.find('$') != CompilerKit::STLString::npos)
@@ -406,7 +407,7 @@ NECTAR_MODULE(DynamicLinker64PEF) {
       for (auto& command_hdr : command_headers) {
         if (CompilerKit::STLString(command_hdr.Name).find(symbol_imp) !=
                 CompilerKit::STLString::npos &&
-            CompilerKit::STLString(command_hdr.Name).find(kLdDefineSymbol) ==
+            CompilerKit::STLString(command_hdr.Name).find(kLinkerDefineSymbol) ==
                 CompilerKit::STLString::npos) {
           CompilerKit::STLString undefined_symbol = command_hdr.Name;
           auto result_of_sym = undefined_symbol.substr(undefined_symbol.find(symbol_imp));
@@ -551,9 +552,9 @@ NECTAR_MODULE(DynamicLinker64PEF) {
   // And check for any duplications
   for (size_t commandHeaderIndex = 0UL; commandHeaderIndex < command_headers.size();
        ++commandHeaderIndex) {
-    if (CompilerKit::STLString(command_headers[commandHeaderIndex].Name).find(kLdDefineSymbol) !=
+    if (CompilerKit::STLString(command_headers[commandHeaderIndex].Name).find(kLinkerDefineSymbol) !=
             CompilerKit::STLString::npos &&
-        CompilerKit::STLString(command_headers[commandHeaderIndex].Name).find(kLdDynamicSym) ==
+        CompilerKit::STLString(command_headers[commandHeaderIndex].Name).find(kLinkerDynamicSym) ==
             CompilerKit::STLString::npos) {
       // ignore :UndefinedSymbol: headers, they do not contain code.
       continue;
@@ -597,9 +598,9 @@ NECTAR_MODULE(DynamicLinker64PEF) {
       if (sub_command_header_index == commandHeaderIndex) continue;
 
       if (CompilerKit::STLString(command_headers[sub_command_header_index].Name)
-                  .find(kLdDefineSymbol) != CompilerKit::STLString::npos &&
+                  .find(kLinkerDefineSymbol) != CompilerKit::STLString::npos &&
           CompilerKit::STLString(command_headers[sub_command_header_index].Name)
-                  .find(kLdDynamicSym) == CompilerKit::STLString::npos) {
+                  .find(kLinkerDynamicSym) == CompilerKit::STLString::npos) {
         if (kVerbose) {
           kConsoleOut << "Ignoring :UndefinedSymbol: headers...\n";
         }
diff --git a/src/CompilerKit/src/Preprocessor/Preprocessor+Generic.cc b/src/CompilerKit/src/Preprocessor/Preprocessor+Generic.cc
index 7b3c219..ab6a9fa 100644
--- a/src/CompilerKit/src/Preprocessor/Preprocessor+Generic.cc
+++ b/src/CompilerKit/src/Preprocessor/Preprocessor+Generic.cc
@@ -20,8 +20,8 @@
 /// @file Preprocessor+Generic.cc
 /// @brief Nectar Preprocessor.
 
-typedef Int32 (*bpp_parser_fn_t)(CompilerKit::STLString& line, std::ifstream& hdr_file,
-                                 std::ofstream& pp_out);
+typedef Int32 (*pp_parser_fn_t)(CompilerKit::STLString& line, std::ifstream& hdr_file,
+                                std::ofstream& pp_out);
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
@@ -41,7 +41,7 @@ enum {
   kCount = 6,
 };
 
-struct bpp_macro_condition final {
+struct pp_macro_condition final {
   int32_t                fType;
   CompilerKit::STLString fTypeName;
 
@@ -51,7 +51,7 @@ struct bpp_macro_condition final {
   }
 };
 
-struct bpp_macro final {
+struct pp_macro final {
   std::vector<CompilerKit::STLString> fArgs;
   CompilerKit::STLString              fName;
   CompilerKit::STLString              fValue;
@@ -68,21 +68,21 @@ struct bpp_macro final {
 }  // namespace Detail
 
 static std::vector<CompilerKit::STLString> kFiles;
-static std::vector<Detail::bpp_macro>      kMacros;
+static std::vector<Detail::pp_macro>       kMacros;
 static std::vector<CompilerKit::STLString> kIncludes;
 
 static CompilerKit::STLString kWorkingDir = "";
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
-// @name bpp_parse_if_condition
+// @name pp_parse_if_condition
 // @brief parse #if condition
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
-int32_t bpp_parse_if_condition(Detail::bpp_macro_condition& cond, Detail::bpp_macro& macro,
-                               bool& inactive_code, bool& defined,
-                               CompilerKit::STLString& macro_str) {
+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::kEqual) {
     auto pos = macro_str.find(macro.fName);
     if (pos == CompilerKit::STLString::npos) return 0;
@@ -241,12 +241,12 @@ std::vector<CompilerKit::STLString> kAllIncludes;
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
-// @name bpp_parse_file
+// @name pp_parse_file
 // @brief parse file to preprocess it.
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
-void bpp_parse_file(std::ifstream& hdr_file, std::ofstream& pp_out) {
+void pp_parse_file(std::ifstream& hdr_file, std::ofstream& pp_out) {
   CompilerKit::STLString hdr_line;
   CompilerKit::STLString line_after_include;
 
@@ -423,7 +423,7 @@ void bpp_parse_file(std::ifstream& hdr_file, std::ofstream& pp_out) {
           }
         }
 
-        Detail::bpp_macro macro;
+        Detail::pp_macro macro;
 
         macro.fArgs  = args;
         macro.fName  = macro_key;
@@ -548,7 +548,7 @@ void bpp_parse_file(std::ifstream& hdr_file, std::ofstream& pp_out) {
                  hdr_line.find("if") != CompilerKit::STLString::npos) {
         inactive_code = true;
 
-        std::vector<Detail::bpp_macro_condition> bpp_macro_condition_list = {
+        std::vector<Detail::pp_macro_condition> pp_macro_condition_list = {
             {
                 .fType     = Detail::kEqual,
                 .fTypeName = "==",
@@ -577,12 +577,12 @@ void bpp_parse_file(std::ifstream& hdr_file, std::ofstream& pp_out) {
 
         int32_t good_to_go = 0;
 
-        for (auto& macro_condition : bpp_macro_condition_list) {
+        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 = bpp_parse_if_condition(macro_condition, found_macro, inactive_code,
-                                                    defined, hdr_line);
+                good_to_go = pp_parse_if_condition(macro_condition, found_macro, inactive_code,
+                                                   defined, hdr_line);
 
                 break;
               }
@@ -727,7 +727,7 @@ void bpp_parse_file(std::ifstream& hdr_file, std::ofstream& pp_out) {
 
             open = true;
 
-            bpp_parse_file(header, pp_out);
+            pp_parse_file(header, pp_out);
 
             break;
           }
@@ -740,7 +740,7 @@ void bpp_parse_file(std::ifstream& hdr_file, std::ofstream& pp_out) {
 
           if (!header.is_open()) throw std::runtime_error("cppdrv: no such include file: " + path);
 
-          bpp_parse_file(header, pp_out);
+          pp_parse_file(header, pp_out);
         }
       } else {
         std::cerr << ("cppdrv: unknown pre-processor directive, " + hdr_line) << "\n";
@@ -763,49 +763,49 @@ NECTAR_MODULE(GenericPreprocessorMain) {
     bool skip        = false;
     bool double_skip = false;
 
-    Detail::bpp_macro macro_1;
+    Detail::pp_macro macro_1;
 
     macro_1.fName  = "__true";
     macro_1.fValue = "1";
 
     kMacros.push_back(macro_1);
 
-    Detail::bpp_macro macro_unreachable;
+    Detail::pp_macro macro_unreachable;
 
     macro_unreachable.fName  = "__unreachable";
     macro_unreachable.fValue = "__compilerkit_unreachable";
 
     kMacros.push_back(macro_unreachable);
 
-    Detail::bpp_macro macro_unused;
+    Detail::pp_macro macro_unused;
 
     macro_unused.fName  = "__unused";
     macro_unused.fValue = "__compilerkit_unused";
 
     kMacros.push_back(macro_unused);
 
-    Detail::bpp_macro macro_0;
+    Detail::pp_macro macro_0;
 
     macro_0.fName  = "__false";
     macro_0.fValue = "0";
 
     kMacros.push_back(macro_0);
 
-    Detail::bpp_macro macro_nectar;
+    Detail::pp_macro macro_nectar;
 
     macro_nectar.fName  = "__NECTAR__";
     macro_nectar.fValue = "1";
 
     kMacros.push_back(macro_nectar);
 
-    Detail::bpp_macro macro_lang;
+    Detail::pp_macro macro_lang;
 
     macro_lang.fName  = "__ncpp";
     macro_lang.fValue = "202601L";
 
     kMacros.push_back(macro_lang);
 
-    Detail::bpp_macro macro_nil;
+    Detail::pp_macro macro_nil;
 
     macro_nil.fName  = "nil";
     macro_nil.fValue = "0";
@@ -880,7 +880,7 @@ NECTAR_MODULE(GenericPreprocessorMain) {
 
           if (is_string) macro_value += "\"";
 
-          Detail::bpp_macro macro;
+          Detail::pp_macro macro;
           macro.fName  = macro_key;
           macro.fValue = macro_value;
 
@@ -903,7 +903,7 @@ NECTAR_MODULE(GenericPreprocessorMain) {
       std::ifstream file_descriptor(file);
       std::ofstream file_descriptor_pp(file + ".pp");
 
-      bpp_parse_file(file_descriptor, file_descriptor_pp);
+      pp_parse_file(file_descriptor, file_descriptor_pp);
     }
 
     return NECTAR_SUCCESS;