bee_version_compare: Rewrite compare_version_strings()

The current algorithm is complicated and broken.

First, it removes common prefixes, so that, for example, '1.5.8' and
'1.5.9' are compared numerically as 8 and 9.  After that, '0's are
skipped, to that, for example, '1.5.09' can compare equal to '1.5.9'.

In a next step, removed digits are restored, so that
that '1.5.1134' and '1.5.1211' are compared as 1134 and 1211 and not
as 34 and 11.

However, the removal of '0's is done independently for both values, so
that a different number of '0's might be removed, while the undo is done
in sync, so that the same number of digits is 'restored'.

As a result, '1.101' compares less that '1.11':

a             b

1.101         1.11  # original
01            1     # after removal of common prefix
1             1     # after removal of '0's
01            11    # after restoration of digits

Additionally, the code tries to sort digits after non-digit characters
but failed to miss the case, when only the second string starts with a
digit.

Rewrite algorithm from scratch.

The new algorithm advances through both strings comparing them at their
beging:

  - if one string ends, the other one is greater
  - otherwise if both strings start with a digit
     - compare numerically
     - if equal, skip over digits and loop
  - otherwise if one string starts with a digit, its greater
  - otherwise if the first character is different, compare character values
  - otherwise, advance to next character and loop

To make the code more readable, the character pointers are dereferenced
multiple times and some conditionals are evaluated multiple times. We
can trust the compiler to optimize this away.

Comparing 'bee list --available' with the old and the new algorithm
produces the following differences:

firefox-9.0.1-0.x86_64          firefox-9.0.1-0.x86_64
firefox-10.0.2-0.x86_64         firefox-10.0.2-0.x86_64
firefox-102.0-0.x86_64       <
firefox-11.0-0.x86_64           firefox-11.0-0.x86_64
firefox-12.0-0.x86_64           firefox-12.0-0.x86_64

firefox-94.0.1-0.x86_64         firefox-94.0.1-0.x86_64
firefox-94.0.2-0.x86_64         firefox-94.0.2-0.x86_64
                             >  firefox-102.0-0.x86_64
firefox_current-4-0.x86_64      firefox_current-4-0.x86_64
firefox_current-5-0.x86_64      firefox_current-5-0.x86_64

java-1.7.0_13-0.x86_64          java-1.7.0_13-0.x86_64
java-1.7.0_17-0.x86_64          java-1.7.0_17-0.x86_64
                             >  java-1.8.0_11-0.x86_64
                             >  java-1.8.0_45-0.x86_64
java-1.8.0_101-0.x86_64         java-1.8.0_101-0.x86_64
java-1.8.0_102-0.x86_64         java-1.8.0_102-0.x86_64
ava-1.8.0_102-1.x86_64         java-1.8.0_102-1.x86_64
java-1.8.0_11-0.x86_64       <
java-1.8.0_45-0.x86_64       <
java-1.8.0_121-0.x86_64         java-1.8.0_121-0.x86_64
java-1.8.0_131-0.x86_64         java-1.8.0_131-0.x86_64

src/bee_version_compare.c

@@ -28,86 +28,47 @@
 
 #include "bee_version.h"
 
-int compare_version_strings(char *v1, char *v2) {
-    char *a, *b;
-    long long i,j;
 
-    assert(v1);
-    assert(v2);
-
-    a = v1;
-    b = v2;
-
-    while(*a && *b && *a == *b) {
-        a++;
-        b++;
-
-        if (*a == *b)
+// '2.23.2'    >  '2.23.0'
+//' 2.23.10'   >  '2.23.8'
+// '2.23.001'  == '2.23.1'
+// '2.23.1001' >  '2.23.101'
+
+int compare_version_strings(char *a, char *b) {
+    while (1) {
+        if (*a == '\0' && *b == '\0')
+            return 0;
+        if (*a == '\0')
+            return -1;
+        if (*b == '\0')
+            return 1;
+
+        if (isdigit(*a) && isdigit (*b)) {
+            long i_a = atoll(a);
+            long i_b = atoll(b);
+            if (i_a < i_b)
+                return -1;
+            if (i_a > i_b)
+                return 1;
+            while(isdigit(*a))
+                a++;
+            while(isdigit(*b))
+                b++;
             continue;
-
-        /* skip leading zeros of numbers != 0 */
-        if (isdigit(*a) && isdigit(*b)) {
-            char *c;
-
-            for (c=a; *c == '0'; c++)
-               ;
-            if (isdigit(*c))
-               a = c;
-
-            for (c=b; *c == '0'; c++)
-               ;
-            if (isdigit(*c))
-               b = c;
         }
-    }
 
-    /* strings are equal ; *a==*b==0*/
-    if(*a == *b)
-        return(0);
-
-    if(isdigit(*a)) {
-        if(isdigit(*b)) {
-            /* rewind string to first digit */
-            /* e.g. to compare 12 vs 100 and not 2 vs 00 */
-            while(a > v1 && isdigit(*(a-1)) &&
-                  b > v2 && isdigit(*(b-1))) {
-                a--;
-                b--;
-            }
-            i = atoll(a);
-            j = atoll(b);
-
-            if(i<j)
-                return(-1);
-            if(i>j)
-                return(1);
-
-            /* numbers are equal but strings are not?           */
-            /* yes ->  leading zeros: atoll("01") == atoll("1") */
-            return(0);
-        }
-        /* a > ('.',alpha, 0) */
-        return(1);
-    }
-
-    if(isalpha(*a)) {
+        if (isdigit(*a))
+            return 1;
+        if (isdigit(*b))
+            return -1;
 
-        /*  alpha < digit */
-        if(isdigit(*b))
-            return(-1);
-
-        if(isalpha(*b)) {
-            if(*a < *b)
-                return(-1);
-            return(1);
-        }
-        return(1);
+        if (*a < *b)
+            return -1;
+        if (*a > *b)
+            return 1;
+        a++;
+        b++;
     }
-
-    if(! *b)
-        return(1);
-
-    return(-1);
 }
 
 int compare_beepackage_names(struct beeversion *v1, struct beeversion *v2) {