Merge pull request 'NetChannels' (#19) from NetChannels into main

Reviewed-on: #19

CMakeLists.txt

@@ -97,8 +97,6 @@ set(EHS_SOURCES
     include/ehs/system/OS.h
     include/ehs/system/Semaphore.h
     include/ehs/system/System.h
-    include/ehs/system/AVX2.h
-    include/ehs/system/AVX512.h
 
     src/json/Json.cpp include/ehs/json/Json.h
     src/json/JsonBase.cpp include/ehs/json/JsonBase.h
@@ -217,7 +215,6 @@ if (IS_OS_WINDOWS)
         src/system/CPU_MSVC_AMD64.asm src/HRNG_MSVC.asm src/Math_MSVC_AMD64.asm
         src/io/Directory_W32.cpp include/ehs/io/Directory_W32.h
         include/ehs/io/socket/ICMP_W32.h src/io/socket/ICMP_W32.cpp
-        src/system/AVX2_MSVC_AMD64.asm src/system/AVX512_MSVC_AMD64.asm
     )
 
 elseif (IS_OS_LINUX)
@@ -237,7 +234,6 @@ elseif (IS_OS_LINUX)
         src/io/Directory_LNX.cpp include/ehs/io/Directory_LNX.h
         src/io/Usb_LNX.cpp include/ehs/io/Usb_LNX.h
         include/ehs/io/socket/ICMP_LNX.h src/io/socket/ICMP_LNX.cpp
-        src/system/AVX2_GCC_AMD64.asm src/system/AVX512_GCC_AMD64.asm
     )
 
     #set(LINUX_WINDOW_SYSTEM "Wayland" CACHE STRING "Linux Window System")
@@ -258,7 +254,7 @@ elseif (IS_OS_LINUX)
     if (IS_ARCH_AMD64)
         list(APPEND EHS_SOURCES src/system/CPU_GCC_AMD64.asm src/HRNG_GCC.asm src/Math_GCC_AMD64.asm)
     elseif (IS_ARCH_ARM64)
-        list(APPEND EHS_SOURCES src/system/CPU_ARM64.cpp src/HRNG_ARM64.cpp src/Math_GCC_ARM64.s src/system/AVX2_AARCH64.cpp src/system/AVX512_AARCH64.cpp)
+        list(APPEND EHS_SOURCES src/system/CPU_ARM64.cpp src/HRNG_ARM64.cpp src/Math_GCC_ARM64.s)
     endif ()
 endif()
 

include/ehs/Log.h

@@ -134,17 +134,17 @@ namespace ehs
 
 #ifndef EHS_LOG_INT
 	#ifdef EHS_DEBUG
-		#define EHS_LOG_INT(type, code, msg) ehs::Log::Raise(ehs::Log(type, {ehs::GetAcronym_8(), EHS_FILE, EHS_FUNC, ehs::Str_8::FromNum((ehs::UInt_32)EHS_LINE)}, code, msg))
+		#define EHS_LOG_INT(type, code, msg) ehs::Log::Raise({type, {ehs::GetAcronym_8(), EHS_FILE, EHS_FUNC, ehs::Str_8::FromNum((ehs::UInt_32)EHS_LINE)}, code, msg})
 	#else
-		#define EHS_LOG_INT(type, code, msg) ehs::Log::Raise(ehs::Log(type, {ehs::GetAcronym_8(), EHS_FUNC}, code, msg))
+		#define EHS_LOG_INT(type, code, msg) ehs::Log::Raise({type, {ehs::GetAcronym_8(), EHS_FUNC}, code, msg})
 	#endif
 #endif
 
 #ifndef EHS_LOG
 	#ifdef EHS_DEBUG
-		#define EHS_LOG(type, code, msg) ehs::Log::Raise(ehs::Log(type, {ehs::GetAppName_8(), EHS_FILE, EHS_FUNC, ehs::Str_8::FromNum((ehs::UInt_32)EHS_LINE)}, code, msg))
+		#define EHS_LOG(type, code, msg) ehs::Log::Raise({type, {ehs::GetAppName_8(), EHS_FILE, EHS_FUNC, ehs::Str_8::FromNum((ehs::UInt_32)EHS_LINE)}, code, msg})
 	#else
-		#define EHS_LOG(type, code, msg) ehs::Log::Raise(ehs::Log(type, {ehs::GetAppName_8(), EHS_FUNC}, code, msg))
+		#define EHS_LOG(type, code, msg) ehs::Log::Raise({type, {ehs::GetAppName_8(), EHS_FUNC}, code, msg})
 	#endif
 #endif
 

include/ehs/Str.h

@@ -48,11 +48,8 @@ namespace ehs
 		/// @param [in] str The C-style string.
 		/// @param [in] size The size of the given C-style string.
 		Str(const T* const str, const N size)
-			: size(size), data(nullptr)
+			: size((size) ? size : Len(str)), data(nullptr)
 		{
-        	if (!size)
-        		return;
-
 			data = new T[this->size + 1];
 
             Util::Copy(data, str, Size(true));
@@ -917,10 +914,10 @@ namespace ehs
 		}
 
 		/// Splits a string into a Vector with the given separator.
-		/// @param [in] delimeter The given string as the separator.
+		/// @param [in] ide The given string as the separator.
 		/// @param [in] max The max amount of times to split the string.
 		/// @returns The resulting string object.
-		Vector<Str<T, N>, N> Split(const Str<T, N>& delimeter, const N max = 0) const
+		Vector<Str<T, N>, N> Split(const Str<T, N>& ide, const N max = 0) const
 		{
 			Vector<Str<T, N>, N> result(0, 5);
 
@@ -928,9 +925,9 @@ namespace ehs
 
 			for (N i = 0, c = 0; i < size; ++i)
 			{
-				if (data[i] == delimeter[c])
+				if (data[i] == ide[c])
 				{
-					if (++c == delimeter.Size())
+					if (++c == ide.Size())
 					{
 					    N r = i - (c - 1) - b;
 					    if (!r)
@@ -958,17 +955,17 @@ namespace ehs
 		}
 
 		/// Removes all instances of the ide.
-		/// @param [in] delimeter The string to look for.
+		/// @param [in] ide The string to look for.
 		/// @returns The resulting string object.
-		Str<T, N> RemoveAll(const Str<T, N>& delimeter) const
+		Str<T, N> RemoveAll(const Str<T, N>& ide) const
 		{
 			Str<T, N> result(size);
 
 			for (N i = 0, b = 0, c = 0; i < size; ++i)
 			{
-				if (data[i] == delimeter[c])
+				if (data[i] == ide[c])
 				{
-					if (++c == delimeter.Size())
+					if (++c == ide.Size())
 						c = 0;
 				}
 				else
@@ -987,18 +984,18 @@ namespace ehs
 		}
 
 		/// Replaces all instances of ide with the replacer.
-		/// @param [in] delimeter The string to look for.
+		/// @param [in] ide The string to look for.
 		/// @param [in] replacer The string placed.
 		/// @returns The resulting string object.
-		Str ReplaceAll(const Str& delimeter, const Str& replacer) const
+		Str ReplaceAll(const Str& ide, const Str& replacer) const
 		{
 			Str<T, N> result;
 
 			for (N i = 0, b = 0; i < size; ++i)
 			{
-				if (data[i] == delimeter[b])
+				if (data[i] == ide[b])
 				{
-					if (++b == delimeter.Size())
+					if (++b == ide.Size())
 					{
 						result.Push(replacer);
 						b = 0;
@@ -1014,20 +1011,20 @@ namespace ehs
 		}
 
 		/// Finds the first instance of the given string object.
-		/// @param [in] delimeter The string to look for.
+		/// @param [in] ide The string to look for.
 		/// @param [out] index The index of the string found. Can be a nullptr.
 		/// @param [in] pattern The search pattern for optimization.
 		/// @param [in] result What index to return where the first instance is found.
 		/// @returns The index where the instance was found with the result varying from the result parameter.
-		bool Find(const Str<T, N> &delimeter, N* const index = nullptr, const SearchPattern pattern = SearchPattern::LEFT_RIGHT, const IndexResult result = IndexResult::BEGINNING) const
+		bool Find(const Str<T, N> &ide, N* const index = nullptr, const SearchPattern pattern = SearchPattern::LEFT_RIGHT, const IndexResult result = IndexResult::BEGINNING) const
 		{
 			if (pattern == SearchPattern::LEFT_RIGHT)
 			{
 				for (N i = 0, c = 0; i < size; ++i)
 				{
-					if (data[i] == delimeter[c])
+					if (data[i] == ide[c])
 					{
-						if (++c == delimeter.Size())
+						if (++c == ide.Size())
 						{
 							if (result == IndexResult::BEGINNING)
                             {
@@ -1049,16 +1046,16 @@ namespace ehs
 			}
 			else if (pattern == SearchPattern::RIGHT_LEFT)
 			{
-				for (N i = size, c = delimeter.Size(); i > 0; --i)
+				for (N i = size, c = ide.Size(); i > 0; --i)
 				{
-					if (data[i - 1] == delimeter[c - 1])
+					if (data[i - 1] == ide[c - 1])
 					{
 						if (--c == 0)
 						{
 							if (result == IndexResult::BEGINNING)
                             {
                                 if (index)
-                                    *index = i - (delimeter.Size() - 1);
+                                    *index = i - (ide.Size() - 1);
 
                                 return true;
                             }
@@ -1078,18 +1075,18 @@ namespace ehs
 		}
 
 		/// Checks if the current string contains the given ide.
-		/// @param [in] delimeter The given ide to check for.
+		/// @param [in] ide The given ide to check for.
 		/// @param [in] pattern The search pattern to use.
 		/// @returns True if the current string does contain the ide.
-        bool Contains(const Str<T, N>& delimeter, const SearchPattern pattern = SearchPattern::LEFT_RIGHT) const
+        bool Contains(const Str<T, N>& ide, const SearchPattern pattern = SearchPattern::LEFT_RIGHT) const
         {
             if (pattern == SearchPattern::LEFT_RIGHT)
             {
                 for (N i = 0, c = 0; i < size; ++i)
                 {
-                    if (data[i] == delimeter[c])
+                    if (data[i] == ide[c])
                     {
-                        if (++c == delimeter.Size())
+                        if (++c == ide.Size())
                         {
                             return true;
                         }
@@ -1098,9 +1095,9 @@ namespace ehs
             }
             else if (pattern == SearchPattern::RIGHT_LEFT)
             {
-                for (N i = size, c = delimeter.Size(); i > 0; --i)
+                for (N i = size, c = ide.Size(); i > 0; --i)
                 {
-                    if (data[i - 1] == delimeter[c - 1])
+                    if (data[i - 1] == ide[c - 1])
                     {
                         if (--c == 0)
                         {
@@ -1113,54 +1110,6 @@ namespace ehs
             return false;
         }
 
-		Vector<Str> ParseArgs() const
-        {
-	        Vector<Str> args;
-        	T *quoteStart = nullptr;
-        	T *spaceStart = nullptr;
-
-        	for (T *i = data; i <= data + size; ++i)
-        	{
-        		if (*i == '\"' && !spaceStart)
-        		{
-        			if (quoteStart)
-        			{
-        				args.Push(Str(quoteStart, i - quoteStart));
-        				quoteStart = nullptr;
-        			}
-        			else
-        			{
-        				if (i + 1 < &data[size - 1])
-        					quoteStart = i + 1;
-        				else
-        					args.Push({});
-        			}
-        		}
-        		else if (*i == ' ' && !quoteStart)
-        		{
-        			if (spaceStart)
-        			{
-        				args.Push(Str(spaceStart, i - spaceStart));
-        				spaceStart = i + 1;
-        			}
-        			else
-        			{
-        				if (i + 1 < &data[size - 1])
-        					spaceStart = i + 1;
-        				else
-        					args.Push({});
-        			}
-        		}
-        	}
-
-        	if (quoteStart)
-        		args.Push(Str(quoteStart, &data[size - 1] - (quoteStart - 1)));
-        	else if (spaceStart)
-        		args.Push(Str(spaceStart, &data[size - 1] - (spaceStart - 1)));
-
-        	return args;
-        }
-
 		/// Checks if the string represents a number. Must not have any alphabetical characters.
 		/// @returns The result.
 		bool IsNum() const

include/ehs/Vector.h

@@ -392,7 +392,7 @@ namespace ehs
 			{
 				if (stride)
 				{
-					rawSize = (this->size + size) / stride * stride;
+					rawSize = (this->size + size()) / stride * stride;
 					if ((this->size + size) % stride)
 						rawSize += stride;
 				}
@@ -403,7 +403,7 @@ namespace ehs
 
 				T* result = new T[rawSize];
 
-				for (N i = 0; i < this->size; ++i)
+				for (N i = 0; i < size; ++i)
 					result[i] = std::move(data[i]);
 
 				delete[] data;

include/ehs/system/AVX2.h

@@ -1,36 +0,0 @@
-#pragma once
-
-#include "ehs/Types.h"
-
-namespace ehs
-{
-    class AVX2
-    {
-    public:
-        /// Compares two unaligned 4 element vectors using 64-bit integers.
-        /// @param [in] a First vector.
-        /// @param [in] b Second vector.
-        /// @returns True if all 4 elements are equal. False otherwise.
-        static bool CompareUnaligned(const UInt_64 *a, const UInt_64 *b);
-
-        /// Compares two unaligned 4 element vectors using 64-bit integers.
-        /// @param [in] a First vector.
-        /// @param [in] b Second vector.
-        /// @returns True if all 4 elements are equal. False otherwise.
-        static bool CompareUnaligned(const SInt_64 *a, const SInt_64 *b);
-
-        /// Compares two aligned 4 element vectors using 64-bit integers.
-        /// @param [in] a First vector.
-        /// @param [in] b Second vector.
-        /// @returns True if all 4 elements are equal. False otherwise.
-        /// @note The parameters "a", and "b" must have alignas(32).
-        static bool CompareAligned(const UInt_64 *a, const UInt_64 *b);
-
-        /// Compares two aligned 4 element vectors using 64-bit integers.
-        /// @param [in] a First vector.
-        /// @param [in] b Second vector.
-        /// @returns True if all 4 elements are equal. False otherwise.
-        /// @note The parameters "a", and "b" must have alignas(32).
-        static bool CompareAligned(const SInt_64 *a, const SInt_64 *b);
-    };
-}

include/ehs/system/AVX512.h

@@ -1,36 +0,0 @@
-#pragma once
-
-#include "ehs/Types.h"
-
-namespace ehs
-{
-    class AVX512
-    {
-    public:
-        /// Compares two unaligned 8 element vectors using 64-bit integers.
-        /// @param [in] a First vector.
-        /// @param [in] b Second vector.
-        /// @returns True if all 8 elements are equal. False otherwise.
-        static bool CompareUnaligned(const UInt_64 *a, const UInt_64 *b);
-
-        /// Compares two unaligned 8 element vectors using 64-bit integers.
-        /// @param [in] a First vector.
-        /// @param [in] b Second vector.
-        /// @returns True if all 8 elements are equal. False otherwise.
-        static bool CompareUnaligned(const SInt_64 *a, const SInt_64 *b);
-
-        /// Compares two aligned 8 element vectors using 64-bit integers.
-        /// @param [in] a First vector.
-        /// @param [in] b Second vector.
-        /// @returns True if all 8 elements are equal. False otherwise.
-        /// @note The parameters "a", and "b" must have alignas(32).
-        static bool CompareAligned(const UInt_64 *a, const UInt_64 *b);
-
-        /// Compares two aligned 8 element vectors using 64-bit integers.
-        /// @param [in] a First vector.
-        /// @param [in] b Second vector.
-        /// @returns True if all 8 elements are equal. False otherwise.
-        /// @note The parameters "a", and "b" must have alignas(32).
-        static bool CompareAligned(const SInt_64 *a, const SInt_64 *b);
-    };
-}

include/ehs/system/CPU.h

@@ -38,70 +38,6 @@ namespace ehs
         #endif
 
 	public:
-		static const bool hasFPU;
-		static const bool hasVME;
-		static const bool hasDE;
-		static const bool hasPSE;
-		static const bool hasTSC;
-		static const bool hasMSR;
-		static const bool hasPAE;
-		static const bool hasMCE;
-		static const bool hasCX8;
-		static const bool hasAPIC;
-		static const bool hasSEP;
-		static const bool hasMTRR;
-		static const bool hasPGE;
-		static const bool hasMCA;
-		static const bool hasCMOV;
-		static const bool hasPSE_36;
-		static const bool hasPSN;
-		static const bool hasCLFSH;
-		static const bool hasDS;
-		static const bool hasACPI;
-		static const bool hasMMX;
-		static const bool hasFXSR;
-		static const bool hasSSE;
-		static const bool hasSSE2;
-		static const bool hasSS;
-		static const bool hasHTT;
-		static const bool hasTM;
-		static const bool hasIA64;
-		static const bool hasPBE;
-		static const bool hasSSE3;
-		static const bool hasPCLMULQDQ;
-		static const bool hasDTES64;
-		static const bool hasMONITOR;
-		static const bool hasVMX;
-		static const bool hasSMX;
-		static const bool hasEST;
-		static const bool hasTM2;
-		static const bool hasSSSE3;
-		static const bool hasCNXT_ID;
-		static const bool hasSDBG;
-		static const bool hasFMA;
-		static const bool hasCX16;
-		static const bool hasXTPR;
-		static const bool hasPDCM;
-		static const bool hasPCID;
-		static const bool hasDCA;
-		static const bool hasSSE4_1;
-		static const bool hasSSE4_2;
-		static const bool hasX2APIC;
-		static const bool hasMOVBE;
-		static const bool hasPOPCNT;
-		static const bool hasTSC_DEADLINE;
-		static const bool hasAES;
-		static const bool hasXSAVE;
-		static const bool hasOSXSAVE;
-		static const bool hasAVX;
-		static const bool hasF16C;
-		static const bool hasRDRND;
-		static const bool hasHYPERVISOR;
-		static const bool hasAVX2;
-		static const bool hasAVX512F;
-		static const bool hasRDSEED;
-		static const bool hasADX;
-
 		static Architecture GetArchitecture();
 
 		static UInt_8 PointerSize();
@@ -132,155 +68,153 @@ namespace ehs
 
 		static UInt_8 GetExtFamilyId();
 
-		/// Retrieves the CPU brand as a null-terminated ASCII string.
-		/// @param[out] input A 48 byte character array representing the brand.
+		static UInt_32 GetFeatureBits_1();
+
+		static bool HasFPU();
+
+		static bool HasVME();
+
+		static bool HasDE();
+
+		static bool HasPSE();
+
+		static bool HasTSC();
+
+		static bool HasMSR();
+
+		static bool HasPAE();
+
+		static bool HasMCE();
+
+		static bool HasCX8();
+
+		static bool HasAPIC();
+
+		static bool HasSEP();
+
+		static bool HasMTRR();
+
+		static bool HasPGE();
+
+		static bool HasMCA();
+
+		static bool HasCMOV();
+
+		static bool HasPAT();
+
+		static bool HasPSE_36();
+
+		static bool HasPSN();
+
+		static bool HasCLFSH();
+
+		static bool HasDS();
+
+		static bool HasACPI();
+
+		static bool HasMMX();
+
+		static bool HasFXSR();
+
+		static bool HasSSE();
+
+		static bool HasSSE2();
+
+		static bool HasSS();
+
+		static bool HasHTT();
+
+		static bool HasTM();
+
+		static bool HasIA64();
+
+		static bool HasPBE();
+
+        static UInt_32 GetFeatureBits_2();
+
+        static bool HasSSE3();
+
+        static bool HasPCLMULQDQ();
+
+        static bool HasDTES64();
+
+        static bool HasMONITOR();
+
+        static bool HasDS_CPL();
+
+        static bool HasVMX();
+
+        static bool HasSMX();
+
+        static bool HasEST();
+
+        static bool HasTM2();
+
+        static bool HasSSSE3();
+
+        static bool HasCNXT_ID();
+
+        static bool HasSDBG();
+
+        static bool HasFMA();
+
+        static bool HasCX16();
+
+        static bool HasXTPR();
+
+        static bool HasPDCM();
+
+        static bool HasPCID();
+
+        static bool HasDCA();
+
+        static bool HasSSE4_1();
+
+        static bool HasSSE4_2();
+
+        static bool HasX2APIC();
+
+        static bool HasMOVBE();
+
+        static bool HasPOPCNT();
+
+        static bool HasTSC_DEADLINE();
+
+        static bool HasAES();
+
+        static bool HasXSAVE();
+
+        static bool HasOSXSAVE();
+
+        static bool HasAVX();
+
+        static bool HasF16C();
+
+        static bool HasRDRND();
+
+        static bool HasHYPERVISOR();
+
+        static UInt_32 GetExtFeatureBits_1();
+
+        static bool HasAVX2();
+
+        static bool HasRDSEED();
+
+        static bool HasADX();
+
+        static UInt_32 GetExtFeatureBits_2();
+
+        static UInt_32 GetExtFeatureBits_3();
+
+        /// Retrieves the CPU brand as a null-terminated ASCII string.
+        /// @param[out] input A 48 byte character array representing the brand.
 		static void GetBrand(Char_8* input);
 
 		static UInt_8 GetCacheLineSize();
 
-		static UInt_32 GetFeatureBits_1();
-
-		static UInt_32 GetFeatureBits_2();
-
-		static UInt_32 GetExtFeatureBits_1();
-
-		static UInt_32 GetExtFeatureBits_2();
-
-		static UInt_32 GetExtFeatureBits_3();
-
-	private:
-		static bool RetrieveFPU();
-
-		static bool RetrieveVME();
-
-		static bool RetrieveDE();
-
-		static bool RetrievePSE();
-
-		static bool RetrieveTSC();
-
-		static bool RetrieveMSR();
-
-		static bool RetrievePAE();
-
-		static bool RetrieveMCE();
-
-		static bool RetrieveCX8();
-
-		static bool RetrieveAPIC();
-
-		static bool RetrieveSEP();
-
-		static bool RetrieveMTRR();
-
-		static bool RetrievePGE();
-
-		static bool RetrieveMCA();
-
-		static bool RetrieveCMOV();
-
-		static bool RetrievePAT();
-
-		static bool RetrievePSE_36();
-
-		static bool RetrievePSN();
-
-		static bool RetrieveCLFSH();
-
-		static bool RetrieveDS();
-
-		static bool RetrieveACPI();
-
-		static bool RetrieveMMX();
-
-		static bool RetrieveFXSR();
-
-		static bool RetrieveSSE();
-
-		static bool RetrieveSSE2();
-
-		static bool RetrieveSS();
-
-		static bool RetrieveHTT();
-
-		static bool RetrieveTM();
-
-		static bool RetrieveIA64();
-
-		static bool RetrievePBE();
-
-        static bool RetrieveSSE3();
-
-        static bool RetrievePCLMULQDQ();
-
-        static bool RetrieveDTES64();
-
-        static bool RetrieveMONITOR();
-
-        static bool RetrieveDS_CPL();
-
-        static bool RetrieveVMX();
-
-        static bool RetrieveSMX();
-
-        static bool RetrieveEST();
-
-        static bool RetrieveTM2();
-
-        static bool RetrieveSSSE3();
-
-        static bool RetrieveCNXT_ID();
-
-        static bool RetrieveSDBG();
-
-        static bool RetrieveFMA();
-
-        static bool RetrieveCX16();
-
-        static bool RetrieveXTPR();
-
-        static bool RetrievePDCM();
-
-        static bool RetrievePCID();
-
-        static bool RetrieveDCA();
-
-        static bool RetrieveSSE4_1();
-
-        static bool RetrieveSSE4_2();
-
-        static bool RetrieveX2APIC();
-
-        static bool RetrieveMOVBE();
-
-        static bool RetrievePOPCNT();
-
-        static bool RetrieveTSC_DEADLINE();
-
-        static bool RetrieveAES();
-
-        static bool RetrieveXSAVE();
-
-        static bool RetrieveOSXSAVE();
-
-        static bool RetrieveAVX();
-
-        static bool RetrieveF16C();
-
-        static bool RetrieveRDRND();
-
-        static bool RetrieveHYPERVISOR();
-
-        static bool RetrieveAVX2();
-
-		static bool RetrieveAVX512F();
-
-        static bool RetrieveRDSEED();
-
-        static bool RetrieveADX();
-
 		//static Str_8 ToStr();
 
+    private:
         static UInt_64 RetrieveTSC_Freq();
 
         static UInt_64 CalculateTSC_Freq();

src/Math.cpp

@@ -36,9 +36,9 @@ namespace ehs
     double Math::Sqrt(const double from)
     {
 		#if defined(EHS_ARCH_X64)
-			if (CPU::hasAVX)
+			if (CPU::HasAVX())
 				return Sqrt_AVX(from);
-			else if (CPU::hasSSE)
+			else if (CPU::HasSSE())
 				return Sqrt_SSE2(from);
 
 			double temp = 0.0;
@@ -59,9 +59,9 @@ namespace ehs
     float Math::Sqrt(const float from)
     {
 		#if defined(EHS_ARCH_X64)
-			if (CPU::hasAVX)
+			if (CPU::HasAVX())
 				return Sqrt_AVX(from);
-			else if (CPU::hasSSE)
+			else if (CPU::HasSSE())
 				return Sqrt_SSE(from);
 
 			float temp = 0.0f;

src/Util.cpp

@@ -1,9 +1,5 @@
 #include "ehs/Util.h"
 
-#include "ehs/system/CPU.h"
-#include "ehs/system/AVX2.h"
-#include "ehs/system/AVX512.h"
-
 namespace ehs
 {
 	bool Util::Compare(const void* const a, const void* const b, const UInt_64 size)
@@ -122,4 +118,4 @@ namespace ehs
 			remainder = size - i;
 		}
 	}
-}
+}

src/io/Console.cpp

@@ -693,7 +693,7 @@ namespace ehs
 	Vector<Str_32> Console::GetArgs_32(const UInt_64 bufferSize)
     {
         #if defined(EHS_OS_WINDOWS)
-            return UTF::To_32(GetCommandLineW()).ParseArgs();
+            return UTF::To_32(GetCommandLineW()).Split(U" ");
         #elif defined(EHS_OS_LINUX)
 			File cmdFile("/proc/self/cmdline", Mode::READ, Disposition::OPEN);
 			Array<Byte> data = cmdFile.ReadArray(bufferSize);
@@ -725,7 +725,7 @@ namespace ehs
 	Vector<Str_16> Console::GetArgs_16(const UInt_64 bufferSize)
     {
         #if defined(EHS_OS_WINDOWS)
-            return Str_16(GetCommandLineW()).ParseArgs();
+            return Str_16(GetCommandLineW()).Split(L" ");
         #elif defined(EHS_OS_LINUX)
 			File cmdFile("/proc/self/cmdline", Mode::READ, Disposition::OPEN);
 			Array<Byte> data = cmdFile.ReadArray(bufferSize);
@@ -755,7 +755,7 @@ namespace ehs
     Vector<Str_8> Console::GetArgs_8(const UInt_64 bufferSize)
     {
         #if defined(EHS_OS_WINDOWS)
-            return UTF::To_8(GetCommandLineW()).ParseArgs();
+            return UTF::To_8(GetCommandLineW()).Split(" ");
         #elif defined(EHS_OS_LINUX)
 			File cmdFile("/proc/self/cmdline", Mode::READ, Disposition::OPEN);
 			Array<Byte> data = cmdFile.ReadArray(bufferSize);

src/system/AVX2_AARCH64.cpp

@@ -1,24 +0,0 @@
-#include "ehs/system/AVX2.h"
-
-namespace ehs
-{
-    bool AVX2::CompareUnaligned(const UInt_64* a, const UInt_64* b)
-    {
-        return false;
-    }
-
-    bool AVX2::CompareUnaligned(const SInt_64* a, const SInt_64* b)
-    {
-        return false;
-    }
-
-    bool AVX2::CompareAligned(const UInt_64* a, const UInt_64* b)
-    {
-        return false;
-    }
-
-    bool AVX2::CompareAligned(const SInt_64* a, const SInt_64* b)
-    {
-        return false;
-    }
-}

src/system/AVX2_GCC_AMD64.asm

@@ -1,49 +0,0 @@
-global _ZN3ehs4AVX216CompareUnalignedEPKmS2_
-global _ZN3ehs4AVX216CompareUnalignedEPKlS2_
-global _ZN3ehs4AVX214CompareAlignedEPKmS2_
-global _ZN3ehs4AVX214CompareAlignedEPKlS2_
-
-section .text
-    _ZN3ehs4AVX216CompareUnalignedEPKmS2_:
-        VMOVDQU YMM0, [RDI]
-        VMOVDQU YMM1, [RSI]
-        VPCMPEQQ YMM2, YMM0, YMM1
-
-        VPMOVMSKB EAX, YMM2
-        CMP EAX, 0xFFFFFFFF
-        SETE AL
-
-        RET
-
-    _ZN3ehs4AVX216CompareUnalignedEPKlS2_:
-        VMOVDQU YMM0, [RDI]
-        VMOVDQU YMM1, [RSI]
-        VPCMPEQQ YMM2, YMM0, YMM1
-
-        VPMOVMSKB EAX, YMM2
-        CMP EAX, 0xFFFFFFFF
-        SETE AL
-
-        RET
-
-    _ZN3ehs4AVX214CompareAlignedEPKmS2_:
-        VMOVDQA YMM0, [RDI]
-        VMOVDQA YMM1, [RSI]
-        VPCMPEQQ YMM2, YMM0, YMM1
-
-        VPMOVMSKB EAX, YMM2
-        CMP EAX, 0xFFFFFFFF
-        SETE AL
-
-        RET
-
-    _ZN3ehs4AVX214CompareAlignedEPKlS2_:
-        VMOVDQA YMM0, [RDI]
-        VMOVDQA YMM1, [RSI]
-        VPCMPEQQ YMM2, YMM0, YMM1
-
-        VPMOVMSKB EAX, YMM2
-        CMP EAX, 0xFFFFFFFF
-        SETE AL
-
-        RET

src/system/AVX2_MSVC_AMD64.asm

@@ -1,49 +0,0 @@
-global ?CompareUnaligned@AVX2@ehs@@SA_NPEBK0@Z
-global ?CompareUnaligned@AVX2@ehs@@SA_NPEBJ0@Z
-global ?CompareAligned@AVX2@ehs@@SA_NPEBK0@Z
-global ?CompareAligned@AVX2@ehs@@SA_NPEBJ0@Z
-
-section .text
-    ?CompareUnaligned@AVX2@ehs@@SA_NPEBK0@Z:
-        VMOVDQU YMM0, [RCX]
-        VMOVDQU YMM1, [RDX]
-        VPCMPEQQ YMM2, YMM0, YMM1
-
-        VPMOVMSKB EAX, YMM2
-        CMP EAX, 0xFFFFFFFF
-        SETE AL
-
-        RET
-
-    ?CompareUnaligned@AVX2@ehs@@SA_NPEBJ0@Z:
-        VMOVDQU YMM0, [RCX]
-        VMOVDQU YMM1, [RDX]
-        VPCMPEQQ YMM2, YMM0, YMM1
-
-        VPMOVMSKB EAX, YMM2
-        CMP EAX, 0xFFFFFFFF
-        SETE AL
-
-        RET
-
-    ?CompareAligned@AVX2@ehs@@SA_NPEBK0@Z:
-        VMOVDQA YMM0, [RCX]
-        VMOVDQA YMM1, [RDX]
-        VPCMPEQQ YMM2, YMM0, YMM1
-
-        VPMOVMSKB EAX, YMM2
-        CMP EAX, 0xFFFFFFFF
-        SETE AL
-
-        RET
-
-    ?CompareAligned@AVX2@ehs@@SA_NPEBJ0@Z:
-        VMOVDQA YMM0, [RCX]
-        VMOVDQA YMM1, [RDX]
-        VPCMPEQQ YMM2, YMM0, YMM1
-
-        VPMOVMSKB EAX, YMM2
-        CMP EAX, 0xFFFFFFFF
-        SETE AL
-
-        RET

src/system/AVX512_AARCH64.cpp

@@ -1,24 +0,0 @@
-#include "ehs/system/AVX512.h"
-
-namespace ehs
-{
-    bool AVX512::CompareUnaligned(const UInt_64* a, const UInt_64* b)
-    {
-        return false;
-    }
-
-    bool AVX512::CompareUnaligned(const SInt_64* a, const SInt_64* b)
-    {
-        return false;
-    }
-
-    bool AVX512::CompareAligned(const UInt_64* a, const UInt_64* b)
-    {
-        return false;
-    }
-
-    bool AVX512::CompareAligned(const SInt_64* a, const SInt_64* b)
-    {
-        return false;
-    }
-}

src/system/AVX512_GCC_AMD64.asm

@@ -1,49 +0,0 @@
-global _ZN3ehs6AVX51216CompareUnalignedEPKmS2_
-global _ZN3ehs6AVX51216CompareUnalignedEPKlS2_
-global _ZN3ehs6AVX51214CompareAlignedEPKmS2_
-global _ZN3ehs6AVX51214CompareAlignedEPKlS2_
-
-section .text
-    _ZN3ehs6AVX51216CompareUnalignedEPKmS2_:
-        VMOVDQU64 ZMM0, [RDI]
-        VMOVDQU64 ZMM1, [RSI]
-
-        VPCMPEQQ K1, ZMM0, ZMM1
-
-        KORTESTQ K1, K1
-        SETC AL
-
-        RET
-
-    _ZN3ehs6AVX51216CompareUnalignedEPKlS2_:
-        VMOVDQU64 ZMM0, [RDI]
-        VMOVDQU64 ZMM1, [RSI]
-
-        VPCMPEQQ K1, ZMM0, ZMM1
-
-        KORTESTQ K1, K1
-        SETC AL
-
-        RET
-
-    _ZN3ehs6AVX51214CompareAlignedEPKmS2_:
-        VMOVDQA64 ZMM0, [RDI]
-        VMOVDQA64 ZMM1, [RSI]
-
-        VPCMPEQQ K1, ZMM0, ZMM1
-
-        KORTESTQ K1, K1
-        SETC AL
-
-        RET
-
-    _ZN3ehs6AVX51214CompareAlignedEPKlS2_:
-        VMOVDQA64 ZMM0, [RDI]
-        VMOVDQA64 ZMM1, [RSI]
-
-        VPCMPEQQ K1, ZMM0, ZMM1
-
-        KORTESTQ K1, K1
-        SETC AL
-
-        RET

src/system/AVX512_MSVC_AMD64.asm

@@ -1,49 +0,0 @@
-global ?CompareUnaligned@AVX512@ehs@@SA_NPEBK0@Z
-global ?CompareUnaligned@AVX512@ehs@@SA_NPEBJ0@Z
-global ?CompareAligned@AVX512@ehs@@SA_NPEBK0@Z
-global ?CompareAligned@AVX512@ehs@@SA_NPEBJ0@Z
-
-section .text
-	?CompareUnaligned@AVX512@ehs@@SA_NPEBK0@Z:
-		VMOVDQU64 ZMM0, [RCX]
-		VMOVDQU64 ZMM1, [RDX]
-
-		VPCMPEQQ K1, ZMM0, ZMM1
-
-		KORTESTQ K1, K1
-		SETC AL
-
-		RET
-
-	?CompareUnaligned@AVX512@ehs@@SA_NPEBJ0@Z:
-		VMOVDQU64 ZMM0, [RCX]
-		VMOVDQU64 ZMM1, [RDX]
-
-		VPCMPEQQ K1, ZMM0, ZMM1
-
-		KORTESTQ K1, K1
-		SETC AL
-
-		RET
-
-	?CompareAligned@AVX512@ehs@@SA_NPEBK0@Z:
-		VMOVDQA64 ZMM0, [RCX]
-		VMOVDQA64 ZMM1, [RDX]
-
-		VPCMPEQQ K1, ZMM0, ZMM1
-
-		KORTESTQ K1, K1
-		SETC AL
-
-		RET
-
-	?CompareAligned@AVX512@ehs@@SA_NPEBJ0@Z:
-		VMOVDQA64 ZMM0, [RCX]
-		VMOVDQA64 ZMM1, [RDX]
-
-		VPCMPEQQ K1, ZMM0, ZMM1
-
-		KORTESTQ K1, K1
-		SETC AL
-
-		RET

src/system/CPU.cpp

@@ -10,70 +10,6 @@ namespace ehs
 		UInt_64 CPU::TSC_Freq = 0;
     #endif
 
-    const bool CPU::hasFPU = RetrieveFPU();
-    const bool CPU::hasVME = RetrieveVME();
-    const bool CPU::hasDE = RetrieveDE();
-    const bool CPU::hasPSE = RetrievePSE();
-    const bool CPU::hasTSC = RetrieveTSC();
-    const bool CPU::hasMSR = RetrieveMSR();
-    const bool CPU::hasPAE = RetrievePAE();
-    const bool CPU::hasMCE = RetrieveMCE();
-    const bool CPU::hasCX8 = RetrieveCX8();
-    const bool CPU::hasAPIC = RetrieveAPIC();
-    const bool CPU::hasSEP = RetrieveSEP();
-    const bool CPU::hasMTRR = RetrieveMTRR();
-    const bool CPU::hasPGE = RetrievePGE();
-    const bool CPU::hasMCA = RetrieveMCA();
-    const bool CPU::hasCMOV = RetrieveCMOV();
-    const bool CPU::hasPSE_36 = RetrievePSE_36();
-    const bool CPU::hasPSN = RetrievePSN();
-    const bool CPU::hasCLFSH = RetrieveCLFSH();
-    const bool CPU::hasDS = RetrieveDS();
-    const bool CPU::hasACPI = RetrieveACPI();
-    const bool CPU::hasMMX = RetrieveMMX();
-    const bool CPU::hasFXSR = RetrieveFXSR();
-    const bool CPU::hasSSE = RetrieveSSE();
-    const bool CPU::hasSSE2 = RetrieveSSE2();
-    const bool CPU::hasSS = RetrieveSS();
-    const bool CPU::hasHTT = RetrieveHTT();
-    const bool CPU::hasTM = RetrieveTM();
-    const bool CPU::hasIA64 = RetrieveIA64();
-    const bool CPU::hasPBE = RetrievePBE();
-    const bool CPU::hasSSE3 = RetrieveSSE3();
-    const bool CPU::hasPCLMULQDQ = RetrievePCLMULQDQ();
-    const bool CPU::hasDTES64 = RetrieveDTES64();
-    const bool CPU::hasMONITOR = RetrieveMONITOR();
-    const bool CPU::hasVMX = RetrieveVMX();
-    const bool CPU::hasSMX = RetrieveSMX();
-    const bool CPU::hasEST = RetrieveEST();
-    const bool CPU::hasTM2 = RetrieveTM2();
-    const bool CPU::hasSSSE3 = RetrieveSSSE3();
-    const bool CPU::hasCNXT_ID = RetrieveCNXT_ID();
-    const bool CPU::hasSDBG = RetrieveSDBG();
-    const bool CPU::hasFMA = RetrieveFMA();
-    const bool CPU::hasCX16 = RetrieveCX16();
-    const bool CPU::hasXTPR = RetrieveXTPR();
-    const bool CPU::hasPDCM = RetrievePDCM();
-    const bool CPU::hasPCID = RetrievePCID();
-    const bool CPU::hasDCA = RetrieveDCA();
-    const bool CPU::hasSSE4_1 = RetrieveSSE4_1();
-    const bool CPU::hasSSE4_2 = RetrieveSSE4_2();
-    const bool CPU::hasX2APIC = RetrieveX2APIC();
-    const bool CPU::hasMOVBE = RetrieveMOVBE();
-    const bool CPU::hasPOPCNT = RetrievePOPCNT();
-    const bool CPU::hasTSC_DEADLINE = RetrieveTSC_DEADLINE();
-    const bool CPU::hasAES = RetrieveAES();
-    const bool CPU::hasXSAVE = RetrieveXSAVE();
-    const bool CPU::hasOSXSAVE = RetrieveOSXSAVE();
-    const bool CPU::hasAVX = RetrieveAVX();
-    const bool CPU::hasF16C = RetrieveF16C();
-    const bool CPU::hasRDRND = RetrieveRDRND();
-    const bool CPU::hasHYPERVISOR = RetrieveHYPERVISOR();
-    const bool CPU::hasAVX2 = RetrieveAVX2();
-    const bool CPU::hasAVX512F = RetrieveAVX512F();
-    const bool CPU::hasRDSEED = RetrieveRDSEED();
-    const bool CPU::hasADX = RetrieveADX();
-
 	Architecture CPU::GetArchitecture()
 	{
 		#if defined(EHS_ARCH_X64)
@@ -183,589 +119,324 @@ namespace ehs
         return (UInt_8)(GetInfoBits() >> 20);
     }
 
-    bool CPU::RetrieveFPU()
+    bool CPU::HasFPU()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000000000000000000001;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000000000000000000001;
     }
 
-    bool CPU::RetrieveVME()
+    bool CPU::HasVME()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000000000000000000010;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000000000000000000010;
     }
 
-    bool CPU::RetrieveDE()
+    bool CPU::HasDE()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000000000000000000100;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000000000000000000100;
     }
 
-    bool CPU::RetrievePSE()
+    bool CPU::HasPSE()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000000000000000001000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000000000000000001000;
     }
 
-    bool CPU::RetrieveTSC()
+    bool CPU::HasTSC()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000000000000000010000;
-        #else
-	            return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000000000000000010000;
     }
 
-    bool CPU::RetrieveMSR()
+    bool CPU::HasMSR()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000000000000000100000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000000000000000100000;
     }
 
-    bool CPU::RetrievePAE()
+    bool CPU::HasPAE()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000000000000001000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000000000000001000000;
     }
 
-    bool CPU::RetrieveMCE()
+    bool CPU::HasMCE()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000000000000010000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000000000000010000000;
     }
 
-    bool CPU::RetrieveCX8()
+    bool CPU::HasCX8()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000000000000100000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000000000000100000000;
     }
 
-    bool CPU::RetrieveAPIC()
+    bool CPU::HasAPIC()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000000000001000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000000000001000000000;
     }
 
-    bool CPU::RetrieveSEP()
+    bool CPU::HasSEP()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000000000100000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000000000100000000000;
     }
 
-    bool CPU::RetrieveMTRR()
+    bool CPU::HasMTRR()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000000001000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000000001000000000000;
     }
 
-    bool CPU::RetrievePGE()
+    bool CPU::HasPGE()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000000010000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000000010000000000000;
     }
 
-    bool CPU::RetrieveMCA()
+    bool CPU::HasMCA()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000000100000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000000100000000000000;
     }
 
-    bool CPU::RetrieveCMOV()
+    bool CPU::HasCMOV()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000001000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000001000000000000000;
     }
 
-    bool CPU::RetrievePAT()
+    bool CPU::HasPAT()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000010000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000010000000000000000;
     }
 
-    bool CPU::RetrievePSE_36()
+    bool CPU::HasPSE_36()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000000100000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000000100000000000000000;
     }
 
-    bool CPU::RetrievePSN()
+    bool CPU::HasPSN()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000001000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000001000000000000000000;
     }
 
-    bool CPU::RetrieveCLFSH()
+    bool CPU::HasCLFSH()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000000010000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000000010000000000000000000;
     }
 
-    bool CPU::RetrieveDS()
+    bool CPU::HasDS()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000001000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000001000000000000000000000;
     }
 
-    bool CPU::RetrieveACPI()
+    bool CPU::HasACPI()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000010000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000010000000000000000000000;
     }
 
-    bool CPU::RetrieveMMX()
+    bool CPU::HasMMX()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000000100000000000000000000000;
-        #else
-	            return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000000100000000000000000000000;
     }
 
-    bool CPU::RetrieveFXSR()
+    bool CPU::HasFXSR()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000001000000000000000000000000;
-        #else
-	            return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000001000000000000000000000000;
     }
 
-    bool CPU::RetrieveSSE()
+    bool CPU::HasSSE()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000010000000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000010000000000000000000000000;
     }
 
-    bool CPU::RetrieveSSE2()
+    bool CPU::HasSSE2()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00000100000000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00000100000000000000000000000000;
     }
 
-    bool CPU::RetrieveSS()
+    bool CPU::HasSS()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00001000000000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00001000000000000000000000000000;
     }
 
-    bool CPU::RetrieveHTT()
+    bool CPU::HasHTT()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00010000000000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00010000000000000000000000000000;
     }
 
-    bool CPU::RetrieveTM()
+    bool CPU::HasTM()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b00100000000000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b00100000000000000000000000000000;
     }
 
-    bool CPU::RetrieveIA64()
+    bool CPU::HasIA64()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b01000000000000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b01000000000000000000000000000000;
     }
 
-    bool CPU::RetrievePBE()
+    bool CPU::HasPBE()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_1() & 0b10000000000000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_1() & 0b10000000000000000000000000000000;
     }
 
-    bool CPU::RetrieveSSE3()
+    bool CPU::HasSSE3()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000000000000000000001;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000000000000000000001;
     }
 
-    bool CPU::RetrievePCLMULQDQ()
+    bool CPU::HasPCLMULQDQ()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000000000000000000010;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000000000000000000010;
     }
 
-    bool CPU::RetrieveDTES64()
+    bool CPU::HasDTES64()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000000000000000000100;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000000000000000000100;
     }
 
-    bool CPU::RetrieveMONITOR()
+    bool CPU::HasMONITOR()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000000000000000001000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000000000000000001000;
     }
 
-    bool CPU::RetrieveDS_CPL()
+    bool CPU::HasDS_CPL()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000000000000000010000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000000000000000010000;
     }
 
-    bool CPU::RetrieveVMX()
+    bool CPU::HasVMX()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000000000000000100000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000000000000000100000;
     }
 
-    bool CPU::RetrieveSMX()
+    bool CPU::HasSMX()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000000000000001000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000000000000001000000;
     }
 
-    bool CPU::RetrieveEST()
+    bool CPU::HasEST()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000000000000010000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000000000000010000000;
     }
 
-    bool CPU::RetrieveTM2()
+    bool CPU::HasTM2()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000000000000100000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000000000000100000000;
     }
 
-    bool CPU::RetrieveSSSE3()
+    bool CPU::HasSSSE3()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000000000001000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000000000001000000000;
     }
 
-    bool CPU::RetrieveCNXT_ID()
+    bool CPU::HasCNXT_ID()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000000000010000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000000000010000000000;
     }
 
-    bool CPU::RetrieveSDBG()
+    bool CPU::HasSDBG()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000000000100000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000000000100000000000;
     }
 
-    bool CPU::RetrieveFMA()
+    bool CPU::HasFMA()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000000001000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000000001000000000000;
     }
 
-    bool CPU::RetrieveCX16()
+    bool CPU::HasCX16()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000000010000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000000010000000000000;
     }
 
-    bool CPU::RetrieveXTPR()
+    bool CPU::HasXTPR()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000000100000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000000100000000000000;
     }
 
-    bool CPU::RetrievePDCM()
+    bool CPU::HasPDCM()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000001000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000001000000000000000;
     }
 
-    bool CPU::RetrievePCID()
+    bool CPU::HasPCID()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000000100000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000000100000000000000000;
     }
 
-    bool CPU::RetrieveDCA()
+    bool CPU::HasDCA()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000001000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000001000000000000000000;
     }
 
-    bool CPU::RetrieveSSE4_1()
+    bool CPU::HasSSE4_1()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000010000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000010000000000000000000;
     }
 
-    bool CPU::RetrieveSSE4_2()
+    bool CPU::HasSSE4_2()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000000100000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000000100000000000000000000;
     }
 
-    bool CPU::RetrieveX2APIC()
+    bool CPU::HasX2APIC()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000001000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000001000000000000000000000;
     }
 
-    bool CPU::RetrieveMOVBE()
+    bool CPU::HasMOVBE()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000010000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000010000000000000000000000;
     }
 
-    bool CPU::RetrievePOPCNT()
+    bool CPU::HasPOPCNT()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000000100000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000000100000000000000000000000;
     }
 
-    bool CPU::RetrieveTSC_DEADLINE()
+    bool CPU::HasTSC_DEADLINE()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000001000000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000001000000000000000000000000;
     }
 
-    bool CPU::RetrieveAES()
+    bool CPU::HasAES()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000010000000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000010000000000000000000000000;
     }
 
-    bool CPU::RetrieveXSAVE()
+    bool CPU::HasXSAVE()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00000100000000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00000100000000000000000000000000;
     }
 
-    bool CPU::RetrieveOSXSAVE()
+    bool CPU::HasOSXSAVE()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00001000000000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00001000000000000000000000000000;
     }
 
-    bool CPU::RetrieveAVX()
+    bool CPU::HasAVX()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00010000000000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00010000000000000000000000000000;
     }
 
-    bool CPU::RetrieveF16C()
+    bool CPU::HasF16C()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b00100000000000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b00100000000000000000000000000000;
     }
 
-    bool CPU::RetrieveRDRND()
+    bool CPU::HasRDRND()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b01000000000000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b01000000000000000000000000000000;
     }
 
-    bool CPU::RetrieveHYPERVISOR()
+    bool CPU::HasHYPERVISOR()
     {
-        #ifdef EHS_ARCH_X64
-            return GetFeatureBits_2() & 0b10000000000000000000000000000000;
-        #else
-	        return false;
-        #endif
+        return GetFeatureBits_2() & 0b10000000000000000000000000000000;
     }
 
-    bool CPU::RetrieveAVX2()
+    bool CPU::HasAVX2()
     {
-        #ifdef EHS_ARCH_X64
-            return GetExtFeatureBits_1() & 0b00000000000000000000000000100000;
-        #else
-	        return false;
-        #endif
+        return GetExtFeatureBits_1() & 0b00000000000000000000000000100000;
     }
 
-    bool CPU::RetrieveAVX512F()
+    bool CPU::HasRDSEED()
     {
-        #ifdef EHS_ARCH_X64
-	            return GetExtFeatureBits_1() & 0b00000000000000010000000000000000;
-        #else
-	            return false;
-        #endif
+        return GetExtFeatureBits_1() & 0b00000000000001000000000000000000;
     }
 
-    bool CPU::RetrieveRDSEED()
+    bool CPU::HasADX()
     {
-        #ifdef EHS_ARCH_X64
-            return GetExtFeatureBits_1() & 0b00000000000001000000000000000000;
-        #else
-	        return false;
-        #endif
-    }
-
-    bool CPU::RetrieveADX()
-    {
-        #ifdef EHS_ARCH_X64
-            return GetExtFeatureBits_1() & 0b00000000000010000000000000000000;
-	    #else
-	        return false;
-	    #endif
+        return GetExtFeatureBits_1() & 0b00000000000010000000000000000000;
     }
 
 	/*