static int construct_bioseq_files(GtBioseq *bs, GtStr *bioseq_indexname,
GtError *err)
{
GtStr *sequence_filename;
GtEncseqEncoder *ee;
GtStrArray *indexfn;
int had_err = 0;
gt_error_check(err);
/* register the signal handler to remove incomplete files upon termination */
if (!bs->use_stdin) {
gt_bioseq_index_filename = gt_str_get(bs->sequence_file);
gt_sig_register_all(remove_bioseq_files);
}
/* if stdin is used as input, we need to create a tempfile containing the
sequence as GtEncseq cannot be built from stdin directly */
if (bs->use_stdin) {
GtStr *tmpfilename;
FILE *tmpfile = NULL;
int i;
char buf[BUFSIZ];
tmpfilename = gt_str_new();
tmpfile = gt_xtmpfp(tmpfilename);
gt_assert(tmpfile);
i = 1;
while (i > 0) {
i = fread(buf, 1, BUFSIZ, stdin);
if (i > 0) fwrite(buf, 1, i, tmpfile);
}
gt_fa_xfclose(tmpfile);
sequence_filename = tmpfilename;
} else {
sequence_filename = gt_str_ref(bs->sequence_file);
}
gt_assert(gt_str_length(sequence_filename) > 0);
ee = gt_encseq_encoder_new();
gt_encseq_encoder_enable_description_support(ee);
gt_encseq_encoder_enable_md5_support(ee);
gt_encseq_encoder_enable_multiseq_support(ee);
gt_encseq_encoder_enable_lossless_support(ee);
indexfn = gt_str_array_new();
gt_str_array_add(indexfn, sequence_filename);
gt_str_delete(sequence_filename);
had_err = gt_encseq_encoder_encode(ee, indexfn,
gt_str_get(bioseq_indexname), err);
/* unregister the signal handler */
if (!bs->use_stdin)
gt_sig_unregister_all();
gt_str_array_delete(indexfn);
gt_encseq_encoder_delete(ee);
return had_err;
}
static void* gt_linspace_align_arguments_new(void)
{
GtLinspaceArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments);
arguments->outputfile = gt_str_new();
arguments->strings = gt_str_array_new();
arguments->files = gt_str_array_new();
arguments->linearcosts = gt_str_array_new();
arguments->affinecosts = gt_str_array_new();
arguments->diagonalbonds = gt_str_array_new();
return arguments;
}
static int add_to_current(GtDiagram *d, GtFeatureNode *node,
GtFeatureNode *parent, GtError *err)
{
GtBlock *block;
NodeInfoElement *ni;
GtStyleQueryStatus rval;
GtStr *caption = NULL;
bool status = true;
const char *nnid_p = NULL,
*nnid_n = NULL,
*nodetype;
gt_assert(d && node);
nodetype = gt_feature_node_get_type(node);
if (get_caption_display_status(d, nodetype, &status, err) < 0) {
return -1;
}
/* Get nodeinfo element and set itself as parent */
ni = nodeinfo_get(d, node);
gt_log_log("adding %s to self", nodetype);
ni->parent = node;
/* create new GtBlock tuple and add to node info */
block = gt_block_new_from_node(node);
caption = gt_str_new();
rval = gt_style_get_str(d->style,
nodetype, "block_caption",
caption, node, err);
if (rval == GT_STYLE_QUERY_ERROR) {
gt_str_delete(caption);
gt_block_delete(block);
return -1;
} else if (rval == GT_STYLE_QUERY_NOT_SET) {
nnid_p = get_node_name_or_id(parent);
nnid_n = get_node_name_or_id(node);
if ((nnid_p || nnid_n) && status)
{
if (parent) {
if (nnid_p && gt_feature_node_has_children(parent))
gt_str_append_cstr(caption, nnid_p);
else
gt_str_append_cstr(caption, "-");
gt_str_append_cstr(caption, "/");
}
if (nnid_n)
gt_str_append_cstr(caption, nnid_n);
} else {
gt_str_delete(caption);
caption = NULL;
}
}
gt_block_set_caption(block, caption);
gt_block_insert_element(block, node);
nodeinfo_add_block(ni, gt_feature_node_get_type(node), GT_UNDEF_REPR, block);
return 0;
}
static void *gt_tyr_occratio_arguments_new(void)
{
Tyr_occratio_options *arguments
= gt_malloc(sizeof (Tyr_occratio_options));
arguments->mersizesstrings = gt_str_array_new();
arguments->outputspec = gt_str_array_new();
arguments->str_inputindex = gt_str_new();
arguments->outputvector = NULL;
arguments->outputmode = 0;
return arguments;
}
static void filter_targetbest(GtFeatureNode *current_feature,
GtDlist *trees, GtHashmap *target_to_elem)
{
unsigned long num_of_targets;
GtDlistelem *previous_elem;
GtStr *first_target_id;
const char *target;
int had_err;
gt_assert(current_feature && trees);
target = gt_feature_node_get_attribute(current_feature, TARGET_STRING);
gt_assert(target);
first_target_id = gt_str_new();
had_err = gt_gff3_parser_parse_target_attributes(target, &num_of_targets,
first_target_id, NULL, NULL,
"", 0, NULL);
gt_assert(!had_err);
if (num_of_targets == 1) {
GtStr *key = gt_str_new();
build_key(key, current_feature, first_target_id);
if (!(previous_elem = gt_hashmap_get(target_to_elem, gt_str_get(key)))) {
/* element with this target_id not included yet -> include it */
include_feature(trees, target_to_elem, current_feature, key);
}
else {
GtFeatureNode *previous_feature = gt_dlistelem_get_data(previous_elem);
/* element with this target_id included already -> compare them */
if (gt_feature_node_get_score(current_feature) >
gt_feature_node_get_score(previous_feature)) {
/* current feature is better -> replace previous feature */
replace_previous_elem(previous_elem, current_feature, trees,
target_to_elem, key);
}
else /* current feature is not better -> remove it */
gt_genome_node_delete((GtGenomeNode*) current_feature);
}
gt_str_delete(key);
}
else
gt_dlist_add(trees, current_feature);
gt_str_delete(first_target_id);
}
static void* gt_matstat_arguments_new_generic(bool doms)
{
Gfmsubcallinfo *arguments = gt_calloc((size_t) 1, sizeof *arguments);
arguments->minlength.defined = false;
arguments->maxlength.defined = false;
arguments->showmode = 0;
arguments->indexname = gt_str_new();
arguments->queryfilenames = gt_str_array_new();
arguments->flagsoutputoption = gt_str_array_new();
arguments->doms = doms;
return arguments;
}
GthSA* gth_sa_new(void)
{
GthSA *sa;
/* allocating space */
sa = gt_calloc(1, sizeof *sa);
/* initialize strings */
sa->gen_id = gt_str_new();
sa->ref_id = gt_str_new();
/* initialize all arrays */
sa->backtrace_path = gth_backtrace_path_new(GT_UNDEF_UWORD,
GT_UNDEF_UWORD,
0, /* ref_dp_start */
GT_UNDEF_UWORD);
sa->exons = gt_array_new(sizeof (Exoninfo));
sa->introns = gt_array_new(sizeof (Introninfo));
return sa;
}
static int extracttarget_from_seqfiles(const char *target,
GtStrArray *seqfiles,
GtError *err)
{
GtStr *unescaped_target;
char *escaped_target;
GtSplitter *splitter;
unsigned long i;
int had_err = 0;
gt_error_check(err);
gt_assert(target && seqfiles);
splitter = gt_splitter_new();
unescaped_target = gt_str_new();
escaped_target = gt_cstr_dup(target);
gt_splitter_split(splitter, escaped_target, strlen(escaped_target), ',');
for (i = 0; !had_err && i < gt_splitter_size(splitter); i++) {
GtSplitter *blank_splitter;
char *token = gt_splitter_get_token(splitter, i);
blank_splitter = gt_splitter_new();
gt_splitter_split(blank_splitter, token, strlen(token), ' ');
had_err = gt_gff3_unescape(unescaped_target,
gt_splitter_get_token(blank_splitter, 0),
strlen(gt_splitter_get_token(blank_splitter, 0)),
err);
if (!had_err) {
unsigned long j;
for (j = 0; j < gt_str_array_size(seqfiles); j++) {
unsigned long k;
GtBioseq *bioseq;
if (!(bioseq = gt_bioseq_new(gt_str_array_get(seqfiles, j), err))) {
had_err = -1;
break;
}
for (k = 0; k < gt_bioseq_number_of_sequences(bioseq); k++) {
TargetInfo target_info;
const char *desc = gt_bioseq_get_description(bioseq, k);
target_info.bioseq = bioseq;
target_info.seqnum = k;
gt_string_matching_bmh(desc, strlen(desc),
gt_str_get(unescaped_target),
gt_str_length(unescaped_target), show_target,
&target_info);
}
gt_bioseq_delete(bioseq);
}
}
gt_splitter_delete(blank_splitter);
}
gt_free(escaped_target);
gt_str_delete(unescaped_target);
gt_splitter_delete(splitter);
return had_err;
}
int gt_extract_and_translate_feature_sequence(GtFeatureNode *feature_node,
const char *type,
bool join,
GtRegionMapping *rm,
GtTransTable *ttable,
GtStr *translation_fr1,
GtStr *translation_fr2,
GtStr *translation_fr3,
GtError *err)
{
GtTranslator *tr = NULL;
GtTranslatorStatus status;
GtCodonIterator *ci = NULL;
unsigned int frame, phase_offset = 0;
char translated;
int had_err = 0;
GtStr *sequence = gt_str_new();
gt_assert(feature_node && type);
had_err = gt_extract_feature_sequence_generic(sequence,
(GtGenomeNode*) feature_node,
type, join, NULL, NULL,
&phase_offset, rm, err);
/* do translation if we have at least one codon */
if (!had_err && gt_str_length(sequence) > phase_offset + 2) {
ci = gt_codon_iterator_simple_new(gt_str_get(sequence) + phase_offset,
gt_str_length(sequence) - phase_offset,
NULL);
tr = gt_translator_new(ci);
if (ttable)
gt_translator_set_translation_table(tr, ttable);
status = gt_translator_next(tr, &translated, &frame, NULL);
while (status == GT_TRANSLATOR_OK) {
if (frame == 0 && translation_fr1)
gt_str_append_char(translation_fr1, translated);
else if (frame == 1 && translation_fr2)
gt_str_append_char(translation_fr2, translated);
else if (frame == 2 && translation_fr3)
gt_str_append_char(translation_fr3, translated);
status = gt_translator_next(tr, &translated, &frame, NULL);
}
if (status == GT_TRANSLATOR_ERROR)
had_err = -1;
}
gt_translator_delete(tr);
gt_codon_iterator_delete(ci);
gt_str_delete(sequence);
return had_err;
}
void gt_graphics_cairo_initialize(GtGraphics *gg, GtGraphicsOutType type,
unsigned int width, unsigned int height)
{
GtGraphicsCairo *g = gt_graphics_cairo_cast(gg);
g->outbuf = gt_str_new();
switch (type)
{
case GT_GRAPHICS_PDF:
#ifdef CAIRO_HAS_PDF_SURFACE
g->surf = cairo_pdf_surface_create_for_stream(str_write_func,
g->outbuf,
width,
height);
break;
#endif
case GT_GRAPHICS_PS:
#ifdef CAIRO_HAS_PS_SURFACE
g->surf = cairo_ps_surface_create_for_stream(str_write_func,
g->outbuf,
width,
height);
break;
#endif
case GT_GRAPHICS_SVG:
#ifdef CAIRO_HAS_SVG_SURFACE
g->surf = cairo_svg_surface_create_for_stream(str_write_func,
g->outbuf,
width,
height);
break;
#endif
case GT_GRAPHICS_PNG:
default:
g->surf = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height);
break;
}
gt_assert(g->surf && cairo_surface_status(g->surf) == CAIRO_STATUS_SUCCESS);
g->cr = cairo_create(g->surf);
gt_assert(cairo_status(g->cr) == CAIRO_STATUS_SUCCESS);
/* set background default to transparent */
g->bg_color.red = g->bg_color.green = 0.0;
g->bg_color.blue = g->bg_color.alpha = 0.0;
g->width = width;
g->height = height;
g->margin_x = g->margin_y = 20;
cairo_set_line_join(g->cr, CAIRO_LINE_JOIN_ROUND);
cairo_set_line_cap(g->cr, CAIRO_LINE_CAP_ROUND);
cairo_select_font_face(g->cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL,
CAIRO_FONT_WEIGHT_NORMAL);
g->type = type;
}
static void* test_symbol(GT_UNUSED void *data)
{
GtStr *symbol;
GtUword i;
symbol = gt_str_new();
for (i = 0; i < NUMBER_OF_SYMBOLS; i++) {
gt_str_reset(symbol);
gt_str_append_ulong(symbol, gt_rand_max(MAX_SYMBOL));
gt_symbol(gt_str_get(symbol));
gt_assert(!strcmp(gt_symbol(gt_str_get(symbol)), gt_str_get(symbol)));
}
gt_str_delete(symbol);
return NULL;
}
static int hmmsearch_call_coarse_search(GtCondenseq* ces,
char *hmmsearch_path,
char *table_filename,
char *hmm_filename,
GtLogger *logger,
GtError *err) {
int had_err = 0;
char **hmmargs = NULL,
*hmmenv[] = { NULL };
GtStr *coarse_fas = gt_condenseq_unique_fasta_file(ces);
GtSafePipe *pipe = NULL;
gt_assert(coarse_fas != NULL);
/* Array has to end with NULL */
hmmargs = gt_calloc((size_t) 8, sizeof (*hmmargs));
hmmargs[0] = hmmsearch_path;
hmmargs[1] = gt_cstr_dup("--noali");
hmmargs[2] = gt_cstr_dup("--notextw");
hmmargs[3] = gt_cstr_dup("--domtblout");
hmmargs[4] = table_filename;
hmmargs[5] = hmm_filename;
hmmargs[6] = gt_str_get(coarse_fas);
gt_logger_log(logger, "calling: %s", hmmsearch_path);
pipe = gt_safe_popen(hmmsearch_path, hmmargs, hmmenv, err);
if (pipe == NULL)
had_err = -1;
gt_free(hmmargs[1]);
gt_free(hmmargs[2]);
gt_free(hmmargs[3]);
gt_free(hmmargs);
gt_str_delete(coarse_fas);
/* pipe test for splint */
if (!had_err && pipe != NULL) {
if (gt_log_enabled()) {
GtStr *line = gt_str_new();
while (gt_str_read_next_line(line, pipe->read_fd) == 0) {
gt_log_log("%s", gt_str_get(line));
gt_str_reset(line);
}
gt_str_delete(line);
}
(void) gt_safe_pclose(pipe);
}
return had_err;
}
static int hmmsearch_call_fine_search(GtStr *table_filename,
char *fine_fasta_filename,
char *hmmsearch_path,
char *hmm_filename,
GtLogger *logger,
GtError *err) {
int had_err = 0;
GtSafePipe *pipe = NULL;
char **hmmargs = NULL,
*hmmenv[] = { NULL };
size_t hmmargc = (size_t) 4;
unsigned int hmmidx = 0;
if (table_filename != NULL) {
hmmargc += (size_t) 2;
}
hmmargs = gt_calloc(hmmargc, sizeof (*hmmargs));
hmmargs[hmmidx++] = hmmsearch_path;
if (table_filename != NULL) {
hmmargs[hmmidx++] = gt_cstr_dup("--tblout");
hmmargs[hmmidx++] = gt_str_get(table_filename);
}
hmmargs[hmmidx++] = hmm_filename;
hmmargs[hmmidx++] = fine_fasta_filename;
gt_assert(hmmargs[hmmidx] == NULL);
gt_logger_log(logger, "calling: %s", hmmsearch_path);
pipe = gt_safe_popen(hmmsearch_path, hmmargs, hmmenv, err);
if (table_filename != NULL)
gt_free(hmmargs[1]);
gt_free(hmmargs);
if (pipe == NULL)
had_err = -1;
if (!had_err) {
GtStr *line = gt_str_new();
gt_assert(pipe != NULL); /* shut up splint */
while (gt_str_read_next_line(line, pipe->read_fd) == 0) {
printf("%s\n", gt_str_get(line));
gt_str_reset(line);
}
gt_str_delete(line);
(void) gt_safe_pclose(pipe);
}
return had_err;
}
static GtIndexOptions* gt_index_options_new(void)
{
GtIndexOptions *oi = gt_malloc(sizeof *oi);
oi->algbounds = gt_str_array_new();
oi->dir = gt_str_new_cstr("fwd");
oi->indexname = NULL;
oi->kysargumentstring = gt_str_new();
oi->lcpdist = false;
oi->maximumspace = 0UL; /* in bytes */
oi->memlimit = gt_str_new();
oi->numofparts = 1U;
oi->option = NULL;
oi->optionalgbounds = NULL;
oi->optioncmpcharbychar = NULL;
oi->optiondifferencecover = NULL;
oi->optionmaxwidthrealmedian = NULL;
oi->optionmemlimit = NULL;
oi->optionoutbcktab = NULL;
oi->optionoutbwttab = NULL;
oi->optionoutlcptab = NULL;
oi->optionoutsuftab = NULL;
oi->optionparts = NULL;
oi->optionprefixlength = NULL;
oi->optionspmopt = NULL;
oi->optionstorespecialcodes = NULL;
oi->outbcktab = false;
oi->outbwttab = false;
oi->outkyssort = false;
oi->outkystab = false;
oi->outlcptab = false;
oi->outsuftab = false; /* only defined for GT_INDEX_OPTIONS_ESA */
oi->prefixlength = GT_PREFIXLENGTH_AUTOMATIC;
oi->swallow_tail = false;
oi->type = GT_INDEX_OPTIONS_UNDEFINED;
return oi;
}
static void show_parse_file_status(GthShowVerbose showverbose,
GtUword filenum,
GtUword numoffiles,
const char *filename)
{
GtStr *buf = gt_str_new();
gt_str_append_cstr(buf, "process file ");
gt_str_append_uword(buf, filenum + 1);
gt_str_append_char(buf, GT_PATH_SEPARATOR);
gt_str_append_uword(buf, numoffiles);
gt_str_append_cstr(buf, ": ");
gt_str_append_cstr(buf, filename);
showverbose(gt_str_get(buf));
gt_str_delete(buf);
}
static GtStr* get_xrf_path(GtError *err)
{
const char *progname;
GtStr *xrf_path, *prog;
gt_error_check(err);
progname = gt_error_get_progname(err);
gt_assert(progname != NULL);
prog = gt_str_new();
gt_str_append_cstr_nt(prog, progname,
gt_cstr_length_up_to_char(progname, ' '));
xrf_path = gt_get_gtdata_path(gt_str_get(prog), err);
if (xrf_path)
gt_str_append_cstr(xrf_path, "/xrf_abbr/");
gt_str_delete(prog);
return xrf_path;
}
GtSequenceBuffer* gt_sequence_buffer_fasta_new(const GtStrArray *sequences)
{
GtSequenceBuffer *sb;
GtSequenceBufferFasta *sbf;
sb = gt_sequence_buffer_create(gt_sequence_buffer_fasta_class());
sbf = gt_sequence_buffer_fasta_cast(sb);
sb->pvt->filenametab = sequences;
sbf->headerbuffer = gt_str_new();
sb->pvt->filenum = 0;
sbf->firstoverallseq = true;
sbf->firstseqinfile = true;
sbf->nextfile = true;
sb->pvt->nextread = sb->pvt->nextfree = 0;
sb->pvt->complete = false;
sb->pvt->lastspeciallength = 0;
return sb;
}
GtLeftborderOutbuffer *gt_leftborderbuffer_new(const char *name,
GtFirstcodesspacelog *fcsl)
{
GtLeftborderOutbuffer *lbbuf = gt_malloc(sizeof (*lbbuf));
lbbuf->totalwrite = 0;
lbbuf->outfilename = gt_str_new();
lbbuf->fp = gt_xtmpfp(lbbuf->outfilename);
lbbuf->nextfree = 0;
lbbuf->allocated = 1024UL;
lbbuf->name = gt_str_new_cstr(name);
lbbuf->spaceuint32_t = gt_malloc(sizeof (*lbbuf->spaceuint32_t) *
lbbuf->allocated);
GT_FCI_ADDWORKSPACE(fcsl,name,
sizeof (*lbbuf->spaceuint32_t) * lbbuf->allocated);
return lbbuf;
}
static int gt_seqtranslate_do_translation(GtTranslateArguments *arguments,
const char *sequence,
GtUword length,
const char *desc,
GtStr **translations,
bool rev,
GtError *err)
{
GtTranslator *tr;
GT_UNUSED GtTranslatorStatus trst;
GtCodonIterator *ci;
char translated;
int had_err = 0;
GtStr *str;
unsigned int frame,
i;
ci = gt_codon_iterator_simple_new(sequence, length, err);
tr = gt_translator_new(ci);
trst = gt_translator_next(tr, &translated, &frame, err);
while (trst == GT_TRANSLATOR_OK) {
gt_str_append_char(translations[frame], translated);
trst = gt_translator_next(tr, &translated, &frame, err);
}
gt_codon_iterator_delete(ci);
gt_translator_delete(tr);
if (trst == GT_TRANSLATOR_ERROR)
return -1;
str = gt_str_new();
for (i = 0; i < 3; i++) {
if (gt_str_length(translations[i]) > 0) {
gt_str_append_cstr(str, desc);
gt_str_append_cstr(str, " (");
gt_str_append_ulong(str, i+1);
gt_str_append_cstr(str, rev ? "-" : "+");
gt_str_append_cstr(str, ")");
gt_fasta_show_entry(gt_str_get(str), gt_str_get(translations[i]),
gt_str_length(translations[i]),
arguments->fasta_width, arguments->outfp);
gt_str_reset(translations[i]);
gt_str_reset(str);
}
}
gt_str_delete(str);
return had_err;
}
GtAlphabet* gt_alphabet_new_from_file_no_suffix(const char *filename,
GtError *err)
{
GtStr *transpath = NULL;
bool haserr = false;
GtAlphabet *alpha;
gt_assert(filename);
gt_error_check(err);
alpha = gt_alphabet_new_empty();
if (!gt_file_exists(filename))
{
GtStr *prog;
const char *progname = gt_error_get_progname(err);
gt_assert(progname != NULL);
prog = gt_str_new();
gt_str_append_cstr_nt(prog, progname,
gt_cstr_length_up_to_char(progname, ' '));
transpath = gt_get_gtdata_path(gt_str_get(prog), err);
gt_str_delete(prog);
gt_str_append_cstr(transpath, "/trans/");
gt_str_append_cstr(transpath, filename);
}
if (read_symbolmap(alpha,
transpath == NULL ? filename : gt_str_get(transpath),
err) != 0)
{
haserr = true;
}
gt_str_delete(transpath);
if (alpha == NULL)
{
haserr = true;
}
if (haserr)
{
gt_alphabet_delete((GtAlphabet*) alpha);
return NULL;
}
return alpha;
}
int gt_mergeesa(int argc, const char **argv, GtError *err)
{
GtStr *storeindex;
GtStrArray *indexnametab;
bool haserr = false;
int parsed_args;
gt_error_check(err);
storeindex = gt_str_new();
indexnametab = gt_str_array_new();
switch (parse_options(storeindex, indexnametab, &parsed_args, argc, argv,
err)) {
case GT_OPTION_PARSER_OK:
break;
case GT_OPTION_PARSER_ERROR:
haserr = true;
break;
case GT_OPTION_PARSER_REQUESTS_EXIT:
return 0;
}
if (!haserr)
{
GtUword i;
GtLogger *logger;
printf("# storeindex=%s\n",gt_str_get(storeindex));
for (i=0; i<gt_str_array_size(indexnametab); i++)
{
printf("# input=%s\n",gt_str_array_get(indexnametab,i));
}
logger = gt_logger_new(false, GT_LOGGER_DEFLT_PREFIX, stdout);
if (gt_performtheindexmerging(storeindex,
indexnametab,
logger,
err) != 0)
{
haserr = true;
}
gt_logger_delete(logger);
}
gt_str_delete(storeindex);
gt_str_array_delete(indexnametab);
return haserr ? -1 : 0;
}
static int gt_compreads_decompress_benchmark(GtHcrDecoder *hcrd,
unsigned long amount,
GtTimer *timer,
GtError *err) {
char qual[BUFSIZ] = {0},
seq[BUFSIZ] = {0};
int had_err = 0;
unsigned long rand,
max_rand = gt_hcr_decoder_num_of_reads(hcrd) - 1,
count;
GtStr *timer_comment = gt_str_new_cstr("extracting ");
GtStr *desc = gt_str_new();
gt_str_append_ulong(timer_comment, amount);
gt_str_append_cstr(timer_comment, " reads of ");
gt_str_append_ulong(timer_comment, max_rand + 1);
gt_str_append_cstr(timer_comment, "!");
if (timer == NULL) {
timer = gt_timer_new_with_progress_description("extract random reads");
gt_timer_start(timer);
}
else {
gt_timer_show_progress(timer, "extract random reads", stdout);
}
gt_log_log("%s",gt_str_get(timer_comment));
for (count = 0; count < amount; count++) {
if (!had_err) {
rand = gt_rand_max(max_rand);
gt_log_log("get read: %lu", rand);
had_err = gt_hcr_decoder_decode(hcrd, rand, seq, qual, desc, err);
gt_log_log("%s",gt_str_get(desc));
gt_log_log("%s",seq);
gt_log_log("%s",qual);
}
}
gt_str_delete(timer_comment);
gt_str_delete(desc);
if (!gt_showtime_enabled())
gt_timer_delete(timer);
return had_err;
}
static int gt_shredder_runner(GT_UNUSED int argc, const char **argv,
int parsed_args, void *tool_arguments,
GtError *err)
{
GtShredderArguments *arguments = tool_arguments;
GtBioseqIterator *bsi;
unsigned long i;
GtBioseq *bioseq;
int had_err;
GtStr *desc;
gt_error_check(err);
gt_assert(arguments);
/* init */
desc = gt_str_new();
bsi = gt_bioseq_iterator_new(argc - parsed_args, argv + parsed_args);
/* shredder */
while (!(had_err = gt_bioseq_iterator_next(bsi, &bioseq, err)) && bioseq) {
for (i = 0; i < arguments->coverage; i++) {
GtShredder *shredder;
unsigned long fragment_length;
const char *fragment;
shredder = gt_shredder_new(bioseq, arguments->minlength,
arguments->maxlength);
gt_shredder_set_overlap(shredder, arguments->overlap);
gt_shredder_set_sample_probability(shredder,
arguments->sample_probability);
while ((fragment = gt_shredder_shred(shredder, &fragment_length, desc))) {
gt_str_append_cstr(desc, " [shreddered fragment]");
gt_fasta_show_entry(gt_str_get(desc), fragment, fragment_length, 0);
}
gt_shredder_delete(shredder);
}
gt_bioseq_delete(bioseq);
}
/* free */
gt_bioseq_iterator_delete(bsi);
gt_str_delete(desc);
return had_err;
}
int gt_gthmkbssmfiles(int argc, const char **argv, GtError *err)
{
GtUword i;
GtStr *filename;
int parsed_args, had_err = 0;
/* option parsing */
switch (gthmkbssmfiles_parse_options(&parsed_args, argc, argv, err)) {
case GT_OPTION_PARSER_OK: break;
case GT_OPTION_PARSER_ERROR: return -1;
case GT_OPTION_PARSER_REQUESTS_EXIT: return 0;
}
gt_assert(parsed_args + 1 == argc);
filename = gt_str_new();
for (i = 0; !had_err && i <= LASTSPECIESNUM; i++) {
GthBSSMParam *bssm_param;
gt_str_append_cstr(filename, argv[parsed_args]);
gt_str_append_char(filename, GT_PATH_SEPARATOR);
gt_str_append_cstr(filename, speciestab[i]);
/* for files which are obsolete due to new model files produced by
gthbssmbuild add an .old after the species name */
if (i >= 8)
gt_str_append_cstr(filename, ".old");
gt_str_append_char(filename, '.');
gt_str_append_cstr(filename, BSSMFILEENDING);
if (!(bssm_param = gth_bssm_param_extract(i, err)))
had_err = -1;
if (!had_err)
had_err = gth_bssm_param_save(bssm_param, gt_str_get(filename), err);
gth_bssm_param_delete(bssm_param);
/* resetting filename */
gt_str_reset(filename);
}
gt_str_delete(filename);
return had_err;
}
static void gt_Sfxmappedrange_storetmp(GtSfxmappedrange *sfxmappedrange,
GtSfxStoretype usedptrptr,
GtSfxmappedrangetype type,
bool writable)
{
FILE *outfp;
gt_assert(sfxmappedrange != NULL);
sfxmappedrange->ptr = NULL;
sfxmappedrange->filename = gt_str_new();
sfxmappedrange->writable = writable;
outfp = gt_xtmpfp(sfxmappedrange->filename);
gt_assert(outfp != NULL);
gt_log_log("write %s to file %s ("GT_WU" units of "GT_WU" bytes)",
gt_str_get(sfxmappedrange->tablename),
gt_str_get(sfxmappedrange->filename),
(GtUword) sfxmappedrange->numofunits,
(GtUword) sfxmappedrange->sizeofunit);
switch (type) {
case GtSfxGtBitsequence:
gt_xfwrite(*(usedptrptr.bs),sfxmappedrange->sizeofunit,
sfxmappedrange->numofunits,outfp);
sfxmappedrange->usedptrptr = (void**) usedptrptr.bs;
gt_free(*(usedptrptr.bs));
*(usedptrptr.bs) = NULL;
break;
case GtSfxunsignedlong:
gt_xfwrite(*(usedptrptr.ulong),sfxmappedrange->sizeofunit,
sfxmappedrange->numofunits,outfp);
sfxmappedrange->usedptrptr = (void**) usedptrptr.ulong;
gt_free(*(usedptrptr.ulong));
*(usedptrptr.ulong) = NULL;
break;
case GtSfxuint32_t:
gt_xfwrite(*(usedptrptr.uint32),sfxmappedrange->sizeofunit,
sfxmappedrange->numofunits,outfp);
sfxmappedrange->usedptrptr = (void**) usedptrptr.uint32;
gt_free(*(usedptrptr.uint32));
*(usedptrptr.uint32) = NULL;
break;
}
gt_fa_fclose(outfp);
}
/* 'static' function */
GtStrArray* gt_trans_table_get_scheme_descriptions()
{
GtUword i;
GtTranslationScheme *scheme;
GtStr *str;
GtStrArray *sa = gt_str_array_new();
str = gt_str_new();
for (i = 1UL; i < (GtUword) GT_SIZEOFTRANSRANGE; i++) {
if (transnum2index[i] == GT_UNDEFTRANSNUM)
continue;
scheme = schemetable + transnum2index[i];
gt_str_reset(str);
gt_str_append_uint(str, scheme->identity);
gt_str_append_cstr(str, ": ");
gt_str_append_cstr(str, scheme->name);
gt_str_array_add_cstr(sa, gt_str_get(str));
}
gt_str_delete(str);
return sa;
}
static GtStr* make_id_unique(GtGFF3Visitor *gff3_visitor, GtFeatureNode *fn)
{
GtUword i = 1;
GtStr *id = gt_str_new_cstr(gt_feature_node_get_attribute(fn, "ID"));
if (gt_cstr_table_get(gff3_visitor->used_ids, gt_str_get(id))) {
GtStr *buf = gt_str_new();
while (!id_string_is_unique(id, buf, gff3_visitor->used_ids, i++));
gt_warning("feature ID \"%s\" not unique: changing to %s", gt_str_get(id),
gt_str_get(buf));
gt_str_set(id, gt_str_get(buf));
gt_str_delete(buf);
}
/* update table with the new id */
gt_cstr_table_add(gff3_visitor->used_ids, gt_str_get(id));
/* store (unique) id */
gt_hashmap_add(gff3_visitor->feature_node_to_unique_id_str, fn, id);
return id;
}
static void* gt_select_arguments_new(void)
{
SelectArguments *arguments = gt_calloc(1, sizeof *arguments);
arguments->seqid = gt_str_new();
arguments->source = gt_str_new();
arguments->gt_strand_char = gt_str_new();
arguments->strand = GT_NUM_OF_STRAND_TYPES;
arguments->targetgt_strand_char = gt_str_new();
arguments->targetstrand = GT_NUM_OF_STRAND_TYPES;
arguments->ofi = gt_output_file_info_new();
arguments->filter_files = gt_str_array_new();
arguments->filter_logic = gt_str_new();
arguments->dropped_file = gt_str_new();
return arguments;
}
static int split_description(const char *filename, GtStr *splitdesc,
unsigned long width, bool force, GtError *err)
{
unsigned long i;
GtBioseq *bioseq;
GtStr *descname;
int had_err = 0;
gt_error_check(err);
gt_assert(filename && splitdesc && gt_str_length(splitdesc));
descname = gt_str_new();
if (!(bioseq = gt_bioseq_new(filename, err)))
had_err = -1;
for (i = 0; !had_err && i < gt_bioseq_number_of_sequences(bioseq); i++) {
GtFile *outfp;
char *seq;
gt_str_reset(descname);
gt_str_append_str(descname, splitdesc);
gt_str_append_char(descname, '/');
gt_str_append_cstr(descname, gt_bioseq_get_description(bioseq, i));
gt_str_append_cstr(descname, gt_file_suffix(filename));
if (!(outfp = gt_output_file_xopen_forcecheck(gt_str_get(descname), "w",
force, err))) {
had_err = -1;
break;
}
seq = gt_bioseq_get_sequence(bioseq, i);
gt_fasta_show_entry(gt_bioseq_get_description(bioseq, i), seq,
gt_bioseq_get_sequence_length(bioseq, i), width,
outfp);
gt_free(seq);
gt_file_delete(outfp);
}
gt_bioseq_delete(bioseq);
gt_str_delete(descname);
return had_err;
}
static int assign_block_caption(GtDiagram *d,
GtFeatureNode *node,
GtFeatureNode *parent,
GtBlock *block,
GtError *err)
{
const char *nnid_p = NULL, *nnid_n = NULL;
GtStr *caption = NULL;
bool status = true;
int rval;
caption = gt_str_new();
rval = gt_style_get_str(d->style,
gt_feature_node_get_type(node), "block_caption",
caption, node, err);
if (rval == GT_STYLE_QUERY_ERROR) {
gt_str_delete(caption);
return -1;
} else if (rval == GT_STYLE_QUERY_NOT_SET) {
nnid_p = get_node_name_or_id(parent);
nnid_n = get_node_name_or_id(node);
if ((nnid_p || nnid_n) && status)
{
if (parent) {
if (nnid_p && gt_feature_node_has_children(parent))
gt_str_append_cstr(caption, nnid_p);
else
gt_str_append_cstr(caption, "-");
gt_str_append_cstr(caption, "/");
}
if (nnid_n)
gt_str_append_cstr(caption, nnid_n);
} else {
gt_str_delete(caption);
caption = NULL;
}
}
gt_block_set_caption(block, caption);
return 0;
}
