static GtOptionParser* gt_cds_option_parser_new(void *tool_arguments)
{
CDSArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option;
gt_assert(arguments);
op = gt_option_parser_new("[option ...] [GFF3_file]",
"Add CDS (coding sequence) features to exon "
"features given in GFF3 file.");
/* -minorflen */
option = gt_option_new_uint_min("minorflen", "set the minimum length an open "
"reading frame (ORF) must have to be added "
"as a CDS feature (measured in amino acids)",
&arguments->minorflen, 64, 1);
gt_option_parser_add_option(op, option);
/* -startcodon */
option = gt_option_new_bool("startcodon", "require than an ORF must begin "
"with a start codon", &arguments->start_codon,
false);
gt_option_parser_add_option(op, option);
/* -finalstopcodon */
option = gt_option_new_bool("finalstopcodon", "require that the final ORF "
"must end with a stop codon",
&arguments->final_stop_codon, false);
gt_option_parser_add_option(op, option);
/* -genericstartcodons */
option = gt_option_new_bool("genericstartcodons", "use generic start codons",
&arguments->generic_start_codons, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -seqfile, -matchdesc, -usedesc and -regionmapping */
gt_seqid2file_register_options(op, arguments->s2fi);
/* -v */
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
/* output file options */
gt_outputfile_register_options(op, &arguments->outfp, arguments->ofi);
gt_option_parser_set_comment_func(op, gt_gtdata_show_help, NULL);
gt_option_parser_set_max_args(op, 1);
return op;
}
static GtOptionParser* gt_splitfasta_option_parser_new(void *tool_arguments)
{
SplitfastaArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *targetsize_option, *splitdesc_option, *o, *numfiles_option;
gt_assert(arguments);
op = gt_option_parser_new("[option ...] fastafile","Split the supplied fasta "
"file.");
numfiles_option = gt_option_new_uint_min("numfiles",
"set the number of target files "
"",
&arguments->num_files, 0,
1);
gt_option_parser_add_option(op, numfiles_option);
targetsize_option = gt_option_new_ulong_min("targetsize",
"set the target file "
"size in MB",
&arguments->max_filesize_in_MB,
50, 1);
gt_option_parser_add_option(op, targetsize_option);
splitdesc_option = gt_option_new_string("splitdesc",
"put every fasta entry in "
"a separate file named by its "
"description in the given directory",
arguments->splitdesc, NULL);
gt_option_parser_add_option(op, splitdesc_option);
gt_option_exclude(targetsize_option, splitdesc_option);
gt_option_exclude(numfiles_option, splitdesc_option);
gt_option_exclude(numfiles_option, targetsize_option);
o = gt_option_new_width(&arguments->width);
gt_option_parser_add_option(op, o);
o = gt_option_new_bool(GT_FORCE_OPT_CSTR, "force writing to output file",
&arguments->force, false);
gt_option_parser_add_option(op, o);
gt_option_parser_set_min_max_args(op, 1, 1);
return op;
}
static GtOptionParser *gt_repfind_option_parser_new(void *tool_arguments)
{
GtOptionParser *op;
GtOption *option, *reverseoption, *queryoption, *extendseedoption,
*scanoption, *sampleoption, *forwardoption, *spmoption;
Maxpairsoptions *arguments = tool_arguments;
op = gt_option_parser_new("[options] -ii indexname",
"Compute maximal repeats.");
gt_option_parser_set_mail_address(op,"<*****@*****.**>");
option = gt_option_new_uint_min("l","Specify minimum length of repeats",
&arguments->userdefinedleastlength,
20U,
1U);
gt_option_parser_add_option(op, option);
forwardoption = gt_option_new_bool("f","Compute maximal forward repeats",
&arguments->forward,
true);
gt_option_parser_add_option(op, forwardoption);
arguments->refforwardoption = gt_option_ref(forwardoption);
reverseoption = gt_option_new_bool("r","Compute maximal reverse matches",
&arguments->reverse,
false);
gt_option_parser_add_option(op, reverseoption);
sampleoption = gt_option_new_uword_min("samples","Specify number of samples",
&arguments->samples,
0,
1UL);
gt_option_is_development_option(sampleoption);
gt_option_parser_add_option(op, sampleoption);
spmoption = gt_option_new_bool("spm","Search for suffix prefix matches",
&arguments->searchspm,
false);
gt_option_is_development_option(spmoption);
gt_option_parser_add_option(op, spmoption);
extendseedoption = gt_option_new_bool("extend","Extend seed to both sides",
&arguments->extendseed,
false);
gt_option_is_development_option(extendseedoption);
gt_option_parser_add_option(op, extendseedoption);
scanoption = gt_option_new_bool("scan","scan index rather than mapping "
"it to main memory",
&arguments->scanfile,
false);
gt_option_parser_add_option(op, scanoption);
option = gt_option_new_string("ii",
"Specify input index",
arguments->indexname, NULL);
gt_option_parser_add_option(op, option);
gt_option_is_mandatory(option);
queryoption = gt_option_new_filename_array("q",
"Specify query files",
arguments->queryfiles);
gt_option_is_development_option(queryoption);
gt_option_parser_add_option(op, queryoption);
option = gt_option_new_bool("v",
"be verbose ",
&arguments->beverbose,
false);
gt_option_parser_add_option(op, option);
gt_option_exclude(queryoption,sampleoption);
gt_option_exclude(queryoption,scanoption);
gt_option_exclude(queryoption,reverseoption);
gt_option_exclude(queryoption,spmoption);
gt_option_exclude(reverseoption,spmoption);
gt_option_exclude(queryoption,spmoption);
gt_option_exclude(sampleoption,spmoption);
return op;
}
static GtIndexOptions* gt_index_options_register_generic_create(
GtOptionParser *op,
GtIndexOptionsIndexType t)
{
GtIndexOptions *idxo;
gt_assert(op != NULL && t != GT_INDEX_OPTIONS_UNDEFINED);
idxo = gt_index_options_new();
idxo->type = t;
idxo->optionprefixlength = gt_option_new_uint_min("pl",
"specify prefix length for bucket sort\n"
"recommendation: use without argument;\n"
"then a reasonable prefix length is "
"automatically determined.",
&idxo->prefixlength,
GT_PREFIXLENGTH_AUTOMATIC,
1U);
gt_option_argument_is_optional(idxo->optionprefixlength);
gt_option_parser_add_option(op, idxo->optionprefixlength);
idxo->optionuserdefinedsortmaxdepth
= gt_option_new_uint_min("sortmaxdepth","sort only up to the given depth.",
&idxo->sfxstrategy.userdefinedsortmaxdepth,
0,
1U);
gt_option_parser_add_option(op, idxo->optionuserdefinedsortmaxdepth);
gt_option_is_development_option(idxo->optionuserdefinedsortmaxdepth);
idxo->optiondifferencecover = gt_option_new_uint_min("dc",
"specify difference cover value",
&idxo->sfxstrategy.differencecover,
0,
4U);
gt_option_parser_add_option(op, idxo->optiondifferencecover);
gt_option_exclude(idxo->optionuserdefinedsortmaxdepth,
idxo->optiondifferencecover);
idxo->optioncmpcharbychar = gt_option_new_bool("cmpcharbychar",
"compare suffixes character "
"by character",
&idxo->sfxstrategy.cmpcharbychar,
false);
gt_option_is_development_option(idxo->optioncmpcharbychar);
gt_option_parser_add_option(op, idxo->optioncmpcharbychar);
idxo->optionnoshortreadsort = gt_option_new_bool("noshortreadsort",
"do not use short read sort",
&idxo->sfxstrategy.noshortreadsort,
false);
gt_option_is_development_option(idxo->optionnoshortreadsort);
gt_option_parser_add_option(op, idxo->optionnoshortreadsort);
idxo->optionmaxwidthrealmedian = gt_option_new_uword("maxwidthrealmedian",
"compute real median for "
"intervals of at most the "
"given widthprefixes",
&idxo->sfxstrategy.
maxwidthrealmedian,
1UL);
gt_option_is_development_option(idxo->optionmaxwidthrealmedian);
gt_option_parser_add_option(op, idxo->optionmaxwidthrealmedian);
idxo->optionalgbounds
= gt_option_new_string_array("algbds",
"length boundaries for the different "
"algorithms to sort buckets of suffixes\n"
"first number: maxbound for insertion sort\n"
"second number: maxbound for blindtrie sort\n"
"third number: maxbound for counting sort",
idxo->algbounds);
gt_option_is_development_option(idxo->optionalgbounds);
gt_option_parser_add_option(op, idxo->optionalgbounds);
idxo->optionstorespecialcodes
= gt_option_new_bool("storespecialcodes",
"store special codes (this may speed up the program)",
&idxo->sfxstrategy.storespecialcodes,false);
gt_option_is_development_option(idxo->optionstorespecialcodes);
gt_option_parser_add_option(op, idxo->optionstorespecialcodes);
idxo->optionparts
= gt_option_new_uint_max("parts",
"specify number of parts in which the index "
"construction is performed",
&idxo->numofparts, 1U, (unsigned) ((1 << 22) - 1));
gt_option_is_development_option(idxo->optionparts);
gt_option_parser_add_option(op, idxo->optionparts);
if (idxo->type == GT_INDEX_OPTIONS_ESA)
{
idxo->optionspmopt = gt_option_new_uint_min("spmopt",
"optimize esa-construction for "
"suffix-prefix matching",
&idxo->sfxstrategy.spmopt_minlength,
0,1U);
gt_option_parser_add_option(op, idxo->optionspmopt);
gt_option_exclude(idxo->optionspmopt, idxo->optiondifferencecover);
idxo->optionmemlimit = gt_option_new_string("memlimit",
"specify maximal amount of memory to be used during "
"index construction (in bytes, the keywords 'MB' "
"and 'GB' are allowed)",
idxo->memlimit, NULL);
gt_option_parser_add_option(op, idxo->optionmemlimit);
gt_option_exclude(idxo->optionmemlimit, idxo->optionparts);
}
idxo->option = gt_option_new_bool("iterscan",
"use iteratorbased-kmer scanning",
&idxo->sfxstrategy.iteratorbasedkmerscanning,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("samplewithprefixlengthnull",
"sort sample with prefixlength=0",
&idxo->sfxstrategy.samplewithprefixlengthnull,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("suftabuint",
"use uint32_t for suftab",
&idxo->sfxstrategy.suftabuint,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("onlybucketinsertion",
"perform only bucket insertion",
&idxo->sfxstrategy.onlybucketinsertion,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("kmerswithencseqreader",
"always perform kmerscanning with encseq-reader",
&idxo->sfxstrategy.kmerswithencseqreader,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("dccheck",
"check intermediate results in difference cover",
&idxo->sfxstrategy.dccheck,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("withradixsort",
"use radixsort to sort the buckets",
&idxo->sfxstrategy.withradixsort,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
idxo->option = gt_option_new_bool("compressedoutput",
"output suftab and lcptab in compressed "
"form",
&idxo->sfxstrategy.compressedoutput,
false);
gt_option_is_development_option(idxo->option);
gt_option_parser_add_option(op, idxo->option);
gt_option_parser_register_hook(op, gt_index_options_check_set_create_opts,
idxo);
return idxo;
}
static GtOptionParser* gt_readjoiner_assembly_option_parser_new(
void *tool_arguments)
{
GtReadjoinerAssemblyArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option, *errors_option, *deadend_option, *v_option,
*q_option, *bubble_option, *deadend_depth_option;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...]",
"Construct string graph and output contigs.");
/* -readset */
option = gt_option_new_string("readset", "specify the readset name",
arguments->readset, NULL);
gt_option_parser_add_option(op, option);
gt_option_is_mandatory(option);
/* -spmfiles */
option = gt_option_new_uint_min("spmfiles", "number of SPM files to read\n"
"this must be equal to the value of -j for the overlap phase",
&arguments->nspmfiles, 1U, 1U);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -l */
option = gt_option_new_uint_min("l", "specify the minimum SPM length",
&arguments->minmatchlength, 0, 2U);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -depthcutoff */
option = gt_option_new_uint_min("depthcutoff", "specify the minimal "
"number of nodes in a contig",
&arguments->depthcutoff, 3U, 1U);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -lengthcutoff */
option = gt_option_new_uint_min("lengthcutoff", "specify the minimal "
"length of a contig",
&arguments->lengthcutoff, 100U, 1U);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -redtrans */
option = gt_option_new_bool("redtrans", "reduce transitive edges",
&arguments->redtrans, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -errors */
errors_option = gt_option_new_bool("errors", "search graph features which "
"may originate from sequencing errors and remove them",
&arguments->errors, false);
gt_option_is_extended_option(errors_option);
gt_option_parser_add_option(op, errors_option);
/* -bubble */
bubble_option = gt_option_new_uint("bubble", "number of rounds of p-bubble "
"removal to perform", &arguments->bubble, 3U);
gt_option_is_extended_option(bubble_option);
gt_option_imply(bubble_option, errors_option);
gt_option_parser_add_option(op, bubble_option);
/* -deadend */
deadend_option = gt_option_new_uint("deadend", "number of rounds of "
"dead end removal to perform a dead end",
&arguments->deadend, 10U);
gt_option_is_extended_option(deadend_option);
gt_option_imply(deadend_option, errors_option);
gt_option_parser_add_option(op, deadend_option);
/* -deadend-depth */
deadend_depth_option = gt_option_new_uint_min("deadend-depth", "specify the "
"maximal depth of a path to an end-vertex by which the path shall be "
"considered a dead end",
&arguments->deadend_depth, 10U, 1U);
gt_option_is_extended_option(deadend_depth_option);
gt_option_imply(deadend_depth_option, errors_option);
gt_option_parser_add_option(op, deadend_depth_option);
/* -paths2seq */
option = gt_option_new_bool("paths2seq", "read <indexname>"
GT_READJOINER_SUFFIX_CONTIG_PATHS " and write "
"<indexname>" GT_READJOINER_SUFFIX_CONTIGS,
&arguments->paths2seq, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -buffersize */
option = gt_option_new_string("buffersize", "specify size for read buffer"
" of paths2seq phase (in bytes, the keywords 'MB' and 'GB' are allowed)",
arguments->buffersizearg, NULL);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
arguments->refoptionbuffersize = gt_option_ref(option);
/* -vd */
option = gt_option_new_bool("vd", "use verbose descriptions for contigs",
&arguments->vd, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -astat */
option = gt_option_new_bool("astat", "calculate A-statistics for each contig",
&arguments->astat, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -cov */
option = gt_option_new_double("cov", "average coverage value to use for the "
"A-statistics calculation", &arguments->coverage, (double)0);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -copynum */
option = gt_option_new_bool("copynum", "load reads copy numbers list from "
"file for the A-statistics calculation",
&arguments->copynum, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -v */
v_option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, v_option);
/* -q */
q_option = gt_option_new_bool("q", "suppress standard output messages",
&arguments->quiet, false);
gt_option_parser_add_option(op, q_option);
gt_option_exclude(q_option, v_option);
/* -load */
option = gt_option_new_bool("load", "save the string graph from file",
&arguments->load, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -save */
option = gt_option_new_bool("save", "save the string graph to file",
&arguments->save, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -show_contigs_info */
option = gt_option_new_bool("cinfo", "output additional files required "
"for contigs graph construction (eqlen only)",
&arguments->show_contigs_info, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
gt_option_parser_set_version_func(op, gt_readjoiner_show_version);
gt_option_parser_set_max_args(op, 0);
return op;
}
static GtOptionParser*
gt_condenseq_compress_option_parser_new(void *tool_arguments)
{
GtCondenseqCompressArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option,
*option_fraction;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[options] INPUTENCSEQ",
"Compresses a GtEncseq to a UniqueEncseq.");
/* -indexname */
option = gt_option_new_string("indexname",
"path and basename of files to store",
arguments->indexname, NULL);
gt_option_parser_add_option(op, option);
/* -kmersize */
option = gt_option_new_uint_min("kmersize",
"kmer-size used for the seeds, default "
"depends on alphabet size",
&arguments->kmersize, GT_UNDEF_UINT, 2U);
gt_option_parser_add_option(op, option);
/* -windowsize */
option = gt_option_new_uint("windowsize",
"Size of window in which to search for hit pairs "
"of kmers, has to be larger than kmersize" ,
&arguments->windowsize, GT_UNDEF_UINT);
gt_option_parser_add_option(op, option);
/* -initsize */
option = gt_option_new_uword("initsize",
"length of inital unique database in bases, "
"should be larger than -alignlength",
&arguments->initsize, GT_UNDEF_UWORD);
gt_option_parser_add_option(op, option);
/* -alignlength */
option = gt_option_new_uword("alignlength",
"required minimal length of an xdrop-alignment, "
"should be larger than -windowsize",
&arguments->minalignlength, GT_UNDEF_UWORD);
gt_option_parser_add_option(op, option);
/* -cutoff */
option = gt_option_new_uword("cutoff",
"if a kmer is found more often than this value "
"it will be ignored for alignment searches. "
"Setting this to 0 will disable cutoffs, "
"leaving it undefined will use a cutoff based "
"on the mean number of occurences of a k-word.",
&arguments->cutoff_value, GT_UNDEF_UWORD);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -fraction */
option_fraction = gt_option_new_uword("fraction",
"when cutoffs aren'd disabled and no specific "
"value is set the mean number of occurrences "
"of each kmer divided by -fraction will be used "
"as cutoff",
&arguments->fraction, (GtUword) 2);
gt_option_is_extended_option(option_fraction);
gt_option_exclude(option, option_fraction);
gt_option_parser_add_option(op, option_fraction);
/* -disable_prune */
option = gt_option_new_bool("disable_prune",
"when cutoffs and this option are set, "
"the database will still save every kmer, even "
"though only cutoff many kmers will be used.",
&arguments->prune, false);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -mat */
option = gt_option_new_int("mat",
"matchscore for extension-alignment, "
"requirements: mat > mis, mat > 2ins, mat > 2del",
&arguments->scores.mat, 2);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -mis */
option = gt_option_new_int("mis",
"mismatchscore for extension-alignment, ",
&arguments->scores.mis, -1);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -ins */
option = gt_option_new_int("ins",
"insertionscore for extension-alignment",
&arguments->scores.ins, -2);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -del */
option = gt_option_new_int("del",
"deletionscore for extension-alignment",
&arguments->scores.del, -2);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -xdrop */
option = gt_option_new_word("xdrop",
"xdrop score for extension-alignment",
&arguments->xdrop, (GtWord) 3);
gt_option_is_extended_option(option);
gt_option_parser_add_option(op, option);
/* -brute_force */
option = gt_option_new_bool("brute_force", "disable filtering of seeds. "
"Incompatible with -diagonals yes "
"or -full_diags yes",
&arguments->brute, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -diagonals */
option = gt_option_new_bool("diagonals", "use sparse diagonals. "
"Incompatible with -brute_force yes. "
"Disabling both diagonals will result in simple "
"filtering of seed positions.",
&arguments->diags, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -full_diags */
option = gt_option_new_bool("full_diags", "use full (time efficient "
"space inefficient) diagonals. "
"Incompatible with -brute_force yes. "
"Disabling both diagonals will result in simple "
"filtering of seed positions.",
&arguments->full_diags, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -clean_percent */
option = gt_option_new_uint("diags_clean",
"Percentage of sparse diagonals that is allowed "
"to be marked as deletable. Sensible default is "
"set." ,
&arguments->clean_percent, GT_UNDEF_UINT);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -verbose */
option = gt_option_new_bool("verbose", "enable verbose output",
&arguments->verbose, false);
gt_option_parser_add_option(op, option);
/* -kdb*/
option = gt_option_new_bool("kdb", "prints out the kmer database (frequency "
"of each kmer), if -verbose each startposition "
"will be shown instead",
&arguments->kdb, false);
gt_option_parser_add_option(op, option);
return op;
}
static GtOptionParser* gt_sketch_option_parser_new(void *tool_arguments)
{
GtSketchArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option, *option2;
static const char *formats[] = { "png",
#ifdef CAIRO_HAS_PDF_SURFACE
"pdf",
#endif
#ifdef CAIRO_HAS_SVG_SURFACE
"svg",
#endif
#ifdef CAIRO_HAS_PS_SURFACE
"ps",
#endif
NULL
};
static const char *inputs[] = {
"gff",
"bed",
"gtf",
NULL
};
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...] image_file [GFF3_file ...]",
"Create graphical representation of GFF3 "
"annotation files.");
/* -pipe */
option = gt_option_new_bool("pipe", "use pipe mode (i.e., show all gff3 "
"features on stdout)", &arguments->pipe, false);
gt_option_parser_add_option(op, option);
/* -flattenfiles */
option = gt_option_new_bool("flattenfiles", "do not group tracks by source "
"file name and remove file names from track "
"description", &arguments->flattenfiles, false);
gt_option_parser_add_option(op, option);
/* -seqid */
option = gt_option_new_string("seqid", "sequence region identifier\n"
"default: first one in file",
arguments->seqid, NULL);
gt_option_parser_add_option(op, option);
gt_option_hide_default(option);
/* -start */
option = gt_option_new_uword_min("start", "start position\n"
"default: first region start",
&arguments->start, GT_UNDEF_UWORD, 1);
gt_option_parser_add_option(op, option);
gt_option_hide_default(option);
/* -end */
option2 = gt_option_new_uword("end", "end position\ndefault: last region end",
&arguments->end, GT_UNDEF_UWORD);
gt_option_parser_add_option(op, option2);
/* -start and -end must be given together */
gt_option_imply(option, option2);
gt_option_imply(option2, option);
gt_option_hide_default(option2);
/* -width */
option = gt_option_new_uint_min("width", "target image width (in pixel)",
&arguments->width,
800, 1);
gt_option_parser_add_option(op, option);
/* -style */
option = gt_option_new_string("style", "style file to use",
arguments->stylefile,
gt_str_get(arguments->stylefile));
gt_option_parser_add_option(op, option);
/* -format */
option = gt_option_new_choice("format", "output graphics format\n"
"choose from png"
#ifdef CAIRO_HAS_PDF_SURFACE
"|pdf"
#endif
#ifdef CAIRO_HAS_SVG_SURFACE
"|svg"
#endif
#ifdef CAIRO_HAS_PS_SURFACE
"|ps"
#endif
"",
arguments->format, formats[0], formats);
gt_option_parser_add_option(op, option);
/* -input */
option = gt_option_new_choice("input", "input data format\n"
"choose from gff|bed|gtf",
arguments->input, inputs[0], inputs);
gt_option_parser_add_option(op, option);
/* -addintrons */
option = gt_option_new_bool("addintrons", "add intron features between "
"existing exon features (before drawing)",
&arguments->addintrons, false);
gt_option_parser_add_option(op, option);
/* -unsafe */
option = gt_option_new_bool("unsafe", "enable unsafe mode for style file",
&arguments->unsafe, false);
gt_option_parser_add_option(op, option);
/* -showrecmaps */
option = gt_option_new_bool("showrecmaps",
"show RecMaps after image creation",
&arguments->showrecmaps, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -streams */
option = gt_option_new_bool("streams", "use streams to write data to file",
&arguments->use_streams, false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
/* -v */
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
/* -force */
option = gt_option_new_bool(GT_FORCE_OPT_CSTR, "force writing to output file",
&arguments->force, false);
gt_option_parser_add_option(op, option);
gt_option_parser_set_min_args(op, 1);
return op;
}
static GtOptionParser* gt_encseq2spm_option_parser_new(void *tool_arguments)
{
GtEncseq2spmArguments *arguments = tool_arguments;
GtOptionParser *op;
GtOption *option, *optionparts, *optionmemlimit;
gt_assert(arguments);
/* init */
op = gt_option_parser_new("[option ...] [file]",
"Compute suffix prefix matches "
"from encoded sequence.");
/* -l */
option = gt_option_new_uint_min("l", "specify the minimum length",
&arguments->minmatchlength, 0, 1U);
gt_option_parser_add_option(op, option);
gt_option_is_mandatory(option);
/* -parts */
optionparts = gt_option_new_uint("parts", "specify the number of parts",
&arguments->numofparts, 0U);
gt_option_parser_add_option(op, optionparts);
/* -memlimit */
optionmemlimit = gt_option_new_string("memlimit",
"specify maximal amount of memory to be used during "
"index construction (in bytes, the keywords 'MB' "
"and 'GB' are allowed)",
arguments->memlimitarg, NULL);
gt_option_parser_add_option(op, optionmemlimit);
gt_option_exclude(optionmemlimit, optionparts);
arguments->refoptionmemlimit = gt_option_ref(optionmemlimit);
/* -checksuftab */
option = gt_option_new_bool("checksuftab", "check the suffix table",
&arguments->checksuftab, false);
gt_option_parser_add_option(op, option);
gt_option_is_development_option(option);
/* -singlestrand */
option = gt_option_new_bool("singlestrand", "use only the forward strand "
"of the sequence",
&arguments->singlestrand, false);
gt_option_parser_add_option(op, option);
/* -spm */
option = gt_option_new_string("spm", "specify output for spms",
arguments->spmspec, NULL);
gt_option_parser_add_option(op, option);
/* -ii */
option = gt_option_new_string("ii", "specify the input sequence",
arguments->encseqinput, NULL);
gt_option_parser_add_option(op, option);
gt_option_is_mandatory(option);
/* -onlyaccum */
option = gt_option_new_bool("onlyaccum", "only accumulate codes",
&arguments->onlyaccum, false);
gt_option_parser_add_option(op, option);
gt_option_is_development_option(option);
/* -onlyallfirstcodes */
option = gt_option_new_bool("onlyallfirstcodes", "only determines allcodes",
&arguments->onlyallfirstcodes, false);
gt_option_parser_add_option(op, option);
gt_option_is_development_option(option);
/* -addbscachedepth */
option = gt_option_new_uint("addbscachedepth", "only determines allcodes",
&arguments->addbscache_depth, 5U);
gt_option_parser_add_option(op, option);
gt_option_is_development_option(option);
/* -phase2extra */
option = gt_option_new_string("phase2extra",
"specify amount of additional space required for "
"the second phase of the computation involving the "
"processing of the intervals (in bytes, "
"the keywords 'MB' and 'GB' are allowed)",
arguments->phase2extraarg, NULL);
gt_option_parser_add_option(op, option);
arguments->refoptionphase2extra = gt_option_ref(option);
gt_option_is_development_option(option);
/* -radixlarge */
option = gt_option_new_bool("radixlarge", "use large tables for radixsort",
&arguments->radixlarge, false);
gt_option_parser_add_option(op, option);
gt_option_is_development_option(option);
/* -radixparts */
option = gt_option_new_uint("radixparts", "specify the number of parts "
"for radixsort",
&arguments->radixparts, 1U);
gt_option_parser_add_option(op, option);
gt_option_is_development_option(option);
/* -singlescan */
option = gt_option_new_uint("singlescan", "run a single scan: 1=fast; "
"2=fast with check; 3=fast with output; "
"4=sfx-mapped4-version",
&arguments->singlescan, 0);
gt_option_parser_add_option(op, option);
gt_option_is_development_option(option);
/* -forcek */
option = gt_option_new_uint("forcek", "specify the value of k",
&arguments->forcek, 0);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
return op;
}
static GtOptionParser *gt_tyr_mkindex_option_parser_new(void *tool_arguments)
{
GtOptionParser *op;
GtOption *option,
*optionminocc,
*optionmaxocc,
*optionpl,
*optionstoreindex,
*optionstorecounts,
*optionscan,
*optionesa;
Tyr_mkindex_options *arguments = tool_arguments;
op = gt_option_parser_new("[options] -esa suffixerator-index [options]",
"Count and index k-mers in the given enhanced "
"suffix array for a fixed value of k.");
gt_option_parser_set_mailaddress(op,"<*****@*****.**>");
optionesa = gt_option_new_string("esa","specify suffixerator-index\n"
"(mandatory option)",
arguments->str_inputindex,
NULL);
gt_option_is_mandatory(optionesa);
gt_option_parser_add_option(op, optionesa);
option = gt_option_new_ulong("mersize",
"Specify the mer size.",
&arguments->mersize,
20UL);
gt_option_parser_add_option(op, option);
optionminocc
= gt_option_new_ulong("minocc",
"Specify the minimum occurrence number for "
"the mers to output/index",
&arguments->userdefinedminocc,
0);
gt_option_parser_add_option(op, optionminocc);
optionmaxocc
= gt_option_new_ulong("maxocc",
"Specify the maximum occurrence number for "
"the mers to output/index",
&arguments->userdefinedmaxocc,
0);
gt_option_parser_add_option(op, optionmaxocc);
optionpl = gt_option_new_uint_min("pl",
"specify prefix length for bucket boundary construction\n"
"recommendation: use without argument;\n"
"then a reasonable prefix length is automatically determined",
&arguments->userdefinedprefixlength,
0,
1U);
gt_option_argument_is_optional(optionpl);
gt_option_parser_add_option(op, optionpl);
arguments->refoptionpl = gt_option_ref(optionpl);
optionstoreindex = gt_option_new_string("indexname",
"store the mers specified by options "
"-maxocc and -minocc in an index",
arguments->str_storeindex, NULL);
gt_option_parser_add_option(op, optionstoreindex);
optionstorecounts = gt_option_new_bool("counts", "store counts of the mers",
&arguments->storecounts,false);
gt_option_parser_add_option(op, optionstorecounts);
option = gt_option_new_bool("test", "perform tests to verify program "
"correctness", &arguments->performtest,
false);
gt_option_is_development_option(option);
gt_option_parser_add_option(op, option);
optionscan = gt_option_new_bool("scan",
"read enhanced suffix array sequentially "
"instead of mapping it to memory",
&arguments->scanfile,
false);
gt_option_parser_add_option(op, optionscan);
option = gt_option_new_verbose(&arguments->verbose);
gt_option_parser_add_option(op, option);
gt_option_imply(optionpl, optionstoreindex);
gt_option_imply(optionstorecounts, optionstoreindex);
gt_option_imply_either_2(optionstoreindex,optionminocc,optionmaxocc);
return op;
}
static GtOptionParser* gtr_option_parser_new(GtR *gtr)
{
GtOptionParser *op;
GtOption *o, *only_option, *debug_option, *debugfp_option;
gt_assert(gtr);
op = gt_option_parser_new("[option ...] [tool | script] [argument ...]",
"The GenomeTools genome analysis system.");
gt_option_parser_set_comment_func(op, show_gtr_help, gtr->tools);
o = gt_option_new_bool("i",
"enter interactive mode after executing 'tool' or "
"'script'", >r->interactive, false);
gt_option_hide_default(o);
gt_option_parser_add_option(op, o);
o = gt_option_new_bool("q", "suppress warnings", >r->quiet, false);
gt_option_hide_default(o);
gt_option_parser_add_option(op, o);
o = gt_option_new_uint_min("j", "set number of parallel threads used at once",
>_jobs, 1, 1);
gt_option_is_development_option(o);
gt_option_parser_add_option(op, o);
o = gt_option_new_bool("test", "perform unit tests and exit", >r->test,
false);
gt_option_hide_default(o);
gt_option_parser_add_option(op, o);
only_option = gt_option_new_string("only", "perform single unit test "
"(requires -test)", gtr->test_only, "");
gt_option_imply(only_option, o);
gt_option_is_development_option(only_option);
gt_option_hide_default(only_option);
gt_option_parser_add_option(op, only_option);
debug_option = gt_option_new_debug(>r->debug);
gt_option_parser_add_option(op, debug_option);
debugfp_option = gt_option_new_string("debugfp",
"set file pointer for debugging output\n"
"use ``stdout'' for standard output\n"
"use ``stderr'' for standard error\n"
"or any other string to use the "
"corresponding file (will be overwritten "
"without warning!)", gtr->debugfp,
"stderr");
gt_option_is_development_option(debugfp_option);
gt_option_parser_add_option(op, debugfp_option);
gt_option_imply(debugfp_option, debug_option);
o = gt_option_new_uint("seed",
"set seed for random number generator manually.\n"
"0 generates a seed from current time and process id",
>r->seed, gtr->seed);
gt_option_hide_default(o);
gt_option_parser_add_option(op, o);
o = gt_option_new_bool("64bit", "exit with code 0 if this is a 64bit binary, "
"with 1 otherwise", >r->check64bit, false);
gt_option_is_development_option(o);
gt_option_parser_add_option(op, o);
o = gt_option_new_bool("list", "list all tools and exit", >r->list, false);
gt_option_is_development_option(o);
gt_option_hide_default(o);
gt_option_parser_add_option(op, o);
o = gt_option_new_filename("testspacepeak", "alloc 64 MB and mmap the given "
"file", gtr->testspacepeak);
gt_option_is_development_option(o);
gt_option_parser_add_option(op, o);
o = gt_option_new_string("createman", "create man page sources in directory",
gtr->manoutdir, "");
gt_option_is_development_option(o);
gt_option_parser_add_option(op, o);
return op;
}
