--- a/src/stdlib/SDL_qsort.c	Mon May 29 03:53:21 2006 +0000
+++ b/src/stdlib/SDL_qsort.c	Mon May 29 04:04:35 2006 +0000
@@ -266,59 +266,59 @@
 /* ---------------------------------------------------------------------- */
 
 static char *
-pivot_big (char *first, char *mid, char *last, size_t size,
-           int compare (const void *, const void *))
+pivot_big(char *first, char *mid, char *last, size_t size,
+          int compare(const void *, const void *))
 {
     size_t d = (((last - first) / size) >> 3) * size;
     char *m1, *m2, *m3;
     {
         char *a = first, *b = first + d, *c = first + 2 * d;
 #ifdef DEBUG_QSORT
-        fprintf (stderr, "< %d %d %d\n", *(int *) a, *(int *) b, *(int *) c);
+        fprintf(stderr, "< %d %d %d\n", *(int *) a, *(int *) b, *(int *) c);
 #endif
-        m1 = compare (a, b) < 0 ?
-            (compare (b, c) < 0 ? b : (compare (a, c) < 0 ? c : a))
-            : (compare (a, c) < 0 ? a : (compare (b, c) < 0 ? c : b));
+        m1 = compare(a, b) < 0 ?
+            (compare(b, c) < 0 ? b : (compare(a, c) < 0 ? c : a))
+            : (compare(a, c) < 0 ? a : (compare(b, c) < 0 ? c : b));
     }
     {
         char *a = mid - d, *b = mid, *c = mid + d;
 #ifdef DEBUG_QSORT
-        fprintf (stderr, ". %d %d %d\n", *(int *) a, *(int *) b, *(int *) c);
+        fprintf(stderr, ". %d %d %d\n", *(int *) a, *(int *) b, *(int *) c);
 #endif
-        m2 = compare (a, b) < 0 ?
-            (compare (b, c) < 0 ? b : (compare (a, c) < 0 ? c : a))
-            : (compare (a, c) < 0 ? a : (compare (b, c) < 0 ? c : b));
+        m2 = compare(a, b) < 0 ?
+            (compare(b, c) < 0 ? b : (compare(a, c) < 0 ? c : a))
+            : (compare(a, c) < 0 ? a : (compare(b, c) < 0 ? c : b));
     }
     {
         char *a = last - 2 * d, *b = last - d, *c = last;
 #ifdef DEBUG_QSORT
-        fprintf (stderr, "> %d %d %d\n", *(int *) a, *(int *) b, *(int *) c);
+        fprintf(stderr, "> %d %d %d\n", *(int *) a, *(int *) b, *(int *) c);
 #endif
-        m3 = compare (a, b) < 0 ?
-            (compare (b, c) < 0 ? b : (compare (a, c) < 0 ? c : a))
-            : (compare (a, c) < 0 ? a : (compare (b, c) < 0 ? c : b));
+        m3 = compare(a, b) < 0 ?
+            (compare(b, c) < 0 ? b : (compare(a, c) < 0 ? c : a))
+            : (compare(a, c) < 0 ? a : (compare(b, c) < 0 ? c : b));
     }
 #ifdef DEBUG_QSORT
-    fprintf (stderr, "-> %d %d %d\n", *(int *) m1, *(int *) m2, *(int *) m3);
+    fprintf(stderr, "-> %d %d %d\n", *(int *) m1, *(int *) m2, *(int *) m3);
 #endif
-    return compare (m1, m2) < 0 ?
-        (compare (m2, m3) < 0 ? m2 : (compare (m1, m3) < 0 ? m3 : m1))
-        : (compare (m1, m3) < 0 ? m1 : (compare (m2, m3) < 0 ? m3 : m2));
+    return compare(m1, m2) < 0 ?
+        (compare(m2, m3) < 0 ? m2 : (compare(m1, m3) < 0 ? m3 : m1))
+        : (compare(m1, m3) < 0 ? m1 : (compare(m2, m3) < 0 ? m3 : m2));
 }
 
 /* ---------------------------------------------------------------------- */
 
 static void
-qsort_nonaligned (void *base, size_t nmemb, size_t size,
-                  int (*compare) (const void *, const void *))
+qsort_nonaligned(void *base, size_t nmemb, size_t size,
+                 int (*compare) (const void *, const void *))
 {
 
     stack_entry stack[STACK_SIZE];
     int stacktop = 0;
     char *first, *last;
-    char *pivot = malloc (size);
+    char *pivot = malloc(size);
     size_t trunc = TRUNC_nonaligned * size;
-    assert (pivot != 0);
+    assert(pivot != 0);
 
     first = (char *) base;
     last = first + (nmemb - 1) * size;
@@ -329,30 +329,30 @@
             /* Select pivot */
             {
                 char *mid = first + size * ((last - first) / size >> 1);
-                Pivot (SWAP_nonaligned, size);
-                memcpy (pivot, mid, size);
+                Pivot(SWAP_nonaligned, size);
+                memcpy(pivot, mid, size);
             }
             /* Partition. */
-            Partition (SWAP_nonaligned, size);
+            Partition(SWAP_nonaligned, size);
             /* Prepare to recurse/iterate. */
-        Recurse (trunc)}
+        Recurse(trunc)}
     }
-    PreInsertion (SWAP_nonaligned, TRUNC_nonaligned, size);
-    Insertion (SWAP_nonaligned);
-    free (pivot);
+    PreInsertion(SWAP_nonaligned, TRUNC_nonaligned, size);
+    Insertion(SWAP_nonaligned);
+    free(pivot);
 }
 
 static void
-qsort_aligned (void *base, size_t nmemb, size_t size,
-               int (*compare) (const void *, const void *))
+qsort_aligned(void *base, size_t nmemb, size_t size,
+              int (*compare) (const void *, const void *))
 {
 
     stack_entry stack[STACK_SIZE];
     int stacktop = 0;
     char *first, *last;
-    char *pivot = malloc (size);
+    char *pivot = malloc(size);
     size_t trunc = TRUNC_aligned * size;
-    assert (pivot != 0);
+    assert(pivot != 0);
 
     first = (char *) base;
     last = first + (nmemb - 1) * size;
@@ -363,29 +363,29 @@
             /* Select pivot */
             {
                 char *mid = first + size * ((last - first) / size >> 1);
-                Pivot (SWAP_aligned, size);
-                memcpy (pivot, mid, size);
+                Pivot(SWAP_aligned, size);
+                memcpy(pivot, mid, size);
             }
             /* Partition. */
-            Partition (SWAP_aligned, size);
+            Partition(SWAP_aligned, size);
             /* Prepare to recurse/iterate. */
-        Recurse (trunc)}
+        Recurse(trunc)}
     }
-    PreInsertion (SWAP_aligned, TRUNC_aligned, size);
-    Insertion (SWAP_aligned);
-    free (pivot);
+    PreInsertion(SWAP_aligned, TRUNC_aligned, size);
+    Insertion(SWAP_aligned);
+    free(pivot);
 }
 
 static void
-qsort_words (void *base, size_t nmemb,
-             int (*compare) (const void *, const void *))
+qsort_words(void *base, size_t nmemb,
+            int (*compare) (const void *, const void *))
 {
 
     stack_entry stack[STACK_SIZE];
     int stacktop = 0;
     char *first, *last;
-    char *pivot = malloc (WORD_BYTES);
-    assert (pivot != 0);
+    char *pivot = malloc(WORD_BYTES);
+    assert(pivot != 0);
 
     first = (char *) base;
     last = first + (nmemb - 1) * WORD_BYTES;
@@ -394,26 +394,26 @@
         char *ffirst = first, *llast = last;
         while (1) {
 #ifdef DEBUG_QSORT
-            fprintf (stderr, "Doing %d:%d: ",
-                     (first - (char *) base) / WORD_BYTES,
-                     (last - (char *) base) / WORD_BYTES);
+            fprintf(stderr, "Doing %d:%d: ",
+                    (first - (char *) base) / WORD_BYTES,
+                    (last - (char *) base) / WORD_BYTES);
 #endif
             /* Select pivot */
             {
                 char *mid =
                     first + WORD_BYTES * ((last - first) / (2 * WORD_BYTES));
-                Pivot (SWAP_words, WORD_BYTES);
+                Pivot(SWAP_words, WORD_BYTES);
                 *(int *) pivot = *(int *) mid;
             }
 #ifdef DEBUG_QSORT
-            fprintf (stderr, "pivot=%d\n", *(int *) pivot);
+            fprintf(stderr, "pivot=%d\n", *(int *) pivot);
 #endif
             /* Partition. */
-            Partition (SWAP_words, WORD_BYTES);
+            Partition(SWAP_words, WORD_BYTES);
             /* Prepare to recurse/iterate. */
-        Recurse (TRUNC_words)}
+        Recurse(TRUNC_words)}
     }
-    PreInsertion (SWAP_words, (TRUNC_words / WORD_BYTES), WORD_BYTES);
+    PreInsertion(SWAP_words, (TRUNC_words / WORD_BYTES), WORD_BYTES);
     /* Now do insertion sort. */
     last = ((char *) base) + nmemb * WORD_BYTES;
     for (first = ((char *) base) + WORD_BYTES; first != last;
@@ -421,30 +421,30 @@
         /* Find the right place for |first|. My apologies for var reuse */
         int *pl = (int *) (first - WORD_BYTES), *pr = (int *) first;
         *(int *) pivot = *(int *) first;
-        for (; compare (pl, pivot) > 0; pr = pl, --pl) {
+        for (; compare(pl, pivot) > 0; pr = pl, --pl) {
             *pr = *pl;
         }
         if (pr != (int *) first)
             *pr = *(int *) pivot;
     }
-    free (pivot);
+    free(pivot);
 }
 
 /* ---------------------------------------------------------------------- */
 
 void
-qsort (void *base, size_t nmemb, size_t size,
-       int (*compare) (const void *, const void *))
+qsort(void *base, size_t nmemb, size_t size,
+      int (*compare) (const void *, const void *))
 {
 
     if (nmemb <= 1)
         return;
     if (((uintptr_t) base | size) & (WORD_BYTES - 1))
-        qsort_nonaligned (base, nmemb, size, compare);
+        qsort_nonaligned(base, nmemb, size, compare);
     else if (size != WORD_BYTES)
-        qsort_aligned (base, nmemb, size, compare);
+        qsort_aligned(base, nmemb, size, compare);
     else
-        qsort_words (base, nmemb, compare);
+        qsort_words(base, nmemb, compare);
 }
 
 #endif /* !HAVE_QSORT */