/src/php-src/ext/standard/strnatcmp.c

Source
/*

  Modified for PHP by Andrei Zmievski <andrei@ispi.net>

  strnatcmp.c -- Perform 'natural order' comparisons of strings in C.
  Copyright (C) 2000 by Martin Pool <mbp@humbug.org.au>

  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.
*/

#include <ctype.h>
#include <string.h>
#include <stdio.h>

#include "php.h"
#include "php_string.h"

/* {{{ compare_right */
static int
compare_right(char const **a, char const *aend, char const **b, char const *bend)
{
  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 ((*a == aend || !isdigit((int)(unsigned char)**a)) &&
      (*b == bend || !isdigit((int)(unsigned char)**b)))
      return bias;
    else if (*a == aend || !isdigit((int)(unsigned char)**a))
      return -1;
    else if (*b == bend || !isdigit((int)(unsigned char)**b))
      return +1;
    else if (**a < **b) {
      if (!bias)
        bias = -1;
    } else if (**a > **b) {
      if (!bias)
        bias = +1;
    }
  }

  return 0;
}
/* }}} */

/* {{{ compare_left */
static int
compare_left(char const **a, char const *aend, char const **b, char const *bend)
{
  /* Compare two left-aligned numbers: the first to have a
     different value wins. */
  for(;; (*a)++, (*b)++) {
    if ((*a == aend || !isdigit((int)(unsigned char)**a)) &&
      (*b == bend || !isdigit((int)(unsigned char)**b)))
      return 0;
    else if (*a == aend || !isdigit((int)(unsigned char)**a))
      return -1;
    else if (*b == bend || !isdigit((int)(unsigned char)**b))
      return +1;
     else if (**a < **b)
       return -1;
     else if (**a > **b)
       return +1;
  }

  return 0;
}
/* }}} */

/* {{{ strnatcmp_ex */
PHPAPI int strnatcmp_ex(char const *a, size_t a_len, char const *b, size_t b_len, bool is_case_insensitive)
{
  unsigned char ca, cb;
  char const *ap, *bp;
  char const *aend = a + a_len,
         *bend = b + b_len;
  int fractional, result;

  if (a_len == 0 || b_len == 0) {
    return (a_len == b_len ? 0 : (a_len > b_len ? 1 : -1));
  }

  ap = a;
  bp = b;

  ca = *ap; cb = *bp;

  /* skip over leading zeros */
  while (ca == '0' && (ap+1 < aend) && isdigit((int)(unsigned char)*(ap+1))) {
    ca = *++ap;
  }

  while (cb == '0' && (bp+1 < bend) && isdigit((int)(unsigned char)*(bp+1))) {
    cb = *++bp;
  }

  while (1) {

    /* Skip consecutive whitespace */
    while (isspace((int)(unsigned char)ca)) {
      ca = *++ap;
    }

    while (isspace((int)(unsigned char)cb)) {
      cb = *++bp;
    }

    /* process run of digits */
    if (isdigit((int)(unsigned char)ca)  &&  isdigit((int)(unsigned char)cb)) {
      fractional = (ca == '0' || cb == '0');

      if (fractional)
        result = compare_left(&ap, aend, &bp, bend);
      else
        result = compare_right(&ap, aend, &bp, bend);

      if (result != 0)
        return result;
      else if (ap == aend && bp == bend)
        /* End of the strings. Let caller sort them out. */
        return 0;
      else if (ap == aend)
        return -1;
      else if (bp == bend)
        return 1;
      else {
        /* Keep on comparing from the current point. */
        ca = *ap; cb = *bp;
      }
    }

    if (is_case_insensitive) {
      ca = toupper((int)(unsigned char)ca);
      cb = toupper((int)(unsigned char)cb);
    }

    if (ca < cb)
      return -1;
    else if (ca > cb)
      return +1;

    ++ap; ++bp;
    if (ap >= aend && bp >= bend)
      /* The strings compare the same.  Perhaps the caller
         will want to call strcmp to break the tie. */
      return 0;
    else if (ap >= aend)
      return -1;
    else if (bp >= bend)
      return 1;

    ca = *ap; cb = *bp;
  }
}
/* }}} */

Line	Count	Source
1		/*
2
3		Modified for PHP by Andrei Zmievski <andrei@ispi.net>
4
5		strnatcmp.c -- Perform 'natural order' comparisons of strings in C.
6		Copyright (C) 2000 by Martin Pool <mbp@humbug.org.au>
7
8		This software is provided 'as-is', without any express or implied
9		warranty. In no event will the authors be held liable for any damages
10		arising from the use of this software.
11
12		Permission is granted to anyone to use this software for any purpose,
13		including commercial applications, and to alter it and redistribute it
14		freely, subject to the following restrictions:
15
16		1. The origin of this software must not be misrepresented; you must not
17		claim that you wrote the original software. If you use this software
18		in a product, an acknowledgment in the product documentation would be
19		appreciated but is not required.
20		2. Altered source versions must be plainly marked as such, and must not be
21		misrepresented as being the original software.
22		3. This notice may not be removed or altered from any source distribution.
23		*/
24
25		#include <ctype.h>
26		#include <string.h>
27		#include <stdio.h>
28
29		#include "php.h"
30		#include "php_string.h"
31
32		/* {{{ compare_right */
33		static int
34		compare_right(char const *a, char const aend, char const *b, char const bend)
35	926	{
36	926	int bias = 0;
37
38		/* The longest run of digits wins. That aside, the greatest
39		value wins, but we can't know that it will until we've scanned
40		both numbers to know that they have the same magnitude, so we
41		remember it in BIAS. */
42	7.00k	for(;; (a)++, (b)++) {
43	7.00k	if ((a == aend \|\| !isdigit((int)(unsigned char)*a)) &&
44	802	(b == bend \|\| !isdigit((int)(unsigned char)*b)))
45	722	return bias;
46	6.27k	else if (a == aend \|\| !isdigit((int)(unsigned char)*a))
47	80	return -1;
48	6.19k	else if (b == bend \|\| !isdigit((int)(unsigned char)*b))
49	124	return +1;
50	6.07k	else if (a < b) {
51	208	if (!bias)
52	60	bias = -1;
53	5.86k	} else if (a > b) {
54	212	if (!bias)
55	58	bias = +1;
56	212	}
57	7.00k	}
58
59	0	return 0;
60	926	}
61		/* }}} */
62
63		/* {{{ compare_left */
64		static int
65		compare_left(char const *a, char const aend, char const *b, char const bend)
66	682	{
67		/* Compare two left-aligned numbers: the first to have a
68		different value wins. */
69	2.93k	for(;; (a)++, (b)++) {
70	2.93k	if ((a == aend \|\| !isdigit((int)(unsigned char)*a)) &&
71	318	(b == bend \|\| !isdigit((int)(unsigned char)*b)))
72	284	return 0;
73	2.65k	else if (a == aend \|\| !isdigit((int)(unsigned char)*a))
74	34	return -1;
75	2.62k	else if (b == bend \|\| !isdigit((int)(unsigned char)*b))
76	26	return +1;
77	2.59k	else if (a < b)
78	70	return -1;
79	2.52k	else if (a > b)
80	268	return +1;
81	2.93k	}
82
83	0	return 0;
84	682	}
85		/* }}} */
86
87		/* {{{ strnatcmp_ex */
88		PHPAPI int strnatcmp_ex(char const a, size_t a_len, char const b, size_t b_len, bool is_case_insensitive)
89	9.27k	{
90	9.27k	unsigned char ca, cb;
91	9.27k	char const ap, bp;
92	9.27k	char const *aend = a + a_len,
93	9.27k	*bend = b + b_len;
94	9.27k	int fractional, result;
95
96	9.27k	if (a_len == 0 \|\| b_len == 0) {
97	844	return (a_len == b_len ? 0 : (a_len > b_len ? 1 : -1));
98	844	}
99
100	8.43k	ap = a;
101	8.43k	bp = b;
102
103	8.43k	ca = ap; cb = bp;
104
105		/* skip over leading zeros */
106	8.43k	while (ca == '0' && (ap+1 < aend) && isdigit((int)(unsigned char)*(ap+1))) {
107	0	ca = *++ap;
108	0	}
109
110	8.43k	while (cb == '0' && (bp+1 < bend) && isdigit((int)(unsigned char)*(bp+1))) {
111	0	cb = *++bp;
112	0	}
113
114	98.6k	while (1) {
115
116		/* Skip consecutive whitespace */
117	98.6k	while (isspace((int)(unsigned char)ca)) {
118	14.2k	ca = *++ap;
119	14.2k	}
120
121	98.6k	while (isspace((int)(unsigned char)cb)) {
122	14.1k	cb = *++bp;
123	14.1k	}
124
125		/* process run of digits */
126	98.6k	if (isdigit((int)(unsigned char)ca) && isdigit((int)(unsigned char)cb)) {
127	1.60k	fractional = (ca == '0' \|\| cb == '0');
128
129	1.60k	if (fractional)
130	682	result = compare_left(&ap, aend, &bp, bend);
131	926	else
132	926	result = compare_right(&ap, aend, &bp, bend);
133
134	1.60k	if (result != 0)
135	660	return result;
136	948	else if (ap == aend && bp == bend)
137		/* End of the strings. Let caller sort them out. */
138	128	return 0;
139	820	else if (ap == aend)
140	0	return -1;
141	820	else if (bp == bend)
142	0	return 1;
143	820	else {
144		/* Keep on comparing from the current point. */
145	820	ca = ap; cb = bp;
146	820	}
147	1.60k	}
148
149	97.8k	if (is_case_insensitive) {
150	0	ca = toupper((int)(unsigned char)ca);
151	0	cb = toupper((int)(unsigned char)cb);
152	0	}
153
154	97.8k	if (ca < cb)
155	1.83k	return -1;
156	96.0k	else if (ca > cb)
157	3.63k	return +1;
158
159	92.3k	++ap; ++bp;
160	92.3k	if (ap >= aend && bp >= bend)
161		/* The strings compare the same. Perhaps the caller
162		will want to call strcmp to break the tie. */
163	1.87k	return 0;
164	90.5k	else if (ap >= aend)
165	54	return -1;
166	90.4k	else if (bp >= bend)
167	244	return 1;
168
169	90.2k	ca = ap; cb = bp;
170	90.2k	}
171	8.43k	}
172		/* }}} */

Coverage Report

Created: 2025-12-14 06:09