← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to mysys/mf_qsort.c

  • Committer: Monty Taylor
  • Date: 2008-09-23 06:09:48 UTC
  • mto: This revision was merged to the branch mainline in revision 419.
  • Revision ID: monty@inaugust.com-20080923060948-pec1d5wxetf84tte
Cleaned up stuff out of global.h.

Show diffs side-by-side

added added

removed removed

Lines of Context:
mysys/mf_qsort.c
88
88
*****************************************************************************/
89
89
 
90
90
#ifdef QSORT_EXTRA_CMP_ARGUMENT
91
 
qsort_t my_qsort2(void *base_ptr, size_t count, size_t size, qsort2_cmp cmp,
92
 
               void *cmp_argument)
 
91
RETQSORTTYPE my_qsort2(void *base_ptr, size_t count, size_t size,
 
92
                       qsort2_cmp cmp, void *cmp_argument)
93
93
#else
94
 
qsort_t my_qsort(void *base_ptr, size_t count, size_t size, qsort_cmp cmp)
 
94
RETQSORTTYPE my_qsort(void *base_ptr, size_t count, size_t size,
 
95
                      qsort_cmp cmp)
95
96
#endif
96
97
{
97
98
  char *low, *high, *pivot;
123
124
    {
124
125
      for (low_ptr = low + size; low_ptr <= high; low_ptr += size)
125
126
      {
126
 
        char *ptr;
127
 
        for (ptr = low_ptr; ptr > low && CMP(ptr - size, ptr) > 0;
128
 
             ptr -= size)
129
 
          SWAP(ptr, ptr - size, size, ptr_cmp);
 
127
        char *ptr;
 
128
        for (ptr = low_ptr; ptr > low && CMP(ptr - size, ptr) > 0;
 
129
             ptr -= size)
 
130
          SWAP(ptr, ptr - size, size, ptr_cmp);
130
131
      }
131
132
      POP(low, high);
132
133
      continue;
157
158
    do
158
159
    {
159
160
      while (CMP(low_ptr, pivot) < 0)
160
 
        low_ptr += size;
 
161
        low_ptr += size;
161
162
      while (CMP(pivot, high_ptr) < 0)
162
 
        high_ptr -= size;
 
163
        high_ptr -= size;
163
164
 
164
165
      if (low_ptr < high_ptr)
165
166
      {
166
 
        SWAP(low_ptr, high_ptr, size, ptr_cmp);
167
 
        low_ptr += size;
168
 
        high_ptr -= size;
 
167
        SWAP(low_ptr, high_ptr, size, ptr_cmp);
 
168
        low_ptr += size;
 
169
        high_ptr -= size;
169
170
      }
170
 
      else 
 
171
      else
171
172
      {
172
 
        if (low_ptr == high_ptr)
173
 
        {
174
 
          low_ptr += size;
175
 
          high_ptr -= size;
176
 
        }
177
 
        break;
 
173
        if (low_ptr == high_ptr)
 
174
        {
 
175
          low_ptr += size;
 
176
          high_ptr -= size;
 
177
        }
 
178
        break;
178
179
      }
179
180
    }
180
181
    while (low_ptr <= high_ptr);
190
191
    {
191
192
      if ((int) (high - low_ptr) <= 0)
192
193
      {
193
 
        POP(low, high);                 /* Nothing more to sort */
 
194
        POP(low, high);                 /* Nothing more to sort */
194
195
      }
195
196
      else
196
 
        low = low_ptr;                  /* Ignore small left part. */
 
197
        low = low_ptr;                  /* Ignore small left part. */
197
198
    }
198
199
    else if ((int) (high - low_ptr) <= 0)
199
200
      high = high_ptr;                  /* Ignore small right part. */