diff options
Diffstat (limited to 'src/lib/libc/stdlib/qsort.c')
-rw-r--r-- | src/lib/libc/stdlib/qsort.c | 171 |
1 files changed, 171 insertions, 0 deletions
diff --git a/src/lib/libc/stdlib/qsort.c b/src/lib/libc/stdlib/qsort.c new file mode 100644 index 0000000000..2a972c0eb0 --- /dev/null +++ b/src/lib/libc/stdlib/qsort.c | |||
@@ -0,0 +1,171 @@ | |||
1 | /*- | ||
2 | * Copyright (c) 1992, 1993 | ||
3 | * The Regents of the University of California. All rights reserved. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions | ||
7 | * are met: | ||
8 | * 1. Redistributions of source code must retain the above copyright | ||
9 | * notice, this list of conditions and the following disclaimer. | ||
10 | * 2. Redistributions in binary form must reproduce the above copyright | ||
11 | * notice, this list of conditions and the following disclaimer in the | ||
12 | * documentation and/or other materials provided with the distribution. | ||
13 | * 3. Neither the name of the University nor the names of its contributors | ||
14 | * may be used to endorse or promote products derived from this software | ||
15 | * without specific prior written permission. | ||
16 | * | ||
17 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND | ||
18 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE | ||
19 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE | ||
20 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE | ||
21 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL | ||
22 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS | ||
23 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) | ||
24 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT | ||
25 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY | ||
26 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF | ||
27 | * SUCH DAMAGE. | ||
28 | */ | ||
29 | |||
30 | #if defined(LIBC_SCCS) && !defined(lint) | ||
31 | static char *rcsid = "$OpenBSD: qsort.c,v 1.8 2003/06/02 20:18:38 millert Exp $"; | ||
32 | #endif /* LIBC_SCCS and not lint */ | ||
33 | |||
34 | #include <sys/types.h> | ||
35 | #include <stdlib.h> | ||
36 | |||
37 | static __inline char *med3(char *, char *, char *, int (*)()); | ||
38 | static __inline void swapfunc(char *, char *, int, int); | ||
39 | |||
40 | #define min(a, b) (a) < (b) ? a : b | ||
41 | |||
42 | /* | ||
43 | * Qsort routine from Bentley & McIlroy's "Engineering a Sort Function". | ||
44 | */ | ||
45 | #define swapcode(TYPE, parmi, parmj, n) { \ | ||
46 | long i = (n) / sizeof (TYPE); \ | ||
47 | register TYPE *pi = (TYPE *) (parmi); \ | ||
48 | register TYPE *pj = (TYPE *) (parmj); \ | ||
49 | do { \ | ||
50 | register TYPE t = *pi; \ | ||
51 | *pi++ = *pj; \ | ||
52 | *pj++ = t; \ | ||
53 | } while (--i > 0); \ | ||
54 | } | ||
55 | |||
56 | #define SWAPINIT(a, es) swaptype = ((char *)a - (char *)0) % sizeof(long) || \ | ||
57 | es % sizeof(long) ? 2 : es == sizeof(long)? 0 : 1; | ||
58 | |||
59 | static __inline void | ||
60 | swapfunc(a, b, n, swaptype) | ||
61 | char *a, *b; | ||
62 | int n, swaptype; | ||
63 | { | ||
64 | if (swaptype <= 1) | ||
65 | swapcode(long, a, b, n) | ||
66 | else | ||
67 | swapcode(char, a, b, n) | ||
68 | } | ||
69 | |||
70 | #define swap(a, b) \ | ||
71 | if (swaptype == 0) { \ | ||
72 | long t = *(long *)(a); \ | ||
73 | *(long *)(a) = *(long *)(b); \ | ||
74 | *(long *)(b) = t; \ | ||
75 | } else \ | ||
76 | swapfunc(a, b, es, swaptype) | ||
77 | |||
78 | #define vecswap(a, b, n) if ((n) > 0) swapfunc(a, b, n, swaptype) | ||
79 | |||
80 | static __inline char * | ||
81 | med3(a, b, c, cmp) | ||
82 | char *a, *b, *c; | ||
83 | int (*cmp)(); | ||
84 | { | ||
85 | return cmp(a, b) < 0 ? | ||
86 | (cmp(b, c) < 0 ? b : (cmp(a, c) < 0 ? c : a )) | ||
87 | :(cmp(b, c) > 0 ? b : (cmp(a, c) < 0 ? a : c )); | ||
88 | } | ||
89 | |||
90 | void | ||
91 | qsort(aa, n, es, cmp) | ||
92 | void *aa; | ||
93 | size_t n, es; | ||
94 | int (*cmp)(); | ||
95 | { | ||
96 | char *pa, *pb, *pc, *pd, *pl, *pm, *pn; | ||
97 | int d, r, swaptype, swap_cnt; | ||
98 | register char *a = aa; | ||
99 | |||
100 | loop: SWAPINIT(a, es); | ||
101 | swap_cnt = 0; | ||
102 | if (n < 7) { | ||
103 | for (pm = (char *)a + es; pm < (char *) a + n * es; pm += es) | ||
104 | for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0; | ||
105 | pl -= es) | ||
106 | swap(pl, pl - es); | ||
107 | return; | ||
108 | } | ||
109 | pm = (char *)a + (n / 2) * es; | ||
110 | if (n > 7) { | ||
111 | pl = (char *)a; | ||
112 | pn = (char *)a + (n - 1) * es; | ||
113 | if (n > 40) { | ||
114 | d = (n / 8) * es; | ||
115 | pl = med3(pl, pl + d, pl + 2 * d, cmp); | ||
116 | pm = med3(pm - d, pm, pm + d, cmp); | ||
117 | pn = med3(pn - 2 * d, pn - d, pn, cmp); | ||
118 | } | ||
119 | pm = med3(pl, pm, pn, cmp); | ||
120 | } | ||
121 | swap(a, pm); | ||
122 | pa = pb = (char *)a + es; | ||
123 | |||
124 | pc = pd = (char *)a + (n - 1) * es; | ||
125 | for (;;) { | ||
126 | while (pb <= pc && (r = cmp(pb, a)) <= 0) { | ||
127 | if (r == 0) { | ||
128 | swap_cnt = 1; | ||
129 | swap(pa, pb); | ||
130 | pa += es; | ||
131 | } | ||
132 | pb += es; | ||
133 | } | ||
134 | while (pb <= pc && (r = cmp(pc, a)) >= 0) { | ||
135 | if (r == 0) { | ||
136 | swap_cnt = 1; | ||
137 | swap(pc, pd); | ||
138 | pd -= es; | ||
139 | } | ||
140 | pc -= es; | ||
141 | } | ||
142 | if (pb > pc) | ||
143 | break; | ||
144 | swap(pb, pc); | ||
145 | swap_cnt = 1; | ||
146 | pb += es; | ||
147 | pc -= es; | ||
148 | } | ||
149 | if (swap_cnt == 0) { /* Switch to insertion sort */ | ||
150 | for (pm = (char *) a + es; pm < (char *) a + n * es; pm += es) | ||
151 | for (pl = pm; pl > (char *) a && cmp(pl - es, pl) > 0; | ||
152 | pl -= es) | ||
153 | swap(pl, pl - es); | ||
154 | return; | ||
155 | } | ||
156 | |||
157 | pn = (char *)a + n * es; | ||
158 | r = min(pa - (char *)a, pb - pa); | ||
159 | vecswap(a, pb - r, r); | ||
160 | r = min(pd - pc, pn - pd - es); | ||
161 | vecswap(pb, pn - r, r); | ||
162 | if ((r = pb - pa) > es) | ||
163 | qsort(a, r / es, es, cmp); | ||
164 | if ((r = pd - pc) > es) { | ||
165 | /* Iterate rather than recurse to save stack space */ | ||
166 | a = pn - r; | ||
167 | n = r / es; | ||
168 | goto loop; | ||
169 | } | ||
170 | /* qsort(pn - r, r / es, es, cmp);*/ | ||
171 | } | ||