--- net-tools-1.60/lib/nstrcmp.c~	1999-01-09 18:55:20 +0300

+++ net-tools-1.60/lib/nstrcmp.c	2002-07-03 01:35:04 +0400

@@ -1,34 +1,157 @@

-/* Copyright 1998 by Andi Kleen. Subject to the GPL. */

-/* $Id: nstrcmp.c,v 1.2 1998/11/15 20:11:38 freitag Exp $ */ 

+/* 

+  compare alpha and numeric segments of two strings.

+

+  Copyright (c) 1998 by Red Hat Software, Inc.

+  Copyright (c) 2002 by Dmitry V. Levin <ldv@altlinux.org>

+

+  This program is free software; you can redistribute it and/or modify

+  it under the terms of the GNU General Public License as published by

+  the Free Software Foundation; either version 2 of the License, or

+  (at your option) any later version.

+

+  This program is distributed in the hope that it will be useful,

+  but WITHOUT ANY WARRANTY; without even the implied warranty of

+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

+  GNU General Public License for more details.

+

+  You should have received a copy of the GNU General Public License

+  along with this program; if not, write to the Free Software

+  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

+*/

+#include <string.h>

 #include <ctype.h>

 #include <stdlib.h>

-#include "util.h"

-/* like strcmp(), but knows about numbers */

-int nstrcmp(const char *astr, const char *b)

+/*

+ * compares alpha and numeric segments of two strings.

+ * returns an integer less than, equal to, or greater

+ * than zero if a is found, respectively, to be less

+ * than, to match, or be greater than b.

+*/

+int

+nstrcmp (const char *a, const char *b)

 {

-    const char *a = astr;

+	char   *str1, *str2;

+	char   *one, *two;

-    while (*a == *b) {

-	if (*a == '\0')

-	    return 0;

-	a++;

-	b++;

-    }

-    if (isdigit(*a)) {

-	if (!isdigit(*b))

-	    return -1;

-	while (a > astr) {

-	    a--;

-	    if (!isdigit(*a)) {

-		a++;

-		break;

-	    }

-	    if (!isdigit(*b))

-		return -1;

-	    b--;

+	/* easy comparison to see if versions are identical */

+	if (!strcmp (a, b))

+		return 0;

+

+	str1 = alloca (strlen (a) + 1);

+	str2 = alloca (strlen (b) + 1);

+

+	strcpy (str1, a);

+	strcpy (str2, b);

+

+	one = str1;

+	two = str2;

+

+	/* loop through each version segment of str1 and str2 and compare them */

+	while (*one && *two)

+	{

+		int     isalnum1 = isalnum (*one);

+		int     isalnum2 = isalnum (*two);

+		int     isnum, rc;

+		char    oldch1, oldch2;

+

+		if (*one == *two)

+		{

+			if (!isalnum1)

+			{

+				++one;

+				++two;

+				continue;

+			}

+		} else

+		{

+			if (!(isalnum1 && isalnum2))

+				return *one - *two;

+		}

+

+		str1 = one;

+		str2 = two;

+

+		/* grab first completely alpha or completely numeric segment */

+		/* leave one and two pointing to the start of the alpha or numeric */

+		/* segment and walk str1 and str2 to end of segment */

+		/* Also take care of the case where the two version segments are */

+		/* different types: one numeric and one alpha */

+		if (isdigit (*str1))

+		{

+			if (isalpha (*str2))

+				return -1;

+			while (*str1 && isdigit (*str1))

+				str1++;

+			while (*str2 && isdigit (*str2))

+				str2++;

+			isnum = 1;

+		} else

+		{

+			while (*str1 && isalpha (*str1))

+				str1++;

+			while (*str2 && isalpha (*str2))

+				str2++;

+			isnum = 0;

+		}

+

+		/* Again, take care of the case where the two version segments are */

+		/* different types: one numeric and one alpha */

+		if (one == str1)

+			return -1;

+		if (two == str2)

+			return 1;

+

+		/* save character at the end of the alpha or numeric segment */

+		/* so that they can be restored after the comparison */

+		oldch1 = *str1;

+		*str1 = '\0';

+		oldch2 = *str2;

+		*str2 = '\0';

+

+		if (isnum)

+		{

+			/* this used to be done by converting the digit segments */

+			/* to ints using atoi() - it's changed because long  */

+			/* digit segments can overflow an int - this should fix that. */

+

+			/* throw away any leading zeros - it's a number, right? */

+			while (*one == '0')

+				one++;

+			while (*two == '0')

+				two++;

+

+			/* whichever number has more digits wins */

+			if (strlen (one) > strlen (two))

+				return 1;

+			if (strlen (two) > strlen (one))

+				return -1;

+		}

+

+		/* strcmp will return which one is greater - even if the two */

+		/* segments are alpha or if they are numeric.  don't return  */

+		/* if they are equal because there might be more segments to */

+		/* compare */

+		rc = strcmp (one, two);

+		if (rc)

+			return rc;

+

+		/* restore character that was replaced by null above */

+		*str1 = oldch1;

+		one = str1;

+		*str2 = oldch2;

+		two = str2;

 	}

-	return atoi(a) > atoi(b) ? 1 : -1;

-    }

-    return *a - *b;

+

+	/* this catches the case where all numeric and alpha segments have */

+	/* compared identically but the segment sepparating characters were */

+	/* different */

+	if (!*one && !*two)

+		return 0;

+

+	/* whichever version still has characters left over wins */

+	if (!*one)

+		return -1;

+	else

+		return 1;

 }