/*- * Copyright (C) 2012 Oleg Moskalenko * Copyright (C) 2012 Gabor Kovesdan * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include "sort.h" #include "vsort.h" static inline bool isdigit_clocale(wchar_t c) { return (c >= L'0' && c <= L'9'); } static inline bool isalpha_clocale(wchar_t c) { return ((c >= L'a' && c <= L'z') || (c >= L'A' && c <= L'Z')); } static inline bool isalnum_clocale(wchar_t c) { return ((c >= L'a' && c <= L'z') || (c >= L'A' && c <= L'Z') || (c >= L'0' && c <= L'9')); } /* * Find string suffix of format: (\.[A-Za-z~][A-Za-z0-9~]*)*$ * Set length of string before suffix. */ static void find_suffix(bwstring_iterator si, bwstring_iterator se, size_t *len) { wchar_t c; size_t clen; bool expect_alpha, sfx; sfx = false; expect_alpha = false; *len = 0; clen = 0; while ((si < se) && (c = bws_get_iter_value(si))) { if (expect_alpha) { expect_alpha = false; if (!isalpha_clocale(c) && (c != L'~')) sfx = false; } else if (c == L'.') { expect_alpha = true; if (!sfx) { sfx = true; *len = clen; } } else if (!isalnum_clocale(c) && (c != L'~')) sfx = false; si = bws_iterator_inc(si, 1); ++clen; } /* This code must be here to make the implementation compatible * with WORDING of GNU sort documentation. * But the GNU sort implementation is not following its own * documentation. GNU sort allows empty file extensions * (just dot with nothing after); but the regular expression in * their documentation does not allow empty file extensions. * We chose to make our implementation compatible with GNU sort * implementation. If they will ever fix their bug, this code * must be uncommented. Or they may choose to fix the info page, * then the code stays commented. * if (expect_alpha) sfx = false; */ if (!sfx) *len = clen; } static inline int cmp_chars(wchar_t c1, wchar_t c2) { if (c1 == c2) return (0); if (c1 == L'~') return (-1); if (c2 == L'~') return (+1); if (isdigit_clocale(c1) || !c1) return ((isdigit_clocale(c2) || !c2) ? 0 : -1); if (isdigit_clocale(c2) || !c2) return (+1); if (isalpha_clocale(c1)) return ((isalpha_clocale(c2)) ? ((int) c1 - (int) c2) : -1); if (isalpha_clocale(c2)) return (+1); return ((int) c1 - (int) c2); } static int cmpversions(bwstring_iterator si1, bwstring_iterator se1, bwstring_iterator si2, bwstring_iterator se2) { int cmp, diff; while ((si1 < se1) || (si2 < se2)) { diff = 0; while (((si1 < se1) && !isdigit_clocale(bws_get_iter_value(si1))) || ((si2 < se2) && !isdigit_clocale(bws_get_iter_value(si2)))) { wchar_t c1, c2; c1 = (si1 < se1) ? bws_get_iter_value(si1) : 0; c2 = (si2 < se2) ? bws_get_iter_value(si2) : 0; cmp = cmp_chars(c1, c2); if (cmp) return (cmp); if (si1 < se1) si1 = bws_iterator_inc(si1, 1); if (si2 < se2) si2 = bws_iterator_inc(si2, 1); } while (bws_get_iter_value(si1) == L'0') si1 = bws_iterator_inc(si1, 1); while (bws_get_iter_value(si2) == L'0') si2 = bws_iterator_inc(si2, 1); while (isdigit_clocale(bws_get_iter_value(si1)) && isdigit_clocale(bws_get_iter_value(si2))) { if (!diff) diff = ((int)bws_get_iter_value(si1) - (int)bws_get_iter_value(si2)); si1 = bws_iterator_inc(si1, 1); si2 = bws_iterator_inc(si2, 1); } if (isdigit_clocale(bws_get_iter_value(si1))) return (1); if (isdigit_clocale(bws_get_iter_value(si2))) return (-1); if (diff) return (diff); } return (0); } /* * Compare two version strings */ int vcmp(struct bwstring *s1, struct bwstring *s2) { bwstring_iterator si1, si2; wchar_t c1, c2; size_t len1, len2, slen1, slen2; int cmp_bytes, cmp_res; if (s1 == s2) return (0); cmp_bytes = bwscmp(s1, s2, 0); if (cmp_bytes == 0) return (0); len1 = slen1 = BWSLEN(s1); len2 = slen2 = BWSLEN(s2); if (slen1 < 1) return (-1); if (slen2 < 1) return (+1); si1 = bws_begin(s1); si2 = bws_begin(s2); c1 = bws_get_iter_value(si1); c2 = bws_get_iter_value(si2); if (c1 == L'.' && (slen1 == 1)) return (-1); if (c2 == L'.' && (slen2 == 1)) return (+1); if (slen1 == 2 && c1 == L'.' && bws_get_iter_value(bws_iterator_inc(si1, 1)) == L'.') return (-1); if (slen2 == 2 && c2 == L'.' && bws_get_iter_value(bws_iterator_inc(si2, 1)) == L'.') return (+1); if (c1 == L'.' && c2 != L'.') return (-1); if (c1 != L'.' && c2 == L'.') return (+1); if (c1 == L'.' && c2 == L'.') { si1 = bws_iterator_inc(si1, 1); si2 = bws_iterator_inc(si2, 1); } find_suffix(si1, bws_end(s1), &len1); find_suffix(si2, bws_end(s2), &len2); if ((len1 == len2) && (bws_iterator_cmp(si1, si2, len1) == 0)) return (cmp_bytes); cmp_res = cmpversions(si1, bws_iterator_inc(si1, len1), si2, bws_iterator_inc(si2, len2)); if (cmp_res == 0) cmp_res = cmp_bytes; return (cmp_res); }