mage-next/src/highestver.c

/*
 *  Copyright (c) 2006-2011 Pacman Development Team <pacman-dev@archlinux.org>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <stdlib.h>
#include <stdio.h> /* printf */
#include <string.h>
#include <ctype.h>

/**
 * Some functions in this file have been adopted from the rpm source, notably
 * 'rpmvercmp' located at lib/rpmvercmp.c and 'parseEVR' located at
 * lib/rpmds.c. It was most recently updated against rpm version 4.8.1. Small
 * modifications have been made to make it more consistent with the libalpm
 * coding style.
 */

/**
 * Split EVR into epoch, version, and release components.
 * @param evr		[epoch:]version[-release] string
 * @retval *ep		pointer to epoch
 * @retval *vp		pointer to version
 * @retval *rp		pointer to release
 */
static void parseEVR(char *evr, const char **ep, const char **vp,
		const char **rp)
{
	const char *epoch;
	const char *version;
	const char *release;
	char *s, *se;

	s = evr;
	/* s points to epoch terminator */
	while (*s && isdigit(*s)) s++;
	/* se points to version terminator */
	se = strrchr(s, '-');

	if(*s == ':') {
		epoch = evr;
		*s++ = '\0';
		version = s;
		if(*epoch == '\0') {
			epoch = "0";
		}
	} else {
		/* different from RPM- always assume 0 epoch */
		epoch = "0";
		version = evr;
	}
	if(se) {
		*se++ = '\0';
		release = se;
	} else {
		release = NULL;
	}

	if(ep) *ep = epoch;
	if(vp) *vp = version;
	if(rp) *rp = release;
}

/**
 * Compare alpha and numeric segments of two versions.
 * return 1: a is newer than b
 *        0: a and b are the same version
 *       -1: b is newer than a
 */
static int rpmvercmp(const char *a, const char *b)
{
	char oldch1, oldch2;
	char *str1, *str2;
	char *ptr1, *ptr2;
	char *one, *two;
	int rc;
	int isnum;
	int ret = 0;

	/* easy comparison to see if versions are identical */
	if(strcmp(a, b) == 0) return 0;

	str1 = strdup(a);
	str2 = strdup(b);

	one = ptr1 = str1;
	two = ptr2 = str2;

	/* loop through each version segment of str1 and str2 and compare them */
	while (*one && *two) {
		while (*one && !isalnum((int)*one)) one++;
		while (*two && !isalnum((int)*two)) two++;

		/* If we ran to the end of either, we are finished with the loop */
		if (!(*one && *two)) break;

		/* If the separator lengths were different, we are also finished */
		if ((one - ptr1) != (two - ptr2)) {
			return (one - ptr1) < (two - ptr2) ? -1 : 1;
		}

		ptr1 = one;
		ptr2 = two;

		/* grab first completely alpha or completely numeric segment */
		/* leave one and two pointing to the start of the alpha or numeric */
		/* segment and walk ptr1 and ptr2 to end of segment */
		if (isdigit((int)*ptr1)) {
			while (*ptr1 && isdigit((int)*ptr1)) ptr1++;
			while (*ptr2 && isdigit((int)*ptr2)) ptr2++;
			isnum = 1;
		} else {
			while (*ptr1 && isalpha((int)*ptr1)) ptr1++;
			while (*ptr2 && isalpha((int)*ptr2)) ptr2++;
			isnum = 0;
		}

		/* save character at the end of the alpha or numeric segment */
		/* so that they can be restored after the comparison */
		oldch1 = *ptr1;
		*ptr1 = '\0';
		oldch2 = *ptr2;
		*ptr2 = '\0';

		/* this cannot happen, as we previously tested to make sure that */
		/* the first string has a non-null segment */
		if (one == ptr1) {
			ret = -1;	/* arbitrary */
			goto cleanup;
		}

		/* take care of the case where the two version segments are */
		/* different types: one numeric, the other alpha (i.e. empty) */
		/* numeric segments are always newer than alpha segments */
		/* XXX See patch #60884 (and details) from bugzilla #50977. */
		if (two == ptr2) {
			ret = isnum ? 1 : -1;
			goto cleanup;
		}

		if (isnum) {
			/* this used to be done by converting the digit segments */
			/* to ints using atoi() - it's changed because long  */
			/* digit segments can overflow an int - this should fix that. */

			/* throw away any leading zeros - it's a number, right? */
			while (*one == '0') one++;
			while (*two == '0') two++;

			/* whichever number has more digits wins */
			if (strlen(one) > strlen(two)) {
				ret = 1;
				goto cleanup;
			}
			if (strlen(two) > strlen(one)) {
				ret = -1;
				goto cleanup;
			}
		}

		/* strcmp will return which one is greater - even if the two */
		/* segments are alpha or if they are numeric.  don't return  */
		/* if they are equal because there might be more segments to */
		/* compare */
		rc = strcmp(one, two);
		if (rc) {
			ret = rc < 1 ? -1 : 1;
			goto cleanup;
		}

		/* restore character that was replaced by null above */
		*ptr1 = oldch1;
		one = ptr1;
		*ptr2 = oldch2;
		two = ptr2;
	}

	/* this catches the case where all numeric and alpha segments have */
	/* compared identically but the segment separating characters were */
	/* different */
	if ((!*one) && (!*two)) {
		ret = 0;
		goto cleanup;
	}

	/* the final showdown. we never want a remaining alpha string to
	 * beat an empty string. the logic is a bit weird, but:
	 * - if one is empty and two is not an alpha, two is newer.
	 * - if one is an alpha, two is newer.
	 * - otherwise one is newer.
	 * */
	if ( (!*one && !isalpha((int)*two))
			|| isalpha((int)*one) ) {
		ret = -1;
	} else {
		ret = 1;
	}

cleanup:
	free(str1);
	free(str2);
	return ret;
}

/** Compare two version strings and determine which one is 'newer'.
 * Returns a value comparable to the way strcmp works. Returns 1
 * if a is newer than b, 0 if a and b are the same version, or -1
 * if b is newer than a.
 *
 * Different epoch values for version strings will override any further
 * comparison. If no epoch is provided, 0 is assumed.
 *
 * Keep in mind that the pkgrel is only compared if it is available
 * on both versions handed to this function. For example, comparing
 * 1.5-1 and 1.5 will yield 0; comparing 1.5-1 and 1.5-2 will yield
 * -1 as expected. This is mainly for supporting versioned dependencies
 * that do not include the pkgrel.
 */
int alpm_pkg_vercmp(const char *a, const char *b)
{
	char *full1, *full2;
	const char *epoch1, *ver1, *rel1;
	const char *epoch2, *ver2, *rel2;
	int ret;

	/* ensure our strings are not null */
	if(!a && !b) {
		return 0;
	} else if(!a) {
		return -1;
	} else if(!b) {
		return 1;
	}
	/* another quick shortcut- if full version specs are equal */
	if(strcmp(a, b) == 0) {
		return 0;
	}

	/* Parse both versions into [epoch:]version[-release] triplets. We probably
	 * don't need epoch and release to support all the same magic, but it is
	 * easier to just run it all through the same code. */
	full1 = strdup(a);
	full2 = strdup(b);

	/* parseEVR modifies passed in version, so have to dupe it first */
	parseEVR(full1, &epoch1, &ver1, &rel1);
	parseEVR(full2, &epoch2, &ver2, &rel2);

	ret = rpmvercmp(epoch1, epoch2);
	if(ret == 0) {
		ret = rpmvercmp(ver1, ver2);
		if(ret == 0 && rel1 && rel2) {
			ret = rpmvercmp(rel1, rel2);
		}
	}

	free(full1);
	free(full2);
	return ret;
}

#define BASENAME "highestver"

static void usage(void)
{
	fprintf(stderr, "usage: %s <ver1> <ver2> ... <verN>\n", BASENAME);
	fprintf(stderr, "prints the highest version.\n");
}

int main(int argc, char *argv[])
{
	int i;
	int ret;
	char *saved;

	if(argc == 1) {
		usage();
		return 2;
	}

	// only one argument given, that is the highest one
	if(argc == 2) {
		saved = strdup(argv[1]);
	}

	// fasten things up
	if(argc == 3) {
		ret = alpm_pkg_vercmp(argv[1], argv[2]);
		if(ret < 0) {
			saved = strdup(argv[2]);
		}
		if(ret == 0) {
			saved = strdup(argv[1]);
		}
		if(ret > 0) {
			saved = strdup(argv[1]);
		}
	}

	if(argc > 3) {
		for(i=1; i < argc; i++) {
			if (i == 1) {
				saved = strdup(argv[i]);
			}
			ret = alpm_pkg_vercmp(saved, argv[i+1]);
			// retval >0 or 0 means saved i the higher on, no need to strcmp
			if(ret < 0) {
				saved = strdup(argv[i+1]);
			}
		}
	}

	if(strlen(saved) > 0) {
		printf("%s\n", saved);
	}

	free(saved);
	return EXIT_SUCCESS;
}
1	niro	2585	/*
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 "highestver"
275
276			static void usage(void)
277			{
278			fprintf(stderr, "usage: %s <ver1> <ver2> ... <verN>\n", BASENAME);
279			fprintf(stderr, "prints the highest version.\n");
280			}
281
282			int main(int argc, char *argv[])
283			{
284			int i;
285			int ret;
286			char *saved;
287
288			if(argc == 1) {
289			usage();
290			return 2;
291			}
292
293			// only one argument given, that is the highest one
294			if(argc == 2) {
295	niro	2629	saved = strdup(argv[1]);
296	niro	2585	}
297
298			// fasten things up
299			if(argc == 3) {
300			ret = alpm_pkg_vercmp(argv[1], argv[2]);
301			if(ret < 0) {
302	niro	2629	saved = strdup(argv[2]);
303	niro	2585	}
304			if(ret == 0) {
305	niro	2629	saved = strdup(argv[1]);
306	niro	2585	}
307			if(ret > 0) {
308	niro	2629	saved = strdup(argv[1]);
309	niro	2585	}
310			}
311
312			if(argc > 3) {
313			for(i=1; i < argc; i++) {
314			if (i == 1) {
315	niro	2629	saved = strdup(argv[i]);
316	niro	2585	}
317			ret = alpm_pkg_vercmp(saved, argv[i+1]);
318			// retval >0 or 0 means saved i the higher on, no need to strcmp
319			if(ret < 0) {
320	niro	2629	saved = strdup(argv[i+1]);
321	niro	2585	}
322			}
323			}
324
325			if(strlen(saved) > 0) {
326			printf("%s\n", saved);
327			}
328
329	niro	2630	free(saved);
330	niro	2585	return EXIT_SUCCESS;
331			}