/src/php-src/ext/standard/strnatcmp.c
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 | 3 | { |
36 | 3 | 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 | 15 | for(;; (*a)++, (*b)++) { |
43 | 15 | if ((*a == aend || !isdigit((unsigned char)**a)) && |
44 | 2 | (*b == bend || !isdigit((unsigned char)**b))) |
45 | 1 | return bias; |
46 | 14 | else if (*a == aend || !isdigit((unsigned char)**a)) |
47 | 1 | return -1; |
48 | 13 | else if (*b == bend || !isdigit((unsigned char)**b)) |
49 | 1 | return +1; |
50 | 12 | else if (**a < **b) { |
51 | 0 | if (!bias) |
52 | 0 | bias = -1; |
53 | 12 | } else if (**a > **b) { |
54 | 2 | if (!bias) |
55 | 2 | bias = +1; |
56 | 2 | } |
57 | 15 | } |
58 | | |
59 | 0 | return 0; |
60 | 3 | } |
61 | | /* }}} */ |
62 | | |
63 | | /* {{{ compare_left */ |
64 | | static int |
65 | | compare_left(char const **a, char const *aend, char const **b, char const *bend) |
66 | 0 | { |
67 | | /* Compare two left-aligned numbers: the first to have a |
68 | | different value wins. */ |
69 | 0 | for(;; (*a)++, (*b)++) { |
70 | 0 | if ((*a == aend || !isdigit((unsigned char)**a)) && |
71 | 0 | (*b == bend || !isdigit((unsigned char)**b))) |
72 | 0 | return 0; |
73 | 0 | else if (*a == aend || !isdigit((unsigned char)**a)) |
74 | 0 | return -1; |
75 | 0 | else if (*b == bend || !isdigit((unsigned char)**b)) |
76 | 0 | return +1; |
77 | 0 | else if (**a < **b) |
78 | 0 | return -1; |
79 | 0 | else if (**a > **b) |
80 | 0 | return +1; |
81 | 0 | } |
82 | | |
83 | 0 | return 0; |
84 | 0 | } |
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 | 42 | { |
90 | 42 | unsigned char ca, cb; |
91 | 42 | char const *ap, *bp; |
92 | 42 | char const *aend = a + a_len, |
93 | 42 | *bend = b + b_len; |
94 | 42 | int fractional, result; |
95 | | |
96 | 42 | if (a_len == 0 || b_len == 0) { |
97 | 9 | return (a_len == b_len ? 0 : (a_len > b_len ? 1 : -1)); |
98 | 9 | } |
99 | | |
100 | 33 | ap = a; |
101 | 33 | bp = b; |
102 | | |
103 | 33 | ca = *ap; cb = *bp; |
104 | | |
105 | | /* skip over leading zeros */ |
106 | 33 | while (ca == '0' && (ap+1 < aend) && isdigit((unsigned char)ap[1])) { |
107 | 0 | ca = *++ap; |
108 | 0 | } |
109 | | |
110 | 33 | while (cb == '0' && (bp+1 < bend) && isdigit((unsigned char)bp[1])) { |
111 | 0 | cb = *++bp; |
112 | 0 | } |
113 | | |
114 | 66 | while (1) { |
115 | | |
116 | | /* Skip consecutive whitespace */ |
117 | 66 | while (isspace(ca)) { |
118 | 2 | ca = *++ap; |
119 | 2 | } |
120 | | |
121 | 66 | while (isspace(cb)) { |
122 | 0 | cb = *++bp; |
123 | 0 | } |
124 | | |
125 | | /* process run of digits */ |
126 | 66 | if (isdigit(ca) && isdigit(cb)) { |
127 | 3 | fractional = (ca == '0' || cb == '0'); |
128 | | |
129 | 3 | if (fractional) |
130 | 0 | result = compare_left(&ap, aend, &bp, bend); |
131 | 3 | else |
132 | 3 | result = compare_right(&ap, aend, &bp, bend); |
133 | | |
134 | 3 | if (result != 0) |
135 | 2 | return result; |
136 | 1 | else if (ap == aend && bp == bend) |
137 | | /* End of the strings. Let caller sort them out. */ |
138 | 0 | return 0; |
139 | 1 | else if (ap == aend) |
140 | 0 | return -1; |
141 | 1 | else if (bp == bend) |
142 | 0 | return 1; |
143 | 1 | else { |
144 | | /* Keep on comparing from the current point. */ |
145 | 1 | ca = *ap; cb = *bp; |
146 | 1 | } |
147 | 3 | } |
148 | | |
149 | 64 | if (is_case_insensitive) { |
150 | 0 | ca = toupper(ca); |
151 | 0 | cb = toupper(cb); |
152 | 0 | } |
153 | | |
154 | 64 | if (ca < cb) |
155 | 11 | return -1; |
156 | 53 | else if (ca > cb) |
157 | 20 | return +1; |
158 | | |
159 | 33 | ++ap; ++bp; |
160 | 33 | 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 | 0 | return 0; |
164 | 33 | else if (ap >= aend) |
165 | 0 | return -1; |
166 | 33 | else if (bp >= bend) |
167 | 0 | return 1; |
168 | | |
169 | 33 | ca = *ap; cb = *bp; |
170 | 33 | } |
171 | 33 | } |
172 | | /* }}} */ |