Modified tNstrcmp so it only uses one while-loop and does not need the mode/state variable. Updated it to sort similarly to Windows natural sorting by treating hyphens similarly. Fixed a bug when one of the two characters was a digit -- it was getting the order reversed. Added some code to do a case-sensitive compare all things being equal (so that AAA sorts before aaa). Fixed places in Tacent that were using tString Left and Right now that the behaviour is consistent with ExtractLeft and ExtractRight.

Author: bluescan

Modules/Foundation/Inc/Foundation/tFundamentals.h

@@ -92,8 +92,8 @@ template<typename T> inline bool tInInterval(const T val, const T min, const T m
 template<typename T> inline bool tInRange(const T val, const T min, const T max)		/* Returns val E [min, max]	*/	{ return tInInterval(val, min, max); }
 template<typename T> inline bool tInRange(const T val, const T min, const T max, tBias bias)							{ return tInInterval(val, min, max, bias); }
 
-template<typename T> inline T tSign(T val)																				{ return val < T(0) ? T(-1) : val > T(0) ? T(1) : T(0); }
-template<typename T> inline T tBinarySign(T val)																		{ return val < T(0) ? T(-1) : T(1); }	// Same as Sign but does not return 0 ever.  Two return values only.
+template<typename T> inline T tSign(T val)			/* +1,-1, or 0 for equal, */										{ return val < T(0) ? T(-1) : val > T(0) ? T(1) : T(0); }
+template<typename T> inline T tBinarySign(T val)																		{ return val < T(0) ? T(-1) : T(1); }	// Same as Sign but does not return 0 ever. Two return values only.
 template<typename T> inline bool tIsZero(T a)																			{ return a == T(0); }
 template<typename T> inline bool tApproxEqual(T a, T b, float e = Epsilon)												{ return (tAbs(a-b) < e); }
 template<typename T> inline bool tEquals(T a, T b)																		{ return a == b; }

Modules/Foundation/Inc/Foundation/tStandard.h

@@ -83,7 +83,11 @@ int tPstrncmp(const char8_t* a, const char8_t* b, int n);
 
 // These do a 'natural' string compare by treating groups of base 10 digits as separate objects to be compared by
 // numeric value rather than alpha-numerically based on the encoding. This results in strings like "page10" coming
-// after "page2" because 10 > 2.
+// after "page2" because 10 > 2. This function can become arbitrarily complex. Some discussion on the topic is here:
+// https://blog.codinghorror.com/sorting-for-humans-natural-sort-order/
+// See the unit tests for examples that match windows explorer sorting. In particular the hyphen character may be
+// skipped when sorting and we fall back to case-sensitive compare all things being equal.
+// The implementation of tNstrcmp is a modified version of the one written by GitHub user ClangPan.
 int tNstrcmp(const char* a, const char* b);
 inline int tNstrcmp(const char8_t* a, const char8_t* b)																	{ return tNstrcmp((const char*)a, (const char*)b); }
 

Modules/Foundation/Src/tStandard.cpp

@@ -19,6 +19,7 @@
 #endif
 #include "Foundation/tStandard.h"
 #include "Foundation/tString.h"
+#include "Foundation/tFundamentals.h"
 #pragma warning (disable: 4146)
 #pragma warning (disable: 4018)
 
@@ -64,68 +65,69 @@ void* tStd::tMemsrch(void* haystack, int haystackNumBytes, void* needle, int nee
 
 int tStd::tNstrcmp(const char* a, const char* b)
 {
-	// This implementation of tNstrcmp was written by GitHub user ClangPan.
-	enum class Mode
-	{
-		String,
-		Number
-	};
-	Mode mode = Mode::String;
+	const char* origa = a;
+	const char* origb = b;
 
+	// This implementation of tNstrcmp is a modified version of the one written by GitHub user ClangPan.
 	while (*a && *b)
 	{
-		if (mode == Mode::String)
+		bool aDigit = tIsdigit(*a);
+		bool bDigit = tIsdigit(*b);
+
+		if (!aDigit && (*a == '-'))
 		{
-			char aChar, bChar;
-			while ((aChar = tolower(*a)) && (bChar = tolower(*b))) // We lowercase the chars for proper comparison
-			{
-				// Check if the chars are digits
-				const bool aDigit = isdigit(aChar), bDigit = isdigit(bChar);
-
-				// If both chars are digits, we continue in NUMBER mode
-				if (aDigit && bDigit)
-				{
-					mode = Mode::Number;
-					break;
-				} 
-
-				// If only the left char is a digit, we have a result
-				if (aDigit) return -1;
-
-				// If only the right char is a digit, we have a result
-				if (bDigit) return +1;
-
-				// compute the difference of both characters
-				const int diff = aChar - bChar;
-
-				// If they differ we have a result
-				if (diff != 0) return diff;
-
-				// Otherwise process the next characters
-				++a; ++b;
-			}
+			++a;
+			continue;
 		}
-		else
+
+		if (!bDigit && (*b == '-'))
+		{
+			++b;
+			continue;
+		}
+
+		// We're comparing (possibly multidigit) numbers.
+		if (aDigit && bDigit)
 		{
-			char *end; // Represents the end of the number string
+			char* enda;
+			char* endb;
 
-			// Get the left number
-			unsigned long aInt = strtoul((char*) a, &end, 10);
-			a = end;
+			// Get the left number.
+			int aInt = strtoul((char*)a, &enda, 10);
 
-			// Get the right number
-			unsigned long bInt = strtoul((char*) b, &end, 10);
-			b = end;
+			// Get the right number.
+			int bInt = strtoul((char*)b, &endb, 10);
 
 			// if the difference is not equal to zero, we have a comparison result
-			const long diff = aInt - bInt;
-			if (diff != 0) return diff;
+			int sign = tMath::tSign(aInt - bInt);
+			if (sign) return sign;
 
-			// otherwise we process the next substring in STRING mode
-			mode = Mode::String;
-		}
+			a = enda;
+			b = endb;
+			continue;
+		} 
+
+		// If only the left char is a digit, we have a result.
+		if (aDigit) return +1;
+
+		// If only the right char is a digit, we have a result.
+		if (bDigit) return -1;
+
+		// compute the difference of both characters
+		int sign = tMath::tSign(tToLower(*a) - tToLower(*b));
+
+		// If they differ we have a result.
+		if (sign) return sign;
+
+		// Otherwise process the next characters.
+		++a; ++b;
 	}
 
+	// If both a and b are at end, we consider letter-case and compare as if we had never done the tToLowers.
+	if (!(*a) && !(*b))
+		return tStrcmp(origa, origb);
+
+	// Now only one of *a or *b are non-zero.
 	if (*b) return -1;
 	if (*a) return +1;
 

Modules/System/Src/tFile.cpp

@@ -196,14 +196,18 @@ tString tSystem::tGetFileName(const tString& file)
 {
 	tString retStr(file);
 	tPathStd(retStr);
-	return retStr.Right('/');
+	if (retStr.FindChar('/') != -1)
+		return retStr.Right('/');
+	return retStr;
 }
 
 
 tString tSystem::tGetFileBaseName(const tString& file)
 {
 	tString r = tGetFileName(file);
-	return r.Left('.');
+	if (r.FindChar('.') != -1)
+		return r.Left('.');
+	return r;
 }
 
 
@@ -1900,11 +1904,7 @@ tStaticAssert(tNumElements(tSystem::FileTypeExtTable) == int(tSystem::tFileType:
 
 tString tSystem::tGetFileExtension(const tString& file)
 {
-	tString ext = file.Right('.'); 
-	if(ext == file)
-		ext.Clear();
-
-	return ext;
+	return file.Right('.');
 }
 
 

UnitTests/Src/TestFoundation.cpp

@@ -475,9 +475,40 @@ void PrintMultiObjList(const tList<MultiObj>& multiObjList)
 tTestUnit(ListSort)
 {
 	tList<MultiObj> multiObjList;
+
+	// Add items with an extension.
+	multiObjList.Append(new MultiObj("page100.txt"));
+	multiObjList.Append(new MultiObj("Page20.txt"));
+	multiObjList.Append(new MultiObj("Page4.txt"));
+	multiObjList.Append(new MultiObj("Page.txt"));
+	multiObjList.Append(new MultiObj("PagE.txt"));
+	multiObjList.Append(new MultiObj("page5.txt"));
+	multiObjList.Append(new MultiObj("Page5.txt"));
+	multiObjList.Append(new MultiObj("aaa.txt"));
+	multiObjList.Append(new MultiObj("AAA.txt"));
+	multiObjList.Append(new MultiObj("zzz.txt"));
+	multiObjList.Append(new MultiObj("ZZZ.txt"));
+	multiObjList.Append(new MultiObj("Page-90.txt"));
+	multiObjList.Append(new MultiObj("page -90.txt"));
+	multiObjList.Append(new MultiObj("page-8.txt"));
+	multiObjList.Append(new MultiObj("page -8.txt"));
+
+	// Add the same items without an extension.
+	multiObjList.Append(new MultiObj("page100"));
 	multiObjList.Append(new MultiObj("Page20"));
 	multiObjList.Append(new MultiObj("Page4"));
 	multiObjList.Append(new MultiObj("Page"));
+	multiObjList.Append(new MultiObj("PagE"));
+	multiObjList.Append(new MultiObj("page5"));
+	multiObjList.Append(new MultiObj("Page5"));
+	multiObjList.Append(new MultiObj("aaa"));
+	multiObjList.Append(new MultiObj("AAA"));
+	multiObjList.Append(new MultiObj("zzz"));
+	multiObjList.Append(new MultiObj("ZZZ"));
+	multiObjList.Append(new MultiObj("Page-90"));
+	multiObjList.Append(new MultiObj("page -90"));
+	multiObjList.Append(new MultiObj("page-8"));
+	multiObjList.Append(new MultiObj("page -8"));
 
 	bool ascending = true;
 	MultiCompFunObj compFunObj(MultiCompFunObj::SortKey::NameAlphaNumeric, ascending);
@@ -486,26 +517,28 @@ tTestUnit(ListSort)
 
 	compFunObj.Key = MultiCompFunObj::SortKey::NameAlphaNumeric;
 	compFunObj.Ascending = true;
-	multiObjList.Sort(compFunObj);
 	tPrintf("\nSorted Alpha Numeric Ascending\n");
+	multiObjList.Sort(compFunObj);
 	PrintMultiObjList(multiObjList);
 
 	compFunObj.Key = MultiCompFunObj::SortKey::NameAlphaNumeric;
 	compFunObj.Ascending = false;
-	multiObjList.Sort(compFunObj);
 	tPrintf("\nSorted Alpha Numeric Descending\n");
+	multiObjList.Sort(compFunObj);
 	PrintMultiObjList(multiObjList);
 
+	// Except for the fact that there are extra items that are not supported by NTFS since you can't have two files
+	// that only differ by case, when this list gets sorted naturally it results in the same order as Windows explorer.
 	compFunObj.Key = MultiCompFunObj::SortKey::NameNatural;
 	compFunObj.Ascending = true;
-	multiObjList.Sort(compFunObj);
 	tPrintf("\nSorted Natural Ascending\n");
+	multiObjList.Sort(compFunObj);
 	PrintMultiObjList(multiObjList);
 
 	compFunObj.Key = MultiCompFunObj::SortKey::NameNatural;
 	compFunObj.Ascending = false;
-	multiObjList.Sort(compFunObj);
 	tPrintf("\nSorted Natural Descending\n");
+	multiObjList.Sort(compFunObj);
 	PrintMultiObjList(multiObjList);
 }