r792: fixed -Wextra warnings and resolved #184
This commit is contained in:
Heng Li
parent
408e098859
commit
7e6e8ca73f
2
Makefile
2
Makefile
|
|
@ -1,4 +1,4 @@
|
|||
CFLAGS= -g -Wall -O2 -Wc++-compat
|
||||
CFLAGS= -g -Wall -O2 -Wc++-compat #-Wextra
|
||||
CPPFLAGS= -DHAVE_KALLOC
|
||||
INCLUDES=
|
||||
OBJS= kthread.o kalloc.o misc.o bseq.o sketch.o sdust.o options.o index.o chain.o align.o hit.o map.o format.o pe.o esterr.o ksw2_ll_sse.o
|
||||
|
|
|
|||
23
align.c
23
align.c
|
|
@ -91,7 +91,8 @@ static int mm_test_zdrop(void *km, const mm_mapopt_t *opt, const uint8_t *qseq,
|
|||
static void mm_fix_cigar(mm_reg1_t *r, const uint8_t *qseq, const uint8_t *tseq, int *qshift, int *tshift)
|
||||
{
|
||||
mm_extra_t *p = r->p;
|
||||
int32_t k, toff = 0, qoff = 0, to_shrink = 0;
|
||||
int32_t toff = 0, qoff = 0, to_shrink = 0;
|
||||
uint32_t k;
|
||||
*qshift = *tshift = 0;
|
||||
if (p->n_cigar <= 1) return;
|
||||
for (k = 0; k < p->n_cigar; ++k) { // indel left alignment
|
||||
|
|
@ -148,8 +149,8 @@ static void mm_fix_cigar(mm_reg1_t *r, const uint8_t *qseq, const uint8_t *tseq,
|
|||
|
||||
static void mm_update_extra(mm_reg1_t *r, const uint8_t *qseq, const uint8_t *tseq, const int8_t *mat, int8_t q, int8_t e)
|
||||
{
|
||||
uint32_t k, l, toff = 0, qoff = 0;
|
||||
int32_t s = 0, max = 0, qshift, tshift;
|
||||
uint32_t k, l;
|
||||
int32_t s = 0, max = 0, qshift, tshift, toff = 0, qoff = 0;
|
||||
mm_extra_t *p = r->p;
|
||||
if (p == 0) return;
|
||||
mm_fix_cigar(r, qseq, tseq, &qshift, &tshift);
|
||||
|
|
@ -407,7 +408,7 @@ static void mm_filter_bad_seeds_alt(void *km, int as1, int cnt1, mm128_t *a, int
|
|||
int re1 = (int32_t)a[as1 + i].x;
|
||||
int qe1 = (int32_t)a[as1 + i].y;
|
||||
gap1 = gap1 > 0? gap1 : -gap1;
|
||||
for (l = k + 1; l < n && a[as1 + K[l]].y - a[as1 + i].y <= max_ext; ++l) {
|
||||
for (l = k + 1; l < n && a[as1 + K[l]].y <= a[as1 + i].y + max_ext; ++l) {
|
||||
int j = K[l];
|
||||
int gap2 = ((int32_t)a[as1 + j].y - a[as1 + j - 1].y) - ((int32_t)a[as1 + j].x - a[as1 + j - 1].x);
|
||||
int q_span_pre = a[as1 + j - 1].y >> 32 & 0xff;
|
||||
|
|
@ -467,7 +468,7 @@ static void mm_fix_bad_ends(const mm_reg1_t *r, const mm128_t *a, int bw, int mi
|
|||
}
|
||||
}
|
||||
|
||||
static void mm_max_stretch(const mm_mapopt_t *opt, const mm_reg1_t *r, const mm128_t *a, int32_t *as, int32_t *cnt)
|
||||
static void mm_max_stretch(const mm_reg1_t *r, const mm128_t *a, int32_t *as, int32_t *cnt)
|
||||
{
|
||||
int32_t i, score, max_score, len, max_i, max_len;
|
||||
|
||||
|
|
@ -505,7 +506,7 @@ static int mm_seed_ext_score(void *km, const mm_mapopt_t *opt, const mm_idx_t *m
|
|||
qe = (uint32_t)a->y + 1, qs = qe - q_span;
|
||||
rs = rs - ext_len > 0? rs - ext_len : 0;
|
||||
qs = qs - ext_len > 0? qs - ext_len : 0;
|
||||
re = re + ext_len < mi->seq[rid].len? re + ext_len : mi->seq[rid].len;
|
||||
re = re + ext_len < (int32_t)mi->seq[rid].len? re + ext_len : mi->seq[rid].len;
|
||||
qe = qe + ext_len < qlen? qe + ext_len : qlen;
|
||||
tseq = (uint8_t*)kmalloc(km, re - rs);
|
||||
mm_idx_getseq(mi, rid, rs, re, tseq);
|
||||
|
|
@ -555,7 +556,7 @@ static void mm_align1(void *km, const mm_mapopt_t *opt, const mm_idx_t *mi, int
|
|||
bw = (int)(opt->bw * 1.5 + 1.);
|
||||
|
||||
if (is_sr && !(mi->flag & MM_I_HPC)) {
|
||||
mm_max_stretch(opt, r, a, &as1, &cnt1);
|
||||
mm_max_stretch(r, a, &as1, &cnt1);
|
||||
rs = (int32_t)a[as1].x + 1 - (int32_t)(a[as1].y>>32&0xff);
|
||||
qs = (int32_t)a[as1].y + 1 - (int32_t)(a[as1].y>>32&0xff);
|
||||
re = (int32_t)a[as1+cnt1-1].x + 1;
|
||||
|
|
@ -591,7 +592,7 @@ static void mm_align1(void *km, const mm_mapopt_t *opt, const mm_idx_t *mi, int
|
|||
rs0 = rs - l > 0? rs - l : 0;
|
||||
l = qlen - qe;
|
||||
l += l * opt->a + opt->end_bonus > opt->q? (l * opt->a + opt->end_bonus - opt->q) / opt->e : 0;
|
||||
re0 = re + l < mi->seq[rid].len? re + l : mi->seq[rid].len;
|
||||
re0 = re + l < (int32_t)mi->seq[rid].len? re + l : mi->seq[rid].len;
|
||||
} else {
|
||||
// compute rs0 and qs0
|
||||
rs0 = (int32_t)a[r->as].x + 1 - (int32_t)(a[r->as].y>>32&0xff);
|
||||
|
|
@ -635,13 +636,13 @@ static void mm_align1(void *km, const mm_mapopt_t *opt, const mm_idx_t *mi, int
|
|||
}
|
||||
}
|
||||
}
|
||||
if (qe < qlen && re < mi->seq[rid].len) {
|
||||
if (qe < qlen && re < (int32_t)mi->seq[rid].len) {
|
||||
l = qlen - qe < opt->max_gap? qlen - qe : opt->max_gap;
|
||||
qe1 = qe1 < qe + l? qe1 : qe + l;
|
||||
qe0 = qe0 > qe1? qe0 : qe1; // at least include qe0
|
||||
l += l * opt->a > opt->q? (l * opt->a - opt->q) / opt->e : 0;
|
||||
l = l < opt->max_gap? l : opt->max_gap;
|
||||
l = l < mi->seq[rid].len - re? l : mi->seq[rid].len - re;
|
||||
l = l < (int32_t)mi->seq[rid].len - re? l : mi->seq[rid].len - re;
|
||||
re1 = re1 < re + l? re1 : re + l;
|
||||
re0 = re0 > re1? re0 : re1;
|
||||
} else re0 = re, qe0 = qe;
|
||||
|
|
@ -875,7 +876,7 @@ mm_reg1_t *mm_align_skeleton(void *km, const mm_mapopt_t *opt, const mm_idx_t *m
|
|||
*n_regs_ = n_regs;
|
||||
kfree(km, qseq0[0]);
|
||||
kfree(km, ez.cigar);
|
||||
mm_filter_regs(km, opt, qlen, n_regs_, regs);
|
||||
mm_filter_regs(opt, qlen, n_regs_, regs);
|
||||
mm_hit_sort_by_dp(km, n_regs_, regs);
|
||||
return regs;
|
||||
}
|
||||
|
|
|
|||
2
bseq.c
2
bseq.c
|
|
@ -67,7 +67,7 @@ static inline void kseq2bseq(kseq_t *ks, mm_bseq1_t *s, int with_qual, int with_
|
|||
int i;
|
||||
s->name = kstrdup(&ks->name);
|
||||
s->seq = kstrdup(&ks->seq);
|
||||
for (i = 0; i < ks->seq.l; ++i) // convert U to T
|
||||
for (i = 0; i < (int)ks->seq.l; ++i) // convert U to T
|
||||
if (s->seq[i] == 'u' || s->seq[i] == 'U')
|
||||
--s->seq[i];
|
||||
s->qual = with_qual && ks->qual.l? kstrdup(&ks->qual) : 0;
|
||||
|
|
|
|||
2
chain.c
2
chain.c
|
|
@ -44,7 +44,7 @@ mm128_t *mm_chain_dp(int max_dist_x, int max_dist_y, int bw, int max_skip, int m
|
|||
int32_t qi = (int32_t)a[i].y, q_span = a[i].y>>32&0xff; // NB: only 8 bits of span is used!!!
|
||||
int32_t max_f = q_span, n_skip = 0, min_d;
|
||||
int32_t sidi = (a[i].y & MM_SEED_SEG_MASK) >> MM_SEED_SEG_SHIFT;
|
||||
while (st < i && ri - a[st].x > max_dist_x) ++st;
|
||||
while (st < i && ri > a[st].x + max_dist_x) ++st;
|
||||
for (j = i - 1; j >= st; --j) {
|
||||
int64_t dr = ri - a[j].x;
|
||||
int32_t dq = qi - (int32_t)a[j].y, dd, sc, log_dd;
|
||||
|
|
|
|||
4
format.c
4
format.c
|
|
@ -137,7 +137,7 @@ static void write_cs_core(kstring_t *s, const uint8_t *tseq, const uint8_t *qseq
|
|||
{
|
||||
int i, q_off, t_off;
|
||||
mm_sprintf_lite(s, "\tcs:Z:");
|
||||
for (i = q_off = t_off = 0; i < r->p->n_cigar; ++i) {
|
||||
for (i = q_off = t_off = 0; i < (int)r->p->n_cigar; ++i) {
|
||||
int j, op = r->p->cigar[i]&0xf, len = r->p->cigar[i]>>4;
|
||||
assert(op >= 0 && op <= 3);
|
||||
if (op == 0) { // match
|
||||
|
|
@ -185,7 +185,7 @@ static void write_MD_core(kstring_t *s, const uint8_t *tseq, const uint8_t *qseq
|
|||
{
|
||||
int i, q_off, t_off, l_MD = 0;
|
||||
mm_sprintf_lite(s, "\tMD:Z:");
|
||||
for (i = q_off = t_off = 0; i < r->p->n_cigar; ++i) {
|
||||
for (i = q_off = t_off = 0; i < (int)r->p->n_cigar; ++i) {
|
||||
int j, op = r->p->cigar[i]&0xf, len = r->p->cigar[i]>>4;
|
||||
assert(op >= 0 && op <= 2); // introns (aka reference skips) are not supported
|
||||
if (op == 0) { // match
|
||||
|
|
|
|||
10
hit.c
10
hit.c
|
|
@ -132,7 +132,7 @@ void mm_set_parent(void *km, float mask_level, int n, mm_reg1_t *r, int sub_diff
|
|||
int j, x = si;
|
||||
radix_sort_64(cov, cov + n_cov);
|
||||
for (j = 0; j < n_cov; ++j) {
|
||||
if (cov[j]>>32 > x) uncov_len += (cov[j]>>32) - x;
|
||||
if ((int)(cov[j]>>32) > x) uncov_len += (cov[j]>>32) - x;
|
||||
x = (int32_t)cov[j] > x? (int32_t)cov[j] : x;
|
||||
}
|
||||
if (ei > x) uncov_len += ei - x;
|
||||
|
|
@ -246,7 +246,7 @@ void mm_select_sub(void *km, float pri_ratio, int min_diff, int best_n, int *n_,
|
|||
}
|
||||
}
|
||||
|
||||
void mm_filter_regs(void *km, const mm_mapopt_t *opt, int qlen, int *n_regs, mm_reg1_t *regs)
|
||||
void mm_filter_regs(const mm_mapopt_t *opt, int qlen, int *n_regs, mm_reg1_t *regs)
|
||||
{ // NB: after this call, mm_reg1_t::parent can be -1 if its parent filtered out
|
||||
int i, k;
|
||||
for (i = k = 0; i < *n_regs; ++i) {
|
||||
|
|
@ -313,8 +313,8 @@ void mm_join_long(void *km, const mm_mapopt_t *opt, int qlen, int *n_regs_, mm_r
|
|||
a1s = &a[r1->as];
|
||||
if (a1s->x <= a0e->x || (int32_t)a1s->y <= (int32_t)a0e->y) continue; // keep colinearity
|
||||
max_gap = min_gap = (int32_t)a1s->y - (int32_t)a0e->y;
|
||||
max_gap = max_gap > a1s->x - a0e->x? max_gap : a1s->x - a0e->x;
|
||||
min_gap = min_gap < a1s->x - a0e->x? min_gap : a1s->x - a0e->x;
|
||||
max_gap = a0e->x + max_gap > a1s->x? max_gap : a1s->x - a0e->x;
|
||||
min_gap = a0e->x + min_gap < a1s->x? min_gap : a1s->x - a0e->x;
|
||||
if (max_gap > opt->max_join_long || min_gap > opt->max_join_short) continue;
|
||||
sc_thres = (int)((float)opt->min_join_flank_sc / opt->max_join_long * max_gap + .499);
|
||||
if (r0->score < sc_thres || r1->score < sc_thres) continue; // require good flanking chains
|
||||
|
|
@ -340,7 +340,7 @@ void mm_join_long(void *km, const mm_mapopt_t *opt, int qlen, int *n_regs_, mm_r
|
|||
r->parent = regs[r->parent].parent;
|
||||
}
|
||||
}
|
||||
mm_filter_regs(km, opt, qlen, n_regs_, regs);
|
||||
mm_filter_regs(opt, qlen, n_regs_, regs);
|
||||
mm_sync_regs(km, *n_regs_, regs);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
26
index.c
26
index.c
|
|
@ -45,10 +45,10 @@ mm_idx_t *mm_idx_init(int w, int k, int b, int flag)
|
|||
|
||||
void mm_idx_destroy(mm_idx_t *mi)
|
||||
{
|
||||
int i;
|
||||
uint32_t i;
|
||||
if (mi == 0) return;
|
||||
if (mi->h) kh_destroy(str, (khash_t(str)*)mi->h);
|
||||
for (i = 0; i < 1<<mi->b; ++i) {
|
||||
for (i = 0; i < 1U<<mi->b; ++i) {
|
||||
free(mi->B[i].p);
|
||||
free(mi->B[i].a.a);
|
||||
kh_destroy(idx, (idxhash_t*)mi->B[i].h);
|
||||
|
|
@ -82,14 +82,15 @@ const uint64_t *mm_idx_get(const mm_idx_t *mi, uint64_t minier, int *n)
|
|||
|
||||
void mm_idx_stat(const mm_idx_t *mi)
|
||||
{
|
||||
int i, n = 0, n1 = 0;
|
||||
int n = 0, n1 = 0;
|
||||
uint32_t i;
|
||||
uint64_t sum = 0, len = 0;
|
||||
fprintf(stderr, "[M::%s] kmer size: %d; skip: %d; is_hpc: %d; #seq: %d\n", __func__, mi->k, mi->w, mi->flag&MM_I_HPC, mi->n_seq);
|
||||
for (i = 0; i < mi->n_seq; ++i)
|
||||
len += mi->seq[i].len;
|
||||
for (i = 0; i < 1<<mi->b; ++i)
|
||||
for (i = 0; i < 1U<<mi->b; ++i)
|
||||
if (mi->B[i].h) n += kh_size((idxhash_t*)mi->B[i].h);
|
||||
for (i = 0; i < 1<<mi->b; ++i) {
|
||||
for (i = 0; i < 1U<<mi->b; ++i) {
|
||||
idxhash_t *h = (idxhash_t*)mi->B[i].h;
|
||||
khint_t k;
|
||||
if (h == 0) continue;
|
||||
|
|
@ -172,7 +173,8 @@ int32_t mm_idx_cal_max_occ(const mm_idx_t *mi, float f)
|
|||
|
||||
static void worker_post(void *g, long i, int tid)
|
||||
{
|
||||
int j, start_a, start_p, n, n_keys;
|
||||
int n, n_keys;
|
||||
size_t j, start_a, start_p;
|
||||
idxhash_t *h;
|
||||
mm_idx_t *mi = (mm_idx_t*)g;
|
||||
mm_idx_bucket_t *b = &mi->B[i];
|
||||
|
|
@ -200,7 +202,7 @@ static void worker_post(void *g, long i, int tid)
|
|||
int absent;
|
||||
mm128_t *p = &b->a.a[j-1];
|
||||
itr = kh_put(idx, h, p->x>>8>>mi->b<<1, &absent);
|
||||
assert(absent && j - start_a == n);
|
||||
assert(absent && j == start_a + n);
|
||||
if (n == 1) {
|
||||
kh_key(h, itr) |= 1;
|
||||
kh_val(h, itr) = p->y;
|
||||
|
|
@ -216,7 +218,7 @@ static void worker_post(void *g, long i, int tid)
|
|||
} else ++n;
|
||||
}
|
||||
b->h = h;
|
||||
assert(b->n == start_p);
|
||||
assert(b->n == (int32_t)start_p);
|
||||
|
||||
// deallocate and clear b->a
|
||||
kfree(0, b->a.a);
|
||||
|
|
@ -336,7 +338,7 @@ mm_idx_t *mm_idx_gen(mm_bseq_file_t *fp, int w, int k, int b, int flag, int mini
|
|||
pipeline_t pl;
|
||||
if (fp == 0 || mm_bseq_eof(fp)) return 0;
|
||||
memset(&pl, 0, sizeof(pipeline_t));
|
||||
pl.mini_batch_size = mini_batch_size < batch_size? mini_batch_size : batch_size;
|
||||
pl.mini_batch_size = (uint64_t)mini_batch_size < batch_size? mini_batch_size : batch_size;
|
||||
pl.batch_size = batch_size;
|
||||
pl.fp = fp;
|
||||
pl.mi = mm_idx_init(w, k, b, flag);
|
||||
|
|
@ -413,8 +415,7 @@ mm_idx_t *mm_idx_str(int w, int k, int is_hpc, int bucket_bits, int n, const cha
|
|||
void mm_idx_dump(FILE *fp, const mm_idx_t *mi)
|
||||
{
|
||||
uint64_t sum_len = 0;
|
||||
uint32_t x[5];
|
||||
int i;
|
||||
uint32_t x[5], i;
|
||||
|
||||
x[0] = mi->w, x[1] = mi->k, x[2] = mi->b, x[3] = mi->n_seq, x[4] = mi->flag;
|
||||
fwrite(MM_IDX_MAGIC, 1, 4, fp);
|
||||
|
|
@ -454,9 +455,8 @@ void mm_idx_dump(FILE *fp, const mm_idx_t *mi)
|
|||
|
||||
mm_idx_t *mm_idx_load(FILE *fp)
|
||||
{
|
||||
int i;
|
||||
char magic[4];
|
||||
uint32_t x[5];
|
||||
uint32_t x[5], i;
|
||||
uint64_t sum_len = 0;
|
||||
mm_idx_t *mi;
|
||||
|
||||
|
|
|
|||
|
|
@ -382,7 +382,7 @@ void ksw_extd2_sse(void *km, int qlen, const uint8_t *query, int tlen, const uin
|
|||
int rev_cigar = !!(flag & KSW_EZ_REV_CIGAR);
|
||||
if (!ez->zdropped && !(flag&KSW_EZ_EXTZ_ONLY)) {
|
||||
ksw_backtrack(km, 1, rev_cigar, 0, (uint8_t*)p, off, off_end, n_col_*16, tlen-1, qlen-1, &ez->m_cigar, &ez->n_cigar, &ez->cigar);
|
||||
} else if (!ez->zdropped && (flag&KSW_EZ_EXTZ_ONLY) && ez->mqe + end_bonus > ez->max) {
|
||||
} else if (!ez->zdropped && (flag&KSW_EZ_EXTZ_ONLY) && ez->mqe + end_bonus > (int)ez->max) {
|
||||
ez->reach_end = 1;
|
||||
ksw_backtrack(km, 1, rev_cigar, 0, (uint8_t*)p, off, off_end, n_col_*16, ez->mqe_t, qlen-1, &ez->m_cigar, &ez->n_cigar, &ez->cigar);
|
||||
} else if (ez->max_t >= 0 && ez->max_q >= 0) {
|
||||
|
|
|
|||
|
|
@ -293,7 +293,7 @@ void ksw_extz2_sse(void *km, int qlen, const uint8_t *query, int tlen, const uin
|
|||
int rev_cigar = !!(flag & KSW_EZ_REV_CIGAR);
|
||||
if (!ez->zdropped && !(flag&KSW_EZ_EXTZ_ONLY)) {
|
||||
ksw_backtrack(km, 1, rev_cigar, 0, (uint8_t*)p, off, off_end, n_col_*16, tlen-1, qlen-1, &ez->m_cigar, &ez->n_cigar, &ez->cigar);
|
||||
} else if (!ez->zdropped && (flag&KSW_EZ_EXTZ_ONLY) && ez->mqe + end_bonus > ez->max) {
|
||||
} else if (!ez->zdropped && (flag&KSW_EZ_EXTZ_ONLY) && ez->mqe + end_bonus > (int)ez->max) {
|
||||
ez->reach_end = 1;
|
||||
ksw_backtrack(km, 1, rev_cigar, 0, (uint8_t*)p, off, off_end, n_col_*16, ez->mqe_t, qlen-1, &ez->m_cigar, &ez->n_cigar, &ez->cigar);
|
||||
} else if (ez->max_t >= 0 && ez->max_q >= 0) {
|
||||
|
|
|
|||
4
main.c
4
main.c
|
|
@ -10,7 +10,7 @@
|
|||
#include "getopt.h"
|
||||
#endif
|
||||
|
||||
#define MM_VERSION "2.10-r784-dirty"
|
||||
#define MM_VERSION "2.10-r792-dirty"
|
||||
|
||||
#ifdef __linux__
|
||||
#include <sys/resource.h>
|
||||
|
|
@ -75,7 +75,7 @@ static inline int64_t mm_parse_num(const char *str)
|
|||
{
|
||||
double x;
|
||||
char *p;
|
||||
x = strtod(optarg, &p);
|
||||
x = strtod(str, &p);
|
||||
if (*p == 'G' || *p == 'g') x *= 1e9;
|
||||
else if (*p == 'M' || *p == 'm') x *= 1e6;
|
||||
else if (*p == 'K' || *p == 'k') x *= 1e3;
|
||||
|
|
|
|||
27
map.c
27
map.c
|
|
@ -39,12 +39,12 @@ static int mm_dust_minier(void *km, int n, mm128_t *a, int l_seq, const char *se
|
|||
for (j = k = 0; j < n; ++j) { // squeeze out minimizers that significantly overlap with LCRs
|
||||
int32_t qpos = (uint32_t)a[j].y>>1, span = a[j].x&0xff;
|
||||
int32_t s = qpos - (span - 1), e = s + span;
|
||||
while (u < n_dreg && (uint32_t)dreg[u] <= s) ++u;
|
||||
if (u < n_dreg && dreg[u]>>32 < e) {
|
||||
while (u < n_dreg && (int32_t)dreg[u] <= s) ++u;
|
||||
if (u < n_dreg && (int32_t)(dreg[u]>>32) < e) {
|
||||
int v, l = 0;
|
||||
for (v = u; v < n_dreg && dreg[v]>>32 < e; ++v) { // iterate over LCRs overlapping this minimizer
|
||||
int ss = s > dreg[v]>>32? s : dreg[v]>>32;
|
||||
int ee = e < (uint32_t)dreg[v]? e : (uint32_t)dreg[v];
|
||||
for (v = u; v < n_dreg && (int32_t)(dreg[v]>>32) < e; ++v) { // iterate over LCRs overlapping this minimizer
|
||||
int ss = s > (int32_t)(dreg[v]>>32)? s : dreg[v]>>32;
|
||||
int ee = e < (int32_t)dreg[v]? e : (uint32_t)dreg[v];
|
||||
l += ee - ss;
|
||||
}
|
||||
if (l <= span>>1) a[k++] = a[j]; // keep the minimizer if less than half of it falls in masked region
|
||||
|
|
@ -56,9 +56,10 @@ static int mm_dust_minier(void *km, int n, mm128_t *a, int l_seq, const char *se
|
|||
|
||||
static void collect_minimizers(void *km, const mm_mapopt_t *opt, const mm_idx_t *mi, int n_segs, const int *qlens, const char **seqs, mm128_v *mv)
|
||||
{
|
||||
int i, j, n, sum = 0;
|
||||
int i, n, sum = 0;
|
||||
mv->n = 0;
|
||||
for (i = n = 0; i < n_segs; ++i) {
|
||||
size_t j;
|
||||
mm_sketch(km, seqs[i], qlens[i], mi->w, mi->k, i, mi->flag&MM_I_HPC, mv);
|
||||
for (j = n; j < mv->n; ++j)
|
||||
mv->a[j].y += sum << 1;
|
||||
|
|
@ -81,12 +82,13 @@ typedef struct {
|
|||
|
||||
static mm_match_t *collect_matches(void *km, int *_n_m, int max_occ, const mm_idx_t *mi, const mm128_v *mv, int64_t *n_a, int *rep_len, int *n_mini_pos, uint64_t **mini_pos)
|
||||
{
|
||||
int i, rep_st = 0, rep_en = 0, n_m;
|
||||
int rep_st = 0, rep_en = 0, n_m;
|
||||
size_t i;
|
||||
mm_match_t *m;
|
||||
*n_mini_pos = 0;
|
||||
*mini_pos = (uint64_t*)kmalloc(km, mv->n * sizeof(uint64_t));
|
||||
m = (mm_match_t*)kmalloc(km, mv->n * sizeof(mm_match_t));
|
||||
for (i = n_m = 0, *rep_len = 0, *n_a = 0; i < mv->n; ++i) {
|
||||
for (i = 0, n_m = 0, *rep_len = 0, *n_a = 0; i < mv->n; ++i) {
|
||||
const uint64_t *cr;
|
||||
mm128_t *p = &mv->a[i];
|
||||
uint32_t q_pos = (uint32_t)p->y, q_span = p->x & 0xff;
|
||||
|
|
@ -120,7 +122,7 @@ static inline int skip_seed(int flag, uint64_t r, const mm_match_t *q, const cha
|
|||
const mm_idx_seq_t *s = &mi->seq[r>>32];
|
||||
int cmp;
|
||||
cmp = strcmp(qname, s->name);
|
||||
if ((flag&MM_F_NO_DIAG) && cmp == 0 && s->len == qlen) {
|
||||
if ((flag&MM_F_NO_DIAG) && cmp == 0 && (int)s->len == qlen) {
|
||||
if ((uint32_t)r>>1 == (q->q_pos>>1)) return 1; // avoid the diagnonal anchors
|
||||
if ((r&1) == (q->q_pos&1)) *is_self = 1; // this flag is used to avoid spurious extension on self chain
|
||||
}
|
||||
|
|
@ -206,7 +208,7 @@ static mm128_t *collect_seed_hits_heap(void *km, const mm_mapopt_t *opt, int max
|
|||
static mm128_t *collect_seed_hits(void *km, const mm_mapopt_t *opt, int max_occ, const mm_idx_t *mi, const char *qname, const mm128_v *mv, int qlen, int64_t *n_a, int *rep_len,
|
||||
int *n_mini_pos, uint64_t **mini_pos)
|
||||
{
|
||||
int i, k, n_m;
|
||||
int i, n_m;
|
||||
mm_match_t *m;
|
||||
mm128_t *a;
|
||||
m = collect_matches(km, &n_m, max_occ, mi, mv, n_a, rep_len, n_mini_pos, mini_pos);
|
||||
|
|
@ -214,6 +216,7 @@ static mm128_t *collect_seed_hits(void *km, const mm_mapopt_t *opt, int max_occ,
|
|||
for (i = 0, *n_a = 0; i < n_m; ++i) {
|
||||
mm_match_t *q = &m[i];
|
||||
const uint64_t *r = q->cr;
|
||||
uint32_t k;
|
||||
for (k = 0; k < q->n; ++k) {
|
||||
int32_t is_self, rpos = (uint32_t)r[k] >> 1;
|
||||
mm128_t *p;
|
||||
|
|
@ -309,10 +312,10 @@ void mm_map_frag(const mm_idx_t *mi, int n_segs, const int *qlens, const char **
|
|||
if (n_regs0 > 0) { // test if the best chain has all the segments
|
||||
int n_chained_segs = 1, max = 0, max_i = -1, max_off = -1, off = 0;
|
||||
for (i = 0; i < n_regs0; ++i) { // find the best chain
|
||||
if (max < u[i]>>32) max = u[i]>>32, max_i = i, max_off = off;
|
||||
if (max < (int)(u[i]>>32)) max = u[i]>>32, max_i = i, max_off = off;
|
||||
off += (uint32_t)u[i];
|
||||
}
|
||||
for (i = 1; i < (uint32_t)u[max_i]; ++i) // count the number of segments in the best chain
|
||||
for (i = 1; i < (int32_t)u[max_i]; ++i) // count the number of segments in the best chain
|
||||
if ((a[max_off+i].y&MM_SEED_SEG_MASK) != (a[max_off+i-1].y&MM_SEED_SEG_MASK))
|
||||
++n_chained_segs;
|
||||
if (n_chained_segs < n_segs)
|
||||
|
|
|
|||
2
mmpriv.h
2
mmpriv.h
|
|
@ -75,7 +75,7 @@ int mm_set_sam_pri(int n, mm_reg1_t *r);
|
|||
void mm_set_parent(void *km, float mask_level, int n, mm_reg1_t *r, int sub_diff);
|
||||
void mm_select_sub(void *km, float pri_ratio, int min_diff, int best_n, int *n_, mm_reg1_t *r);
|
||||
void mm_select_sub_multi(void *km, float pri_ratio, float pri1, float pri2, int max_gap_ref, int min_diff, int best_n, int n_segs, const int *qlens, int *n_, mm_reg1_t *r);
|
||||
void mm_filter_regs(void *km, const mm_mapopt_t *opt, int qlen, int *n_regs, mm_reg1_t *regs);
|
||||
void mm_filter_regs(const mm_mapopt_t *opt, int qlen, int *n_regs, mm_reg1_t *regs);
|
||||
void mm_join_long(void *km, const mm_mapopt_t *opt, int qlen, int *n_regs, mm_reg1_t *regs, mm128_t *a);
|
||||
void mm_hit_sort_by_dp(void *km, int *n_regs, mm_reg1_t *r);
|
||||
void mm_set_mapq(void *km, int n_regs, mm_reg1_t *regs, int min_chain_sc, int match_sc, int rep_len, int is_sr);
|
||||
|
|
|
|||
|
|
@ -132,6 +132,11 @@ int mm_set_opt(const char *preset, mm_idxopt_t *io, mm_mapopt_t *mo)
|
|||
|
||||
int mm_check_opt(const mm_idxopt_t *io, const mm_mapopt_t *mo)
|
||||
{
|
||||
if (io->k <= 0 || io->w <= 0) {
|
||||
if (mm_verbose >= 1)
|
||||
fprintf(stderr, "[ERROR]\033[1;31m -k and -w must be positive\033[0m\n");
|
||||
return -5;
|
||||
}
|
||||
if (mo->best_n < 0) {
|
||||
if (mm_verbose >= 1)
|
||||
fprintf(stderr, "[ERROR]\033[1;31m -N must be no less than 0\033[0m\n");
|
||||
|
|
|
|||
8
pe.c
8
pe.c
|
|
@ -105,7 +105,7 @@ void mm_pair(void *km, int max_gap_ref, int pe_bonus, int sub_diff, int match_sc
|
|||
max = -1;
|
||||
max_idx[0] = max_idx[1] = -1;
|
||||
last[0] = last[1] = -1;
|
||||
kv_resize(uint64_t, km, sc, n);
|
||||
kv_resize(uint64_t, km, sc, (size_t)n);
|
||||
for (i = 0; i < n; ++i) {
|
||||
if (a[i].key & 1) { // reverse first read or forward second read
|
||||
mm_reg1_t *q, *r;
|
||||
|
|
@ -151,8 +151,8 @@ void mm_pair(void *km, int max_gap_ref, int pe_bonus, int sub_diff, int match_sc
|
|||
}
|
||||
}
|
||||
mapq_pe = r[0]->mapq > r[1]->mapq? r[0]->mapq : r[1]->mapq;
|
||||
for (i = 0; i < sc.n; ++i)
|
||||
if ((sc.a[i]>>32) + sub_diff >= max>>32)
|
||||
for (i = 0; i < (int)sc.n; ++i)
|
||||
if ((sc.a[i]>>32) + sub_diff >= (uint64_t)max>>32)
|
||||
++n_sub;
|
||||
if (sc.n > 1) {
|
||||
int mapq_pe_alt;
|
||||
|
|
@ -164,7 +164,7 @@ void mm_pair(void *km, int max_gap_ref, int pe_bonus, int sub_diff, int match_sc
|
|||
if (sc.n == 1) {
|
||||
if (r[0]->mapq < 2) r[0]->mapq = 2;
|
||||
if (r[1]->mapq < 2) r[1]->mapq = 2;
|
||||
} else if (max>>32 > sc.a[sc.n - 2]>>32) {
|
||||
} else if ((uint64_t)max>>32 > sc.a[sc.n - 2]>>32) {
|
||||
if (r[0]->mapq < 1) r[0]->mapq = 1;
|
||||
if (r[1]->mapq < 1) r[1]->mapq = 1;
|
||||
}
|
||||
|
|
|
|||
6
sdust.c
6
sdust.c
|
|
@ -70,10 +70,10 @@ void sdust_buf_destroy(sdust_buf_t *buf)
|
|||
static inline void shift_window(int t, kdq_t(int) *w, int T, int W, int *L, int *rw, int *rv, int *cw, int *cv)
|
||||
{
|
||||
int s;
|
||||
if (kdq_size(w) >= W - SD_WLEN + 1) { // TODO: is this right for SD_WLEN!=3?
|
||||
if ((ssize_t)kdq_size(w) >= W - SD_WLEN + 1) { // TODO: is this right for SD_WLEN!=3?
|
||||
s = *kdq_shift(int, w);
|
||||
*rw -= --cw[s];
|
||||
if (*L > kdq_size(w))
|
||||
if (*L > (int)kdq_size(w))
|
||||
--*L, *rv -= --cv[s];
|
||||
}
|
||||
kdq_push(int, w, t);
|
||||
|
|
@ -114,7 +114,7 @@ static void find_perfect(void *km, perf_intv_v *P, const kdq_t(int) *w, int T, i
|
|||
r += c[t]++;
|
||||
new_r = r, new_l = kdq_size(w) - i - 1;
|
||||
if (new_r * 10 > T * new_l) {
|
||||
for (j = 0; j < P->n && P->a[j].start >= i + start; ++j) { // find insertion position
|
||||
for (j = 0; j < (int)P->n && P->a[j].start >= i + start; ++j) { // find insertion position
|
||||
perf_intv_t *p = &P->a[j];
|
||||
if (max_r == 0 || p->r * max_l > max_r * p->l)
|
||||
max_r = p->r, max_l = p->l;
|
||||
|
|
|
|||
Loading…
Reference in New Issue