This behavior differs from glibc strverscmp(3) but is useful and matches the behavior of GNU sort -V and musl strverscmp(3.
117 lines
3.8 KiB
C
117 lines
3.8 KiB
C
/*
|
|
* Copyright (c) 2013 Jonas 'Sortie' Termansen.
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*
|
|
* string/strverscmp.c
|
|
* Compares two version strings.
|
|
*/
|
|
|
|
#include <stdbool.h>
|
|
#include <string.h>
|
|
|
|
static bool is_number(char c)
|
|
{
|
|
return '0' <= c && c <= '9';
|
|
}
|
|
|
|
static int to_number(char c)
|
|
{
|
|
return c - '0';
|
|
}
|
|
|
|
int strverscmp(const char* a, const char* b)
|
|
{
|
|
for ( size_t i = 0; true; i++ )
|
|
{
|
|
// Be a regular strcmp if the strings are equal.
|
|
if ( a[i] == '\0' && b[i] == '\0' )
|
|
return 0;
|
|
if ( a[i] == b[i] )
|
|
continue;
|
|
|
|
// Be a regular strcmp if no digits are involed when they differ.
|
|
// Note: This implementation uses version number comparison if *either*
|
|
// of the first differing characters are digits, unlike glibc
|
|
// which is documented to require *both*. This behavior matches
|
|
// GNU sort -V and musl. It's also useful as "1.2.txt" compares
|
|
// before "1.2.3.txt".
|
|
bool version_string = is_number(a[i]) || is_number(b[i]);
|
|
if ( !version_string && a[i] < b[i] )
|
|
return -1;
|
|
if ( !version_string && a[i] > b[i] )
|
|
return 1;
|
|
|
|
// Because the number of leading zeroes matter, we have to find the
|
|
// entire numeric block we are currently within. We know the strings are
|
|
// equal until i, so we can simply find the number of shared digits by
|
|
// looking in the first string.
|
|
size_t digits_start = i;
|
|
while ( digits_start && is_number(a[digits_start-1]) )
|
|
digits_start--;
|
|
size_t shared_digits = i - digits_start;
|
|
|
|
// Find the number of shared leading zeroes.
|
|
size_t shared_zeroes = 0;
|
|
while ( shared_zeroes < shared_digits &&
|
|
to_number(a[digits_start + shared_zeroes]) == 0 )
|
|
shared_zeroes++;
|
|
|
|
// Try to expand the leading zeroes amount into a.
|
|
size_t a_zeroes = shared_zeroes;
|
|
while ( is_number(a[digits_start + a_zeroes]) == 0 )
|
|
a_zeroes++;
|
|
|
|
// Try to expand the leading zeroes amount into b.
|
|
size_t b_zeroes = shared_zeroes;
|
|
while ( is_number(b[digits_start + b_zeroes]) == 0 )
|
|
b_zeroes++;
|
|
|
|
// We treat strings with leading zeroes as if they have a decimal point
|
|
// in front of them, so strings with more zeroes sort lower.
|
|
if ( a_zeroes > b_zeroes )
|
|
return -1;
|
|
if ( b_zeroes > a_zeroes )
|
|
return 1;
|
|
|
|
// Find the number of consecutive digits in a where the strings differ.
|
|
size_t a_digits = a_zeroes;
|
|
while ( is_number(a[digits_start + a_digits]) )
|
|
a_digits++;
|
|
|
|
// Find the number of consecutive digits in b where the strings differ.
|
|
size_t b_digits = b_zeroes;
|
|
while ( is_number(b[digits_start + b_digits]) )
|
|
b_digits++;
|
|
|
|
// We know the strings have the same amount of leading zeroes, so we
|
|
// so if a a block is longer than the other, then the value must be
|
|
// longer as well.
|
|
if ( a_digits < b_digits )
|
|
return -1;
|
|
if ( b_digits < a_digits )
|
|
return 1;
|
|
|
|
// Finally run through the strings from where they differ and sort them
|
|
// numerically. We know this terminates because the strings differ. The
|
|
// strings have the same amount of digits, so comparing them is easy.
|
|
for ( size_t n = shared_zeroes; true; n++ )
|
|
{
|
|
if ( a[digits_start + n] < b[digits_start + n] )
|
|
return -1;
|
|
if ( b[digits_start + n] < a[digits_start + n] )
|
|
return 1;
|
|
}
|
|
}
|
|
}
|