cleanups and add more comments

[cc65] / libsrc / common / qsort.c

diff --git a/libsrc/common/qsort.c b/libsrc/common/qsort.c
index 0cdfeb82c089560c49b1a214d18e90c3be27c97c..383962934fb91244594f329fd69ba6de98638e62 100644 (file)
--- a/libsrc/common/qsort.c
+++ b/libsrc/common/qsort.c
@@ -10,55 +10,53 @@
 
 
 
-static void QuickSort (void* Base, int Lo, int Hi, size_t Size,
-                      int (*Compare)(const void*, const void*))
+static void QuickSort (register unsigned char* Base, int Lo, int Hi,
+                       register size_t Size,
+                       int (*Compare)(const void*, const void*))
 /* Internal recursive function. Works with ints, but this shouldn't be
  * a problem.
  */
 {
     int I, J;
 
-    /* Get a char pointer */
-    unsigned char* B = Base;
-
     /* Quicksort */
     while (Hi > Lo) {
-       I = Lo + Size;
-       J = Hi;
-       while (I <= J) {
-           while (I <= J && Compare (B + Lo, B + I) >= 0) {
-               I += Size;
-           }
-           while (I <= J && Compare (B + Lo, B + J) < 0) {
-               J -= Size;
-           }
-           if (I <= J) {
-               _swap (B + I, B + J, Size);
-               I += Size;
-               J -= Size;
-           }
-       }
-       if (J != Lo) {
-           _swap (B + J, B + Lo, Size);
-       }
-               if (((unsigned) J) * 2 > (Hi + Lo)) {
-           QuickSort (Base, J + Size, Hi, Size, Compare);
-           Hi = J - Size;
-       } else {
-           QuickSort (Base, Lo, J - Size, Size, Compare);
-           Lo = J + Size;
-       }
+        I = Lo + Size;
+        J = Hi;
+        while (I <= J) {
+            while (I <= J && Compare (Base + Lo, Base + I) >= 0) {
+                I += Size;
+            }
+            while (I <= J && Compare (Base + Lo, Base + J) < 0) {
+                J -= Size;
+            }
+            if (I <= J) {
+                _swap (Base + I, Base + J, Size);
+                I += Size;
+                J -= Size;
+            }
+        }
+        if (J != Lo) {
+            _swap (Base + J, Base + Lo, Size);
+        }
+        if (((unsigned) J) * 2 > (Hi + Lo)) {
+            QuickSort (Base, J + Size, Hi, Size, Compare);
+            Hi = J - Size;
+        } else {
+            QuickSort (Base, Lo, J - Size, Size, Compare);
+            Lo = J + Size;
+        }
     }
 }
 
 
 
 void __fastcall__ qsort (void* base, size_t nmemb, size_t size,
-                        int (*compare)(const void*, const void*))
+                         int (*compare)(const void*, const void*))
 /* Quicksort implementation */
 {
     if (nmemb > 1) {
-               QuickSort (base, 0, (nmemb-1) * size, size, compare);
+        QuickSort (base, 0, (nmemb-1) * size, size, compare);
     }
 }