META: Code cleanup and work in progress IDL compiler and fixes.

	- IDL compiler, refer to ticket for it.
	- Code has been cleaned up and improved.
	- Fix build rules on Linux.

Signed-off-by: Amlal <amlal@el-mahrouss-logic.com>

11 files changed, 147 insertions, 136 deletions

diff --git a/dev/NDK/ReadMe.md b/dev/NDK/ReadMe.md
index 50139b9..657fae9 100644
--- a/dev/NDK/ReadMe.md
+++ b/dev/NDK/ReadMe.md
@@ -1,5 +1,5 @@
 # NDK Compiler DLL
 
-## Compiler, Assembler and Linker
+## Compiler, Assembler and Linker DLL.
 
-This contains a set of tools necessary to compile ZKA programs.
+This contains a set of tools necessary to compile a ZKA program.
diff --git a/dev/NDK/Sources/Assembler32x0.cxx b/dev/NDK/Sources/Assembler32x0.cxx
index 6f98cdf..033f8d9 100644
--- a/dev/NDK/Sources/Assembler32x0.cxx
+++ b/dev/NDK/Sources/Assembler32x0.cxx
@@ -23,11 +23,6 @@
 #include <NDK/Parser.hxx>
 #include <NDK/NFC/AE.hxx>
 #include <NDK/NFC/PEF.hxx>
-#include <filesystem>
-#include <fstream>
-#include <iostream>
-#include <memory>
-#include <vector>
 
 /////////////////////
 
diff --git a/dev/NDK/Sources/Assembler64x0.cxx b/dev/NDK/Sources/Assembler64x0.cxx
index b5ec35b..059572c 100644
--- a/dev/NDK/Sources/Assembler64x0.cxx
+++ b/dev/NDK/Sources/Assembler64x0.cxx
@@ -27,7 +27,6 @@
 #include <filesystem>
 #include <fstream>
 #include <iostream>
-#include <memory>
 #include <vector>
 
 /////////////////////
diff --git a/dev/NDK/Sources/AssemblerAMD64.cxx b/dev/NDK/Sources/AssemblerAMD64.cxx
index cfbed97..800ee65 100644
--- a/dev/NDK/Sources/AssemblerAMD64.cxx
+++ b/dev/NDK/Sources/AssemblerAMD64.cxx
@@ -36,7 +36,6 @@
 #include <filesystem>
 #include <fstream>
 #include <iostream>
-#include <memory>
 #include <vector>
 
 /////////////////////
diff --git a/dev/NDK/Sources/CPlusPlusCompilerAMD64.cxx b/dev/NDK/Sources/CPlusPlusCompilerAMD64.cxx
index b819040..01a060a 100644
--- a/dev/NDK/Sources/CPlusPlusCompilerAMD64.cxx
+++ b/dev/NDK/Sources/CPlusPlusCompilerAMD64.cxx
@@ -22,7 +22,7 @@
 
 #include <NDK/Asm/CPU/amd64.hxx>
 #include <NDK/Parser.hxx>
-#include <UUID.hxx>
+#include <NDK/UUID.hxx>
 
 /* ZKA C++ Compiler driver */
 /* This is part of the NDK. */
diff --git a/dev/NDK/Sources/CPlusPlusCompilerPreProcessor.cxx b/dev/NDK/Sources/CPlusPlusCompilerPreProcessor.cxx
index ed9cc92..841c890 100644
--- a/dev/NDK/Sources/CPlusPlusCompilerPreProcessor.cxx
+++ b/dev/NDK/Sources/CPlusPlusCompilerPreProcessor.cxx
@@ -31,7 +31,7 @@ typedef Int32 (*bpp_parser_fn_t)(std::string& line, std::ifstream& hdr_file, std
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
-namespace details
+namespace detail
 {
 	enum
 	{
@@ -67,10 +67,10 @@ namespace details
 		std::string		fMacroName;
 		bpp_parser_fn_t fParse;
 	};
-} // namespace details
+} // namespace detail
 
 static std::vector<std::string>		   kFiles;
-static std::vector<details::bpp_macro> kMacros;
+static std::vector<detail::bpp_macro> kMacros;
 static std::vector<std::string>		   kIncludes;
 
 static std::string kWorkingDir;
@@ -88,13 +88,13 @@ static std::vector<std::string> kKeywords = {
 
 /////////////////////////////////////////////////////////////////////////////////////////
 
-int32_t bpp_parse_if_condition(details::bpp_macro_condition& cond,
-							   details::bpp_macro&			 macro,
+int32_t bpp_parse_if_condition(detail::bpp_macro_condition& cond,
+							   detail::bpp_macro&			 macro,
 							   bool&						 inactive_code,
 							   bool&						 defined,
 							   std::string&					 macro_str)
 {
-	if (cond.fType == details::kEqual)
+	if (cond.fType == detail::kEqual)
 	{
 		auto substr_macro =
 			macro_str.substr(macro_str.find(macro.fName) + macro.fName.size());
@@ -115,7 +115,7 @@ int32_t bpp_parse_if_condition(details::bpp_macro_condition& cond,
 			return 1;
 		}
 	}
-	else if (cond.fType == details::kNotEqual)
+	else if (cond.fType == detail::kNotEqual)
 	{
 		auto substr_macro =
 			macro_str.substr(macro_str.find(macro.fName) + macro.fName.size());
@@ -211,7 +211,7 @@ int32_t bpp_parse_if_condition(details::bpp_macro_condition& cond,
 		lhs = atol(number.c_str());
 	}
 
-	if (cond.fType == details::kGreaterThan)
+	if (cond.fType == detail::kGreaterThan)
 	{
 		if (lhs < rhs)
 		{
@@ -224,7 +224,7 @@ int32_t bpp_parse_if_condition(details::bpp_macro_condition& cond,
 		return 0;
 	}
 
-	if (cond.fType == details::kGreaterEqThan)
+	if (cond.fType == detail::kGreaterEqThan)
 	{
 		if (lhs <= rhs)
 		{
@@ -237,7 +237,7 @@ int32_t bpp_parse_if_condition(details::bpp_macro_condition& cond,
 		return 0;
 	}
 
-	if (cond.fType == details::kLesserEqThan)
+	if (cond.fType == detail::kLesserEqThan)
 	{
 		if (lhs >= rhs)
 		{
@@ -250,7 +250,7 @@ int32_t bpp_parse_if_condition(details::bpp_macro_condition& cond,
 		return 0;
 	}
 
-	if (cond.fType == details::kLesserThan)
+	if (cond.fType == detail::kLesserThan)
 	{
 		if (lhs > rhs)
 		{
@@ -461,7 +461,7 @@ void bpp_parse_file(std::ifstream& hdr_file, std::ofstream& pp_out)
 					}
 				}
 
-				details::bpp_macro macro;
+				detail::bpp_macro macro;
 
 				macro.fArgs	 = args;
 				macro.fName	 = macro_key;
@@ -699,29 +699,29 @@ void bpp_parse_file(std::ifstream& hdr_file, std::ofstream& pp_out)
 			{
 				inactive_code = true;
 
-				std::vector<details::bpp_macro_condition> bpp_macro_condition_list = {
+				std::vector<detail::bpp_macro_condition> bpp_macro_condition_list = {
 					{
-						.fType	   = details::kEqual,
+						.fType	   = detail::kEqual,
 						.fTypeName = "==",
 					},
 					{
-						.fType	   = details::kNotEqual,
+						.fType	   = detail::kNotEqual,
 						.fTypeName = "!=",
 					},
 					{
-						.fType	   = details::kLesserThan,
+						.fType	   = detail::kLesserThan,
 						.fTypeName = "<",
 					},
 					{
-						.fType	   = details::kGreaterThan,
+						.fType	   = detail::kGreaterThan,
 						.fTypeName = ">",
 					},
 					{
-						.fType	   = details::kLesserEqThan,
+						.fType	   = detail::kLesserEqThan,
 						.fTypeName = "<=",
 					},
 					{
-						.fType	   = details::kGreaterEqThan,
+						.fType	   = detail::kGreaterEqThan,
 						.fTypeName = ">=",
 					},
 				};
@@ -941,19 +941,19 @@ NDK_MODULE(CPlusPlusPreprocessorMain)
 		bool skip		 = false;
 		bool double_skip = false;
 
-		details::bpp_macro macro_1;
+		detail::bpp_macro macro_1;
 		macro_1.fName  = "__true";
 		macro_1.fValue = "1";
 
 		kMacros.push_back(macro_1);
 
-		details::bpp_macro macro_0;
+		detail::bpp_macro macro_0;
 		macro_0.fName  = "__false";
 		macro_0.fValue = "0";
 
 		kMacros.push_back(macro_0);
 
-		details::bpp_macro macro_zka;
+		detail::bpp_macro macro_zka;
 		macro_zka.fName	 = "__ZKA__";
 		macro_zka.fValue = "1";
 
@@ -1035,7 +1035,7 @@ NDK_MODULE(CPlusPlusPreprocessorMain)
 					if (is_string)
 						macro_value += "\"";
 
-					details::bpp_macro macro;
+					detail::bpp_macro macro;
 					macro.fName	 = macro_key;
 					macro.fValue = macro_value;
 
diff --git a/dev/NDK/Sources/IdlCompiler.cxx b/dev/NDK/Sources/IdlCompiler.cxx
new file mode 100644
index 0000000..300374b
--- /dev/null
+++ b/dev/NDK/Sources/IdlCompiler.cxx
@@ -0,0 +1,32 @@
+/* -------------------------------------------
+
+	Copyright ZKA Technologies
+
+    FILE: XIDL.cxx
+    PURPOSE: XPCOM IDL COMPILER.
+
+------------------------------------------- */
+
+#include <NDK/NFC/ErrorID.hxx>
+
+//! Assembler Kit
+#include <NDK/Asm/Asm.hxx>
+
+//! Preferred Executable Format
+#include <NDK/NFC/PEF.hxx>
+#include <NDK/UUID.hxx>
+//! Dist version
+#include <NDK/Version.hxx>
+
+//! Advanced Executable Object Format
+#include <NDK/NFC/AE.hxx>
+
+/***
+    @brief IDL compiler maih.
+*/
+
+NDK_MODULE(ZKAIdlMain)
+{
+
+    return 0;
+}
diff --git a/dev/NDK/Sources/Linker.cxx b/dev/NDK/Sources/Linker.cxx
index 385f742..4aa9cb6 100644
--- a/dev/NDK/Sources/Linker.cxx
+++ b/dev/NDK/Sources/Linker.cxx
@@ -50,9 +50,8 @@
 enum
 {
 	eABIStart	= 0x1010, /* Invalid ABI start of ABI list. */
-	eABINewOS	= 0x5046, /* PF (NewOSKrnl) */
-	eABIMTL		= 0x4650, /* FP (MTL firmware) */
-	eABIInvalid = 1,
+	eABINewOS	= 0x5046, /* PF (ZKA PEF ABI) */
+	eABIInvalid = 0xFFFF,
 };
 
 static std::string kOutput			 = "";
@@ -77,6 +76,10 @@ static uintptr_t kMIBCount = 8;
 #define kPrintF			printf
 #define kLinkerSplash() kPrintF(kWhite kLinkerVersion, kDistVersion)
 
+/***
+    @brief ZKA linker main
+*/
+
 NDK_MODULE(ZKALinkerMain)
 {
 	bool is_executable = true;
@@ -95,12 +98,12 @@ NDK_MODULE(ZKALinkerMain)
 			kStdOut << "/Verbose: Enable linker trace.\n";
 			kStdOut << "/DLL: Output as a shared PEF.\n";
 			kStdOut << "/FAT: Output as a FAT PEF.\n";
-			kStdOut << "/32x0: Output as a 32x0 PEF.\n";
-			kStdOut << "/64x0: Output as a 64x0 PEF.\n";
-			kStdOut << "/amd64: Output as a AMD64 PEF.\n";
-			kStdOut << "/rv64: Output as a RISC-V PEF.\n";
-			kStdOut << "/power64: Output as a POWER PEF.\n";
-			kStdOut << "/arm64: Output as a ARM64 PEF.\n";
+			kStdOut << "/32X0: Output as a 32x0 PEF.\n";
+			kStdOut << "/64X0: Output as a 64x0 PEF.\n";
+			kStdOut << "/AMD64: Output as a AMD64 PEF.\n";
+			kStdOut << "/RV64: Output as a RISC-V PEF.\n";
+			kStdOut << "/POWER64: Output as a POWER PEF.\n";
+			kStdOut << "/ARM64: Output as a ARM64 PEF.\n";
 			kStdOut << "/Output: Select the output file name.\n";
 
 			return 0;
@@ -244,9 +247,9 @@ NDK_MODULE(ZKALinkerMain)
 	pef_container.Start = kLinkerDefaultOrigin;
 	pef_container.HdrSz = sizeof(NDK::PEFContainer);
 
-	std::ofstream outputFc(kOutput, std::ofstream::binary);
+	std::ofstream output_fc(kOutput, std::ofstream::binary);
 
-	if (outputFc.bad())
+	if (output_fc.bad())
 	{
 		if (kVerbose)
 		{
@@ -258,7 +261,7 @@ NDK_MODULE(ZKALinkerMain)
 
 	//! Read AE to convert as PEF.
 
-	std::vector<NDK::PEFCommandHeader> commandHdrsList;
+	std::vector<NDK::PEFCommandHeader> command_headers;
 	NDK::Utils::AEReadableProtocol	   readProto{};
 
 	for (const auto& i : kObjectList)
@@ -298,7 +301,7 @@ NDK_MODULE(ZKALinkerMain)
 				{
 					if (kVerbose)
 					{
-						kStdOut << "Yes.\n";
+						kStdOut << "Architecture matches.\n";
 					}
 				}
 			}
@@ -373,7 +376,7 @@ NDK_MODULE(ZKALinkerMain)
 					kStdOut << "link: object record offset: " << command_header.Offset << "\n";
 				}
 
-				commandHdrsList.emplace_back(command_header);
+				command_headers.emplace_back(command_header);
 			}
 
 			delete[] raw_ae_records;
@@ -381,6 +384,8 @@ NDK_MODULE(ZKALinkerMain)
 			std::vector<char> bytes;
 			bytes.resize(ae_header.fCodeSize);
 
+			// TODO: Port this for NeFS filesystems.
+
 			readProto.FP.seekg(std::streamsize(ae_header.fStartCode));
 			readProto.FP.read(bytes.data(), std::streamsize(ae_header.fCodeSize));
 
@@ -403,48 +408,48 @@ NDK_MODULE(ZKALinkerMain)
 
 	pef_container.Cpu = archs;
 
-	outputFc << pef_container;
+	output_fc << pef_container;
 
 	if (kVerbose)
 	{
 		kStdOut << "link: wrote container header.\n";
 	}
 
-	outputFc.seekp(std::streamsize(pef_container.HdrSz));
+	output_fc.seekp(std::streamsize(pef_container.HdrSz));
 
 	std::vector<std::string> not_found;
 	std::vector<std::string> symbols;
 
 	// step 2: check for errors (multiple symbols, undefined ones)
 
-	for (auto& commandHdr : commandHdrsList)
+	for (auto& command_hdr : command_headers)
 	{
 		// check if this symbol needs to be resolved.
-		if (std::string(commandHdr.Name).find(kLdDefineSymbol) !=
+		if (std::string(command_hdr.Name).find(kLdDefineSymbol) !=
 				std::string::npos &&
-			std::string(commandHdr.Name).find(kLdDynamicSym) == std::string::npos)
+			std::string(command_hdr.Name).find(kLdDynamicSym) == std::string::npos)
 		{
 			if (kVerbose)
-				kStdOut << "link: found undefined symbol: " << commandHdr.Name << "\n";
+				kStdOut << "link: found undefined symbol: " << command_hdr.Name << "\n";
 
 			if (auto it = std::find(not_found.begin(), not_found.end(),
-									std::string(commandHdr.Name));
+									std::string(command_hdr.Name));
 				it == not_found.end())
 			{
-				not_found.emplace_back(commandHdr.Name);
+				not_found.emplace_back(command_hdr.Name);
 			}
 		}
 
-		symbols.emplace_back(commandHdr.Name);
+		symbols.emplace_back(command_hdr.Name);
 	}
 
 	// Now try to solve these symbols.
 
-	for (size_t not_found_idx = 0; not_found_idx < commandHdrsList.size();
+	for (size_t not_found_idx = 0; not_found_idx < command_headers.size();
 		 ++not_found_idx)
 	{
 		if (auto it = std::find(not_found.begin(), not_found.end(),
-								std::string(commandHdrsList[not_found_idx].Name));
+								std::string(command_headers[not_found_idx].Name));
 			it != not_found.end())
 		{
 			std::string symbol_imp = *it;
@@ -462,14 +467,14 @@ NDK_MODULE(ZKALinkerMain)
 
 			// the reason we do is because, this may not match the symbol, and we need
 			// to look for other matching symbols.
-			for (auto& commandHdr : commandHdrsList)
+			for (auto& command_hdr : command_headers)
 			{
-				if (std::string(commandHdr.Name).find(symbol_imp) !=
+				if (std::string(command_hdr.Name).find(symbol_imp) !=
 						std::string::npos &&
-					std::string(commandHdr.Name).find(kLdDefineSymbol) ==
+					std::string(command_hdr.Name).find(kLdDefineSymbol) ==
 						std::string::npos)
 				{
-					std::string undefined_symbol = commandHdr.Name;
+					std::string undefined_symbol = command_hdr.Name;
 					auto		result_of_sym =
 						undefined_symbol.substr(undefined_symbol.find(symbol_imp));
 
@@ -482,7 +487,7 @@ NDK_MODULE(ZKALinkerMain)
 					not_found.erase(it);
 
 					if (kVerbose)
-						kStdOut << "link: found symbol: " << commandHdr.Name << "\n";
+						kStdOut << "link: found symbol: " << command_hdr.Name << "\n";
 
 					break;
 				}
@@ -519,10 +524,10 @@ NDK_MODULE(ZKALinkerMain)
 
 	dateHeader.Flags  = 0;
 	dateHeader.Kind	  = NDK::kPefZero;
-	dateHeader.Offset = outputFc.tellp();
+	dateHeader.Offset = output_fc.tellp();
 	dateHeader.Size	  = timeStampStr.size();
 
-	commandHdrsList.push_back(dateHeader);
+	command_headers.push_back(dateHeader);
 
 	NDK::PEFCommandHeader abiHeader{};
 
@@ -552,11 +557,11 @@ NDK_MODULE(ZKALinkerMain)
 	memcpy(abiHeader.Name, abi.c_str(), abi.size());
 
 	abiHeader.Size	 = abi.size();
-	abiHeader.Offset = outputFc.tellp();
+	abiHeader.Offset = output_fc.tellp();
 	abiHeader.Flags	 = 0;
 	abiHeader.Kind	 = NDK::kPefLinkerID;
 
-	commandHdrsList.push_back(abiHeader);
+	command_headers.push_back(abiHeader);
 
 	NDK::PEFCommandHeader stackHeader{0};
 
@@ -566,7 +571,7 @@ NDK_MODULE(ZKALinkerMain)
 	stackHeader.Offset = (kMIBCount * 1024 * 1024);
 	memcpy(stackHeader.Name, kLinkerStackSizeSymbol, strlen(kLinkerStackSizeSymbol));
 
-	commandHdrsList.push_back(stackHeader);
+	command_headers.push_back(stackHeader);
 
 	NDK::PEFCommandHeader uuidHeader{};
 
@@ -585,47 +590,47 @@ NDK_MODULE(ZKALinkerMain)
 	memcpy(uuidHeader.Name + strlen("Container:GUID:4:"), uuidStr.c_str(),
 		   uuidStr.size());
 
-	uuidHeader.Size	  = 16;
-	uuidHeader.Offset = outputFc.tellp();
-	uuidHeader.Flags  = 0;
+	uuidHeader.Size	  = strlen(uuidHeader.Name);
+	uuidHeader.Offset = output_fc.tellp();
+	uuidHeader.Flags  = NDK::kPefLinkerID;
 	uuidHeader.Kind	  = NDK::kPefZero;
 
-	commandHdrsList.push_back(uuidHeader);
+	command_headers.push_back(uuidHeader);
 
 	// prepare a symbol vector.
-	std::vector<std::string> undefSymbols;
-	std::vector<std::string> duplSymbols;
-	std::vector<std::string> resolveSymbols;
+	std::vector<std::string> undef_symbols;
+	std::vector<std::string> dupl_symbols;
+	std::vector<std::string> resolve_symbols;
 
 	constexpr Int32 cPaddingOffset = 16;
 
-	size_t previousOffset = (commandHdrsList.size() * sizeof(NDK::PEFCommandHeader)) + cPaddingOffset;
+	size_t previous_offset = (command_headers.size() * sizeof(NDK::PEFCommandHeader)) + cPaddingOffset;
 
 	// Finally write down the command headers.
 	// And check for any duplications
 	for (size_t commandHeaderIndex = 0UL;
-		 commandHeaderIndex < commandHdrsList.size(); ++commandHeaderIndex)
+		 commandHeaderIndex < command_headers.size(); ++commandHeaderIndex)
 	{
-		if (std::string(commandHdrsList[commandHeaderIndex].Name)
+		if (std::string(command_headers[commandHeaderIndex].Name)
 					.find(kLdDefineSymbol) != std::string::npos &&
-			std::string(commandHdrsList[commandHeaderIndex].Name)
+			std::string(command_headers[commandHeaderIndex].Name)
 					.find(kLdDynamicSym) == std::string::npos)
 		{
 			// ignore :UndefinedSymbol: headers, they do not contain code.
 			continue;
 		}
 
-		std::string symbolName = commandHdrsList[commandHeaderIndex].Name;
+		std::string symbol_name = command_headers[commandHeaderIndex].Name;
 
-		if (!symbolName.empty())
+		if (!symbol_name.empty())
 		{
-			undefSymbols.emplace_back(symbolName);
+			undef_symbols.emplace_back(symbol_name);
 		}
 
-		commandHdrsList[commandHeaderIndex].Offset += previousOffset;
-		previousOffset += commandHdrsList[commandHeaderIndex].Size;
+		command_headers[commandHeaderIndex].Offset += previous_offset;
+		previous_offset += command_headers[commandHeaderIndex].Size;
 
-		std::string name = commandHdrsList[commandHeaderIndex].Name;
+		std::string name = command_headers[commandHeaderIndex].Name;
 
 		/// so this is valid when we get to the entrypoint.
 		/// it is always a code64 container. And should equal to kPefStart as well.
@@ -633,33 +638,33 @@ NDK_MODULE(ZKALinkerMain)
 		if (name.find(kPefStart) != std::string::npos &&
 			name.find(".code64") != std::string::npos)
 		{
-			pef_container.Start = commandHdrsList[commandHeaderIndex].Offset;
-			auto tellCurPos		= outputFc.tellp();
+			pef_container.Start = command_headers[commandHeaderIndex].Offset;
+			auto tellCurPos		= output_fc.tellp();
 
-			outputFc.seekp(0);
-			outputFc << pef_container;
+			output_fc.seekp(0);
+			output_fc << pef_container;
 
-			outputFc.seekp(tellCurPos);
+			output_fc.seekp(tellCurPos);
 		}
 
 		if (kVerbose)
 		{
 			kStdOut << "link: command header name: " << name << "\n";
-			kStdOut << "link: real address of command header content: " << commandHdrsList[commandHeaderIndex].Offset << "\n";
+			kStdOut << "link: real address of command header content: " << command_headers[commandHeaderIndex].Offset << "\n";
 		}
 
-		outputFc << commandHdrsList[commandHeaderIndex];
+		output_fc << command_headers[commandHeaderIndex];
 
-		for (size_t subCommandHeaderIndex = 0UL;
-			 subCommandHeaderIndex < commandHdrsList.size();
-			 ++subCommandHeaderIndex)
+		for (size_t sub_command_header_index = 0UL;
+			 sub_command_header_index < command_headers.size();
+			 ++sub_command_header_index)
 		{
-			if (subCommandHeaderIndex == commandHeaderIndex)
+			if (sub_command_header_index == commandHeaderIndex)
 				continue;
 
-			if (std::string(commandHdrsList[subCommandHeaderIndex].Name)
+			if (std::string(command_headers[sub_command_header_index].Name)
 						.find(kLdDefineSymbol) != std::string::npos &&
-				std::string(commandHdrsList[subCommandHeaderIndex].Name)
+				std::string(command_headers[sub_command_header_index].Name)
 						.find(kLdDynamicSym) == std::string::npos)
 			{
 				if (kVerbose)
@@ -671,19 +676,19 @@ NDK_MODULE(ZKALinkerMain)
 				continue;
 			}
 
-			auto& commandHdr = commandHdrsList[subCommandHeaderIndex];
+			auto& command_hdr = command_headers[sub_command_header_index];
 
-			if (commandHdr.Name ==
-				std::string(commandHdrsList[commandHeaderIndex].Name))
+			if (command_hdr.Name ==
+				std::string(command_headers[commandHeaderIndex].Name))
 			{
-				if (std::find(duplSymbols.cbegin(), duplSymbols.cend(),
-							  commandHdr.Name) == duplSymbols.cend())
+				if (std::find(dupl_symbols.cbegin(), dupl_symbols.cend(),
+							  command_hdr.Name) == dupl_symbols.cend())
 				{
-					duplSymbols.emplace_back(commandHdr.Name);
+					dupl_symbols.emplace_back(command_hdr.Name);
 				}
 
 				if (kVerbose)
-					kStdOut << "link: found duplicate symbol: " << commandHdr.Name
+					kStdOut << "link: found duplicate symbol: " << command_hdr.Name
 							<< "\n";
 
 				kDuplicateSymbols = true;
@@ -691,9 +696,9 @@ NDK_MODULE(ZKALinkerMain)
 		}
 	}
 
-	if (!duplSymbols.empty())
+	if (!dupl_symbols.empty())
 	{
-		for (auto& symbol : duplSymbols)
+		for (auto& symbol : dupl_symbols)
 		{
 			kStdOut << "link: multiple symbols of " << symbol << ".\n";
 		}
@@ -706,7 +711,7 @@ NDK_MODULE(ZKALinkerMain)
 
 	for (auto byte : kObjectBytes)
 	{
-		outputFc << byte;
+		output_fc << byte;
 	}
 
 	if (kVerbose)
@@ -714,28 +719,28 @@ NDK_MODULE(ZKALinkerMain)
 
 	// step 3: check if we have those symbols
 
-	std::vector<std::string> unrefSyms;
+	std::vector<std::string> unreferenced_symbols;
 
-	for (auto& commandHdr : commandHdrsList)
+	for (auto& command_hdr : command_headers)
 	{
 		if (auto it = std::find(not_found.begin(), not_found.end(),
-								std::string(commandHdr.Name));
+								std::string(command_hdr.Name));
 			it != not_found.end())
 		{
-			unrefSyms.emplace_back(commandHdr.Name);
+			unreferenced_symbols.emplace_back(command_hdr.Name);
 		}
 	}
 
-	if (!unrefSyms.empty())
+	if (!unreferenced_symbols.empty())
 	{
-		for (auto& unreferenced_symbol : unrefSyms)
+		for (auto& unreferenced_symbol : unreferenced_symbols)
 		{
 			kStdOut << "link: undefined symbol " << unreferenced_symbol << "\n";
 		}
 	}
 
 	if (!kStartFound || kDuplicateSymbols && std::filesystem::exists(kOutput) ||
-		!unrefSyms.empty())
+		!unreferenced_symbols.empty())
 	{
 		if (kVerbose)
 			kStdOut << "link: file: " << kOutput
diff --git a/dev/NDK/Sources/XIDL.cxx b/dev/NDK/Sources/XIDL.cxx
deleted file mode 100644
index 6284fd7..0000000
--- a/dev/NDK/Sources/XIDL.cxx
+++ /dev/null
@@ -1,14 +0,0 @@
-/* -------------------------------------------
-
-	Copyright ZKA Technologies
-
-    FILE: XIDL.cxx
-    PURPOSE: XPCOM IDL COMPILER.
-
-------------------------------------------- */
-
-int ZKAXIDLMain(int argc, char const *argv[])
-{
-    
-    return 0;
-}
diff --git a/dev/NDK/Sources/compile_flags.txt b/dev/NDK/Sources/compile_flags.txt
deleted file mode 100644
index 6ec6b8a..0000000
--- a/dev/NDK/Sources/compile_flags.txt
+++ /dev/null
@@ -1,5 +0,0 @@
--std=c++20
--I../
--I../Headers
--I./
--I./Detail/
diff --git a/dev/NDK/Version.hxx b/dev/NDK/Version.hxx
index accfc79..937252c 100644
--- a/dev/NDK/Version.hxx
+++ b/dev/NDK/Version.hxx
@@ -6,5 +6,5 @@
 
 #pragma once
 
-#define kDistVersion "v1.1.14"
-#define kDistRelease "Havok"
\ No newline at end of file
+#define kDistVersion "v1.1.0"
+#define kDistRelease "Master"