removed buggy qsort header and implemented myself

1 files changed, 40 insertions, 30 deletions

diff --git a/sys/libbio/align.c b/sys/libbio/align.c
index 8d1c119..0f00fce 100644
--- a/sys/libbio/align.c
+++ b/sys/libbio/align.c
@@ -87,16 +87,24 @@ sortpos(uintptr len, uint64 vals[], int locs[])
 #undef SWAP
 }
 
+/*
+ * sketch
+ * @param seq:  '0' terminated string
+ * @param len:  number of sequential sketches to keep
+ * @param vals: buffer to store hashes of sketch.
+ * @param locs: buffer to store location of sketch hashes
+ */
 error
-aln·sketch(byte *seq, int L, uint64 *vals[aln·N], int *locs[aln·N])
+aln·sketch(byte *seq, int len, uint64 *vals[aln·N], int *locs[aln·N])
 {
     int    i, n, l, *loc;
-    uint64 kmer, tmp[4], h[3], *val;
+    uint64 kmer, h[3], *val;
+    int    tmpi[2];
+    uint64 tmpu[2];
 
     for (n = 0; n < aln·N; n++) {
-        val = vals[n];
-        for (l = 0; l < L; l++) {
-            val[l] = UINT64_MAX;
+        for (l = 0; l < len; l++) {
+            vals[n][l] = UINT64_MAX;
         }
     }
 
@@ -112,26 +120,21 @@ aln·sketch(byte *seq, int L, uint64 *vals[aln·N], int *locs[aln·N])
             loc = locs[n];
 
             h[2] = (h[0] + n * h[1]) & aln·mask;
-            for (i = 0; i < L && h[2] < val[i]; i++) {
+            for (i = 0; i < len && h[2] < val[i]; i++) {
                 ;
             }
 
-            tmp[1] = h[2];
-            tmp[3] = l;
+            tmpu[1] = h[2];
+            tmpi[1] = l;
             for (i -= 1; i >= 0; i--) {
-                tmp[0] = tmp[1];
-                tmp[1] = val[i];
-                val[i] = tmp[0];
-
-                tmp[2] = tmp[3];
-                tmp[3] = loc[i];
-                loc[i] = tmp[2];
+                tmpu[0] = tmpu[1], tmpu[1] = val[i], val[i] = tmpu[0];
+                tmpi[0] = tmpi[1], tmpi[1] = loc[i], loc[i] = tmpi[0];
             }
         }
     }
 
     for (n = 0; n < aln·N; n++) {
-        sortpos(L, vals[n], locs[n]);
+        sortpos(len, vals[n], locs[n]);
     }
     
     return 0;
@@ -139,30 +142,37 @@ aln·sketch(byte *seq, int L, uint64 *vals[aln·N], int *locs[aln·N])
 
 static
 int
-cmparrs(int L, uint64 a[], uint64 b[])
+lessarrs(int len, uint64 a[], uint64 b[])
 {
     int l;
 
-    for (l = 0; l < L; l++) {
-        if (a[l] < b[l]) return -1;
+    for (l = 0; l < len; l++) {
+        if (a[l] < b[l]) return 1;
+        if (a[l] > b[l]) return 0;
     }
 
-    return +1;
+    return 0;
+}
+
+static
+void
+swaparrs(int len, uint64 a[], uint64 b[])
+{
+    int l;
+    uint64 tmp;
+
+    for (l = 0; l < len; l++) {
+        tmp = a[l], a[l] = b[l], b[l] = tmp;
+    }
 }
 
-// TODO: replace with inlined version
 error
-aln·sort(uintptr len, int L, uint64 *vals)
+aln·sort(uintptr n, int len, uint64 *vals)
 {
-    uint64 tmp[128];
-#define LESS(i, j) (cmparrs((L), (vals+(i)*L), (vals+(j)*L)))
-#define SWAP(i, j) (memcpy(tmp, (vals+(i)*L), (sizeof(uint64)*L)),     \
-                    memcpy((vals+(i)*L), (vals+(j)*L), (sizeof(uint64)*L)), \
-                    memcpy((vals+(j)*L), tmp,  (sizeof(uint64)*L)))
-       
-    QSORT(len, LESS, SWAP);
+#define LESS(i, j) (lessarrs(len, vals+((i)*len), vals+((j)*len)))
+#define SWAP(i, j) (swaparrs(len, vals+((i)*len), vals+((j)*len)))
+    QSORT(n, LESS, SWAP);
 #undef LESS
 #undef SWAP
-    // qsort(vals, len, l*sizeof(uint64), &compare);
     return 0;
 }