Contents of /branches/mage-next/src/vercomp.c
Parent Directory | Revision Log
Revision 2585 -
(show annotations)
(download)
Mon Feb 3 14:02:05 2014 UTC (10 years, 7 months ago) by niro
File MIME type: text/plain
File size: 8154 byte(s)
Mon Feb 3 14:02:05 2014 UTC (10 years, 7 months ago) by niro
File MIME type: text/plain
File size: 8154 byte(s)
-added vercomp and highestver sources
1 | /* |
2 | * Copyright (c) 2006-2011 Pacman Development Team <pacman-dev@archlinux.org> |
3 | * |
4 | * This program is free software; you can redistribute it and/or modify |
5 | * it under the terms of the GNU General Public License as published by |
6 | * the Free Software Foundation; either version 2 of the License, or |
7 | * (at your option) any later version. |
8 | * |
9 | * This program is distributed in the hope that it will be useful, |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
12 | * GNU General Public License for more details. |
13 | * |
14 | * You should have received a copy of the GNU General Public License |
15 | * along with this program. If not, see <http://www.gnu.org/licenses/>. |
16 | */ |
17 | |
18 | #include <stdlib.h> |
19 | #include <stdio.h> /* printf */ |
20 | #include <string.h> |
21 | #include <ctype.h> |
22 | |
23 | /** |
24 | * Some functions in this file have been adopted from the rpm source, notably |
25 | * 'rpmvercmp' located at lib/rpmvercmp.c and 'parseEVR' located at |
26 | * lib/rpmds.c. It was most recently updated against rpm version 4.8.1. Small |
27 | * modifications have been made to make it more consistent with the libalpm |
28 | * coding style. |
29 | */ |
30 | |
31 | /** |
32 | * Split EVR into epoch, version, and release components. |
33 | * @param evr [epoch:]version[-release] string |
34 | * @retval *ep pointer to epoch |
35 | * @retval *vp pointer to version |
36 | * @retval *rp pointer to release |
37 | */ |
38 | static void parseEVR(char *evr, const char **ep, const char **vp, |
39 | const char **rp) |
40 | { |
41 | const char *epoch; |
42 | const char *version; |
43 | const char *release; |
44 | char *s, *se; |
45 | |
46 | s = evr; |
47 | /* s points to epoch terminator */ |
48 | while (*s && isdigit(*s)) s++; |
49 | /* se points to version terminator */ |
50 | se = strrchr(s, '-'); |
51 | |
52 | if(*s == ':') { |
53 | epoch = evr; |
54 | *s++ = '\0'; |
55 | version = s; |
56 | if(*epoch == '\0') { |
57 | epoch = "0"; |
58 | } |
59 | } else { |
60 | /* different from RPM- always assume 0 epoch */ |
61 | epoch = "0"; |
62 | version = evr; |
63 | } |
64 | if(se) { |
65 | *se++ = '\0'; |
66 | release = se; |
67 | } else { |
68 | release = NULL; |
69 | } |
70 | |
71 | if(ep) *ep = epoch; |
72 | if(vp) *vp = version; |
73 | if(rp) *rp = release; |
74 | } |
75 | |
76 | /** |
77 | * Compare alpha and numeric segments of two versions. |
78 | * return 1: a is newer than b |
79 | * 0: a and b are the same version |
80 | * -1: b is newer than a |
81 | */ |
82 | static int rpmvercmp(const char *a, const char *b) |
83 | { |
84 | char oldch1, oldch2; |
85 | char *str1, *str2; |
86 | char *ptr1, *ptr2; |
87 | char *one, *two; |
88 | int rc; |
89 | int isnum; |
90 | int ret = 0; |
91 | |
92 | /* easy comparison to see if versions are identical */ |
93 | if(strcmp(a, b) == 0) return 0; |
94 | |
95 | str1 = strdup(a); |
96 | str2 = strdup(b); |
97 | |
98 | one = ptr1 = str1; |
99 | two = ptr2 = str2; |
100 | |
101 | /* loop through each version segment of str1 and str2 and compare them */ |
102 | while (*one && *two) { |
103 | while (*one && !isalnum((int)*one)) one++; |
104 | while (*two && !isalnum((int)*two)) two++; |
105 | |
106 | /* If we ran to the end of either, we are finished with the loop */ |
107 | if (!(*one && *two)) break; |
108 | |
109 | /* If the separator lengths were different, we are also finished */ |
110 | if ((one - ptr1) != (two - ptr2)) { |
111 | return (one - ptr1) < (two - ptr2) ? -1 : 1; |
112 | } |
113 | |
114 | ptr1 = one; |
115 | ptr2 = two; |
116 | |
117 | /* grab first completely alpha or completely numeric segment */ |
118 | /* leave one and two pointing to the start of the alpha or numeric */ |
119 | /* segment and walk ptr1 and ptr2 to end of segment */ |
120 | if (isdigit((int)*ptr1)) { |
121 | while (*ptr1 && isdigit((int)*ptr1)) ptr1++; |
122 | while (*ptr2 && isdigit((int)*ptr2)) ptr2++; |
123 | isnum = 1; |
124 | } else { |
125 | while (*ptr1 && isalpha((int)*ptr1)) ptr1++; |
126 | while (*ptr2 && isalpha((int)*ptr2)) ptr2++; |
127 | isnum = 0; |
128 | } |
129 | |
130 | /* save character at the end of the alpha or numeric segment */ |
131 | /* so that they can be restored after the comparison */ |
132 | oldch1 = *ptr1; |
133 | *ptr1 = '\0'; |
134 | oldch2 = *ptr2; |
135 | *ptr2 = '\0'; |
136 | |
137 | /* this cannot happen, as we previously tested to make sure that */ |
138 | /* the first string has a non-null segment */ |
139 | if (one == ptr1) { |
140 | ret = -1; /* arbitrary */ |
141 | goto cleanup; |
142 | } |
143 | |
144 | /* take care of the case where the two version segments are */ |
145 | /* different types: one numeric, the other alpha (i.e. empty) */ |
146 | /* numeric segments are always newer than alpha segments */ |
147 | /* XXX See patch #60884 (and details) from bugzilla #50977. */ |
148 | if (two == ptr2) { |
149 | ret = isnum ? 1 : -1; |
150 | goto cleanup; |
151 | } |
152 | |
153 | if (isnum) { |
154 | /* this used to be done by converting the digit segments */ |
155 | /* to ints using atoi() - it's changed because long */ |
156 | /* digit segments can overflow an int - this should fix that. */ |
157 | |
158 | /* throw away any leading zeros - it's a number, right? */ |
159 | while (*one == '0') one++; |
160 | while (*two == '0') two++; |
161 | |
162 | /* whichever number has more digits wins */ |
163 | if (strlen(one) > strlen(two)) { |
164 | ret = 1; |
165 | goto cleanup; |
166 | } |
167 | if (strlen(two) > strlen(one)) { |
168 | ret = -1; |
169 | goto cleanup; |
170 | } |
171 | } |
172 | |
173 | /* strcmp will return which one is greater - even if the two */ |
174 | /* segments are alpha or if they are numeric. don't return */ |
175 | /* if they are equal because there might be more segments to */ |
176 | /* compare */ |
177 | rc = strcmp(one, two); |
178 | if (rc) { |
179 | ret = rc < 1 ? -1 : 1; |
180 | goto cleanup; |
181 | } |
182 | |
183 | /* restore character that was replaced by null above */ |
184 | *ptr1 = oldch1; |
185 | one = ptr1; |
186 | *ptr2 = oldch2; |
187 | two = ptr2; |
188 | } |
189 | |
190 | /* this catches the case where all numeric and alpha segments have */ |
191 | /* compared identically but the segment separating characters were */ |
192 | /* different */ |
193 | if ((!*one) && (!*two)) { |
194 | ret = 0; |
195 | goto cleanup; |
196 | } |
197 | |
198 | /* the final showdown. we never want a remaining alpha string to |
199 | * beat an empty string. the logic is a bit weird, but: |
200 | * - if one is empty and two is not an alpha, two is newer. |
201 | * - if one is an alpha, two is newer. |
202 | * - otherwise one is newer. |
203 | * */ |
204 | if ( (!*one && !isalpha((int)*two)) |
205 | || isalpha((int)*one) ) { |
206 | ret = -1; |
207 | } else { |
208 | ret = 1; |
209 | } |
210 | |
211 | cleanup: |
212 | free(str1); |
213 | free(str2); |
214 | return ret; |
215 | } |
216 | |
217 | /** Compare two version strings and determine which one is 'newer'. |
218 | * Returns a value comparable to the way strcmp works. Returns 1 |
219 | * if a is newer than b, 0 if a and b are the same version, or -1 |
220 | * if b is newer than a. |
221 | * |
222 | * Different epoch values for version strings will override any further |
223 | * comparison. If no epoch is provided, 0 is assumed. |
224 | * |
225 | * Keep in mind that the pkgrel is only compared if it is available |
226 | * on both versions handed to this function. For example, comparing |
227 | * 1.5-1 and 1.5 will yield 0; comparing 1.5-1 and 1.5-2 will yield |
228 | * -1 as expected. This is mainly for supporting versioned dependencies |
229 | * that do not include the pkgrel. |
230 | */ |
231 | int alpm_pkg_vercmp(const char *a, const char *b) |
232 | { |
233 | char *full1, *full2; |
234 | const char *epoch1, *ver1, *rel1; |
235 | const char *epoch2, *ver2, *rel2; |
236 | int ret; |
237 | |
238 | /* ensure our strings are not null */ |
239 | if(!a && !b) { |
240 | return 0; |
241 | } else if(!a) { |
242 | return -1; |
243 | } else if(!b) { |
244 | return 1; |
245 | } |
246 | /* another quick shortcut- if full version specs are equal */ |
247 | if(strcmp(a, b) == 0) { |
248 | return 0; |
249 | } |
250 | |
251 | /* Parse both versions into [epoch:]version[-release] triplets. We probably |
252 | * don't need epoch and release to support all the same magic, but it is |
253 | * easier to just run it all through the same code. */ |
254 | full1 = strdup(a); |
255 | full2 = strdup(b); |
256 | |
257 | /* parseEVR modifies passed in version, so have to dupe it first */ |
258 | parseEVR(full1, &epoch1, &ver1, &rel1); |
259 | parseEVR(full2, &epoch2, &ver2, &rel2); |
260 | |
261 | ret = rpmvercmp(epoch1, epoch2); |
262 | if(ret == 0) { |
263 | ret = rpmvercmp(ver1, ver2); |
264 | if(ret == 0 && rel1 && rel2) { |
265 | ret = rpmvercmp(rel1, rel2); |
266 | } |
267 | } |
268 | |
269 | free(full1); |
270 | free(full2); |
271 | return ret; |
272 | } |
273 | |
274 | #define BASENAME "vercmp" |
275 | |
276 | static void usage(void) |
277 | { |
278 | fprintf(stderr, "usage: %s <ver1> <ver2>\n\n", BASENAME); |
279 | fprintf(stderr, "output values:\n"); |
280 | fprintf(stderr, " < 0 : if ver1 < ver2\n"); |
281 | fprintf(stderr, " 0 : if ver1 == ver2\n"); |
282 | fprintf(stderr, " > 0 : if ver1 > ver2\n"); |
283 | } |
284 | |
285 | int main(int argc, char *argv[]) |
286 | { |
287 | const char *s1 = ""; |
288 | const char *s2 = ""; |
289 | int ret; |
290 | |
291 | if(argc == 1) { |
292 | usage(); |
293 | return 2; |
294 | } |
295 | if(argc > 1 && |
296 | (strcmp(argv[1], "-h") == 0 || strcmp(argv[1], "--help") == 0 |
297 | || strcmp(argv[1], "--usage") == 0)) { |
298 | usage(); |
299 | return 0; |
300 | } |
301 | if(argc > 2) { |
302 | s2 = argv[2]; |
303 | } |
304 | if(argc > 1) { |
305 | s1 = argv[1]; |
306 | } |
307 | |
308 | ret = alpm_pkg_vercmp(s1, s2); |
309 | printf("%d\n", ret); |
310 | return EXIT_SUCCESS; |
311 | } |