static void gt_gff3_arguments_delete(void *tool_arguments)
{
GFF3Arguments *arguments = tool_arguments;
if (!arguments) return;
gt_file_delete(arguments->outfp);
gt_str_delete(arguments->newsource);
gt_output_file_info_delete(arguments->ofi);
gt_typecheck_info_delete(arguments->tci);
gt_str_delete(arguments->offsetfile);
gt_free(arguments);
}
static void gt_condenser_search_arguments_delete(void *tool_arguments)
{
GtCondenserSearchArguments *arguments = tool_arguments;
if (arguments != NULL) {
gt_str_delete(arguments->dbpath);
gt_str_delete(arguments->querypath);
gt_file_delete(arguments->outfp);
gt_output_file_info_delete(arguments->ofi);
gt_free(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_condenseq_hmmsearch_arguments_delete(void *tool_arguments)
{
GtCondenseqHmmsearchArguments *arguments = tool_arguments;
if (arguments != NULL) {
gt_condenseq_search_arguments_delete(arguments->csa);
gt_str_delete(arguments->hmm);
gt_str_delete(arguments->hmmsearch_path);
gt_str_delete(arguments->outtable_filename);
gt_free(arguments);
}
}
static void gt_tir_arguments_delete(void *tool_arguments)
{
GtTirArguments *arguments = tool_arguments;
if (!arguments) return;
gt_str_delete(arguments->str_indexname);
gt_str_delete(arguments->cutoffs);
gt_str_delete(arguments->str_overlaps);
gt_str_array_delete(arguments->hmm_files);
gt_option_delete(arguments->optionoverlaps);
gt_free(arguments);
}
static void freesimpleoption(Cmppairwiseopt *cmppairwise)
{
gt_str_array_delete(cmppairwise->strings);
gt_str_array_delete(cmppairwise->files);
gt_str_delete(cmppairwise->text);
if (cmppairwise->charlistlen != NULL)
{
gt_str_delete(cmppairwise->charlistlen->charlist);
gt_free(cmppairwise->charlistlen);
}
}
static void gt_sketch_page_arguments_delete(void *tool_arguments)
{
SketchPageArguments *arguments = tool_arguments;
if (!arguments) return;
gt_str_delete(arguments->seqid);
gt_str_delete(arguments->format);
gt_str_delete(arguments->text);
gt_str_delete(arguments->stylefile);
gt_str_delete(arguments->seqfile);
gt_free(arguments);
}
static void gt_encseq2spm_arguments_delete(void *tool_arguments)
{
GtEncseq2spmArguments *arguments = tool_arguments;
if (!arguments) return;
gt_str_delete(arguments->encseqinput);
gt_str_delete(arguments->spmspec);
gt_option_delete(arguments->refoptionmemlimit);
gt_option_delete(arguments->refoptionphase2extra);
gt_str_delete(arguments->memlimitarg);
gt_str_delete(arguments->phase2extraarg);
gt_free(arguments);
}
static void gt_speck_arguments_delete(void *tool_arguments)
{
SpeccheckArguments *arguments = tool_arguments;
if (!arguments) return;
gt_str_delete(arguments->specfile);
gt_str_delete(arguments->format);
gt_file_delete(arguments->outfp);
gt_seqid2file_info_delete(arguments->s2fi);
gt_output_file_info_delete(arguments->ofi);
gt_typecheck_info_delete(arguments->tci);
gt_free(arguments);
}
static void gt_condenseq_extract_arguments_delete(void *tool_arguments)
{
GtCondenserExtractArguments *arguments = tool_arguments;
if (arguments != NULL) {
gt_file_delete(arguments->outfp);
gt_output_file_info_delete(arguments->ofi);
gt_str_delete(arguments->mode);
gt_str_delete(arguments->sepchar);
gt_option_delete(arguments->sepchar_opt);
gt_free(arguments);
}
}
void gt_match_delete(GtMatch *match)
{
if (!match) return;
gt_assert(match->c_class);
if (match->c_class->free)
match->c_class->free(match);
if (match->seqid1)
gt_str_delete(match->seqid1);
if (match->seqid2)
gt_str_delete(match->seqid2);
gt_free(match);
}
static void gt_ltrdigest_arguments_delete(void *tool_arguments)
{
GtLTRdigestOptions *arguments = tool_arguments;
if (!arguments) return;
gt_str_delete(arguments->trna_lib);
gt_str_delete(arguments->prefix);
gt_str_delete(arguments->cutoffs);
gt_str_array_delete(arguments->hmm_files);
gt_file_delete(arguments->outfp);
gt_output_file_info_delete(arguments->ofi);
gt_seqid2file_info_delete(arguments->s2fi);
gt_free(arguments);
}
static void gt_tyr_mkindex_arguments_delete(void *tool_arguments)
{
Tyr_mkindex_options *arguments = tool_arguments;
if (!arguments)
{
return;
}
gt_str_delete(arguments->str_storeindex);
gt_str_delete(arguments->str_inputindex);
gt_option_delete(arguments->refoptionpl);
gt_free(arguments);
}
static void gt_genomediff_arguments_delete(void *tool_arguments)
{
GtGenomediffArguments *arguments = tool_arguments;
if (!arguments) return;
gt_str_delete(arguments->indexname);
gt_str_delete(arguments->unitfile);
gt_str_delete(arguments->indextype);
gt_str_array_delete(arguments->filenames);
gt_option_delete(arguments->ref_unitfile);
gt_encseq_options_delete(arguments->loadopts);
gt_index_options_delete(arguments->idxopts);
gt_free(arguments);
}
void gt_seqiterator_fastq_delete(GtSeqIterator *si)
{
GtSeqIteratorFastQ *seqit;
if (!si) return;
seqit = gt_seqiterator_fastq_cast(si);
gt_str_delete(seqit->qdescbuffer);
gt_str_delete(seqit->sequencebuffer);
gt_str_delete(seqit->qualsbuffer);
gt_str_delete(seqit->descbuffer);
if (seqit->curfile)
gt_file_delete(seqit->curfile);
seqit->currentread = seqit->maxread;
}
static void gt_tyr_search_arguments_delete(void *tool_arguments)
{
Tyr_search_options *arguments = tool_arguments;
if (!arguments)
{
return;
}
gt_str_delete(arguments->str_inputindex);
gt_str_delete(arguments->strandspec);
gt_str_array_delete(arguments->queryfilenames);
gt_str_array_delete(arguments->showmodespec);
gt_free(arguments);
}
static void gt_ltrdigest_arguments_delete(void *tool_arguments)
{
GtLTRdigestOptions *arguments = tool_arguments;
if (!arguments) return;
#ifdef HAVE_HMMER
gt_str_array_delete(arguments->pdom_opts.hmm_files);
#endif
gt_str_delete(arguments->trna_lib);
gt_str_delete(arguments->prefix);
gt_str_delete(arguments->cutoffs);
gt_file_delete(arguments->outfp);
gt_outputfileinfo_delete(arguments->ofi);
gt_free(arguments);
}
static int extract_feature_visitor_feature_node(GtNodeVisitor *nv,
GtFeatureNode *fn, GtError *err)
{
GtExtractFeatureVisitor *efv;
GtFeatureNodeIterator *fni;
GtFeatureNode *child;
GtStrArray *target_ids = NULL;
GtStr *seqid = NULL,
*description,
*sequence;
int had_err = 0;
gt_error_check(err);
efv = gt_extract_feature_visitor_cast(nv);
gt_assert(efv->region_mapping);
fni = gt_feature_node_iterator_new(fn);
if (efv->target)
target_ids = gt_str_array_new();
if (efv->seqid)
seqid = gt_str_new();
description = gt_str_new();
sequence = gt_str_new();
while (!had_err && (child = gt_feature_node_iterator_next(fni))) {
if (seqid)
gt_str_reset(seqid);
if (target_ids)
gt_str_array_reset(target_ids);
if (gt_extract_feature_sequence(sequence, (GtGenomeNode*) child, efv->type,
efv->join, seqid, target_ids,
efv->region_mapping, err)) {
had_err = -1;
}
if (!had_err && gt_str_length(sequence)) {
efv->fastaseq_counter++;
construct_description(description, efv->type, efv->fastaseq_counter,
efv->join, efv->translate, seqid, target_ids);
had_err = show_entry(description, sequence, efv->translate, efv->width,
efv->outfp);
gt_str_reset(description);
gt_str_reset(sequence);
}
}
gt_str_delete(sequence);
gt_str_delete(description);
gt_str_delete(seqid);
gt_str_array_delete(target_ids);
gt_feature_node_iterator_delete(fni);
return had_err;
}
void gt_ltrdigest_pdom_visitor_free(GtNodeVisitor *nv)
{
GtLTRdigestPdomVisitor *lv;
GtUword i;
if (!nv) return;
lv = gt_ltrdigest_pdom_visitor_cast(nv);
for (i = 0UL; i < 3UL; i++) {
gt_str_delete(lv->fwd[i]);
gt_str_delete(lv->rev[i]);
}
gt_str_delete(lv->cmdline);
gt_str_delete(lv->tag);
gt_cstr_array_delete(lv->args);
}
void gt_region_mapping_delete(GtRegionMapping *rm)
{
if (!rm) return;
if (rm->reference_count) {
rm->reference_count--;
return;
}
gt_str_delete(rm->sequence_filename);
gt_str_delete(rm->sequence_file);
gt_str_delete(rm->sequence_name);
gt_mapping_delete(rm->mapping);
gt_bioseq_delete(rm->bioseq);
gt_free(rm);
}
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 void gt_seed_extend_arguments_delete(void *tool_arguments)
{
GtSeedExtendArguments *arguments = tool_arguments;
if (arguments != NULL) {
gt_str_delete(arguments->dbs_indexname);
gt_str_delete(arguments->dbs_queryname);
gt_str_delete(arguments->dbs_memlimit_str);
gt_str_delete(arguments->se_char_access_mode);
gt_option_delete(arguments->se_option_greedy);
gt_option_delete(arguments->se_option_xdrop);
gt_option_delete(arguments->se_option_withali);
gt_free(arguments);
}
}
void gt_bed_parser_delete(GtBEDParser *bed_parser)
{
if (!bed_parser) return;
gt_free(bed_parser->block_type);
gt_free(bed_parser->thick_feature_type);
gt_free(bed_parser->feature_type);
gt_str_delete(bed_parser->another_word);
gt_str_delete(bed_parser->word);
gt_hashmap_delete(bed_parser->seqid_to_str_mapping);
while (gt_queue_size(bed_parser->feature_nodes))
gt_genome_node_delete(gt_queue_get(bed_parser->feature_nodes));
gt_queue_delete(bed_parser->feature_nodes);
gt_region_node_builder_delete(bed_parser->region_node_builder);
gt_free(bed_parser);
}
static int sequence_node_add_stream_next(GtNodeStream *ns, GtGenomeNode **gn,
GtError *err)
{
GtSequenceNodeAddStream *s;
int had_err;
gt_error_check(err);
s = gt_sequence_node_add_stream_cast(ns);
/* stream nodes as long as we have some, record seen seqids */
if (!(had_err = gt_node_stream_next(s->in_stream, gn, err)) && *gn) {
had_err = gt_genome_node_accept(*gn, s->collect_vis, err);
}
/* if there are no more */
if (!had_err && !*gn) {
if (!s->seqids) {
s->seqids = gt_cstr_table_get_all(s->seqid_table);
}
gt_assert(s->seqids);
if (s->cur_seqid >= gt_str_array_size(s->seqids)) {
*gn = NULL;
return 0;
} else {
GtGenomeNode *new_sn;
GtUword len;
char *seq = NULL;
GtStr *seqid = gt_str_new(),
*seqstr = gt_str_new();
gt_str_append_cstr(seqid, gt_str_array_get(s->seqids, s->cur_seqid));
had_err = gt_region_mapping_get_sequence_length(s->rm, &len, seqid, err);
if (!had_err) {
had_err = gt_region_mapping_get_sequence(s->rm, &seq, seqid, 1, len,
err);
}
if (!had_err) {
gt_str_append_cstr_nt(seqstr, seq, len);
new_sn = gt_sequence_node_new(gt_str_get(seqid), seqstr);
*gn = new_sn;
}
s->cur_seqid++;
gt_free(seq);
gt_str_delete(seqid);
gt_str_delete(seqstr);
}
}
return had_err;
}
static void region_node_change_seqid(GtGenomeNode *gn, GtStr *seqid)
{
GtRegionNode *rn = gt_region_node_cast(gn);
gt_assert(rn && seqid);
gt_str_delete(rn->seqid);
rn->seqid = gt_str_ref(seqid);
}
static void feature_node_change_seqid(GtGenomeNode *gn, GtStr *seqid)
{
GtFeatureNode *fn = gt_feature_node_cast(gn);
gt_assert(fn && seqid);
gt_str_delete(fn->seqid);
fn->seqid = gt_str_ref(seqid);
}
static int gtf_in_stream_process_file(GtGTFInStream *gtf_in_stream,
GtError *err)
{
GtGTFParser *gtf_parser;
GtStr *filenamestr;
FILE *fpin;
int had_err;
gt_error_check(err);
gt_assert(gtf_in_stream);
gtf_parser = gt_gtf_parser_new(gtf_in_stream->type_checker);
/* open input file */
if (gtf_in_stream->filename)
fpin = gt_fa_xfopen(gtf_in_stream->filename, "r");
else
fpin = stdin;
/* parse input file */
filenamestr = gt_str_new_cstr(gtf_in_stream->filename
? gtf_in_stream->filename : "stdin");
had_err = gt_gtf_parser_parse(gtf_parser, gtf_in_stream->genome_node_buffer,
filenamestr, fpin, gtf_in_stream->tidy, err);
gt_str_delete(filenamestr);
/* close input file, if necessary */
if (gtf_in_stream->filename)
gt_fa_xfclose(fpin);
/* free */
gt_gtf_parser_delete(gtf_parser);
return had_err;
}
void gt_xrf_abbr_entry_delete(GtXRFAbbrEntry *abbr_entry)
{
if (!abbr_entry) return;
gt_str_delete(abbr_entry->filename);
gt_hashmap_delete(abbr_entry->content);
gt_free(abbr_entry);
}
static void gt_encseq_bitextract_arguments_delete(void *tool_arguments)
{
GtEncseqBitextractArguments *arguments = tool_arguments;
if (!arguments) return;
gt_str_delete(arguments->readmode);
gt_free(arguments);
}
bool indexfilealreadyexists(const GtStr *indexname,const char *suffix)
{
struct stat statbuf;
GtStr *tmpfilename;
tmpfilename = gt_str_clone(indexname);
gt_str_append_cstr(tmpfilename,suffix);
if (stat(gt_str_get(tmpfilename),&statbuf) == 0)
{
gt_str_delete(tmpfilename);
return true;
}
gt_str_delete(tmpfilename);
return false;
}
