void gt_xdrop_resources_delete(GtXdropresources *res)
{
if (res != NULL)
{
GT_FREEARRAY (&res->fronts, GtXdropfrontvalue);
GT_FREEARRAY (&res->big_t, GtXdropscore);
gt_free(res);
}
}
void gt_ft_trimstat_delete(GtFtTrimstat *trimstat)
{
if (trimstat != NULL)
{
gt_free(trimstat->trim_dist);
GT_FREEARRAY(&trimstat->distance_dist,GtUword);
GT_FREEARRAY(&trimstat->maxvalid_dist,GtUword);
gt_free(trimstat->matchlength_dist);
gt_free(trimstat);
}
}
GtUword gt_spmsk_inl_delete(GtBUstate_spmsk *state)
{
if (state != NULL)
{
GtUword tmpcount;
GT_FREEARRAY(&state->Wset,GtUlong);
GT_FREEARRAY(&state->Lset,GtUlong);
gt_GtArrayGtBUItvinfo_delete_spmsk(
(GtArrayGtBUItvinfo_spmsk *) state->stack,state);
tmpcount = state->spmcounter;
gt_free(state);
return tmpcount;
}
return 0;
}
static int verifycodelists(const GtEncseq *encseq,
unsigned int kmersize,
unsigned int numofchars,
const GtArrayGtCodetype *codeliststream,
GtError *err)
{
bool haserr = false;
GtArrayGtCodetype codeliststring;
const GtUchar *characters;
GtUword stringtotallength;
gt_error_check(err);
stringtotallength = gt_encseq_total_length(encseq);
characters = gt_alphabet_characters(gt_encseq_alphabet(encseq));
GT_INITARRAY(&codeliststring,GtCodetype);
collectkmercode(&codeliststring,
encseq,
kmersize,
numofchars,
stringtotallength);
if (comparecodelists(codeliststream,
&codeliststring,
kmersize,
numofchars,
(const char *) characters,
err) != 0)
{
haserr = true;
}
GT_FREEARRAY(&codeliststring,GtCodetype);
return haserr ? -1 : 0;
}
void gt_wlis_filter_matches_delete(GtWLisFilterMatches *wlismatches)
{
if (wlismatches != NULL)
{
GT_FREEARRAY(&wlismatches->items,GtWlisItem);
gt_free(wlismatches);
}
}
Pckbuckettable *gt_pckbuckettable_new(const FMindex *fmindex,
unsigned int numofchars,
unsigned long totallength,
unsigned int maxdepth)
{
GtArrayPckbck_Boundsatdepth stack;
Pckbck_Boundsatdepth parent, child;
unsigned long rangesize, idx, *rangeOccs;
Pckbuckettable *pckbt;
Mbtab *tmpmbtab;
GT_INITARRAY(&stack,Pckbck_Boundsatdepth);
child.lowerbound = 0;
child.upperbound = totallength+1;
child.depth = 0;
child.code = (GtCodetype) 0;
GT_STOREINARRAY(&stack,Pckbck_Boundsatdepth,128,child);
rangeOccs = gt_malloc(sizeof (*rangeOccs) * GT_MULT2(numofchars));
tmpmbtab = gt_malloc(sizeof (*tmpmbtab) * numofchars);
pckbt = pckbuckettable_allocandinittable(numofchars,maxdepth,true);
while (stack.nextfreePckbck_Boundsatdepth > 0)
{
parent
= stack.spacePckbck_Boundsatdepth[--stack.nextfreePckbck_Boundsatdepth];
gt_assert(parent.lowerbound < parent.upperbound);
rangesize = gt_bwtrangesplitallwithoutspecial(tmpmbtab,
rangeOccs,
fmindex,
parent.lowerbound,
parent.upperbound);
gt_assert(rangesize <= (unsigned long) numofchars);
for (idx = 0; idx < rangesize; idx++)
{
child.lowerbound = tmpmbtab[idx].lowerbound;
child.upperbound = tmpmbtab[idx].upperbound;
child.depth = parent.depth + 1;
gt_assert(child.depth <= maxdepth);
child.code = parent.code * numofchars + idx;
pckbuckettable_storeBoundsatdepth(pckbt,&child);
if (child.depth < maxdepth)
{
if (child.lowerbound + 1 < child.upperbound)
{
GT_STOREINARRAY(&stack,Pckbck_Boundsatdepth,128,child);
} else
{
pckbuckettable_followleafedge(pckbt,fmindex,&child);
}
}
}
}
GT_FREEARRAY(&stack,Pckbck_Boundsatdepth);
gt_free(rangeOccs);
gt_free(tmpmbtab);
printf("filled: %lu (%.2f)\n",pckbt->numofvalues,
(double) pckbt->numofvalues/pckbt->maxnumofvalues);
return pckbt;
}
void gt_bare_encseq_delete(GtBareEncseq *bare_encseq)
{
if (bare_encseq != NULL)
{
gt_free(bare_encseq->charcount);
GT_FREEARRAY(&bare_encseq->specialranges,GtBareSpecialrange);
gt_free(bare_encseq);
}
}
static int gt_tyr_occratio_runner(GT_UNUSED int argc,
GT_UNUSED const char **argv,
GT_UNUSED int parsed_args,
void *tool_arguments,
GtError *err)
{
Verboseinfo *verboseinfo;
Tyr_occratio_options *arguments = tool_arguments;
bool haserr = false;
GtArrayuint64_t uniquedistribution,
nonuniquedistribution,
nonuniquemultidistribution;
verboseinfo = newverboseinfo(arguments->verbose);
GT_INITARRAY(&uniquedistribution,uint64_t);
GT_INITARRAY(&nonuniquedistribution,uint64_t);
GT_INITARRAY(&nonuniquemultidistribution,uint64_t);
if (tyr_occratio(arguments->str_inputindex,
arguments->scanfile,
arguments->minmersize,
arguments->maxmersize,
&uniquedistribution,
&nonuniquedistribution,
&nonuniquemultidistribution,
verboseinfo,
err) != 0)
{
haserr = true;
}
if (!haserr)
{
showoccratios(&uniquedistribution,
&nonuniquedistribution,
&nonuniquemultidistribution,
arguments->outputmode,
arguments->outputvector);
}
freeverboseinfo(&verboseinfo);
GT_FREEARRAY(&uniquedistribution,uint64_t);
GT_FREEARRAY(&nonuniquedistribution,uint64_t);
GT_FREEARRAY(&nonuniquemultidistribution,uint64_t);
return haserr ? -1 : 0;
}
static void gt_seq_iterator_sequence_buffer_delete(GtSeqIterator *si)
{
GtSeqIteratorSequenceBuffer *seqit;
if (!si) return;
seqit = gt_seq_iterator_sequence_buffer_cast(si);
gt_desc_buffer_delete(seqit->descptr);
gt_sequence_buffer_delete(seqit->fb);
GT_FREEARRAY(&seqit->sequencebuffer, GtUchar);
seqit->currentread = seqit->maxread;
}
static void freeconstructedfmindex(Fmindex *fm)
{
GT_FREEARRAY (&fm->specpos, GtPairBwtidx);
FREESPACE (fm->bfreq);
FREESPACE (fm->superbfreq);
FREESPACE (fm->tfreq);
FREESPACE (fm->markpostable);
if (fm->suffixlength > 0)
{
FREESPACE(fm->boundarray);
}
}
void gt_Outlcpinfo_delete(GtOutlcpinfo *outlcpinfo)
{
if (outlcpinfo == NULL)
{
return;
}
gt_turningwheel_delete(outlcpinfo->turnwheel);
if (outlcpinfo->lcpsubtab.lcp2file != NULL)
{
if (!outlcpinfo->swallow_tail_lcpvalues &&
outlcpinfo->lcpsubtab.lcp2file->countoutputlcpvalues <
outlcpinfo->numsuffixes2output)
{
outlcpinfo->lcpsubtab.lcp2file->countoutputlcpvalues
+= outmany0lcpvalues(outlcpinfo->numsuffixes2output -
outlcpinfo->lcpsubtab.lcp2file
->countoutputlcpvalues,
outlcpinfo->lcpsubtab.lcp2file->outfplcptab);
}
gt_assert(outlcpinfo->swallow_tail_lcpvalues ||
outlcpinfo->lcpsubtab.lcp2file->countoutputlcpvalues ==
outlcpinfo->numsuffixes2output);
GT_FREEARRAY(&outlcpinfo->lcpsubtab.lcp2file->largelcpvalues,
Largelcpvalue);
gt_fa_fclose(outlcpinfo->lcpsubtab.lcp2file->outfplcptab);
gt_fa_fclose(outlcpinfo->lcpsubtab.lcp2file->outfpllvtab);
gt_free(outlcpinfo->lcpsubtab.lcp2file->reservoir);
outlcpinfo->lcpsubtab.lcp2file->smalllcpvalues = NULL;
outlcpinfo->lcpsubtab.lcp2file->reservoir = NULL;
outlcpinfo->lcpsubtab.lcp2file->sizereservoir = 0;
gt_free(outlcpinfo->lcpsubtab.lcp2file);
} else
{
gt_free(outlcpinfo->lcpsubtab.tableoflcpvalues.bucketoflcpvalues);
#ifndef NDEBUG
gt_free(outlcpinfo->lcpsubtab.tableoflcpvalues.isset);
#endif
}
gt_free(outlcpinfo->lcpsubtab.lcpprocess);
outlcpinfo->lcpsubtab.tableoflcpvalues.bucketoflcpvalues = NULL;
#ifndef NDEBUG
outlcpinfo->lcpsubtab.tableoflcpvalues.isset = NULL;
#endif
outlcpinfo->lcpsubtab.tableoflcpvalues.numofentries = 0;
if (outlcpinfo->lcpsubtab.distlcpvalues != NULL)
{
gt_disc_distri_show(outlcpinfo->lcpsubtab.distlcpvalues,NULL);
gt_disc_distri_delete(outlcpinfo->lcpsubtab.distlcpvalues);
}
gt_free(outlcpinfo);
}
void gt_condenseq_delete(GtCondenseq *condenseq)
{
if (condenseq != NULL) {
GtUword i;
for (i = 0; i < condenseq->ldb_nelems; i++) {
gt_editscript_delete(condenseq->links[i].editscript);
}
for (i = 0; i < condenseq->udb_nelems; i++) {
GT_FREEARRAY(&(condenseq->uniques[i].links), uint32_t);
}
gt_alphabet_delete(condenseq->alphabet);
gt_encseq_delete(condenseq->unique_es);
gt_free(condenseq->buffer);
gt_free(condenseq->filename);
gt_free(condenseq->links);
gt_free(condenseq->orig_ids);
gt_free(condenseq->ubuffer);
gt_free(condenseq->uniques);
gt_intset_delete(condenseq->sdstab);
gt_intset_delete(condenseq->ssptab);
gt_free(condenseq);
}
}
int gt_verifymappedstr(const GtEncseq *encseq,
unsigned int prefixlength,
GtError *err)
{
unsigned int numofchars;
GtArrayGtCodetype codeliststream;
bool haserr = false;
gt_error_check(err);
numofchars = gt_alphabet_num_of_chars(gt_encseq_alphabet(encseq));
GT_INITARRAY(&codeliststream,GtCodetype);
if (getfastastreamkmers(gt_encseq_filenames(encseq),
numofchars,
prefixlength,
gt_alphabet_symbolmap(
gt_encseq_alphabet(encseq)),
false,
&codeliststream,
err) != 0)
{
haserr = true;
}
if (!haserr)
{
if (verifycodelists(encseq,
prefixlength,
numofchars,
&codeliststream,
err) != 0)
{
haserr = true;
}
}
GT_FREEARRAY(&codeliststream,GtCodetype);
return haserr ? -1 : 0;
}
GT_UNUSED static void gt_kmer_database_delete_hash_value(GtArrayGtUword *array)
{
GT_FREEARRAY(array, GtUword);
gt_free(array);
}
static int enumeratelcpintervals(const char *inputindex,
Sequentialsuffixarrayreader *ssar,
const char *storeindex,
bool storecounts,
GtUword mersize,
GtUword minocc,
GtUword maxocc,
bool performtest,
GtLogger *logger,
GtError *err)
{
TyrDfsstate *state;
bool haserr = false;
unsigned int alphasize;
gt_error_check(err);
state = gt_malloc(sizeof (*state));
GT_INITARRAY(&state->occdistribution,Countwithpositions);
state->esrspace = gt_encseq_create_reader_with_readmode(
gt_encseqSequentialsuffixarrayreader(ssar),
gt_readmodeSequentialsuffixarrayreader(ssar),
0);
state->mersize = (GtUword) mersize;
state->encseq = gt_encseqSequentialsuffixarrayreader(ssar);
alphasize = gt_alphabet_num_of_chars(gt_encseq_alphabet(state->encseq));
state->readmode = gt_readmodeSequentialsuffixarrayreader(ssar);
state->storecounts = storecounts;
state->minocc = minocc;
state->maxocc = maxocc;
state->totallength = gt_encseq_total_length(state->encseq);
state->performtest = performtest;
state->countoutputmers = 0;
state->merindexfpout = NULL;
state->countsfilefpout = NULL;
GT_INITARRAY(&state->largecounts,Largecount);
if (strlen(storeindex) == 0)
{
state->sizeofbuffer = 0;
state->bytebuffer = NULL;
} else
{
state->sizeofbuffer = MERBYTES(mersize);
state->bytebuffer = gt_malloc(sizeof *state->bytebuffer
* state->sizeofbuffer);
}
if (performtest)
{
state->currentmer = gt_malloc(sizeof *state->currentmer
* state->mersize);
state->suftab = gt_suftabSequentialsuffixarrayreader(ssar);
} else
{
state->currentmer = NULL;
state->suftab = NULL;
}
if (state->mersize > state->totallength)
{
gt_error_set(err,"mersize "GT_WU" > "GT_WU" = totallength not allowed",
state->mersize,
state->totallength);
haserr = true;
} else
{
if (strlen(storeindex) == 0)
{
state->processoccurrencecount = adddistpos2distribution;
} else
{
state->merindexfpout = gt_fa_fopen_with_suffix(storeindex,MERSUFFIX,
"wb",err);
if (state->merindexfpout == NULL)
{
haserr = true;
} else
{
if (state->storecounts)
{
state->countsfilefpout
= gt_fa_fopen_with_suffix(storeindex,COUNTSSUFFIX,"wb",err);
if (state->countsfilefpout == NULL)
{
haserr = true;
}
}
}
state->processoccurrencecount = outputsortedstring2index;
}
if (!haserr)
{
if (gt_depthfirstesa(ssar,
tyr_allocateDfsinfo,
tyr_freeDfsinfo,
tyr_processleafedge,
NULL,
tyr_processcompletenode,
tyr_assignleftmostleaf,
tyr_assignrightmostleaf,
(Dfsstate*) state,
logger,
err) != 0)
{
haserr = true;
}
if (strlen(storeindex) == 0)
{
showfinalstatistics(state,inputindex,logger);
}
}
if (!haserr)
{
if (state->countsfilefpout != NULL)
{
gt_logger_log(logger,"write "GT_WU" mercounts > "GT_WU
" to file \"%s%s\"",
state->largecounts.nextfreeLargecount,
(GtUword) MAXSMALLMERCOUNT,
storeindex,
COUNTSSUFFIX);
gt_xfwrite(state->largecounts.spaceLargecount, sizeof (Largecount),
(size_t) state->largecounts.nextfreeLargecount,
state->countsfilefpout);
}
}
if (!haserr)
{
gt_logger_log(logger,"number of "GT_WU"-mers in index: "GT_WU"",
mersize,
state->countoutputmers);
gt_logger_log(logger,"index size: %.2f megabytes\n",
GT_MEGABYTES(state->countoutputmers * state->sizeofbuffer +
sizeof (GtUword) * EXTRAINTEGERS));
}
}
/* now out EXTRAINTEGERS integer values */
if (!haserr && state->merindexfpout != NULL)
{
outputbytewiseUlongvalue(state->merindexfpout,
(GtUword) state->mersize);
outputbytewiseUlongvalue(state->merindexfpout,(GtUword) alphasize);
}
gt_fa_xfclose(state->merindexfpout);
gt_fa_xfclose(state->countsfilefpout);
GT_FREEARRAY(&state->occdistribution,Countwithpositions);
gt_free(state->currentmer);
gt_free(state->bytebuffer);
GT_FREEARRAY(&state->largecounts,Largecount);
gt_encseq_reader_delete(state->esrspace);
gt_free(state);
return haserr ? -1 : 0;
}
int gt_mapspec_read(GtMapspecSetupFunc setup, void *data,
const char *filename, GtUword expectedsize,
void **mapped, GtError *err)
{
void *mapptr;
uint64_t expectedaccordingtomapspec;
GtUword byteoffset = 0;
size_t numofbytes;
GtMapspec *ms = gt_malloc(sizeof (GtMapspec));
GtMapspecification *mapspecptr;
int had_err = 0;
GtUword totalpadunits = 0;
gt_error_check(err);
GT_INITARRAY(&ms->mapspectable, GtMapspecification);
setup(ms, data, false);
mapptr = gt_fa_mmap_read(filename, &numofbytes, err);
if (mapptr == NULL)
{
had_err = -1;
}
*mapped = mapptr;
if (!had_err)
{
if (assigncorrecttype(ms->mapspectable.spaceGtMapspecification,
mapptr,0,err) != 0)
{
had_err = -1;
}
}
if (!had_err)
{
expectedaccordingtomapspec =
detexpectedaccordingtomapspec(&ms->mapspectable);
if (expectedaccordingtomapspec != (uint64_t) numofbytes)
{
gt_error_set(err, GT_WU " bytes read from %s, but " Formatuint64_t
" expected",
(GtUword) numofbytes,
filename,
PRINTuint64_tcast(expectedaccordingtomapspec));
had_err = -1;
}
}
if (!had_err)
{
mapspecptr = ms->mapspectable.spaceGtMapspecification;
gt_assert(mapspecptr != NULL);
byteoffset = CALLCASTFUNC(uint64_t,unsigned_long,
(uint64_t) (mapspecptr->sizeofunit *
mapspecptr->numofunits));
if (byteoffset % (GtUword) GT_WORDSIZE_INBYTES > 0)
{
size_t padunits
= GT_WORDSIZE_INBYTES - (byteoffset % GT_WORDSIZE_INBYTES);
byteoffset += (GtUword) padunits;
totalpadunits += (GtUword) padunits;
}
for (mapspecptr++;
mapspecptr < ms->mapspectable.spaceGtMapspecification +
ms->mapspectable.nextfreeGtMapspecification; mapspecptr++)
{
if (assigncorrecttype(mapspecptr,mapptr,byteoffset,err) != 0)
{
had_err = -1;
break;
}
byteoffset = CALLCASTFUNC(uint64_t,unsigned_long,
(uint64_t) (byteoffset +
mapspecptr->sizeofunit *
mapspecptr->numofunits));
if (byteoffset % (GtUword) GT_WORDSIZE_INBYTES > 0)
{
size_t padunits
= GT_WORDSIZE_INBYTES - (byteoffset % GT_WORDSIZE_INBYTES);
byteoffset += (GtUword) padunits;
totalpadunits += (GtUword) padunits;
}
}
}
if (!had_err)
{
if (expectedsize + totalpadunits != byteoffset)
{
gt_error_set(err,"mapping: expected file size is "GT_WU" bytes, "
"but file has "GT_WU" bytes",
expectedsize,byteoffset);
had_err = -1;
}
}
GT_FREEARRAY(&ms->mapspectable,GtMapspecification);
gt_free(ms);
return had_err;
}
int gt_mapspec_write(GtMapspecSetupFunc setup, FILE *fp,
void *data, GtUword expectedsize, GtError *err)
{
GtMapspecification *mapspecptr;
GtUword byteoffset = 0;
int had_err = 0;
GtUword totalpadunits = 0;
GtUword byteswritten;
GtMapspec *ms = gt_malloc(sizeof (GtMapspec));
gt_error_check(err);
GT_INITARRAY(&ms->mapspectable,GtMapspecification);
setup(ms, data, true);
gt_assert(ms->mapspectable.spaceGtMapspecification != NULL);
for (mapspecptr = ms->mapspectable.spaceGtMapspecification;
mapspecptr < ms->mapspectable.spaceGtMapspecification +
ms->mapspectable.nextfreeGtMapspecification;
mapspecptr++)
{
#ifdef SKDEBUG
printf("# %s",__func__);
showmapspec(mapspecptr);
printf(" at byteoffset "GT_WU"\n",byteoffset);
#endif
if (mapspecptr->numofunits > 0)
{
switch (mapspecptr->typespec)
{
case GtCharType:
WRITEACTIONWITHTYPE(char);
break;
case GtFilelengthvaluesType:
WRITEACTIONWITHTYPE(GtFilelengthvalues);
break;
case GtUcharType:
WRITEACTIONWITHTYPE(GtUchar);
break;
case Uint16Type:
WRITEACTIONWITHTYPE(uint16_t);
break;
case Uint32Type:
WRITEACTIONWITHTYPE(uint32_t);
break;
case GtUlongType:
WRITEACTIONWITHTYPE(GtUlong);
break;
case Uint64Type:
WRITEACTIONWITHTYPE(uint64_t);
break;
case GtBitsequenceType:
WRITEACTIONWITHTYPE(GtBitsequence);
break;
case GtUlongBoundType:
WRITEACTIONWITHTYPE(GtUlongBound);
break;
case GtPairBwtidxType:
WRITEACTIONWITHTYPE(GtPairBwtidx);
break;
case GtTwobitencodingType:
WRITEACTIONWITHTYPE(GtTwobitencoding);
break;
case GtSpecialcharinfoType:
WRITEACTIONWITHTYPE(GtSpecialcharinfo);
break;
case GtBitElemType:
WRITEACTIONWITHTYPE(BitElem);
break;
case GtUintType:
WRITEACTIONWITHTYPE(unsigned int);
break;
default:
gt_error_set(err, "no map specification for size " GT_WU,
(GtUword) mapspecptr->sizeofunit);
had_err = -1;
}
}
if (had_err)
{
break;
}
byteoffset = CALLCASTFUNC(uint64_t,unsigned_long,
(uint64_t) (byteoffset +
mapspecptr->sizeofunit *
mapspecptr->numofunits));
if (gt_mapspec_pad(fp,&byteswritten,byteoffset,err) != 0)
{
had_err = -1;
}
byteoffset += byteswritten;
totalpadunits += byteswritten;
}
if (!had_err)
{
if (expectedsize + totalpadunits != byteoffset)
{
gt_error_set(err, "expected file size is " GT_WU " bytes, "
"but file has " GT_WU " bytes",
expectedsize, byteoffset);
had_err = -1;
}
}
GT_FREEARRAY(&ms->mapspectable,GtMapspecification);
gt_free(ms);
return had_err;
}