int gt_mapfmindex (Fmindex *fmindex,const char *indexname,
GtLogger *logger,GtError *err)
{
FILE *fpin = NULL;
bool haserr = false, storeindexpos = true;
GtSpecialcharinfo specialcharinfo;
gt_error_check(err);
fmindex->mappedptr = NULL;
fmindex->bwtformatching = NULL;
fmindex->alphabet = NULL;
fpin = gt_fa_fopen_with_suffix(indexname,FMASCIIFILESUFFIX,"rb",err);
if (fpin == NULL)
{
haserr = true;
}
if (!haserr)
{
if (scanfmafileviafileptr(fmindex,
&specialcharinfo,
&storeindexpos,
indexname,
fpin,
logger,
err) != 0)
{
haserr = true;
}
}
gt_fa_xfclose(fpin);
if (!haserr)
{
fmindex->bwtformatching = mapbwtencoding(indexname,logger,err);
if (fmindex->bwtformatching == NULL)
{
haserr = true;
}
}
if (!haserr)
{
fmindex->specpos.nextfreeGtPairBwtidx
= (unsigned long) gt_determinenumberofspecialstostore(&specialcharinfo);
fmindex->specpos.spaceGtPairBwtidx = NULL;
fmindex->specpos.allocatedGtPairBwtidx = 0;
fmindex->alphabet = gt_alphabet_ref(
gt_encseq_alphabet(fmindex->bwtformatching));
if (fmindex->alphabet == NULL)
{
haserr = true;
}
}
if (!haserr)
{
GtStr *tmpfilename;
gt_computefmkeyvalues (fmindex,
&specialcharinfo,
fmindex->bwtlength,
fmindex->log2bsize,
fmindex->log2markdist,
gt_alphabet_num_of_chars(fmindex->alphabet),
fmindex->suffixlength,
storeindexpos);
tmpfilename = gt_str_new_cstr(indexname);
gt_str_append_cstr(tmpfilename,FMDATAFILESUFFIX);
if (gt_fillfmmapspecstartptr(fmindex,storeindexpos,tmpfilename,err) != 0)
{
haserr = true;
}
gt_str_delete(tmpfilename);
}
if (haserr)
{
gt_freefmindex(fmindex);
}
return haserr ? -1 : 0;
}
static int gt_matstat_runner(GT_UNUSED int argc, GT_UNUSED const char **argv,
GT_UNUSED int parsed_args,
void *tool_arguments, GtError *err)
{
Gfmsubcallinfo *arguments = tool_arguments;
Fmindex fmindex;
Suffixarray suffixarray;
void *packedindex = NULL;
GtLogger *logger = NULL;
bool haserr = false;
const GtAlphabet *alphabet = NULL;
#ifdef WITHBCKTAB
unsigned int prefixlength = 0;
#endif
GtUword totallength;
bool gt_mapfmindexfail = false;
gt_error_check(err);
gt_assert(arguments);
logger = gt_logger_new(false, GT_LOGGER_DEFLT_PREFIX, stdout);
if (arguments->indextype == Fmindextype)
{
if (gt_mapfmindex(&fmindex,gt_str_get(arguments->indexname),
logger, err) != 0)
{
haserr = true;
gt_mapfmindexfail = true;
} else
{
alphabet = fmindex.alphabet;
}
totallength = fmindex.bwtlength-1;
} else
{
unsigned int mappedbits;
if (arguments->indextype == Esaindextype)
{
mappedbits = SARR_ESQTAB | SARR_SUFTAB
#undef WITHBCKTAB
#ifdef WITHBCKTAB
| SARR_BCKTAB
#endif
;
} else
{
if (dotestsequence(arguments))
{
mappedbits = SARR_ESQTAB;
} else
{
mappedbits = 0;
}
}
if (gt_mapsuffixarray(&suffixarray,
mappedbits,
gt_str_get(arguments->indexname),
logger,
err) != 0)
{
haserr = true;
totallength = 0;
} else
{
alphabet = gt_encseq_alphabet(suffixarray.encseq);
#ifdef WITHBCKTAB
prefixlength = suffixarray.prefixlength;
#endif
totallength = gt_encseq_total_length(suffixarray.encseq);
}
if (!haserr)
{
if (arguments->indextype == Packedindextype)
{
packedindex =
gt_loadvoidBWTSeqForSA(gt_str_get(arguments->indexname),
false,
err);
if (packedindex == NULL)
{
haserr = true;
}
}
}
}
if (!haserr)
{
const void *theindex;
Greedygmatchforwardfunction gmatchforwardfunction;
if (arguments->indextype == Fmindextype)
{
theindex = (const void *) &fmindex;
if (arguments->doms)
{
gmatchforwardfunction = gt_skfmmstats;
} else
{
gmatchforwardfunction = gt_skfmuniqueforward;
}
} else
{
if (arguments->indextype == Esaindextype)
{
theindex = (const void *) &suffixarray;
if (arguments->doms)
{
gmatchforwardfunction = gt_suffixarraymstats;
} else
{
gmatchforwardfunction = gt_suffixarrayuniqueforward;
}
} else
{
gt_assert(arguments->indextype == Packedindextype);
theindex = (const void *) packedindex;
if (arguments->doms)
{
gmatchforwardfunction = gt_voidpackedindexmstatsforward;
} else
{
gmatchforwardfunction = gt_voidpackedindexuniqueforward;
}
}
}
if (!haserr)
{
#ifdef WITHBCKTAB
if (prefixlength > 0 &&
arguments->indextype == Esaindextype &&
runsubstringiteration(gmatchforwardfunction,
theindex,
totallength,
suffixarray.bcktab,
suffixarray.countspecialcodes,
alphabet,
prefixlength,
arguments->queryfilenames,
err) != 0)
{
haserr = true;
}
#endif
if (!haserr &&
gt_findsubquerygmatchforward(dotestsequence(arguments)
? suffixarray.encseq
: NULL,
theindex,
totallength,
gmatchforwardfunction,
alphabet,
arguments->queryfilenames,
arguments->minlength,
arguments->maxlength,
(arguments->showmode & SHOWSEQUENCE)
? true : false,
(arguments->showmode & SHOWQUERYPOS)
? true : false,
(arguments->showmode & SHOWSUBJECTPOS)
? true : false,
err) != 0)
{
haserr = true;
}
}
}
if (arguments->indextype == Fmindextype)
{
if (!gt_mapfmindexfail)
{
gt_freefmindex(&fmindex);
}
} else
{
if (arguments->indextype == Packedindextype && packedindex != NULL)
{
gt_deletevoidBWTSeq(packedindex);
}
gt_freesuffixarray(&suffixarray);
}
gt_logger_delete(logger);
return haserr ? -1 : 0;;
}
