Mercurial > hg > CbC > CbC_gcc
comparison libiberty/strverscmp.c @ 0:a06113de4d67
first commit
author | kent <kent@cr.ie.u-ryukyu.ac.jp> |
---|---|
date | Fri, 17 Jul 2009 14:47:48 +0900 |
parents | |
children | 04ced10e8804 |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:a06113de4d67 |
---|---|
1 /* Compare strings while treating digits characters numerically. | |
2 Copyright (C) 1997, 2002, 2005 Free Software Foundation, Inc. | |
3 This file is part of the libiberty library. | |
4 Contributed by Jean-François Bignolles <bignolle@ecoledoc.ibp.fr>, 1997. | |
5 | |
6 Libiberty is free software; you can redistribute it and/or | |
7 modify it under the terms of the GNU Lesser General Public | |
8 License as published by the Free Software Foundation; either | |
9 version 2.1 of the License, or (at your option) any later version. | |
10 | |
11 Libiberty is distributed in the hope that it will be useful, | |
12 but WITHOUT ANY WARRANTY; without even the implied warranty of | |
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
14 Lesser General Public License for more details. | |
15 | |
16 You should have received a copy of the GNU Lesser General Public | |
17 License along with the GNU C Library; if not, write to the Free | |
18 Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA | |
19 02110-1301 USA. */ | |
20 | |
21 #include "libiberty.h" | |
22 #include "safe-ctype.h" | |
23 | |
24 /* | |
25 @deftypefun int strverscmp (const char *@var{s1}, const char *@var{s2}) | |
26 The @code{strverscmp} function compares the string @var{s1} against | |
27 @var{s2}, considering them as holding indices/version numbers. Return | |
28 value follows the same conventions as found in the @code{strverscmp} | |
29 function. In fact, if @var{s1} and @var{s2} contain no digits, | |
30 @code{strverscmp} behaves like @code{strcmp}. | |
31 | |
32 Basically, we compare strings normally (character by character), until | |
33 we find a digit in each string - then we enter a special comparison | |
34 mode, where each sequence of digits is taken as a whole. If we reach the | |
35 end of these two parts without noticing a difference, we return to the | |
36 standard comparison mode. There are two types of numeric parts: | |
37 "integral" and "fractional" (those begin with a '0'). The types | |
38 of the numeric parts affect the way we sort them: | |
39 | |
40 @itemize @bullet | |
41 @item | |
42 integral/integral: we compare values as you would expect. | |
43 | |
44 @item | |
45 fractional/integral: the fractional part is less than the integral one. | |
46 Again, no surprise. | |
47 | |
48 @item | |
49 fractional/fractional: the things become a bit more complex. | |
50 If the common prefix contains only leading zeroes, the longest part is less | |
51 than the other one; else the comparison behaves normally. | |
52 @end itemize | |
53 | |
54 @smallexample | |
55 strverscmp ("no digit", "no digit") | |
56 @result{} 0 // @r{same behavior as strcmp.} | |
57 strverscmp ("item#99", "item#100") | |
58 @result{} <0 // @r{same prefix, but 99 < 100.} | |
59 strverscmp ("alpha1", "alpha001") | |
60 @result{} >0 // @r{fractional part inferior to integral one.} | |
61 strverscmp ("part1_f012", "part1_f01") | |
62 @result{} >0 // @r{two fractional parts.} | |
63 strverscmp ("foo.009", "foo.0") | |
64 @result{} <0 // @r{idem, but with leading zeroes only.} | |
65 @end smallexample | |
66 | |
67 This function is especially useful when dealing with filename sorting, | |
68 because filenames frequently hold indices/version numbers. | |
69 @end deftypefun | |
70 | |
71 */ | |
72 | |
73 /* states: S_N: normal, S_I: comparing integral part, S_F: comparing | |
74 fractional parts, S_Z: idem but with leading Zeroes only */ | |
75 #define S_N 0x0 | |
76 #define S_I 0x4 | |
77 #define S_F 0x8 | |
78 #define S_Z 0xC | |
79 | |
80 /* result_type: CMP: return diff; LEN: compare using len_diff/diff */ | |
81 #define CMP 2 | |
82 #define LEN 3 | |
83 | |
84 | |
85 /* Compare S1 and S2 as strings holding indices/version numbers, | |
86 returning less than, equal to or greater than zero if S1 is less than, | |
87 equal to or greater than S2 (for more info, see the Glibc texinfo doc). */ | |
88 | |
89 int | |
90 strverscmp (const char *s1, const char *s2) | |
91 { | |
92 const unsigned char *p1 = (const unsigned char *) s1; | |
93 const unsigned char *p2 = (const unsigned char *) s2; | |
94 unsigned char c1, c2; | |
95 int state; | |
96 int diff; | |
97 | |
98 /* Symbol(s) 0 [1-9] others (padding) | |
99 Transition (10) 0 (01) d (00) x (11) - */ | |
100 static const unsigned int next_state[] = | |
101 { | |
102 /* state x d 0 - */ | |
103 /* S_N */ S_N, S_I, S_Z, S_N, | |
104 /* S_I */ S_N, S_I, S_I, S_I, | |
105 /* S_F */ S_N, S_F, S_F, S_F, | |
106 /* S_Z */ S_N, S_F, S_Z, S_Z | |
107 }; | |
108 | |
109 static const int result_type[] = | |
110 { | |
111 /* state x/x x/d x/0 x/- d/x d/d d/0 d/- | |
112 0/x 0/d 0/0 0/- -/x -/d -/0 -/- */ | |
113 | |
114 /* S_N */ CMP, CMP, CMP, CMP, CMP, LEN, CMP, CMP, | |
115 CMP, CMP, CMP, CMP, CMP, CMP, CMP, CMP, | |
116 /* S_I */ CMP, -1, -1, CMP, +1, LEN, LEN, CMP, | |
117 +1, LEN, LEN, CMP, CMP, CMP, CMP, CMP, | |
118 /* S_F */ CMP, CMP, CMP, CMP, CMP, LEN, CMP, CMP, | |
119 CMP, CMP, CMP, CMP, CMP, CMP, CMP, CMP, | |
120 /* S_Z */ CMP, +1, +1, CMP, -1, CMP, CMP, CMP, | |
121 -1, CMP, CMP, CMP | |
122 }; | |
123 | |
124 if (p1 == p2) | |
125 return 0; | |
126 | |
127 c1 = *p1++; | |
128 c2 = *p2++; | |
129 /* Hint: '0' is a digit too. */ | |
130 state = S_N | ((c1 == '0') + (ISDIGIT (c1) != 0)); | |
131 | |
132 while ((diff = c1 - c2) == 0 && c1 != '\0') | |
133 { | |
134 state = next_state[state]; | |
135 c1 = *p1++; | |
136 c2 = *p2++; | |
137 state |= (c1 == '0') + (ISDIGIT (c1) != 0); | |
138 } | |
139 | |
140 state = result_type[state << 2 | (((c2 == '0') + (ISDIGIT (c2) != 0)))]; | |
141 | |
142 switch (state) | |
143 { | |
144 case CMP: | |
145 return diff; | |
146 | |
147 case LEN: | |
148 while (ISDIGIT (*p1++)) | |
149 if (!ISDIGIT (*p2++)) | |
150 return 1; | |
151 | |
152 return ISDIGIT (*p2) ? -1 : diff; | |
153 | |
154 default: | |
155 return state; | |
156 } | |
157 } |