Notational changes; no need to use generic types any more.

diff --git a/src/backend/utils/sort/qsort_tuple.c b/src/backend/utils/sort/qsort_tuple.c
index 0cb1f27d55285e00129018d9807db0c871a3863e..b3d75743cda5a640bcc8717c1206a3ffd62dcd32 100644 (file)
--- a/src/backend/utils/sort/qsort_tuple.c
+++ b/src/backend/utils/sort/qsort_tuple.c
@@ -74,15 +74,17 @@ swapfunc(SortTuple *a, SortTuple *b, size_t n)
 #define vecswap(a, b, n) if ((n) > 0) swapfunc((a), (b), (size_t)(n))
 
 static SortTuple *
-med3(SortTuple *a, SortTuple *b, SortTuple *c, qsort_arg_comparator cmp, void *arg)
+med3(SortTuple *a, SortTuple *b, SortTuple *c, SortTupleComparator cmp,
+        Tuplesortstate *state)
 {
-       return cmp(a, b, arg) < 0 ?
-               (cmp(b, c, arg) < 0 ? b : (cmp(a, c, arg) < 0 ? c : a))
-               : (cmp(b, c, arg) > 0 ? b : (cmp(a, c, arg) < 0 ? a : c));
+       return cmp(a, b, state) < 0 ?
+               (cmp(b, c, state) < 0 ? b : (cmp(a, c, state) < 0 ? c : a))
+               : (cmp(b, c, state) > 0 ? b : (cmp(a, c, state) < 0 ? a : c));
 }
 
 static void
-qsort_tuple(SortTuple *a, size_t n, qsort_arg_comparator cmp, void *arg)
+qsort_tuple(SortTuple *a, size_t n, SortTupleComparator cmp,
+                       Tuplesortstate *state)
 {
        SortTuple  *pa,
                           *pb,
@@ -99,14 +101,14 @@ loop:
        if (n < 7)
        {
                for (pm = a + 1; pm < a + n; pm++)
-                       for (pl = pm; pl > a && cmp(pl - 1, pl, arg) > 0; pl--)
+                       for (pl = pm; pl > a && cmp(pl - 1, pl, state) > 0; pl--)
                                swap(pl, pl - 1);
                return;
        }
        presorted = 1;
        for (pm = a + 1; pm < a + n; pm++)
        {
-               if (cmp(pm - 1, pm, arg) > 0)
+               if (cmp(pm - 1, pm, state) > 0)
                {
                        presorted = 0;
                        break;
@@ -122,18 +124,18 @@ loop:
                if (n > 40)
                {
                        d = (n / 8);
-                       pl = med3(pl, pl + d, pl + 2 * d, cmp, arg);
-                       pm = med3(pm - d, pm, pm + d, cmp, arg);
-                       pn = med3(pn - 2 * d, pn - d, pn, cmp, arg);
+                       pl = med3(pl, pl + d, pl + 2 * d, cmp, state);
+                       pm = med3(pm - d, pm, pm + d, cmp, state);
+                       pn = med3(pn - 2 * d, pn - d, pn, cmp, state);
                }
-               pm = med3(pl, pm, pn, cmp, arg);
+               pm = med3(pl, pm, pn, cmp, state);
        }
        swap(a, pm);
        pa = pb = a + 1;
        pc = pd = a + (n - 1);
        for (;;)
        {
-               while (pb <= pc && (r = cmp(pb, a, arg)) <= 0)
+               while (pb <= pc && (r = cmp(pb, a, state)) <= 0)
                {
                        if (r == 0)
                        {
@@ -142,7 +144,7 @@ loop:
                        }
                        pb++;
                }
-               while (pb <= pc && (r = cmp(pc, a, arg)) >= 0)
+               while (pb <= pc && (r = cmp(pc, a, state)) >= 0)
                {
                        if (r == 0)
                        {
@@ -163,7 +165,7 @@ loop:
        r = Min(pd - pc, pn - pd - 1);
        vecswap(pb, pn - r, r);
        if ((r = pb - pa) > 1)
-               qsort_tuple(a, r, cmp, arg);
+               qsort_tuple(a, r, cmp, state);
        if ((r = pd - pc) > 1)
        {
                /* Iterate rather than recurse to save stack space */
@@ -171,5 +173,5 @@ loop:
                n = r;
                goto loop;
        }
-/*             qsort_tuple(pn - r, r, cmp, arg);*/
+/*             qsort_tuple(pn - r, r, cmp, state);*/
 }

diff --git a/src/backend/utils/sort/tuplesort.c b/src/backend/utils/sort/tuplesort.c
index 690ceffeb62f6ad8e58a2bc687e9218f9f490127..6d7012afb93eb40f07e3d6182e7f357e71e8647c 100644 (file)
--- a/src/backend/utils/sort/tuplesort.c
+++ b/src/backend/utils/sort/tuplesort.c
@@ -195,6 +195,9 @@ typedef enum
 #define TAPE_BUFFER_OVERHEAD           (BLCKSZ * 3)
 #define MERGE_BUFFER_SIZE                      (BLCKSZ * 32)
 
+typedef int    (*SortTupleComparator) (const SortTuple *a, const SortTuple *b,
+       Tuplesortstate *state);
+
 /*
  * Private state of a Tuplesort operation.
  */
@@ -223,8 +226,7 @@ struct Tuplesortstate
         * <0, 0, >0 according as a<b, a=b, a>b.  The API must match
         * qsort_arg_comparator.
         */
-       int                     (*comparetup) (const SortTuple *a, const SortTuple *b,
-                                                                                  Tuplesortstate *state);
+       SortTupleComparator     comparetup;
 
        /*
         * Function to copy a supplied input tuple into palloc'd space and set up
@@ -1227,10 +1229,10 @@ tuplesort_performsort(Tuplesortstate *state)
                         * amount of memory.  Just qsort 'em and we're done.
                         */
                        if (state->memtupcount > 1)
-                               qsort_tuple((void *) state->memtuples,
+                               qsort_tuple(state->memtuples,
                                                        state->memtupcount,
-                                                       (qsort_arg_comparator) state->comparetup,
-                                                       (void *) state);
+                                                       state->comparetup,
+                                                       state);
                        state->current = 0;
                        state->eof_reached = false;
                        state->markpos_offset = 0;