X-Git-Url: https://sigrok.org/gitweb/?p=pulseview.git;a=blobdiff_plain;f=pv%2Fstrnatcmp.hpp;fp=pv%2Fstrnatcmp.hpp;h=6c7754cc9ceb0af53a9cb246199c734b4695c083;hp=0000000000000000000000000000000000000000;hb=51307fd601232b11fade64ceaadc0eca84cca69b;hpb=0623eb8c7d596c8507f6c69263990973ba65f70c

diff --git a/pv/strnatcmp.hpp b/pv/strnatcmp.hpp
new file mode 100644
index 00000000..6c7754cc
--- /dev/null
+++ b/pv/strnatcmp.hpp
@@ -0,0 +1,160 @@
+/*
+ * This file is part of the PulseView project.
+ *
+ * Copyright (C) 2000, 2004 by Martin Pool <mbp sourcefrog net>
+ *
+ * This software is provided 'as-is', without any express or implied
+ * warranty.  In no event will the authors be held liable for any damages
+ * arising from the use of this software.
+ *
+ * Permission is granted to anyone to use this software for any purpose,
+ * including commercial applications, and to alter it and redistribute it
+ * freely, subject to the following restrictions:
+ *
+ * 1. The origin of this software must not be misrepresented; you must not
+ *    claim that you wrote the original software. If you use this software
+ *    in a product, an acknowledgment in the product documentation would be
+ *    appreciated but is not required.
+ * 2. Altered source versions must be plainly marked as such, and must not be
+ *    misrepresented as being the original software.
+ * 3. This notice may not be removed or altered from any source distribution.
+ */
+
+// strnatcmp.c -- Perform 'natural order' comparisons of strings in C.
+// This file has been modified for C++ compatibility.
+// Original at https://github.com/sourcefrog/natsort/blob/master/strnatcmp.c
+
+#ifndef PULSEVIEW_PV_STRNATCMP_HPP
+#define PULSEVIEW_PV_STRNATCMP_HPP
+
+#include <stddef.h>	/* size_t */
+#include <ctype.h>
+#include <string>
+
+using std::string;
+
+static int compare_right(char const *a, char const *b)
+{
+	int bias = 0;
+
+	// The longest run of digits wins. That aside, the greatest
+	// value wins, but we can't know that it will until we've scanned
+	// both numbers to know that they have the same magnitude, so we
+	// remember it in bias.
+	for (;; a++, b++) {
+		if (!isdigit(*a) && !isdigit(*b))
+			return bias;
+		if (!isdigit(*a))
+			return -1;
+		if (!isdigit(*b))
+			return +1;
+
+		if (*a < *b) {
+			if (!bias)
+				bias = -1;
+		} else if (*a > *b) {
+			if (!bias)
+				bias = +1;
+		} else if (!*a && !*b)
+			return bias;
+	}
+
+	return 0;
+}
+
+static int compare_left(char const *a, char const *b)
+{
+	// Compare two left-aligned numbers: the first to have a
+	// different value wins.
+	for (;; a++, b++) {
+		if (!isdigit(*a)  &&  !isdigit(*b))
+			return 0;
+		if (!isdigit(*a))
+			return -1;
+		if (!isdigit(*b))
+			return +1;
+		if (*a < *b)
+			return -1;
+		if (*a > *b)
+			return +1;
+	}
+
+	return 0;
+}
+
+static int strnatcmp0(char const *a, char const *b, int fold_case)
+{
+	int ai, bi, fractional, result;
+	char ca, cb;
+
+	ai = bi = 0;
+
+	while (1) {
+		ca = a[ai];
+		cb = b[bi];
+
+		// Skip over leading spaces or zeroes
+		while (isspace(ca))
+			ca = a[++ai];
+
+		while (isspace(cb))
+			cb = b[++bi];
+
+		// Process run of digits
+		if (isdigit(ca) && isdigit(cb)) {
+			fractional = (ca == '0' || cb == '0');
+
+			if (fractional) {
+				if ((result = compare_left(a + ai, b + bi)) != 0)
+					return result;
+			} else {
+				if ((result = compare_right(a + ai, b + bi)) != 0)
+					return result;
+			}
+		}
+
+		if (!ca && !cb) {
+			// The strings compare the same. Perhaps the caller
+			// will want to call strcmp to break the tie
+			return 0;
+		}
+
+		if (fold_case) {
+			ca = toupper(ca);
+			cb = toupper(cb);
+		}
+
+		if (ca < cb)
+			return -1;
+
+		if (ca > cb)
+			return +1;
+
+		++ai;
+		++bi;
+	}
+}
+
+// Compare, recognizing numeric strings and being case sensitive
+int strnatcmp(char const *a, char const *b)
+{
+	return strnatcmp0(a, b, 0);
+}
+
+int strnatcmp(const string a, const string b)
+{
+	return strnatcmp0(a.c_str(), b.c_str(), 0);
+}
+
+// Compare, recognizing numeric strings and ignoring case
+int strnatcasecmp(char const *a, char const *b)
+{
+	return strnatcmp0(a, b, 1);
+}
+
+int strnatcasecmp(const string a, const string b)
+{
+	return strnatcmp0(a.c_str(), b.c_str(), 1);
+}
+
+#endif // PULSEVIEW_PV_STRNATCMP_HPP