updated the alphanum comparison function

[samtools.git] / bam_sort.c

diff --git a/bam_sort.c b/bam_sort.c
index abf8d4f6caf6dfeb25af423784934d78fe677478..2c2b83d20d41047d3680a243762d0f1b95a0509d 100644 (file)
--- a/bam_sort.c
+++ b/bam_sort.c
@@ -10,24 +10,28 @@
 
 static int g_is_by_qname = 0;
 
-static inline int strnum_cmp(const char *a, const char *b)
+static int strnum_cmp(const char *_a, const char *_b)
 {
-       char *pa, *pb;
-       pa = (char*)a; pb = (char*)b;
+       const unsigned char *a = (const unsigned char*)_a, *b = (const unsigned char*)_b;
+       const unsigned char *pa = a, *pb = b;
        while (*pa && *pb) {
                if (isdigit(*pa) && isdigit(*pb)) {
-                       long ai, bi;
-                       ai = strtol(pa, &pa, 10);
-                       bi = strtol(pb, &pb, 10);
-                       if (ai != bi) return ai<bi? -1 : ai>bi? 1 : 0;
+                       while (*pa == '0') ++pa;
+                       while (*pb == '0') ++pb;
+                       while (isdigit(*pa) && isdigit(*pb) && *pa == *pb) ++pa, ++pb;
+                       if (isdigit(*pa) && isdigit(*pb)) {
+                               int i = 0;
+                               while (isdigit(pa[i]) && isdigit(pb[i])) ++i;
+                               return isdigit(pa[i])? 1 : isdigit(pb[i])? -1 : (int)*pa - (int)*pb;
+                       } else if (isdigit(*pa)) return 1;
+                       else if (isdigit(*pb)) return -1;
+                       else if (pa - a != pb - b) return pa - a < pb - b? 1 : -1;
                } else {
-                       if (*pa != *pb) break;
+                       if (*pa != *pb) return (int)*pa - (int)*pb;
                        ++pa; ++pb;
                }
        }
-       if (*pa == *pb)
-               return (pa-a) < (pb-b)? -1 : (pa-a) > (pb-b)? 1 : 0;
-       return *pa<*pb? -1 : *pa>*pb? 1 : 0;
+       return *pa? 1 : *pb? -1 : 0;
 }
 
 #define HEAP_EMPTY 0xffffffffffffffffull
@@ -418,6 +422,31 @@ void bam_sort_core(int is_by_qname, const char *fn, const char *prefix, size_t m
        bam_sort_core_ext(is_by_qname, fn, prefix, max_mem, 0);
 }
 
+
+size_t bam_sort_get_max_mem(char *max_mem_string)
+{
+       char c;
+       size_t max_mem;
+       size_t multiplier=1;
+       c=max_mem_string[strlen(max_mem_string)-1];
+       switch(c) {
+       case 'G':
+               multiplier*=1024;
+       case 'M':
+               multiplier*=1024;
+       case 'K':
+               multiplier*=1024;
+       case 'B':
+               max_mem_string[strlen(max_mem_string)-1]='\0';
+               break;
+       default:
+               break;
+       }
+       max_mem = multiplier * atol(max_mem_string);
+       // max_mem should be checked that it was not zero after atol!
+       return max_mem;
+}
+
 int bam_sort(int argc, char *argv[])
 {
        size_t max_mem = 500000000;
@@ -426,7 +455,7 @@ int bam_sort(int argc, char *argv[])
                switch (c) {
                case 'o': is_stdout = 1; break;
                case 'n': is_by_qname = 1; break;
-               case 'm': max_mem = atol(optarg); break;
+               case 'm': max_mem = bam_sort_get_max_mem(optarg); break;
                }
        }
        if (optind + 2 > argc) {