static int gt_inlineseq_split_runner(int argc, const char **argv,
int parsed_args,
void *tool_arguments, GtError *err)
{
GtInlineseqSplitArguments *arguments = tool_arguments;
GtNodeStream *gff3_in_stream = NULL,
*gff3_out_stream = NULL,
*split_stream = NULL,
*last_stream = NULL;
GtFile *seq_out_file = NULL,
*gff3_out_file = NULL;
int had_err = 0;
gt_error_check(err);
gt_assert(arguments);
if (gt_str_length(arguments->seqoutfile) > 0) {
seq_out_file = gt_file_new(gt_str_get(arguments->seqoutfile), "w+", err);
if (!seq_out_file)
had_err = -1;
}
if (!had_err && gt_str_length(arguments->gffoutfile) > 0) {
gff3_out_file = gt_file_new(gt_str_get(arguments->gffoutfile), "w+", err);
if (!gff3_out_file)
had_err = -1;
}
if (!had_err) {
last_stream = gff3_in_stream = gt_gff3_in_stream_new_unsorted(
argc - parsed_args,
argv + parsed_args);
gt_assert(gff3_in_stream);
}
if (!had_err) {
last_stream = split_stream = gt_sequence_node_out_stream_new(last_stream,
seq_out_file,
err);
gt_assert(split_stream);
}
if (!had_err) {
last_stream = gff3_out_stream = gt_gff3_out_stream_new(last_stream,
gff3_out_file);
had_err = gt_node_stream_pull(last_stream, err);
}
gt_node_stream_delete(gff3_in_stream);
gt_node_stream_delete(gff3_out_stream);
gt_node_stream_delete(split_stream);
gt_file_delete(seq_out_file);
gt_file_delete(gff3_out_file);
return had_err;
}
static int create_manpage(const char *outdir, const char *toolname,
GtOptionParser *option_parser, GtError *err)
{
GtFile *outfile = NULL;
GtStr *man, *pathbuf;
char *utoolname;
int had_err = 0;
gt_error_check(err);
gt_assert(outdir && toolname && option_parser);
man = gt_str_new();
pathbuf = gt_str_new_cstr(outdir);
utoolname = gt_cstr_dup(toolname);
gt_cstr_rep(utoolname, ' ', '_');
if (!gt_file_exists(gt_str_get(pathbuf)))
gt_xmkdir(gt_str_get(pathbuf));
gt_str_append_char(pathbuf, GT_PATH_SEPARATOR);
gt_str_append_cstr(pathbuf, utoolname);
gt_str_append_cstr(pathbuf, ".mansrc");
gt_free(utoolname);
if (!(outfile = gt_file_new(gt_str_get(pathbuf), "w+", err)))
had_err = -1;
if (!had_err)
had_err = gt_option_parser_manpage(option_parser, toolname, man, err);
if (!had_err)
gt_file_xprintf(outfile, "%s", gt_str_get(man));
gt_file_delete(outfile);
gt_str_delete(pathbuf);
gt_str_delete(man);
return had_err;
}
void gt_io_delete(GtIO *io)
{
if (!io) return;
gt_file_delete(io->fp);
gt_str_delete(io->path);
gt_free(io);
}
static void close_output_files(Store_in_subset_file_data
*store_in_subset_file_data)
{
unsigned long i;
GtStr *buf;
buf = gt_str_new();
for (i = 0; i < store_in_subset_file_data->num_of_subset_files; i++) {
if (store_in_subset_file_data->subset_files[i]) {
if (store_in_subset_file_data->gthsplitinfo->showverbose) {
gt_str_reset(buf);
gt_str_append_cstr(buf, "split file created: ");
gt_str_append_str(buf, store_in_subset_file_data->subset_filenames[i]);
gt_str_append_cstr(buf, " (size=");
gt_str_append_ulong(buf,
store_in_subset_file_data->subset_file_sa_counter[i]);
gt_str_append_cstr(buf, ")");
store_in_subset_file_data->gthsplitinfo->showverbose(gt_str_get(buf));
}
gt_assert(store_in_subset_file_data->subset_filenames[i]);
/* put XML trailer in file before closing it */
gth_xml_show_trailer(true, store_in_subset_file_data->subset_files[i]);
gt_file_delete(store_in_subset_file_data->subset_files[i]);
gt_str_delete(store_in_subset_file_data->subset_filenames[i]);
store_in_subset_file_data->subset_files[i] = NULL;
store_in_subset_file_data->subset_file_sa_counter[i] = 0;
}
}
gt_str_delete(buf);
}
int gt_seqiterator_fastq_next(GtSeqIterator *seqit,
const GtUchar **sequence,
unsigned long *len,
char **desc,
GtError *err)
{
int errstatus = 0;
GtSeqIteratorFastQ *seqitf;
gt_assert(seqit);
seqitf = gt_seqiterator_fastq_cast((GtSeqIterator*) seqit);
gt_assert(seqit && len && desc);
seqitf = gt_seqiterator_fastq_cast(seqit);
gt_str_reset(seqitf->qualsbuffer);
gt_str_reset(seqitf->qdescbuffer);
gt_str_reset(seqitf->sequencebuffer);
gt_str_reset(seqitf->descbuffer);
/* parse file */
errstatus = parse_fastq_block(seqitf, err);
if (!errstatus) {
*sequence = (GtUchar*) gt_str_get(seqitf->sequencebuffer);
*len = gt_str_length(seqitf->sequencebuffer);
*desc = gt_str_get(seqitf->descbuffer);
if (seqitf->qualities)
*seqitf->qualities = (GtUchar*) gt_str_get(seqitf->qualsbuffer);
errstatus = 1;
} else {
if (errstatus == EOF) {
/* we could not get a next entry from this file */
/* can we open another? */
if (seqitf->filenum+1 < gt_str_array_size(seqitf->filenametab)) {
const char *filename;
filename = gt_str_array_get(seqitf->filenametab, ++seqitf->filenum);
gt_file_delete(seqitf->curfile);
seqitf->curfile = gt_file_xopen(filename, "r");
seqitf->curline = 1;
/* get first entry from next file*/
errstatus = parse_fastq_block(seqitf, err);
if (!errstatus) {
*sequence = (GtUchar*) gt_str_get(seqitf->sequencebuffer);
*len = gt_str_length(seqitf->sequencebuffer);
*desc = gt_str_get(seqitf->descbuffer);
if (seqitf->qualities)
*seqitf->qualities = (GtUchar*) gt_str_get(seqitf->qualsbuffer);
errstatus = 1;
} else {
errstatus = -1;
}
} else {
/* all entries read from all files */
errstatus = 0;
}
} else {
errstatus = -1;
}
}
return errstatus;
}
static void gt_seqtransform_arguments_delete(void *tool_arguments)
{
SeqtransformArguments *arguments = tool_arguments;
if (!arguments) return;
gt_file_delete(arguments->outfp);
gt_outputfileinfo_delete(arguments->ofi);
gt_free(arguments);
}
static void gt_convertseq_arguments_delete(void *tool_arguments)
{
GtConvertseqArguments *arguments = tool_arguments;
if (!arguments) return;
gt_file_delete(arguments->outfp);
gt_output_file_info_delete(arguments->ofi);
gt_free(arguments);
}
static void gt_gff3_to_gtf_arguments_delete(void *tool_arguments)
{
GFF3ToGTFArguments *arguments = tool_arguments;
if (!arguments) return;
gt_file_delete(arguments->outfp);
gt_output_file_info_delete(arguments->ofi);
gt_free(arguments);
}
static void gt_mergefeat_arguments_delete(void *tool_arguments)
{
InterFeatArguments *arguments = tool_arguments;
if (!arguments) return;
gt_file_delete(arguments->outfp);
gt_output_file_info_delete(arguments->ofi);
gt_free(arguments);
}
static void gt_encseq_info_arguments_delete(void *tool_arguments)
{
GtEncseqInfoArguments *arguments = tool_arguments;
if (!arguments) return;
gt_file_delete(arguments->outfp);
gt_output_file_info_delete(arguments->ofi);
gt_free(arguments);
}
static void gt_seqmutate_arguments_delete(void *tool_arguments)
{
MutateArguments *arguments = tool_arguments;
if (!arguments) return;
gt_file_delete(arguments->outfp);
gt_outputfileinfo_delete(arguments->ofi);
gt_free(arguments);
}
static void gt_seqfilter_arguments_delete(void *tool_arguments)
{
SeqFilterArguments *arguments = tool_arguments;
if (!arguments) return;
gt_file_delete(arguments->outfp);
gt_output_file_info_delete(arguments->ofi);
gt_free(arguments);
}
static void gt_eval_arguments_delete(void *tool_arguments)
{
EvalArguments *arguments = tool_arguments;
if (!arguments) return;
gt_file_delete(arguments->outfp);
gt_output_file_info_delete(arguments->ofi);
gt_free(arguments);
}
bool gth_intermediate_output_is_correct(char *outputfilename,
GthSACollection *orig_sa_collection,
GthInput *input,
GtFile **outfp, GtError *err)
{
SACollectionData sa_collection_data;
GthSACollection *read_sa_collection;
GtFileMode file_mode;
bool rval;
#ifndef NDEBUG
GtUword numofgenomicfiles, numofreferencefiles;
#endif
gt_error_check(err);
gt_assert(outputfilename);
gt_assert(*outfp);
#ifndef NDEBUG
numofgenomicfiles = gth_input_num_of_gen_files(input);
numofreferencefiles = gth_input_num_of_ref_files(input);
#endif
/* init */
read_sa_collection = gth_sa_collection_new(GTH_DC_NONE);
sa_collection_data.sa_collection = read_sa_collection;
sa_collection_data.sa_filter = NULL;
sa_collection_data.stat = NULL;
/* store file mode */
file_mode = gt_file_mode(*outfp);
/* close output file */
gt_file_delete(*outfp);
/* open intermediate file again for reading */
*outfp = gt_file_xopen_file_mode(file_mode, outputfilename, "r");
gt_assert(*outfp);
/* read in the intermediate output */
if (gt_parse_intermediate_output(input, store_in_sa_collection,
&sa_collection_data, outputfilename, *outfp,
err)) {
fprintf(stderr, "error: %s\n", gt_error_get(err));
exit(EXIT_FAILURE);
}
/* array of genomic files did not grow */
gt_assert(numofgenomicfiles == gth_input_num_of_gen_files(input));
/* array of reference files did not grow */
gt_assert(numofreferencefiles == gth_input_num_of_ref_files(input));
/* compare the trees */
rval = gth_sa_collections_are_equal(orig_sa_collection, read_sa_collection);
/* free */
gth_sa_collection_delete(read_sa_collection);
return rval;
}
static void gt_inlineseq_add_arguments_delete(void *tool_arguments)
{
InlineseqAddArguments *arguments = tool_arguments;
if (!arguments) return;
gt_file_delete(arguments->outfp);
gt_seqid2file_info_delete(arguments->s2fi);
gt_output_file_info_delete(arguments->ofi);
gt_free(arguments);
}
static void gt_cds_arguments_delete(void *tool_arguments)
{
CDSArguments *arguments = tool_arguments;
if (!arguments) return;
gt_file_delete(arguments->outfp);
gt_outputfileinfo_delete(arguments->ofi);
gt_seqid2file_info_delete(arguments->s2fi);
gt_free(arguments);
}
static void gt_splicesiteinfo_arguments_delete(void *tool_arguments)
{
SpliceSiteInfoArguments *arguments = tool_arguments;
if (!arguments) return;
gt_file_delete(arguments->outfp);
gt_outputfileinfo_delete(arguments->ofi);
gt_seqid2file_info_delete(arguments->s2fi);
gt_free(arguments);
}
static void gt_extractseq_arguments_delete(void *tool_arguments)
{
ExtractSeqArguments *arguments = tool_arguments;
if (!arguments) return;
gt_file_delete(arguments->outfp);
gt_outputfileinfo_delete(arguments->ofi);
gt_str_delete(arguments->fastakeyfile);
gt_str_delete(arguments->pattern);
gt_free(arguments);
}
static void gt_extractfeat_arguments_delete(void *tool_arguments)
{
GtExtractFeatArguments *arguments = tool_arguments;
if (!arguments) return;
gt_file_delete(arguments->outfp);
gt_output_file_info_delete(arguments->ofi);
gt_seqid2file_info_delete(arguments->s2fi);
gt_str_delete(arguments->type);
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_file_delete(arguments->outfp);
gt_seqid2file_info_delete(arguments->s2fi);
gt_output_file_info_delete(arguments->ofi);
gt_free(arguments);
}
static void gt_interfeat_arguments_delete(void *tool_arguments)
{
InterFeatArguments *arguments = tool_arguments;
if (!arguments) return;
gt_file_delete(arguments->outfp);
gt_output_file_info_delete(arguments->ofi);
gt_str_delete(arguments->source_type);
gt_str_delete(arguments->dest_type);
gt_free(arguments);
}
int gt_graphics_cairo_save_to_file(const GtGraphics *gg, const char *filename,
GtError *err)
{
const GtGraphicsCairo *g = (const GtGraphicsCairo*) gg;
cairo_surface_t *bgsurf = NULL;
cairo_t *bgc = NULL;
cairo_status_t rval;
GtFile *outfile;
gt_error_check(err);
gt_assert(g && filename);
/* do nothing if no surface was created */
if (g->from_context)
return 0;
switch (g->type)
{
case GT_GRAPHICS_PNG:
/* blend rendered image with background color */
bgsurf = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, g->width,
g->height);
bgc = cairo_create(bgsurf);
cairo_set_source_rgba(bgc, g->bg_color.red, g->bg_color.green,
g->bg_color.blue, g->bg_color.alpha);
cairo_paint(bgc);
cairo_set_source_surface(bgc, g->surf, 0, 0);
cairo_paint(bgc);
rval = cairo_surface_write_to_png(bgsurf, filename);
gt_assert(rval == CAIRO_STATUS_SUCCESS ||
rval == CAIRO_STATUS_WRITE_ERROR);
if (rval == CAIRO_STATUS_WRITE_ERROR)
{
cairo_destroy(bgc);
cairo_surface_destroy(bgsurf);
gt_error_set(err, "an I/O error occurred while attempting "
"to write image file \"%s\"", filename);
return -1;
}
cairo_destroy(bgc);
cairo_surface_destroy(bgsurf);
break;
default:
cairo_show_page(g->cr);
cairo_surface_flush(g->surf);
cairo_surface_finish(g->surf);
outfile = gt_file_open(GT_FILE_MODE_UNCOMPRESSED, filename, "w+", err);
if (outfile)
{
gt_file_xwrite(outfile, gt_str_get_mem(g->outbuf),
gt_str_length(g->outbuf));
gt_file_delete(outfile);
} else return -1;
break;
}
return 0;
}
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 void gt_match_iterator_open_free(GtMatchIterator *mp)
{
GtMatchIteratorOpen *mpo;
if (!mp) return;
mpo = gt_match_iterator_open_cast(mp);
if (mpo->pvt->matchfilep != NULL)
fclose(mpo->pvt->matchfilep);
if (mpo->pvt->gtmatchfilep != NULL)
gt_file_delete(mpo->pvt->gtmatchfilep);
gt_free(mpo->pvt);
}
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_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);
}
}
GtUword gt_file_number_of_lines(const char *path)
{
GtUword number_of_lines = 0;
GtFile *fp;
int cc;
gt_assert(path);
fp = gt_file_xopen(path, "r");
while ((cc = gt_file_xfgetc(fp)) != EOF)
if (cc == '\n') number_of_lines++;
gt_file_delete(fp);
return number_of_lines;
}
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_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);
}
int gt_chseqids(int argc, const char **argv, GtError *err)
{
GtNodeStream *gff3_in_stream, *chseqids_stream, *sort_stream = NULL,
*gff3_out_stream = NULL;
ChseqidsArguments arguments;
GtStr *chseqids;
int parsed_args, had_err = 0;
gt_error_check(err);
/* option parsing */
switch (parse_options(&parsed_args, &arguments, argc, argv, err)) {
case GT_OPTION_PARSER_OK: break;
case GT_OPTION_PARSER_ERROR: return -1;
case GT_OPTION_PARSER_REQUESTS_EXIT: return 0;
}
/* create the streams */
gff3_in_stream = gt_gff3_in_stream_new_sorted(argv[parsed_args + 1]);
if (arguments.verbose && arguments.outfp)
gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) gff3_in_stream);
chseqids = gt_str_new_cstr(argv[parsed_args]);
chseqids_stream = gt_chseqids_stream_new(gff3_in_stream, chseqids, err);
if (!chseqids_stream)
had_err = -1;
gt_str_delete(chseqids);
if (!had_err) {
if (arguments.sort) {
sort_stream = gt_sort_stream_new(chseqids_stream);
gff3_out_stream = gt_gff3_out_stream_new(sort_stream, arguments.outfp);
}
else {
gff3_out_stream = gt_gff3_out_stream_new(chseqids_stream,
arguments.outfp);
}
}
/* pull the features through the stream and free them afterwards */
if (!had_err)
had_err = gt_node_stream_pull(gff3_out_stream, err);
/* free */
gt_node_stream_delete(gff3_out_stream);
gt_node_stream_delete(chseqids_stream);
gt_node_stream_delete(sort_stream);
gt_node_stream_delete(gff3_in_stream);
gt_file_delete(arguments.outfp);
return had_err;
}
