static int gt_cge_spacedseed_arguments_check(int rest_argc,
void *tool_arguments,
GtError *err)
{
Cge_spacedseed_options *arguments = tool_arguments;
if (gt_str_length(arguments->str_inputindex) == 0)
{
gt_error_set(err,"missing indexname");
return -1;
}
if (gt_option_is_set(arguments->refoptionesaindex))
{
arguments->withesa = true;
} else
{
gt_assert(gt_option_is_set(arguments->refoptionpckindex));
arguments->withesa = false;
}
if (rest_argc != 0)
{
gt_error_set(err,"superfluous file arguments");
return -1;
}
return 0;
}
static int gt_index_options_check_set_create_opts(void *oip, GtError *err)
{
int had_err = 0;
GtIndexOptions *oi = (GtIndexOptions*) oip;
gt_assert(oi != NULL && oi->type != GT_INDEX_OPTIONS_UNDEFINED);
gt_error_check(err);
/* readmode needs to be initialized to fwd */
oi->readmode = (GtReadmode) 0;
if (!had_err)
{
if (gt_option_is_set(oi->optionalgbounds))
{
if (gt_parse_algbounds(&oi->sfxstrategy,oi->algbounds,err) != 0)
{
had_err = -1;
}
} else
{
oi->sfxstrategy.maxinsertionsort = MAXINSERTIONSORTDEFAULT;
oi->sfxstrategy.maxbltriesort = MAXBLTRIESORTDEFAULT;
oi->sfxstrategy.maxcountingsort = MAXCOUNTINGSORTDEFAULT;
}
}
if (!had_err && oi->sfxstrategy.kmerswithencseqreader &&
oi->sfxstrategy.spmopt_minlength > 0)
{
gt_error_set(err,"options -spmopt and -kmerswithencseqreader are "
"not compatible");
had_err = -1;
}
if (!had_err
&& oi->optionmemlimit != NULL
&& gt_option_is_set(oi->optionmemlimit))
{
had_err = gt_option_parse_spacespec(&oi->maximumspace,"memlimit",
oi->memlimit,err);
}
if (!had_err)
{
if (oi->sfxstrategy.maxinsertionsort > oi->sfxstrategy.maxbltriesort)
{
gt_error_set(err,"first argument of option -algbds must not be larger "
"than second argument");
had_err = -1;
} else
{
if (oi->sfxstrategy.maxbltriesort > oi->sfxstrategy.maxcountingsort)
{
gt_error_set(err,"second argument of option -algbds must not be larger "
"than third argument");
had_err = -1;
}
}
}
return had_err;
}
static int gt_tir_arguments_check(GT_UNUSED int rest_argc,
void *tool_arguments,
GT_UNUSED GtError *err)
{
GtTirArguments *arguments = tool_arguments;
int had_err = 0;
gt_error_check(err);
gt_assert(arguments);
if (!had_err) {
if (gt_option_is_set(arguments->optionoverlaps)) {
if (strcmp(gt_str_get(arguments->str_overlaps), "no") == 0) {
arguments->best_overlaps = false;
arguments->no_overlaps = true;
} else if (strcmp(gt_str_get(arguments->str_overlaps), "best") == 0 ) {
arguments->best_overlaps = true;
arguments->no_overlaps = false;
} else if (strcmp(gt_str_get(arguments->str_overlaps), "all") == 0 ) {
arguments->best_overlaps = false;
arguments->no_overlaps = false;
} else {
gt_assert(0); /* cannot happen */
}
} else {
/* default is "best" */
arguments->best_overlaps = true; /* take best prediction
if overlap occurs, default */
arguments->no_overlaps = false; /* overlapping predictions (not)
allowed*/
}
}
return had_err;
}
static int gt_idxlocali_arguments_check (GT_UNUSED int rest_argc,
void *tool_arguments,
GT_UNUSED GtError * err)
{
IdxlocaliOptions *arguments = tool_arguments;
if (gt_option_is_set (arguments->refoptionesaindex))
{
arguments->withesa = true;
} else
{
gt_assert (gt_option_is_set (arguments->refoptionpckindex));
arguments->withesa = false;
}
return 0;
}
bool gt_typecheck_info_option_used(const GtTypecheckInfo *tci)
{
gt_assert(tci && tci->typecheck_option);
if (gt_option_is_set(tci->typecheck_option) || tci->typecheck_built_in)
return true;
return false;
}
static int gt_tyr_mkindex_arguments_check(int rest_argc,
void *tool_arguments,
GtError *err)
{
Tyr_mkindex_options *arguments = tool_arguments;
if (rest_argc != 0)
{
gt_error_set(err,"superfluous arguments");
return -1;
}
if (gt_option_is_set(arguments->refoptionpl))
{
if (arguments->userdefinedprefixlength == 0)
{
arguments->prefixlength.flag = Autoprefixlength;
arguments->prefixlength.value = 0;
} else
{
arguments->prefixlength.flag = Determinedprefixlength;
arguments->prefixlength.value = arguments->userdefinedprefixlength;
}
} else
{
arguments->prefixlength.flag = Undeterminedprefixlength;
arguments->prefixlength.value = 0;
}
return 0;
}
static int gt_repfind_arguments_check(GT_UNUSED int rest_argc,
void *tool_arguments,
GT_UNUSED GtError *err)
{
Maxpairsoptions *arguments = tool_arguments;
if (!gt_option_is_set(arguments->refforwardoption) && arguments->reverse)
{
arguments->forward = false;
}
return 0;
}
static int gt_readjoiner_assembly_arguments_check(GT_UNUSED int rest_argc,
void *tool_arguments, GtError *err)
{
GtReadjoinerAssemblyArguments *arguments = tool_arguments;
int had_err = 0;
gt_error_check(err);
if (had_err == 0 && gt_option_is_set(arguments->refoptionbuffersize))
if (gt_option_parse_spacespec(&arguments->buffersize,
"buffersize", arguments->buffersizearg, err) != 0)
had_err = -1;
return had_err;
}
static int gt_seed_extend_arguments_check(int rest_argc, void *tool_arguments,
GtError *err)
{
GtSeedExtendArguments *arguments = tool_arguments;
int had_err = 0;
gt_error_check(err);
gt_assert(arguments != NULL);
/* -t parameter as alias for maxfreq := t - 1 */
if (arguments->dbs_suppress < GT_UWORD_MAX) {
arguments->dbs_maxfreq = arguments->dbs_suppress - 1;
}
/* no alignment output */
if (!gt_option_is_set(arguments->se_option_withali)) {
arguments->se_alignmentwidth = 0;
}
/* parse memlimit argument */
arguments->dbs_memlimit = GT_UWORD_MAX;
if (strcmp(gt_str_get(arguments->dbs_memlimit_str), "") != 0) {
had_err = gt_option_parse_spacespec(&arguments->dbs_memlimit,
"memlimit",
arguments->dbs_memlimit_str,
err);
if (!had_err && arguments->dbs_memlimit == 0) {
gt_error_set(err,
"argument to option \"-memlimit\" must be at least 1MB");
had_err = -1;
}
}
/* minimum maxfreq value for 1 input file */
if (!had_err && arguments->dbs_maxfreq == 1 &&
strcmp(gt_str_get(arguments->dbs_queryname), "") == 0) {
if (arguments->dbs_suppress == GT_UWORD_MAX) {
gt_error_set(err, "argument to option \"-maxfreq\" must be >= 2 to "
"find matching k-mers");
} else {
gt_error_set(err, "argument to option \"-t\" must be >= 3 to find "
"matching k-mers");
}
had_err = -1;
}
/* no extra arguments */
if (!had_err && rest_argc > 0) {
gt_error_set(err, "too many arguments (-help shows correct usage)");
had_err = -1;
}
return had_err;
}
static int gt_condenseq_extract_arguments_check(int rest_argc,
void *tool_arguments,
GtError *err)
{
GtCondenserExtractArguments *arguments = tool_arguments;
int had_err = 0;
gt_error_check(err);
gt_assert(arguments);
if (rest_argc != 1) {
had_err = -1;
gt_error_set(err, "archive parameter is mandatory, use -help for usage");
}
if (!had_err &&
arguments->range.start != GT_UNDEF_UWORD) {
if (arguments->range.start > arguments->range.end) {
had_err = -1;
gt_error_set(err, "give range of positions in the form 'a b' with a "
"<= b");
}
if (!had_err &&
strcmp(gt_str_get(arguments->mode), "fasta") == 0) {
had_err = -1;
gt_error_set(err, "-range is incompatible to fasta output");
}
}
if (!had_err &&
arguments->seqrange.start != GT_UNDEF_UWORD) {
if (arguments->seqrange.start > arguments->seqrange.end) {
had_err = -1;
gt_error_set(err, "give range of positions in the form 'a b' with a "
"<= b");
}
}
if (!had_err &&
gt_option_is_set(arguments->sepchar_opt)) {
if (strcmp(gt_str_get(arguments->mode), "fasta") == 0) {
had_err = -1;
gt_error_set(err, "-sepchar is incompatible with -output fasta");
}
if (!had_err &&
gt_str_length(arguments->sepchar) != (GtUword) 1) {
had_err = -1;
gt_error_set(err, "sepchar (\"%s\" given) has to be a single character",
gt_str_get(arguments->sepchar));
}
}
return had_err;
}
static int gt_genomediff_arguments_check(int rest_argc,
void *tool_arguments,
GtError *err)
{
GtGenomediffArguments *arguments = tool_arguments;
bool prepared_index;
int had_err = 0;
gt_error_check(err);
gt_assert(arguments);
if (rest_argc == 0) {
gt_error_set(err, "give at least one file (base)name!");
had_err = -1;
}
if (!had_err) {
if (strcmp("esa", gt_str_get(arguments->indextype)) == 0)
arguments->with_esa = true;
else if (strcmp("pck", gt_str_get(arguments->indextype)) == 0)
arguments->with_pck = true;
}
prepared_index = (arguments->with_esa || arguments->with_pck);
if (!had_err && arguments->user_max_depth != -1 && !arguments->with_pck)
gt_warning("option -maxdepth does only apply to -indextype pck");
if (!had_err &&
prepared_index && gt_encseq_options_mirrored_value(arguments->loadopts))
gt_warning("option -mirrored is ignored with esa and pck index");
if (!had_err && prepared_index && rest_argc > 1) {
gt_error_set(err, "there should be only one basename argument with "
"-indextype esa|pck");
had_err = -1;
}
if (rest_argc == 1 && gt_str_length(arguments->indexname) != 0) {
gt_error_set(err, "Option -indexname is only needed with sequence files, "
"if one file is given as argument, this should be an index.");
had_err = -1;
}
if (!had_err && rest_argc > 1 && gt_str_length(arguments->indexname) == 0) {
gt_error_set(err, "more than one input file given, please use -indexname "
"for basename of indices created during run.");
had_err = -1;
}
if (!had_err)
arguments->with_units = gt_option_is_set(arguments->ref_unitfile);
return had_err;
}
static int gt_gdiffcalc_arguments_check(GT_UNUSED int rest_argc,
void *tool_arguments,
GT_UNUSED GtError *err)
{
GtGenomediffArguments *arguments = tool_arguments;
int had_err = 0;
gt_error_check(err);
gt_assert(arguments);
gt_assert(rest_argc == 1);
if (!had_err)
arguments->with_units = gt_option_is_set(arguments->ref_unitfile);
return had_err;
}
static int gt_index_options_check_set_out_opts(void *oip, GtError *err)
{
int had_err = 0;
GtIndexOptions *oi = (GtIndexOptions*) oip;
gt_assert(oi != NULL && oi->type != GT_INDEX_OPTIONS_UNDEFINED);
gt_error_check(err);
if (!had_err) {
int retval;
retval = gt_readmode_parse(gt_str_get(oi->dir), err);
if (retval < 0) {
had_err = -1;
} else {
oi->readmode = (GtReadmode) retval;
if (oi->type == GT_INDEX_OPTIONS_PACKED
&& (oi->readmode == GT_READMODE_COMPL
|| oi->readmode == GT_READMODE_REVCOMPL)) {
gt_error_set(err,"construction of packed index not possible for "
"complemented and for reverse complemented sequences");
had_err = -1;
}
}
}
if (!had_err && oi->type == GT_INDEX_OPTIONS_PACKED) {
#ifndef S_SPLINT_S
gt_computePackedIndexDefaults(&oi->bwtIdxParams, BWTBaseFeatures);
#endif
}
if (!had_err && gt_option_is_set(oi->optionkys)) {
oi->outkystab = true;
if (strcmp(gt_str_get(oi->kysargumentstring), "sort") == 0) {
oi->outkyssort = true;
} else {
if (strcmp(gt_str_get(oi->kysargumentstring),"nosort") != 0) {
gt_error_set(err,"illegal argument to option -kys: either use no "
"argument or argument \"sort\"");
had_err = -1;
}
}
}
return had_err;
}
GtTypeChecker* gt_typecheck_info_create_type_checker(const GtTypecheckInfo *tci,
GtError *err)
{
GtTypeChecker *type_checker = NULL;
int had_err = 0;
gt_error_check(err);
gt_assert(tci);
if (tci->typecheck_built_in)
type_checker = gt_type_checker_builtin_new();
else {
GtStr *obo_file;
gt_assert(gt_option_is_set(tci->typecheck_option));
if (!gt_str_length(tci->typecheck)) {
/* a. */
if (!(obo_file = get_obo_path(err)))
had_err = -1;
if (!had_err)
gt_str_append_cstr(obo_file, "sofa.obo");
}
else if (gt_file_exists(gt_str_get(tci->typecheck))) {
/* b. */
obo_file = gt_str_new_cstr(gt_str_get(tci->typecheck));
}
else {
/* c. */
if (!(obo_file = get_obo_path(err)))
had_err = -1;
if (!had_err) {
gt_str_append_str(obo_file, tci->typecheck);
gt_str_append_cstr(obo_file, ".obo");
}
}
if (!had_err)
type_checker = gt_type_checker_obo_new(gt_str_get(obo_file), err);
gt_str_delete(obo_file);
}
return type_checker;
}
GtXRFChecker* gt_xrfcheck_info_create_xrf_checker(const GtXRFCheckInfo *xci,
GtError *err)
{
GtXRFChecker *xrf_checker = NULL;
int had_err = 0;
GtStr *xrf_file;
gt_error_check(err);
gt_assert(xci);
gt_assert(gt_option_is_set(xci->xrfcheck_option));
if (!gt_str_length(xci->xrfcheck)) {
/* a. */
if (!(xrf_file = get_xrf_path(err)))
had_err = -1;
if (!had_err)
gt_str_append_cstr(xrf_file, "GO.xrf_abbr");
}
else if (gt_file_exists(gt_str_get(xci->xrfcheck))) {
/* b. */
xrf_file = gt_str_new_cstr(gt_str_get(xci->xrfcheck));
}
else {
/* c. */
if (!(xrf_file = get_xrf_path(err)))
had_err = -1;
if (!had_err) {
gt_str_append_str(xrf_file, xci->xrfcheck);
gt_str_append_cstr(xrf_file, ".xrf_abbr");
}
}
if (!had_err)
xrf_checker = gt_xrf_checker_new(gt_str_get(xrf_file), err);
gt_str_delete(xrf_file);
return xrf_checker;
}
static GtOPrval parse_options(int *parsed_args,
Cmppairwiseopt *pw,
int argc, const char **argv, GtError *err)
{
GtOptionParser *op;
GtOption *optionstrings,
*optionfiles,
*optioncharlistlen,
*optiontext,
*optionshowedist;
GtStrArray *charlistlen;
GtOPrval oprval;
gt_error_check(err);
charlistlen = gt_str_array_new();
pw->strings = gt_str_array_new();
pw->files = gt_str_array_new();
pw->text = gt_str_new();
pw->charlistlen = NULL;
pw->showedist = false;
op = gt_option_parser_new("options", "Apply function to pairs of strings.");
gt_option_parser_set_mail_address(op, "<*****@*****.**>");
optionstrings = gt_option_new_string_array("ss", "use two strings",
pw->strings);
gt_option_parser_add_option(op, optionstrings);
optionfiles = gt_option_new_filename_array("ff", "use two files",
pw->files);
gt_option_parser_add_option(op, optionfiles);
optioncharlistlen = gt_option_new_string_array("a",
"use character list and length",
charlistlen);
gt_option_parser_add_option(op, optioncharlistlen);
optiontext = gt_option_new_string("t", "use text", pw->text, NULL);
gt_option_parser_add_option(op, optiontext);
optionshowedist = gt_option_new_bool("e", "output unit edit distance",
&pw->showedist, false);
gt_option_parser_add_option(op, optionshowedist);
gt_option_exclude(optionstrings, optionfiles);
gt_option_exclude(optionstrings, optioncharlistlen);
gt_option_exclude(optionstrings, optiontext);
gt_option_exclude(optionfiles, optioncharlistlen);
gt_option_exclude(optionfiles, optiontext);
gt_option_exclude(optioncharlistlen, optiontext);
gt_option_imply(optionshowedist, optionstrings);
oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
err);
if (oprval == GT_OPTION_PARSER_OK)
{
if (gt_option_is_set(optionstrings))
{
if (gt_str_array_size(pw->strings) != 2UL)
{
gt_error_set(err, "option -ss requires two string arguments");
oprval = GT_OPTION_PARSER_ERROR;
}
} else
{
if (gt_option_is_set(optionfiles))
{
if (gt_str_array_size(pw->files) != 2UL)
{
gt_error_set(err, "option -ff requires two filename arguments");
oprval = GT_OPTION_PARSER_ERROR;
}
} else
{
if (gt_option_is_set(optioncharlistlen))
{
GtWord readint;
if (gt_str_array_size(charlistlen) != 2UL)
{
gt_error_set(err,
"option -a requires charlist and length argument");
oprval = GT_OPTION_PARSER_ERROR;
}
pw->charlistlen = gt_malloc(sizeof *pw->charlistlen);
pw->charlistlen->charlist =
gt_str_ref(gt_str_array_get_str(charlistlen,
0));
if (sscanf(gt_str_array_get(charlistlen,1UL), GT_WD, &readint) != 1 ||
readint < 1L)
{
gt_error_set(err,
"option -a requires charlist and length argument");
oprval = GT_OPTION_PARSER_ERROR;
}
pw->charlistlen->len = (GtUword) readint;
} else
{
if (!gt_option_is_set(optiontext))
{
gt_error_set(err,
"use exactly one of the options -ss, -ff, -a, -t");
oprval = GT_OPTION_PARSER_ERROR;
}
}
}
}
}
gt_option_parser_delete(op);
if (oprval == GT_OPTION_PARSER_OK && *parsed_args != argc)
{
gt_error_set(err, "superfluous program parameters");
oprval = GT_OPTION_PARSER_ERROR;
}
gt_str_array_delete(charlistlen);
return oprval;
}
static int gt_seed_extend_runner(GT_UNUSED int argc,
GT_UNUSED const char **argv,
GT_UNUSED int parsed_args,
void *tool_arguments,
GtError *err)
{
GtSeedExtendArguments *arguments = tool_arguments;
GtEncseqLoader *encseq_loader = NULL;
GtEncseq *aencseq = NULL, *bencseq = NULL;
GtGreedyextendmatchinfo *grextinfo = NULL;
GtXdropmatchinfo *xdropinfo = NULL;
GtQuerymatchoutoptions *querymatchoutopt = NULL;
GtTimer *seedextendtimer = NULL;
GtExtendCharAccess cam = GT_EXTEND_CHAR_ACCESS_ANY;
GtUword errorpercentage = 0UL;
int had_err = 0;
gt_error_check(err);
gt_assert(arguments != NULL);
gt_assert(arguments->se_minidentity >= GT_EXTEND_MIN_IDENTITY_PERCENTAGE &&
arguments->se_minidentity <= 100UL);
/* Calculate error percentage from minidentity */
errorpercentage = 100UL - arguments->se_minidentity;
/* Measure whole running time */
if (arguments->benchmark || arguments->verbose) {
gt_showtime_enable();
}
if (gt_showtime_enabled())
{
seedextendtimer = gt_timer_new();
gt_timer_start(seedextendtimer);
}
/* Load encseq A */
encseq_loader = gt_encseq_loader_new();
gt_encseq_loader_enable_autosupport(encseq_loader);
aencseq = gt_encseq_loader_load(encseq_loader,
gt_str_get(arguments->dbs_indexname),
err);
if (aencseq == NULL)
had_err = -1;
/* If there is a 2nd read set: Load encseq B */
if (!had_err) {
if (strcmp(gt_str_get(arguments->dbs_queryname), "") != 0) {
bencseq = gt_encseq_loader_load(encseq_loader,
gt_str_get(arguments->dbs_queryname),
err);
} else {
bencseq = gt_encseq_ref(aencseq);
}
if (bencseq == NULL) {
had_err = -1;
gt_encseq_delete(aencseq);
}
}
gt_encseq_loader_delete(encseq_loader);
/* set character access method */
if (!had_err && (gt_option_is_set(arguments->se_option_greedy) ||
gt_option_is_set(arguments->se_option_xdrop) ||
arguments->se_alignmentwidth > 0))
{
cam = gt_greedy_extend_char_access(gt_str_get
(arguments->se_char_access_mode),
err);
if ((int) cam == -1) {
had_err = -1;
gt_encseq_delete(aencseq);
gt_encseq_delete(bencseq);
}
}
/* Use bias dependent parameters, adapted from E. Myers' DALIGNER */
if (!had_err && arguments->bias_parameters) {
const GtAlphabet *alpha = gt_encseq_alphabet(aencseq);
const double bias_factor[10] = {.690, .690, .690, .690, .780,
.850, .900, .933, .966, 1.000};
if (gt_alphabet_is_dna(alpha)) {
GtUword at, cg;
at = gt_encseq_charcount(aencseq, gt_alphabet_encode(alpha, 'a'));
at += gt_encseq_charcount(aencseq, gt_alphabet_encode(alpha, 't'));
cg = gt_encseq_charcount(aencseq, gt_alphabet_encode(alpha, 'c'));
cg += gt_encseq_charcount(aencseq, gt_alphabet_encode(alpha, 'g'));
if (at + cg > 0) {
const double ratio = (double)MIN(at, cg) / (at + cg);
int bias_index = (int)MAX(0.0, (ratio + 0.025) * 20.0 - 1.0);
gt_assert(bias_index < 10);
arguments->se_maxalilendiff = 30;
arguments->se_perc_match_hist = (GtUword)(100.0 - errorpercentage *
bias_factor[bias_index]);
if (arguments->verbose) {
printf("# Base ratio = %4.2lf -> percmathistory = "GT_WU"\n",
ratio, arguments->se_perc_match_hist);
}
} else {
had_err = -1;
}
} else {
had_err = -1;
}
if (had_err) {
gt_error_set(err, "option \"-bias-parameters\" can only be applied to "
"the DNA alphabet");
gt_encseq_delete(aencseq);
gt_encseq_delete(bencseq);
}
}
/* Prepare options for greedy extension */
if (!had_err && gt_option_is_set(arguments->se_option_greedy)) {
grextinfo = gt_greedy_extend_matchinfo_new(errorpercentage,
arguments->se_maxalilendiff,
arguments->se_historysize,
arguments->se_perc_match_hist,
arguments->se_alignlength,
cam,
arguments->se_extendgreedy);
if (arguments->benchmark) {
gt_greedy_extend_matchinfo_silent_set(grextinfo);
}
}
/* Prepare options for xdrop extension */
if (!had_err && gt_option_is_set(arguments->se_option_xdrop)) {
xdropinfo = gt_xdrop_matchinfo_new(arguments->se_alignlength,
errorpercentage,
arguments->se_xdropbelowscore,
arguments->se_extendxdrop);
if (arguments->benchmark) {
gt_xdrop_matchinfo_silent_set(xdropinfo);
}
}
/* Prepare output options */
if (!had_err && (arguments->se_alignmentwidth > 0 ||
gt_option_is_set(arguments->se_option_xdrop)))
{
querymatchoutopt
= gt_querymatchoutoptions_new(arguments->se_alignmentwidth);
if (gt_option_is_set(arguments->se_option_xdrop) ||
gt_option_is_set(arguments->se_option_greedy))
{
const GtUword sensitivity = gt_option_is_set(arguments->se_option_greedy)
? arguments->se_extendgreedy : 100;
gt_querymatchoutoptions_extend(querymatchoutopt,
errorpercentage,
arguments->se_maxalilendiff,
arguments->se_historysize,
arguments->se_perc_match_hist,
cam,
sensitivity);
}
}
/* Start algorithm */
if (!had_err) {
GtDiagbandseed dbsarguments;
dbsarguments.errorpercentage = errorpercentage;
dbsarguments.userdefinedleastlength = arguments->se_alignlength;
dbsarguments.seedlength = arguments->dbs_seedlength;
dbsarguments.logdiagbandwidth = arguments->dbs_logdiagbandwidth;
dbsarguments.mincoverage = arguments->dbs_mincoverage;
dbsarguments.maxfreq = arguments->dbs_maxfreq;
dbsarguments.memlimit = arguments->dbs_memlimit;
dbsarguments.mirror = arguments->mirror;
dbsarguments.overlappingseeds = arguments->overlappingseeds;
dbsarguments.verify = arguments->dbs_verify;
dbsarguments.verbose = arguments->verbose;
dbsarguments.debug_kmer = arguments->dbs_debug_kmer;
dbsarguments.debug_seedpair = arguments->dbs_debug_seedpair;
dbsarguments.seed_display = arguments->seed_display;
dbsarguments.extendgreedyinfo = grextinfo;
dbsarguments.extendxdropinfo = xdropinfo;
dbsarguments.querymatchoutopt = querymatchoutopt;
had_err = gt_diagbandseed_run(aencseq, bencseq, &dbsarguments, err);
/* clean up */
gt_encseq_delete(aencseq);
gt_encseq_delete(bencseq);
if (gt_option_is_set(arguments->se_option_greedy)) {
gt_greedy_extend_matchinfo_delete(grextinfo);
}
if (gt_option_is_set(arguments->se_option_xdrop)) {
gt_xdrop_matchinfo_delete(xdropinfo);
}
if (arguments->se_alignmentwidth > 0 ||
gt_option_is_set(arguments->se_option_xdrop)) {
gt_querymatchoutoptions_delete(querymatchoutopt);
}
}
if (gt_showtime_enabled()) {
if (!had_err) {
char *keystring
= gt_seed_extend_params_keystring(gt_option_is_set(arguments->
se_option_greedy),
gt_option_is_set(arguments->
se_option_xdrop),
arguments->dbs_seedlength,
arguments->se_alignlength,
arguments->se_minidentity,
arguments->se_maxalilendiff,
arguments->se_perc_match_hist,
arguments->se_extendgreedy,
arguments->se_extendxdrop,
arguments->se_xdropbelowscore);
printf("# TIME seedextend-%s", keystring);
gt_free(keystring);
gt_timer_show_formatted(seedextendtimer,
" overall " GT_WD ".%06ld\n",
stdout);
}
gt_timer_delete(seedextendtimer);
}
return had_err;
}
static OPrval parse_options(int *parsed_args,
LTRharvestoptions *lo,
int argc, const char **argv, GtError *err)
{
GtOptionParser *op;
GtOption *optionindex,
*optionltrsearchseqrange,
*optionseed,
*optionminlenltr,
*optionmaxlenltr,
*optionmindistltr,
*optionmaxdistltr,
*optionmintsd,
*optionmaxtsd,
*optionsimilar,
*optionmotif,
*optionmotifmis,
*optionvic,
*optionoverlaps,
*optionxdrop,
*optionmat,
*optionmis,
*optionins,
*optiondel,
*optionv,
*optionoffset,
*optionlongoutput,
*optionout,
*optionoutinner,
*optiongff3;
OPrval oprval;
GtRange default_ltrsearchseqrange = {0,0};
unsigned int vicinityforcorrectboundaries;
static const char *overlaps[] = {
"best", /* the default */
"no",
"all",
NULL
};
gt_error_check(err);
op = gt_option_parser_new("[option ...] -index filenameindex",
"Predict LTR retrotransposons.");
/* -index */
lo->str_indexname = gt_str_new();
optionindex = gt_option_new_string("index",
"specify the name of the enhanced suffix "
"array index (mandatory)",
lo->str_indexname, NULL);
gt_option_is_mandatory(optionindex);
gt_option_parser_add_option(op, optionindex);
/* -range */
optionltrsearchseqrange
= gt_option_new_range("range",
"specify sequence range in which LTRs are searched",
&lo->repeatinfo.ltrsearchseqrange,
&default_ltrsearchseqrange);
gt_option_parser_add_option(op, optionltrsearchseqrange);
/* -seed */
optionseed = gt_option_new_ulong_min("seed",
"specify minimum seed length for"
" exact repeats",
&lo->minseedlength,
30UL,
1UL);
gt_option_parser_add_option(op, optionseed);
/* -minlenltr */
optionminlenltr = gt_option_new_ulong_min_max("minlenltr",
"specify minimum length for each LTR",
&lo->repeatinfo.lmin,
100UL,
1UL,
GT_UNDEF_ULONG);
gt_option_parser_add_option(op, optionminlenltr);
/* -maxlenltr */
optionmaxlenltr = gt_option_new_ulong_min_max("maxlenltr",
"specify maximum length for each LTR",
&lo->repeatinfo.lmax,
1000UL,
1UL,
GT_UNDEF_ULONG);
gt_option_parser_add_option(op, optionmaxlenltr);
/* -mindistltr */
optionmindistltr = gt_option_new_ulong_min_max("mindistltr",
"specify minimum distance of "
"LTR startpositions",
&lo->repeatinfo.dmin,
1000UL,
1UL,
GT_UNDEF_ULONG);
gt_option_parser_add_option(op, optionmindistltr);
/* -maxdistltr */
optionmaxdistltr = gt_option_new_ulong_min_max("maxdistltr",
"specify maximum distance of "
"LTR startpositions",
&lo->repeatinfo.dmax,
15000UL,
1UL,
GT_UNDEF_ULONG);
gt_option_parser_add_option(op, optionmaxdistltr);
/* -similar */
optionsimilar = gt_option_new_double_min_max("similar",
"specify similaritythreshold in "
"range [1..100%]",
&lo->similaritythreshold,
(double) 85.0,
(double) 0.0,
100.0);
gt_option_parser_add_option(op, optionsimilar);
/* -mintsd */
optionmintsd = gt_option_new_uint_min_max("mintsd",
"specify minimum length for each TSD",
&lo->minlengthTSD,
4U,
0,
GT_UNDEF_UINT);
gt_option_parser_add_option(op, optionmintsd);
/* -maxtsd */
optionmaxtsd = gt_option_new_uint_min_max("maxtsd",
"specify maximum length for each TSD",
&lo->maxlengthTSD,
20U,
0,
GT_UNDEF_UINT);
gt_option_parser_add_option(op, optionmaxtsd);
/* -motif */
/* characters will be tranformed later
into characters from virtualtree alphabet */
lo->motif.firstleft = (GtUchar) 't';
lo->motif.secondleft = (GtUchar) 'g';
lo->motif.firstright = (GtUchar) 'c';
lo->motif.secondright = (GtUchar) 'a';
lo->motif.str_motif = gt_str_new();
optionmotif = gt_option_new_string("motif",
"specify 2 nucleotides startmotif + "
"2 nucleotides endmotif: ****",
lo->motif.str_motif, NULL);
gt_option_parser_add_option(op, optionmotif);
/* -motifmis */
optionmotifmis = gt_option_new_uint_min_max("motifmis",
"specify maximum number of "
"mismatches in motif [0,3]",
&lo->motif.allowedmismatches,
4U,
0,
3U);
gt_option_parser_add_option(op, optionmotifmis);
/* -vic */
optionvic = gt_option_new_uint_min_max("vic",
"specify the number of nucleotides (to the left and "
"to the right) that will be searched "
"for TSDs and/or motifs around 5' and 3' boundary "
"of predicted LTR retrotransposons",
&vicinityforcorrectboundaries,
60U,
1U,
500U);
gt_option_parser_add_option(op, optionvic);
/* -overlaps */
lo->str_overlaps = gt_str_new();
optionoverlaps = gt_option_new_choice("overlaps",
"specify no|best|all",
lo->str_overlaps,
overlaps[0],
overlaps);
gt_option_parser_add_option(op, optionoverlaps);
/* -xdrop */
optionxdrop = gt_option_new_int_min("xdrop",
"specify xdropbelowscore for extension-alignment",
&lo->xdropbelowscore,
(int)5,
(int)0);
gt_option_parser_add_option(op, optionxdrop);
/* -mat */
lo->arbitscores.gcd = 1; /* set only for initialization,
do not change! */
optionmat = gt_option_new_int_min("mat",
"specify matchscore for extension-alignment",
&lo->arbitscores.mat,
2,
1);
gt_option_parser_add_option(op, optionmat);
/* -mis */
optionmis = gt_option_new_int_max("mis",
"specify mismatchscore for extension-alignment",
&lo->arbitscores.mis,
-2,
-1);
gt_option_parser_add_option(op, optionmis);
/* -ins */
optionins = gt_option_new_int_max("ins",
"specify insertionscore for extension-alignment",
&lo->arbitscores.ins,
-3,
-1);
gt_option_parser_add_option(op, optionins);
/* -del */
optiondel = gt_option_new_int_max("del",
"specify deletionscore for extension-alignment",
&lo->arbitscores.del,
-3,
-1);
gt_option_parser_add_option(op, optiondel);
/* -v */
optionv = gt_option_new_bool("v",
"verbose mode",
&lo->verbosemode,
false);
gt_option_parser_add_option(op, optionv);
/* -longoutput */
optionlongoutput = gt_option_new_bool("longoutput",
"additional motif/TSD output",
&lo->longoutput,
false);
gt_option_parser_add_option(op, optionlongoutput);
/* -out */
lo->fastaoutput = false; /* by default no FASTA output */
lo->str_fastaoutputfilename = gt_str_new();
optionout = gt_option_new_string("out",
"specify FASTA outputfilename",
lo->str_fastaoutputfilename, NULL);
gt_option_parser_add_option(op, optionout);
/* -outinner */
lo->fastaoutputinnerregion = false;
lo->str_fastaoutputfilenameinnerregion = gt_str_new();
optionoutinner = gt_option_new_string("outinner",
"specify FASTA outputfilename for inner regions",
lo->str_fastaoutputfilenameinnerregion, NULL);
gt_option_parser_add_option(op, optionoutinner);
/* -gff3 */
lo->gff3output = false; /* by default no gff3 output */
lo->str_gff3filename = gt_str_new();
optiongff3 = gt_option_new_string("gff3",
"specify GFF3 outputfilename",
lo->str_gff3filename, NULL);
gt_option_parser_add_option(op, optiongff3);
/* -offset */
optionoffset = gt_option_new_ulong("offset",
"offset added to GFF3 coordinates",
&lo->offset,
0UL);
gt_option_parser_add_option(op, optionoffset);
gt_option_is_extended_option(optionoffset);
/* implications */
gt_option_imply(optionmaxtsd, optionmintsd);
gt_option_imply(optionmotifmis, optionmotif);
gt_option_imply_either_2(optionlongoutput, optionmintsd, optionmotif);
gt_option_parser_refer_to_manual(op);
oprval = gt_option_parser_parse(op, parsed_args, argc, argv, gt_versionfunc,
err);
lo->vicinityforcorrectboundaries = (Seqpos) vicinityforcorrectboundaries;
if (oprval == OPTIONPARSER_OK)
{
if (lo->repeatinfo.lmin > lo->repeatinfo.lmax)
{
gt_error_set(err,"argument of -minlenltr is greater than argument of"
" -maxlenltr");
oprval = OPTIONPARSER_ERROR;
}
if (lo->repeatinfo.dmin > lo->repeatinfo.dmax)
{
gt_error_set(err,
"argument of -mindistltr is greater than argument of -maxdistltr");
oprval = OPTIONPARSER_ERROR;
}
if (lo->repeatinfo.lmax > lo->repeatinfo.dmin)
{
gt_error_set(err,"argument of -maxlenltr is greater than argument of"
" -mindistltr");
oprval = OPTIONPARSER_ERROR;
}
if (lo->minlengthTSD > lo->maxlengthTSD)
{
gt_error_set(err,
"argument of -mintsd is greater than argument of -maxtsd");
oprval = OPTIONPARSER_ERROR;
}
/* If option motif is set,
store characters, transform them later */
if (gt_option_is_set(optionmotif))
{
if (gt_str_length(lo->motif.str_motif) != 4UL)
{
gt_error_set(err,
"argument of -motif has not exactly 4 characters");
oprval = OPTIONPARSER_ERROR;
}
lo->motif.firstleft = (GtUchar) gt_str_get(lo->motif.str_motif)[0];
lo->motif.secondleft = (GtUchar) gt_str_get(lo->motif.str_motif)[1];
lo->motif.firstright = (GtUchar) gt_str_get(lo->motif.str_motif)[2];
lo->motif.secondright = (GtUchar) gt_str_get(lo->motif.str_motif)[3];
/* default if motif specified */
if (!gt_option_is_set(optionmotifmis))
{
lo->motif.allowedmismatches = 0;
}
}
/* If option overlaps is set */
if (gt_option_is_set(optionoverlaps))
{
if (strcmp(gt_str_get(lo->str_overlaps), "no") == 0)
{
lo->bestofoverlap = false;
lo->nooverlapallowed = true;
}
else if (strcmp(gt_str_get(lo->str_overlaps), "best") == 0 )
{
lo->bestofoverlap = true;
lo->nooverlapallowed = false;
}
else if (strcmp(gt_str_get(lo->str_overlaps), "all") == 0 )
{
lo->bestofoverlap = false;
lo->nooverlapallowed = false;
}
else
{
gt_assert(0); /* cannot happen */
}
}
else
{
/* default is "best" */
lo->bestofoverlap = true; /* take best prediction
if overlap occurs, default */
lo->nooverlapallowed = false; /* overlapping predictions (not)allowed*/
}
/* if FASTA output is set */
if (gt_option_is_set(optionout))
{
lo->fastaoutput = true;
}
/* if FASTA output inner region is set */
if (gt_option_is_set(optionoutinner))
{
lo->fastaoutputinnerregion = true;
}
/* if GFF3 output is set */
if (gt_option_is_set(optiongff3))
{
lo->gff3output = true;
}
if (gt_option_is_set(optionltrsearchseqrange))
{
if (lo->repeatinfo.ltrsearchseqrange.start >
lo->repeatinfo.ltrsearchseqrange.end)
{
gt_error_set(err,
"arguments of -range: first arg must be <= than second arg");
oprval = OPTIONPARSER_ERROR;
}
}
}
gt_option_parser_delete(op);
return oprval;
}
static int gt_compressedbits_runner(GT_UNUSED int argc,
GT_UNUSED const char **argv,
GT_UNUSED int parsed_args,
void *tool_arguments,
GtError *err)
{
GtCompressdbitsArguments *arguments = tool_arguments;
int had_err = 0;
unsigned long idx;
unsigned long long num_of_bits = 0ULL;
GtBitsequence *bits = NULL;
GtCompressedBitsequence *cbs = NULL, *read_cbs = NULL;
GtStr *filename = gt_str_new();
FILE *fp = NULL;
gt_error_check(err);
gt_assert(arguments);
gt_assert(argc == parsed_args);
if (gt_option_is_set(arguments->filename_op)) {
FILE *file = NULL;
gt_assert(arguments->filename != NULL);
file = gt_xfopen(gt_str_get(arguments->filename), "r");
if ((size_t) 1 != gt_xfread(&num_of_bits,
sizeof (num_of_bits), (size_t) 1, file)) {
had_err = -1;
}
if (!had_err) {
gt_log_log("bits to read: %llu", num_of_bits);
arguments->size = (unsigned long) GT_NUMOFINTSFORBITS(num_of_bits);
bits = gt_malloc(sizeof (*bits) * arguments->size);
if ((size_t) arguments->size !=
gt_xfread(bits, sizeof (*bits),
(size_t) arguments->size, file)) {
had_err = -1;
}
}
gt_xfclose(file);
}
else {
bits = gt_calloc(sizeof (*bits), (size_t) arguments->size);
num_of_bits = (unsigned long long) (GT_INTWORDSIZE * arguments->size);
if (arguments->fill_random) {
for (idx = 0; idx < arguments->size; idx++) {
bits[idx] =
(GtBitsequence) (0xAAAAAAAAAAAAAAAAUL ^ gt_rand_max(ULONG_MAX));
}
}
else {
for (idx = 0; idx < arguments->size; idx++)
bits[idx] = (GtBitsequence) (0xAAAAAAAAAAAAAAAAUL ^ idx);
}
}
if (!had_err) {
fp = gt_xtmpfp(filename);
gt_fa_xfclose(fp);
fp = NULL;
gt_log_log("filename: %s", gt_str_get(filename));
gt_log_log("size in words: %lu", arguments->size);
cbs = gt_compressed_bitsequence_new(
bits, arguments->samplerate,
(unsigned long) num_of_bits);
gt_log_log("original size in MB: %2.3f",
(sizeof (*bits) * arguments->size) / (1024.0 * 1024.0));
gt_log_log("compressed size in MB: %2.3f",
gt_compressed_bitsequence_size(cbs) / (1024.0 * 1024.0));
gt_log_log("popcount table size thereof in MB: %2.3f",
gt_popcount_tab_calculate_size(15U) / (1024.0 * 1024.0));
had_err = gt_compressed_bitsequence_write(cbs, gt_str_get(filename), err);
}
if (!had_err)
{
read_cbs =
gt_compressed_bitsequence_new_from_file(gt_str_get(filename), err);
if (read_cbs == NULL)
had_err = -1;
}
if (!had_err && bits != NULL && arguments->check_consistency) {
for (idx = 0; (unsigned long long) idx < num_of_bits; ++idx) {
int GT_UNUSED bit = gt_compressed_bitsequence_access(read_cbs, idx);
int GT_UNUSED original = GT_ISIBITSET(bits, idx) ? 1 : 0;
gt_assert(gt_compressed_bitsequence_access(cbs, idx) == bit);
gt_assert(original == bit);
}
}
gt_compressed_bitsequence_delete(cbs);
gt_compressed_bitsequence_delete(read_cbs);
gt_free(bits);
gt_str_delete(filename);
return had_err;
}
static GtOPrval parsemkfmindex(Mkfmcallinfo *mkfmcallinfo,
int argc,
const char **argv,
GtError *err)
{
GtOptionParser *op;
GtOption *option, *optionfmout;
GtOPrval oprval;
int parsed_args;
gt_error_check(err);
mkfmcallinfo->indexnametab = gt_str_array_new();
mkfmcallinfo->outfmindex = gt_str_new();
mkfmcallinfo->leveldesc = gt_str_new();
op = gt_option_parser_new("[option ...] -ii indexfile [...]",
"Compute FM-index.");
gt_option_parser_set_mail_address(op, "<*****@*****.**>");
optionfmout = gt_option_new_string("fmout",
"specify name of FM-index to be generated\n"
"(mandatory if more than one input index "
"is specified)",
mkfmcallinfo->outfmindex, NULL);
gt_option_parser_add_option(op, optionfmout);
option = gt_option_new_filename_array("ii", "specify indices to be used",
mkfmcallinfo->indexnametab);
gt_option_is_mandatory(option);
gt_option_parser_add_option(op, option);
option = gt_option_new_string("size",
"specify size (tiny, small, medium, big)",
mkfmcallinfo->leveldesc, "medium");
gt_option_parser_add_option(op, option);
option = gt_option_new_bool("noindexpos",
"store no index positions (hence the positions of\n"
"matches in the index cannot be retrieved)",
&mkfmcallinfo->noindexpos,false);
gt_option_parser_add_option(op, option);
oprval = gt_option_parser_parse(op, &parsed_args, argc, argv, gt_versionfunc,
err);
if (oprval == GT_OPTION_PARSER_OK)
{
if (!gt_option_is_set(optionfmout))
{
if (gt_str_array_size(mkfmcallinfo->indexnametab) > 1UL)
{
gt_error_set(err,"if more than one index is given, then "
"option -fmout is mandatory");
oprval = GT_OPTION_PARSER_ERROR;
} else
{
char *basenameptr;
basenameptr = gt_basename(gt_str_array_get(mkfmcallinfo->indexnametab,
0));
gt_str_set(mkfmcallinfo->outfmindex,basenameptr);
gt_free(basenameptr);
}
}
}
gt_option_parser_delete(op);
if (oprval == GT_OPTION_PARSER_OK && parsed_args != argc)
{
gt_error_set(err,"superfluous program parameters");
oprval = GT_OPTION_PARSER_ERROR;
}
return oprval;
}
bool gt_xrfcheck_info_option_used(const GtXRFCheckInfo *xci)
{
gt_assert(xci && xci->xrfcheck_option);
return gt_option_is_set(xci->xrfcheck_option);
}
static int gt_encseq2spm_arguments_check(int rest_argc,
void *tool_arguments,
GtError *err)
{
GtEncseq2spmArguments *arguments = tool_arguments;
bool haserr = false;
gt_error_check(err);
if (rest_argc != 0)
{
gt_error_set(err,"unnecessary arguments");
haserr = true;
}
if (!haserr && gt_str_length(arguments->spmspec) > 0)
{
const char *spmspecstring = gt_str_get(arguments->spmspec);
if (strcmp(spmspecstring,"show") == 0)
{
arguments->outputspms = true;
} else
{
if (strcmp(spmspecstring,"count") == 0)
{
arguments->countspms = true;
} else
{
gt_error_set(err,"illegal argument \"%s\" to option -spm",
spmspecstring);
haserr = true;
}
}
}
if (!haserr && gt_option_is_set(arguments->refoptionmemlimit))
{
if (gt_option_parse_spacespec(&arguments->maximumspace,
"memlimit",
arguments->memlimitarg,
err) != 0)
{
haserr = true;
}
if (!haserr && !gt_ma_bookkeeping_enabled()) {
gt_error_set(err, "option '-memlimit' requires "
"GT_MEM_BOOKKEEPING=on");
haserr = true;
}
}
if (!haserr && gt_option_is_set(arguments->refoptionphase2extra))
{
if (gt_option_parse_spacespec(&arguments->phase2extra,
"phase2extra",
arguments->phase2extraarg,
err) != 0)
{
haserr = true;
}
}
#ifdef GT_THREADS_ENABLED
if (!haserr) {
if (gt_jobs > 1 && gt_ma_bookkeeping_enabled()) {
gt_error_set(err, "gt option '-j' and GT_MEM_BOOKKEEPING=on "
"are incompatible");
haserr = true;
}
}
#endif
return haserr ? -1 : 0;
}
static int gt_tyr_occratio_arguments_check(int rest_argc,
void *tool_arguments,
GtError *err)
{
Tyr_occratio_options *arguments = tool_arguments;
bool haserr = false;
Optionargmodedesc outputmodedesctable[] =
{
{"unique","number of unique mers",TYROCC_OUTPUTUNIQUE},
{"nonunique","number of nonunique mers (single count)",
TYROCC_OUTPUTNONUNIQUE},
{"nonuniquemulti","number of nonunique mers (multi count)",
TYROCC_OUTPUTNONUNIQUEMULTI},
{"relative","fraction of unique/non-unique mers relative to all mers",
TYROCC_OUTPUTRELATIVE},
{"total","number of all mers",TYROCC_OUTPUTTOTAL}
};
if (rest_argc != 0)
{
gt_error_set(err,"superfluous arguments");
return -1;
}
if (gt_option_is_set(arguments->refoptionmersizes))
{
unsigned long *mersizes = NULL;
unsigned long idx,
numofmersizes = gt_str_array_size(arguments->mersizesstrings);
if (numofmersizes == 0)
{
gt_error_set(err,"missing argument to option -mersizes:");
haserr = true;
} else
{
mersizes = gt_malloc(sizeof(*mersizes) * numofmersizes);
for (idx=0; idx<numofmersizes; idx++)
{
long readnum;
if (sscanf(gt_str_array_get(arguments->mersizesstrings,idx),
"%ld",&readnum) != 1 || readnum <= 0)
{
gt_error_set(err,"invalid argument \"%s\" of option -mersizes: "
"must be a positive integer",
gt_str_array_get(arguments->mersizesstrings,idx));
haserr = true;
break;
}
mersizes[idx] = (unsigned long) readnum;
if (idx > 0 && mersizes[idx-1] >= mersizes[idx])
{
gt_error_set(err,"invalid argumnt %s to option -mersizes: "
"positive numbers must be strictly increasing",
gt_str_array_get(arguments->mersizesstrings,idx));
haserr = true;
break;
}
}
}
if (!haserr)
{
gt_assert(mersizes != NULL);
arguments->minmersize = mersizes[0];
arguments->maxmersize = mersizes[numofmersizes-1];
INITBITTAB(arguments->outputvector,arguments->maxmersize+1);
for (idx=0; idx<numofmersizes; idx++)
{
SETIBIT(arguments->outputvector,mersizes[idx]);
}
}
gt_free(mersizes);
} else
{
if (arguments->minmersize == 0)
{
gt_error_set(err,"if option -mersizes is not used, then option "
"-minmersize is mandatory");
haserr = true;
}
if (!haserr)
{
if (arguments->maxmersize == 0)
{
gt_error_set(err,"if option -mersizes is not used, then option "
"-maxmersize is mandatory");
haserr = true;
}
}
if (!haserr)
{
if (arguments->minmersize > arguments->maxmersize)
{
gt_error_set(err,"minimum mer size must not be larger than "
"maximum mer size");
haserr = true;
}
}
if (!haserr)
{
if (arguments->minmersize+arguments->stepmersize > arguments->maxmersize)
{
gt_error_set(err,"minimum mer size + step value must be smaller or "
"equal to maximum mersize");
haserr = true;
}
}
if (!haserr)
{
unsigned long outputval;
INITBITTAB(arguments->outputvector,arguments->maxmersize+1);
for (outputval = arguments->minmersize;
outputval <= arguments->maxmersize;
outputval += arguments->stepmersize)
{
SETIBIT(arguments->outputvector,outputval);
}
}
}
if (!haserr)
{
unsigned long idx;
for (idx=0; idx<gt_str_array_size(arguments->outputspec); idx++)
{
if (optionargaddbitmask(outputmodedesctable,
sizeof (outputmodedesctable)/
sizeof (outputmodedesctable[0]),
&arguments->outputmode,
"-output",
gt_str_array_get(arguments->outputspec,idx),
err) != 0)
{
haserr = true;
break;
}
}
}
if (!haserr)
{
if ((arguments->outputmode & TYROCC_OUTPUTRELATIVE) &&
!(arguments->outputmode &
(TYROCC_OUTPUTUNIQUE | TYROCC_OUTPUTNONUNIQUE |
TYROCC_OUTPUTNONUNIQUEMULTI)))
{
gt_error_set(err,"argument relative to option -output requires that one "
"of the arguments unique, nonunique, or nonuniquemulti "
"is used");
haserr = true;
}
}
return haserr ? - 1: 0;
}
static GtOPrval gthsplit_parse_options(int *parsed_args,
Gthsplitinfo *gthsplitinfo,
int argc, const char **argv,
const GthPlugins *plugins, GtError *err)
{
GtOptionParser *op;
GtOption *optalignmentscore, *optcoverage, *optrange, *optverbose, *optgzip,
*optbzip2, *optforce;
bool alignmentscore, coverage, verbose, gzip, bzip2;
GtOPrval oprval;
gt_error_check(err);
op = gt_option_parser_new("-alignmentscore | -coverage [option ...] "
"[file ...]", "Split GenomeThreader output files "
"containing intermediate results.");
/* specify all options with a corresponding help-text */
optalignmentscore = gt_option_new_bool("alignmentscore", "split according to "
"the overall alignment score (scr)",
&alignmentscore, false);
gt_option_parser_add_option(op, optalignmentscore);
optcoverage = gt_option_new_bool("coverage", "split according to coverage "
"(cov)", &coverage, false);
gt_option_parser_add_option(op, optcoverage);
optrange = gt_option_new_uint_max(RANGE_OPT_CSTR, "set the percentage range "
"used to create the sets",
>hsplitinfo->range, DEFAULT_RANGE, 100);
gt_option_parser_add_option(op, optrange);
/* add sa_filter options */
gth_sa_filter_register_options(op, gthsplitinfo->sa_filter, false);
/* -v */
optverbose = gt_option_new_verbose(&verbose);
gt_option_parser_add_option(op, optverbose);
optgzip = gt_option_new_bool("gzip", "write gzip compressed output file(s)",
&gzip, false);
gt_option_parser_add_option(op, optgzip);
optbzip2 = gt_option_new_bool("bzip2", "write bzip2 compressed output "
"file(s)", &bzip2, false);
gt_option_parser_add_option(op, optbzip2);
optforce = gt_option_new_bool(GT_FORCE_OPT_CSTR,"force writing to split "
"files", >hsplitinfo->force, false);
gt_option_parser_add_option(op, optforce);
gt_option_exclude(optalignmentscore, optcoverage);
gt_option_exclude(optgzip, optbzip2);
gt_option_is_mandatory_either(optalignmentscore, optcoverage);
gt_option_parser_set_mail_address(op, "<*****@*****.**>");
oprval = gt_option_parser_parse(op, parsed_args, argc, argv,
plugins->gth_version_func, err);
if (oprval == GT_OPTION_PARSER_OK && alignmentscore)
gthsplitinfo->splitmode = ALIGNMENTSCORE_SPLIT;
if (oprval == GT_OPTION_PARSER_OK && coverage)
gthsplitinfo->splitmode = COVERAGE_SPLIT;
if (oprval == GT_OPTION_PARSER_OK && 100 % gthsplitinfo->range) {
gt_error_set(err, "argument to option %s must divide 100 without rest",
RANGE_OPT_CSTR);
oprval = GT_OPTION_PARSER_ERROR;
}
if (oprval == GT_OPTION_PARSER_OK && verbose)
gthsplitinfo->showverbose = gth_show_on_stdout;
if (oprval == GT_OPTION_PARSER_OK && gzip)
gthsplitinfo->file_mode = GT_FILE_MODE_GZIP;
if (oprval == GT_OPTION_PARSER_OK && bzip2)
gthsplitinfo->file_mode = GT_FILE_MODE_BZIP2;
/* save consensus files */
if (oprval == GT_OPTION_PARSER_OK) {
while (*parsed_args < argc) {
gt_str_array_add_cstr(gthsplitinfo->consensusfiles, argv[*parsed_args]);
(*parsed_args)++;
}
}
if (oprval == GT_OPTION_PARSER_OK &&
!gt_str_array_size(gthsplitinfo->consensusfiles) &&
(gt_option_is_set(optgzip) || gt_option_is_set(optbzip2))) {
gt_error_set(err, "to use compression, at least on input file has to be "
"supplied");
oprval = GT_OPTION_PARSER_ERROR;
}
gt_option_parser_delete(op);
return oprval;
}
static int gt_matstat_arguments_check(GT_UNUSED int rest_argc,
void *tool_arguments, GtError *err)
{
Gfmsubcallinfo *arguments = tool_arguments;
int had_err = 0;
const Optionargmodedesc msgfmsubmodedesctable[] =
{
{"sequence","matching sequence",SHOWSEQUENCE},
{"querypos","position in query sequence",SHOWQUERYPOS},
{"subjectpos","position in subject sequence",SHOWSUBJECTPOS}
};
const Optionargmodedesc gfmsubmodedesctable[] =
{
{"sequence","matching sequence",SHOWSEQUENCE},
{"querypos","position in query sequence",SHOWQUERYPOS}
};
gt_error_check(err);
gt_assert(arguments);
if (gt_option_is_set(arguments->optionfmindex))
{
arguments->indextype = Fmindextype;
} else
{
if (gt_option_is_set(arguments->optionesaindex))
{
arguments->indextype = Esaindextype;
} else
{
if (gt_option_is_set(arguments->optionpckindex))
{
arguments->indextype = Packedindextype;
} else
{
gt_error_set(err,"one of the options -esa, -pck must be used");
return -1;
}
}
}
if (gt_option_is_set(arguments->optionmin))
{
arguments->minlength.defined = true;
}
if (gt_option_is_set(arguments->optionmax))
{
arguments->maxlength.defined = true;
}
if (!gt_option_is_set(arguments->optionmin) &&
!gt_option_is_set(arguments->optionmax))
{
gt_error_set(err,"one of the options -min or -max must be set");
return -1;
}
if (arguments->minlength.defined &&
arguments->maxlength.defined)
{
if (arguments->maxlength.valueunsignedlong <
arguments->minlength.valueunsignedlong)
{
gt_error_set(err,"minvalue must be smaller or equal than maxvalue");
return -1;
}
}
if (gt_option_is_set(arguments->optionoutput))
{
if (gt_str_array_size(arguments->flagsoutputoption) == 0)
{
gt_error_set(err,"missing arguments to option -output");
return -1;
} else
{
GtUword i;
for (i=0; i<gt_str_array_size(arguments->flagsoutputoption); i++)
{
if (arguments->doms)
{
if (gt_optionargaddbitmask(msgfmsubmodedesctable,
sizeof (msgfmsubmodedesctable)/
sizeof (msgfmsubmodedesctable[0]),
&arguments->showmode,
"-output",
gt_str_array_get(arguments->flagsoutputoption,
i),
err) != 0)
{
return -1;
}
} else
{
if (gt_optionargaddbitmask(gfmsubmodedesctable,
sizeof (gfmsubmodedesctable)/
sizeof (gfmsubmodedesctable[0]),
&arguments->showmode,
"-output",
gt_str_array_get(arguments->flagsoutputoption,
i),
err) != 0)
{
return -1;
}
}
}
}
}
return had_err;
}
