void qsortEx(void *base, size_t num, size_t width, CompareFunction comp, CompareInfo *ExtraArgs)
{
char *lo, *hi;
char *mid;
char *loguy, *higuy;
size_t size;
char *lostk[30], *histk[30];
int stkptr;
if (num < 2 || width == 0) return;
stkptr = 0;
lo = base;
hi = (char *) base + width * (num - 1);
recurse:
size = (hi - lo) / width + 1;
if (size <= CUTOFF)
{
shortsort(lo, hi, width, comp,ExtraArgs);
}
else
{
mid = lo + (size / 2) * width;
swap(mid, lo, width);
loguy = lo;
higuy = hi + width;
for (;;) {
// Changed <= to < and >= to > according to the advise of "pete" of comp.lang.c.
do {
loguy += width;
}
while (loguy <= hi && comp(loguy, lo,ExtraArgs) < 0);
do {
higuy -= width;
}
while (higuy > lo && comp(higuy, lo,ExtraArgs) > 0);
if (higuy < loguy) break;
swap(loguy, higuy, width);
}
swap(lo, higuy, width);
if (higuy - 1 - lo >= hi - loguy)
{
if (lo + width < higuy)
{
lostk[stkptr] = lo;
histk[stkptr] = higuy - width;
++stkptr;
}
if (loguy < hi)
{
lo = loguy;
goto recurse;
}
}
else
{
if (loguy < hi)
{
lostk[stkptr] = loguy;
histk[stkptr] = hi;
++stkptr;
}
if (lo + width < higuy)
{
hi = higuy - width;
goto recurse;
}
}
}
--stkptr;
if (stkptr >= 0)
{
lo = lostk[stkptr];
hi = histk[stkptr];
goto recurse;
}
else
return;
}
void qsortFast (
void *base,
unsigned num,
unsigned width
)
{
char *lo, *hi; /* ends of sub-array currently sorting */
char *mid; /* points to middle of subarray */
char *loguy, *higuy; /* traveling pointers for partition step */
unsigned size; /* size of the sub-array */
char *lostk[30], *histk[30];
int stkptr; /* stack for saving sub-array to be processed */
int temp;
if ( sizeof(drawSurf_t) != 8 ) {
Com_Error( ERR_DROP, "change SWAP_DRAW_SURF macro" );
}
/* Note: the number of stack entries required is no more than
1 + log2(size), so 30 is sufficient for any array */
if (num < 2 || width == 0)
return; /* nothing to do */
stkptr = 0; /* initialize stack */
lo = (char *)base;
hi = (char *)base + width * (num-1); /* initialize limits */
/* this entry point is for pseudo-recursion calling: setting
lo and hi and jumping to here is like recursion, but stkptr is
prserved, locals aren't, so we preserve stuff on the stack */
recurse:
size = (hi - lo) / width + 1; /* number of el's to sort */
/* below a certain size, it is faster to use a O(n^2) sorting method */
if (size <= CUTOFF) {
shortsort((drawSurf_t *)lo, (drawSurf_t *)hi);
}
else {
/* First we pick a partititioning element. The efficiency of the
algorithm demands that we find one that is approximately the
median of the values, but also that we select one fast. Using
the first one produces bad performace if the array is already
sorted, so we use the middle one, which would require a very
wierdly arranged array for worst case performance. Testing shows
that a median-of-three algorithm does not, in general, increase
performance. */
mid = lo + (size / 2) * width; /* find middle element */
SWAP_DRAW_SURF(mid, lo); /* swap it to beginning of array */
/* We now wish to partition the array into three pieces, one
consisiting of elements <= partition element, one of elements
equal to the parition element, and one of element >= to it. This
is done below; comments indicate conditions established at every
step. */
loguy = lo;
higuy = hi + width;
/* Note that higuy decreases and loguy increases on every iteration,
so loop must terminate. */
for (;;) {
/* lo <= loguy < hi, lo < higuy <= hi + 1,
A[i] <= A[lo] for lo <= i <= loguy,
A[i] >= A[lo] for higuy <= i <= hi */
do {
loguy += width;
} while (loguy <= hi &&
( ((drawSurf_t *)loguy)->sort <= ((drawSurf_t *)lo)->sort ) );
/* lo < loguy <= hi+1, A[i] <= A[lo] for lo <= i < loguy,
either loguy > hi or A[loguy] > A[lo] */
do {
higuy -= width;
} while (higuy > lo &&
( ((drawSurf_t *)higuy)->sort >= ((drawSurf_t *)lo)->sort ) );
/* lo-1 <= higuy <= hi, A[i] >= A[lo] for higuy < i <= hi,
either higuy <= lo or A[higuy] < A[lo] */
if (higuy < loguy)
break;
/* if loguy > hi or higuy <= lo, then we would have exited, so
A[loguy] > A[lo], A[higuy] < A[lo],
loguy < hi, highy > lo */
SWAP_DRAW_SURF(loguy, higuy);
/* A[loguy] < A[lo], A[higuy] > A[lo]; so condition at top
of loop is re-established */
}
/* A[i] >= A[lo] for higuy < i <= hi,
A[i] <= A[lo] for lo <= i < loguy,
higuy < loguy, lo <= higuy <= hi
implying:
A[i] >= A[lo] for loguy <= i <= hi,
A[i] <= A[lo] for lo <= i <= higuy,
A[i] = A[lo] for higuy < i < loguy */
SWAP_DRAW_SURF(lo, higuy); /* put partition element in place */
/* OK, now we have the following:
A[i] >= A[higuy] for loguy <= i <= hi,
A[i] <= A[higuy] for lo <= i < higuy
A[i] = A[lo] for higuy <= i < loguy */
/* We've finished the partition, now we want to sort the subarrays
[lo, higuy-1] and [loguy, hi].
We do the smaller one first to minimize stack usage.
We only sort arrays of length 2 or more.*/
if ( higuy - 1 - lo >= hi - loguy ) {
if (lo + width < higuy) {
lostk[stkptr] = lo;
histk[stkptr] = higuy - width;
++stkptr;
} /* save big recursion for later */
if (loguy < hi) {
lo = loguy;
goto recurse; /* do small recursion */
}
}
else {
if (loguy < hi) {
lostk[stkptr] = loguy;
histk[stkptr] = hi;
++stkptr; /* save big recursion for later */
}
if (lo + width < higuy) {
hi = higuy - width;
goto recurse; /* do small recursion */
}
}
}
/* We have sorted the array, except for any pending sorts on the stack.
Check if there are any, and do them. */
--stkptr;
if (stkptr >= 0) {
lo = lostk[stkptr];
hi = histk[stkptr];
goto recurse; /* pop subarray from stack */
}
else
return; /* all subarrays done */
}
void qsortr(void *base, size_t num, size_t width,
int (*comp)(const void *, const void *,void *ExtraArgs),
void *ExtraArgs)
{
char *lo, *hi;
char *mid;
char *loguy, *higuy;
size_t size;
char *lostk[30], *histk[30];
int stkptr;
if (num < 2 || width == 0) return;
stkptr = 0;
lo = base;
hi = (char *) base + width * (num - 1);
recurse:
size = (hi - lo) / width + 1;
if (size <= CUTOFF)
{
shortsort(lo, hi, width, comp,ExtraArgs);
}
else
{
mid = lo + (size / 2) * width;
swap(mid, lo, width);
loguy = lo;
higuy = hi + width;
for (;;)
{
do { loguy += width; } while (loguy <= hi && comp(loguy, lo,ExtraArgs) <= 0);
do { higuy -= width; } while (higuy > lo && comp(higuy, lo,ExtraArgs) >= 0);
if (higuy < loguy) break;
swap(loguy, higuy, width);
}
swap(lo, higuy, width);
if (higuy - 1 - lo >= hi - loguy)
{
if (lo + width < higuy)
{
lostk[stkptr] = lo;
histk[stkptr] = higuy - width;
++stkptr;
}
if (loguy < hi)
{
lo = loguy;
goto recurse;
}
}
else
{
if (loguy < hi)
{
lostk[stkptr] = loguy;
histk[stkptr] = hi;
++stkptr;
}
if (lo + width < higuy)
{
hi = higuy - width;
goto recurse;
}
}
}
--stkptr;
if (stkptr >= 0)
{
lo = lostk[stkptr];
hi = histk[stkptr];
goto recurse;
}
else
return;
}
void qsort_wkey(void *base, unsigned int num, unsigned int width, unsigned int *key, int (*comp)(const void *, const void *))
{
#define CUTOFF 8
char *lo, *hi;
char *mid;
char *loguy, *higuy;
unsigned int size;
char *lostk[30], *histk[30];
unsigned int *lostk_key[30], *histk_key[30];
int stkptr;
unsigned int *lo_key, *hi_key, *mid_key;
unsigned int *loguy_key, *higuy_key;
if (num < 2 || width == 0) return;
stkptr = 0;
lo = (char *) base;
hi = (char *) base + width * (num - 1);
lo_key = key;
hi_key = key + (num - 1);
recurse:
size = ((unsigned int)(hi - lo)) / width + 1;
if (size <= CUTOFF) {
shortsort(lo, hi, width, lo_key, hi_key, comp);
}
else {
mid = lo + (size / 2) * width;
mid_key = lo_key + (size / 2);
swap(mid, lo, width, mid_key, lo_key);
loguy = lo;
higuy = hi + width;
loguy_key = lo_key;
higuy_key = hi_key + 1;
for (;;) {
do {
loguy += width;
loguy_key++;
} while (loguy <= hi && comp(loguy, lo) <= 0);
do {
higuy -= width;
higuy_key--;
} while (higuy > lo && comp(higuy, lo) >= 0);
if (higuy < loguy) break;
swap(loguy, higuy, width, loguy_key, higuy_key);
}
swap(lo, higuy, width, lo_key, higuy_key);
if (higuy - 1 - lo >= hi - loguy) {
if (lo + width < higuy) {
lostk[stkptr] = lo;
histk[stkptr] = higuy - width;
lostk_key[stkptr] = lo_key;
histk_key[stkptr] = higuy_key - 1;
++stkptr;
}
if (loguy < hi) {
lo = loguy;
lo_key = loguy_key;
goto recurse;
}
}
else {
if (loguy < hi) {
lostk[stkptr] = loguy;
histk[stkptr] = hi;
lostk_key[stkptr] = loguy_key;
histk_key[stkptr] = hi_key;
++stkptr;
}
if (lo + width < higuy) {
hi = higuy - width;
hi_key = higuy_key - 1;
goto recurse;
}
}
}
--stkptr;
if (stkptr >= 0) {
lo = lostk[stkptr];
hi = histk[stkptr];
lo_key = lostk_key[stkptr];
hi_key = histk_key[stkptr];
goto recurse;
}
else
return;
}
void qsort (
void *base,
unsigned num,
unsigned width,
int (*comp)(const void *, const void *)
)
{
/* Note: the number of stack entries required is no more than
1 + log2(num), so 30 is sufficient for any array */
char *lo, *hi; /* ends of sub-array currently sorting */
char *mid; /* points to middle of subarray */
char *loguy, *higuy; /* traveling pointers for partition step */
unsigned size; /* size of the sub-array */
char *lostk[STKSIZ], *histk[STKSIZ];
int stkptr; /* stack for saving sub-array to be processed */
if (num < 2)
return; /* nothing to do */
stkptr = 0; /* initialize stack */
lo = (char *)base;
hi = (char *)base + width * (num-1); /* initialize limits */
/* this entry point is for pseudo-recursion calling: setting
lo and hi and jumping to here is like recursion, but stkptr is
preserved, locals aren't, so we preserve stuff on the stack */
recurse:
size = (hi - lo) / width + 1; /* number of el's to sort */
/* below a certain size, it is faster to use a O(n^2) sorting method */
if (size <= CUTOFF) {
shortsort(lo, hi, width, comp);
}
else {
/* First we pick a partitioning element. The efficiency of the
algorithm demands that we find one that is approximately the median
of the values, but also that we select one fast. We choose the
median of the first, middle, and last elements, to avoid bad
performance in the face of already sorted data, or data that is made
up of multiple sorted runs appended together. Testing shows that a
median-of-three algorithm provides better performance than simply
picking the middle element for the latter case. */
mid = lo + (size / 2) * width; /* find middle element */
/* Sort the first, middle, last elements into order */
if (comp(lo, mid) > 0) {
swap(lo, mid, width);
}
if (comp(lo, hi) > 0) {
swap(lo, hi, width);
}
if (comp(mid, hi) > 0) {
swap(mid, hi, width);
}
/* We now wish to partition the array into three pieces, one consisting
of elements <= partition element, one of elements equal to the
partition element, and one of elements > than it. This is done
below; comments indicate conditions established at every step. */
loguy = lo;
higuy = hi;
/* Note that higuy decreases and loguy increases on every iteration,
so loop must terminate. */
for (;;) {
/* lo <= loguy < hi, lo < higuy <= hi,
A[i] <= A[mid] for lo <= i <= loguy,
A[i] > A[mid] for higuy <= i < hi,
A[hi] >= A[mid] */
/* The doubled loop is to avoid calling comp(mid,mid), since some
existing comparison funcs don't work when passed the same
value for both pointers. */
if (mid > loguy) {
do {
loguy += width;
} while (loguy < mid && comp(loguy, mid) <= 0);
}
if (mid <= loguy) {
do {
loguy += width;
} while (loguy <= hi && comp(loguy, mid) <= 0);
}
/* lo < loguy <= hi+1, A[i] <= A[mid] for lo <= i < loguy,
either loguy > hi or A[loguy] > A[mid] */
do {
higuy -= width;
} while (higuy > mid && comp(higuy, mid) > 0);
/* lo <= higuy < hi, A[i] > A[mid] for higuy < i < hi,
either higuy == lo or A[higuy] <= A[mid] */
if (higuy < loguy)
break;
/* if loguy > hi or higuy == lo, then we would have exited, so
A[loguy] > A[mid], A[higuy] <= A[mid],
loguy <= hi, higuy > lo */
swap(loguy, higuy, width);
/* If the partition element was moved, follow it. Only need
to check for mid == higuy, since before the swap,
A[loguy] > A[mid] implies loguy != mid. */
if (mid == higuy)
mid = loguy;
/* A[loguy] <= A[mid], A[higuy] > A[mid]; so condition at top
of loop is re-established */
}
/* A[i] <= A[mid] for lo <= i < loguy,
A[i] > A[mid] for higuy < i < hi,
A[hi] >= A[mid]
higuy < loguy
implying:
higuy == loguy-1
or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */
/* Find adjacent elements equal to the partition element. The
doubled loop is to avoid calling comp(mid,mid), since some
existing comparison funcs don't work when passed the same value
for both pointers. */
higuy += width;
if (mid < higuy) {
do {
higuy -= width;
} while (higuy > mid && comp(higuy, mid) == 0);
}
if (mid >= higuy) {
do {
higuy -= width;
} while (higuy > lo && comp(higuy, mid) == 0);
}
/* OK, now we have the following:
higuy < loguy
lo <= higuy <= hi
A[i] <= A[mid] for lo <= i <= higuy
A[i] == A[mid] for higuy < i < loguy
A[i] > A[mid] for loguy <= i < hi
A[hi] >= A[mid] */
/* We've finished the partition, now we want to sort the subarrays
[lo, higuy] and [loguy, hi].
We do the smaller one first to minimize stack usage.
We only sort arrays of length 2 or more.*/
if ( higuy - lo >= hi - loguy ) {
if (lo < higuy) {
lostk[stkptr] = lo;
histk[stkptr] = higuy;
++stkptr;
} /* save big recursion for later */
if (loguy < hi) {
lo = loguy;
goto recurse; /* do small recursion */
}
}
else {
if (loguy < hi) {
lostk[stkptr] = loguy;
histk[stkptr] = hi;
++stkptr; /* save big recursion for later */
}
if (lo < higuy) {
hi = higuy;
goto recurse; /* do small recursion */
}
}
}
/* We have sorted the array, except for any pending sorts on the stack.
Check if there are any, and do them. */
--stkptr;
if (stkptr >= 0) {
lo = lostk[stkptr];
hi = histk[stkptr];
goto recurse; /* pop subarray from stack */
}
else
return; /* all subarrays done */
}
/* =============================================================================
* sort
* =============================================================================
*/
void
sort (void *base,
unsigned num,
unsigned width,
int (*cmp)(const void* p1, const void* p2, long n, long offset),
long n,
long offset)
{
if (num < 2 || width == 0) {
return;
}
char* lostk[30];
char* histk[30];
int stkptr = 0;
char* lo = (char*)base;
char* hi = (char*)base + (width * (num - 1));
unsigned size;
recurse:
size = (hi - lo) / width + 1;
if (size <= CUTOFF) {
shortsort(lo, hi, width, cmp, n, offset);
} else {
char* mid = lo + (size / 2) * width;
swap(mid, lo, width);
char* loguy = lo;
char* higuy = hi + width;
for (;;) {
do {
loguy += width;
} while (loguy <= hi && cmp(loguy, lo, n, offset) <= 0);
do {
higuy -= width;
} while (higuy > lo && cmp(higuy, lo, n, offset) >= 0);
if (higuy < loguy) {
break;
}
swap(loguy, higuy, width);
}
swap(lo, higuy, width);
if (higuy - 1 - lo >= hi - loguy) {
if (lo + width < higuy) {
lostk[stkptr] = lo;
histk[stkptr] = higuy - width;
++stkptr;
}
if (loguy < hi) {
lo = loguy;
goto recurse;
}
} else {
if (loguy < hi) {
lostk[stkptr] = loguy;
histk[stkptr] = hi;
++stkptr;
}
if (lo + width < higuy) {
hi = higuy - width;
goto recurse;
}
}
}
--stkptr;
if (stkptr >= 0) {
lo = lostk[stkptr];
hi = histk[stkptr];
goto recurse;
}
}
