static int read_DB(DAZZ_DB *block, char *name, int kmer) { int i, isdam; isdam = Open_DB(name,block); if (isdam < 0) Clean_Exit(1); Trim_DB(block); if (block->cutoff < kmer) { for (i = 0; i < block->nreads; i++) if (block->reads[i].rlen < kmer) { fprintf(stderr,"%s: Block %s contains reads < %dbp long ! Run DBsplit.\n", Prog_Name,name,kmer); Clean_Exit(1); } } Read_All_Sequences(block,0); return (isdam); }
static char *CommandBuffer(char *aname, char *bname, char *spath) { static char *cat = NULL; static int max = -1; int len; len = 2*(strlen(aname) + strlen(bname) + strlen(spath)) + 200; if (len > max) { max = ((int) (1.2*len)) + 100; if ((cat = (char *) realloc(cat,max+1)) == NULL) { fprintf(stderr,"%s: Out of memory (Making path name)\n",Prog_Name); Clean_Exit(1); } } return (cat); }
void * Safe_realloc (void * q, size_t len, const char * src_fname, size_t line_num) // Reallocate memory for q to len bytes and return a // pointer to the new memory. If fail, print a message and exit, // assuming the call came from source file src_fname at line line_num . { char Clean_Exit_Msg_Line [MAX_ERROR_MSG_LEN]; void * p; p = realloc (q, len); if (p == NULL) { sprintf (Clean_Exit_Msg_Line, "ERROR: realloc failed %lu bytes", (long unsigned) (len)); Clean_Exit (Clean_Exit_Msg_Line, src_fname, line_num); } return p; }
void * Safe_malloc (size_t len, const char * src_fname, size_t line_num) // Allocate and return a pointer to len bytes of memory. // If fail, print a message and exit, assuming the call came from // source file src_fname at line line_num . { void * p; char Clean_Exit_Msg_Line [MAX_ERROR_MSG_LEN]; p = malloc (len); if (p == NULL) { sprintf (Clean_Exit_Msg_Line, "ERROR: malloc failed %lu bytes", (long unsigned) (len)); Clean_Exit (Clean_Exit_Msg_Line, src_fname, line_num); } return p; }
void * Safe_calloc (size_t n, size_t len, const char * src_fname, size_t line_num) // Allocate and return a pointer to enough memory to hold an // array with n entries of len bytes each. All memory is // cleared to 0. If fail, print a message and exit, assuming the // call came from source file src_fname at line line_num . { void * p; char Clean_Exit_Msg_Line [MAX_ERROR_MSG_LEN]; p = calloc (n, len); if (p == NULL) { sprintf (Clean_Exit_Msg_Line, "ERROR: calloc failed %lu x %lu", (long unsigned) (n), (long unsigned) (len)); Clean_Exit (Clean_Exit_Msg_Line, src_fname, line_num); } return p; }
static DAZZ_DB *complement_DB(DAZZ_DB *block, int inplace) { static DAZZ_DB _cblock, *cblock = &_cblock; int nreads; DAZZ_READ *reads; char *seq; nreads = block->nreads; reads = block->reads; if (inplace) { seq = (char *) block->bases; cblock = block; } else { seq = (char *) Malloc(block->reads[nreads].boff+1,"Allocating dazzler sequence block"); if (seq == NULL) Clean_Exit(1); *seq++ = 4; memmove(seq,block->bases,block->reads[nreads].boff); *cblock = *block; cblock->bases = (void *) seq; cblock->tracks = NULL; } { int i; float x; x = cblock->freq[0]; cblock->freq[0] = cblock->freq[3]; cblock->freq[3] = x; x = cblock->freq[1]; cblock->freq[1] = cblock->freq[2]; cblock->freq[2] = x; for (i = 0; i < nreads; i++) complement(seq+reads[i].boff,reads[i].rlen); } { DAZZ_TRACK *src, *trg; int *data, *tata; int i, x, rlen; int64 *tano, *anno; int64 j, k; for (src = block->tracks; src != NULL; src = src->next) { tano = (int64 *) src->anno; tata = (int *) src->data; if (inplace) { data = tata; anno = tano; trg = src; } else { data = (int *) Malloc(sizeof(int)*tano[nreads], "Allocating dazzler interval track data"); anno = (int64 *) Malloc(sizeof(int64)*(nreads+1), "Allocating dazzler interval track index"); trg = (DAZZ_TRACK *) Malloc(sizeof(DAZZ_TRACK), "Allocating dazzler interval track header"); if (data == NULL || trg == NULL || anno == NULL) Clean_Exit(1); trg->name = Strdup(src->name,"Copying track name"); if (trg->name == NULL) Clean_Exit(1); trg->size = 4; trg->anno = (void *) anno; trg->data = (void *) data; trg->next = cblock->tracks; cblock->tracks = trg; } for (i = 0; i < nreads; i++) { rlen = reads[i].rlen; anno[i] = tano[i]; j = tano[i+1]-1; k = tano[i]; while (k < j) { x = tata[j]; data[j--] = rlen - tata[k]; data[k++] = rlen - x; } if (k == j) data[k] = rlen - tata[k]; } anno[nreads] = tano[nreads]; } } return (cblock); }
static int read_DB(DAZZ_DB *block, char *name, char **mask, int *mstat, int mtop, int kmer) { int i, isdam, status, kind, stop; isdam = Open_DB(name,block); if (isdam < 0) Clean_Exit(1); for (i = 0; i < mtop; i++) { status = Check_Track(block,mask[i],&kind); if (status >= 0) if (kind == MASK_TRACK) mstat[i] = 0; else { if (mstat[i] != 0) mstat[i] = -3; } else { if (mstat[i] == -2) mstat[i] = status; } if (status == 0 && kind == MASK_TRACK) Open_Track(block,mask[i]); } Trim_DB(block); stop = 0; for (i = 0; i < mtop; i++) { DAZZ_TRACK *track; int64 *anno; int j; status = Check_Track(block,mask[i],&kind); if (status < 0 || kind != MASK_TRACK) continue; stop += 1; track = Open_Track(block,mask[i]); Load_All_Track_Data(track); anno = (int64 *) (track->anno); for (j = 0; j <= block->nreads; j++) anno[j] /= sizeof(int); } if (stop > 1) { int64 nsize; DAZZ_TRACK *track; nsize = merge_size(block,stop); track = merge_tracks(block,stop,nsize); while (block->tracks != NULL) Close_Track(block,block->tracks); block->tracks = track; } if (block->cutoff < kmer) { for (i = 0; i < block->nreads; i++) if (block->reads[i].rlen < kmer) { fprintf(stderr,"%s: Block %s contains reads < %dbp long ! Run DBsplit.\n", Prog_Name,name,kmer); Clean_Exit(1); } } Load_All_Reads(block,0); return (isdam); }
static DAZZ_TRACK *merge_tracks(DAZZ_DB *block, int mtop, int64 nsize) { DAZZ_TRACK *ntrack; Event ev[mtop+1]; Event *heap[mtop+2]; int r, mhalf; int64 *anno; int *data; ntrack = (DAZZ_TRACK *) Malloc(sizeof(DAZZ_TRACK),"Allocating merged track"); if (ntrack == NULL) Clean_Exit(1); ntrack->name = Strdup("merge","Allocating merged track"); ntrack->anno = anno = (int64 *) Malloc(sizeof(int64)*(block->nreads+1),"Allocating merged track"); ntrack->data = data = (int *) Malloc(sizeof(int)*nsize,"Allocating merged track"); ntrack->size = sizeof(int); ntrack->next = NULL; if (anno == NULL || data == NULL || ntrack->name == NULL) Clean_Exit(1); { DAZZ_TRACK *track; int i; track = block->tracks; for (i = 0; i < mtop; i++) { ev[i].ano = ((int *) (track->data)) + ((int64 *) (track->anno))[0]; ev[i].out = 1; heap[i+1] = ev+i; track = track->next; } ev[mtop].idx = INT32_MAX; heap[mtop+1] = ev+mtop; } mhalf = mtop/2; nsize = 0; for (r = 0; r < block->nreads; r++) { int i, level, hsize; DAZZ_TRACK *track; anno[r] = nsize; track = block->tracks; for (i = 0; i < mtop; i++) { ev[i].end = ((int *) (track->data)) + ((int64 *) (track->anno))[r+1]; if (ev[i].ano < ev[i].end) ev[i].idx = *(ev[i].ano); else ev[i].idx = INT32_MAX; track = track->next; } hsize = mtop; for (i = mhalf; i > 1; i--) reheap(i,heap,hsize); level = 0; while (1) { Event *p; reheap(1,heap,hsize); p = heap[1]; if (p->idx == INT32_MAX) break; p->out = 1-p->out; if (p->out) { level -= 1; if (level == 0) data[nsize++] = p->idx; } else { if (level == 0) data[nsize++] = p->idx; level += 1; } p->ano += 1; if (p->ano >= p->end) p->idx = INT32_MAX; else p->idx = *(p->ano); } } anno[r] = nsize; return (ntrack); }