nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /* GLIB - Library of useful routines for C programming
2 * Copyright (C) 1991, 1992, 1996, 1997,1999,2004 Free Software Foundation, Inc.
3 * Copyright (C) 2000 Eazel, Inc.
4 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
5 *
6 * This library 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 of the License, or (at your option) any later version.
10 *
11 * This library 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 this library; if not, see <http://www.gnu.org/licenses/>.
18 */
19  
20 #include "config.h"
21  
22 #include <limits.h>
23 #include <stdlib.h>
24 #include <string.h>
25 #include "galloca.h"
26 #include "gmem.h"
27  
28 #include "gqsort.h"
29  
30 #include "gtestutils.h"
31  
32 /* This file was originally from stdlib/msort.c in gnu libc, just changed
33 to build inside glib and to not fall back to an unstable quicksort
34 for large arrays. */
35  
36 /* An alternative to qsort, with an identical interface.
37 This file is part of the GNU C Library.
38 Copyright (C) 1992,95-97,99,2000,01,02,04,07 Free Software Foundation, Inc.
39 Written by Mike Haertel, September 1988.
40  
41 The GNU C Library is free software; you can redistribute it and/or
42 modify it under the terms of the GNU Lesser General Public
43 License as published by the Free Software Foundation; either
44 version 2.1 of the License, or (at your option) any later version.
45  
46 The GNU C Library is distributed in the hope that it will be useful,
47 but WITHOUT ANY WARRANTY; without even the implied warranty of
48 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
49 Lesser General Public License for more details.
50  
51 You should have received a copy of the GNU Lesser General Public
52 License along with the GNU C Library; if not, see
53 <http://www.gnu.org/licenses/>. */
54  
55  
56 struct msort_param
57 {
58 size_t s;
59 size_t var;
60 GCompareDataFunc cmp;
61 void *arg;
62 char *t;
63 };
64  
65 static void msort_with_tmp (const struct msort_param *p, void *b, size_t n);
66  
67 static void
68 msort_with_tmp (const struct msort_param *p, void *b, size_t n)
69 {
70 char *b1, *b2;
71 size_t n1, n2;
72 char *tmp = p->t;
73 const size_t s = p->s;
74 GCompareDataFunc cmp = p->cmp;
75 void *arg = p->arg;
76  
77 if (n <= 1)
78 return;
79  
80 n1 = n / 2;
81 n2 = n - n1;
82 b1 = b;
83 b2 = (char *) b + (n1 * p->s);
84  
85 msort_with_tmp (p, b1, n1);
86 msort_with_tmp (p, b2, n2);
87  
88 switch (p->var)
89 {
90 case 0:
91 while (n1 > 0 && n2 > 0)
92 {
93 if ((*cmp) (b1, b2, arg) <= 0)
94 {
95 *(guint32 *) tmp = *(guint32 *) b1;
96 b1 += sizeof (guint32);
97 --n1;
98 }
99 else
100 {
101 *(guint32 *) tmp = *(guint32 *) b2;
102 b2 += sizeof (guint32);
103 --n2;
104 }
105 tmp += sizeof (guint32);
106 }
107 break;
108 case 1:
109 while (n1 > 0 && n2 > 0)
110 {
111 if ((*cmp) (b1, b2, arg) <= 0)
112 {
113 *(guint64 *) tmp = *(guint64 *) b1;
114 b1 += sizeof (guint64);
115 --n1;
116 }
117 else
118 {
119 *(guint64 *) tmp = *(guint64 *) b2;
120 b2 += sizeof (guint64);
121 --n2;
122 }
123 tmp += sizeof (guint64);
124 }
125 break;
126 case 2:
127 while (n1 > 0 && n2 > 0)
128 {
129 unsigned long *tmpl = (unsigned long *) tmp;
130 unsigned long *bl;
131  
132 tmp += s;
133 if ((*cmp) (b1, b2, arg) <= 0)
134 {
135 bl = (unsigned long *) b1;
136 b1 += s;
137 --n1;
138 }
139 else
140 {
141 bl = (unsigned long *) b2;
142 b2 += s;
143 --n2;
144 }
145 while (tmpl < (unsigned long *) tmp)
146 *tmpl++ = *bl++;
147 }
148 break;
149 case 3:
150 while (n1 > 0 && n2 > 0)
151 {
152 if ((*cmp) (*(const void **) b1, *(const void **) b2, arg) <= 0)
153 {
154 *(void **) tmp = *(void **) b1;
155 b1 += sizeof (void *);
156 --n1;
157 }
158 else
159 {
160 *(void **) tmp = *(void **) b2;
161 b2 += sizeof (void *);
162 --n2;
163 }
164 tmp += sizeof (void *);
165 }
166 break;
167 default:
168 while (n1 > 0 && n2 > 0)
169 {
170 if ((*cmp) (b1, b2, arg) <= 0)
171 {
172 memcpy (tmp, b1, s);
173 tmp += s;
174 b1 += s;
175 --n1;
176 }
177 else
178 {
179 memcpy (tmp, b2, s);
180 tmp += s;
181 b2 += s;
182 --n2;
183 }
184 }
185 break;
186 }
187  
188 if (n1 > 0)
189 memcpy (tmp, b1, n1 * s);
190 memcpy (b, p->t, (n - n2) * s);
191 }
192  
193  
194 static void
195 msort_r (void *b, size_t n, size_t s, GCompareDataFunc cmp, void *arg)
196 {
197 size_t size = n * s;
198 char *tmp = NULL;
199 struct msort_param p;
200  
201 /* For large object sizes use indirect sorting. */
202 if (s > 32)
203 size = 2 * n * sizeof (void *) + s;
204  
205 if (size < 1024)
206 /* The temporary array is small, so put it on the stack. */
207 p.t = g_alloca (size);
208 else
209 {
210 /* It's large, so malloc it. */
211 tmp = g_malloc (size);
212 p.t = tmp;
213 }
214  
215 p.s = s;
216 p.var = 4;
217 p.cmp = cmp;
218 p.arg = arg;
219  
220 if (s > 32)
221 {
222 /* Indirect sorting. */
223 char *ip = (char *) b;
224 void **tp = (void **) (p.t + n * sizeof (void *));
225 void **t = tp;
226 void *tmp_storage = (void *) (tp + n);
227 char *kp;
228 size_t i;
229  
230 while ((void *) t < tmp_storage)
231 {
232 *t++ = ip;
233 ip += s;
234 }
235 p.s = sizeof (void *);
236 p.var = 3;
237 msort_with_tmp (&p, p.t + n * sizeof (void *), n);
238  
239 /* tp[0] .. tp[n - 1] is now sorted, copy around entries of
240 the original array. Knuth vol. 3 (2nd ed.) exercise 5.2-10. */
241 for (i = 0, ip = (char *) b; i < n; i++, ip += s)
242 if ((kp = tp[i]) != ip)
243 {
244 size_t j = i;
245 char *jp = ip;
246 memcpy (tmp_storage, ip, s);
247  
248 do
249 {
250 size_t k = (kp - (char *) b) / s;
251 tp[j] = jp;
252 memcpy (jp, kp, s);
253 j = k;
254 jp = kp;
255 kp = tp[k];
256 }
257 while (kp != ip);
258  
259 tp[j] = jp;
260 memcpy (jp, tmp_storage, s);
261 }
262 }
263 else
264 {
265 if ((s & (sizeof (guint32) - 1)) == 0
266 && ((char *) b - (char *) 0) % ALIGNOF_GUINT32 == 0)
267 {
268 if (s == sizeof (guint32))
269 p.var = 0;
270 else if (s == sizeof (guint64)
271 && ((char *) b - (char *) 0) % ALIGNOF_GUINT64 == 0)
272 p.var = 1;
273 else if ((s & (sizeof (unsigned long) - 1)) == 0
274 && ((char *) b - (char *) 0)
275 % ALIGNOF_UNSIGNED_LONG == 0)
276 p.var = 2;
277 }
278 msort_with_tmp (&p, b, n);
279 }
280 g_free (tmp);
281 }
282  
283 /**
284 * g_qsort_with_data:
285 * @pbase: (not nullable): start of array to sort
286 * @total_elems: elements in the array
287 * @size: size of each element
288 * @compare_func: function to compare elements
289 * @user_data: data to pass to @compare_func
290 *
291 * This is just like the standard C qsort() function, but
292 * the comparison routine accepts a user data argument.
293 *
294 * This is guaranteed to be a stable sort since version 2.32.
295 */
296 void
297 g_qsort_with_data (gconstpointer pbase,
298 gint total_elems,
299 gsize size,
300 GCompareDataFunc compare_func,
301 gpointer user_data)
302 {
303 msort_r ((gpointer)pbase, total_elems, size, compare_func, user_data);
304 }