GtMD5Tab* gt_md5_tab_new_from_cache_file(const char *cache_file,
GtUword num_of_seqs,
bool use_file_locking,
GtError *err)
{
GtMD5Tab *md5_tab;
bool reading_succeeded = false;
gt_assert(cache_file);
gt_error_check(err);
md5_tab = gt_calloc(1, sizeof *md5_tab);
md5_tab->num_of_md5s = num_of_seqs;
if (gt_file_exists(cache_file)) {
reading_succeeded = read_fingerprints(md5_tab,
cache_file,
use_file_locking);
}
if (!reading_succeeded) {
gt_free(md5_tab);
gt_error_set(err, "could not read fingerprints file \"%s\" or "
"invalid file contents", cache_file);
return NULL;
}
md5_tab->owns_md5s = false;
return md5_tab;
}
GtUword gt_cntlist_xload(const char *filename, GtBitsequence **cntlist,
GtUword expected_nofreads)
{
int retval;
GtUword found_nofreads;
GtError *err;
if (!gt_file_exists(filename))
{
fprintf(stderr, "FATAL: error by loading contained reads list: "
"file %s does not exist\n", filename);
exit(EXIT_FAILURE);
}
err = gt_error_new();
retval = gt_cntlist_parse(filename, true, cntlist, &found_nofreads, err);
if (retval != 0)
{
fprintf(stderr, "FATAL: error by parsing contained reads list: %s\n",
gt_error_get(err));
exit(EXIT_FAILURE);
}
gt_error_delete(err);
if (found_nofreads != expected_nofreads)
{
fprintf(stderr, "FATAL: error by parsing contained reads list: "
"file specifies a wrong number of reads\nexpected "GT_WU", found "
GT_WU"\n", expected_nofreads, found_nofreads);
exit(EXIT_FAILURE);
}
return gt_cntlist_count(*cntlist, found_nofreads);
}
GtMatchIterator* gt_match_iterator_open_new(const char *matchfile, GtError *err)
{
GtMatchIterator *mp;
GtMatchIteratorOpen *mpo;
mp = gt_match_iterator_create(gt_match_iterator_open_class());
mpo = (GtMatchIteratorOpen*) mp;
mpo->pvt = gt_calloc(1, sizeof (GtMatchIteratorOpenMembers));
GtFileMode mode;
if (gt_file_exists(matchfile)) {
mode = gt_file_mode_determine(matchfile);
if (mode == GT_FILE_MODE_UNCOMPRESSED) {
mpo->pvt->matchfilep = fopen(matchfile, "r");
mpo->pvt->gtmatchfilep = NULL;
if (!mpo->pvt->matchfilep) {
gt_error_set(err, "Could not open %s", matchfile);
return NULL;
}
} else {
mpo->pvt->gtmatchfilep = gt_file_open(mode, matchfile, "r", err);
mpo->pvt->matchfilep = NULL;
if (!mpo->pvt->gtmatchfilep)
return NULL;
}
mpo->pvt->matchfile = matchfile;
return mp;
} else {
gt_error_set(err, "No such file or directory %s", matchfile);
return NULL;
}
}
static GtBioseq* bioseq_new_with_recreate_and_type(GtStr *sequence_file,
bool recreate, GtError *err)
{
GtBioseq *bs;
int had_err = 0;
gt_error_check(err);
bs = gt_calloc(1, sizeof *bs);
if (!strcmp(gt_str_get(sequence_file), "-"))
bs->use_stdin = true;
if (!bs->use_stdin && !gt_file_exists(gt_str_get(sequence_file))) {
gt_error_set(err, "sequence file \"%s\" does not exist or is not readable",
gt_str_get(sequence_file));
had_err = -1;
}
if (!had_err) {
bs->sequence_file = gt_str_ref(sequence_file);
had_err = bioseq_fill(bs, recreate, err);
}
if (had_err) {
gt_bioseq_delete(bs);
return NULL;
}
gt_assert(bs->encseq);
bs->descriptions = gt_calloc(gt_encseq_num_of_sequences(bs->encseq),
sizeof (char*));
return bs;
}
GtMD5Tab* gt_md5_tab_new(const char *sequence_file, void *seqs,
GtGetSeqFunc get_seq, GtGetSeqLenFunc get_seq_len,
GtUword num_of_seqs, bool use_cache_file,
bool use_file_locking)
{
GtMD5Tab *md5_tab;
bool reading_succeeded = false;
GtStr *fingerprints_filename;
gt_assert(sequence_file && seqs && get_seq && get_seq_len);
md5_tab = gt_calloc(1, sizeof *md5_tab);
md5_tab->num_of_md5s = num_of_seqs;
fingerprints_filename = gt_str_new_cstr(sequence_file);
gt_str_append_cstr(fingerprints_filename, GT_MD5_TAB_FILE_SUFFIX);
if (use_cache_file && gt_file_exists(gt_str_get(fingerprints_filename)) &&
!gt_file_is_newer(sequence_file, gt_str_get(fingerprints_filename))) {
/* only try to read the fingerprint file if the sequence file was not
modified in the meantime */
reading_succeeded = read_fingerprints(md5_tab,
gt_str_get(fingerprints_filename),
use_file_locking);
}
if (!reading_succeeded) {
md5_tab->md5_fingerprints = gt_calloc(num_of_seqs, sizeof (char*));
add_fingerprints(md5_tab->md5_fingerprints, seqs, get_seq, get_seq_len,
num_of_seqs);
md5_tab->owns_md5s = true;
if (use_cache_file) {
write_fingerprints(md5_tab->md5_fingerprints, md5_tab->num_of_md5s,
fingerprints_filename, use_file_locking);
}
}
gt_str_delete(fingerprints_filename);
return md5_tab;
}
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;
}
static void remove_indexfile(const char *suffix)
{
GtStr *fn = gt_str_new_cstr(gt_bioseq_index_filename);
gt_str_append_cstr(fn, suffix);
if (gt_file_exists(gt_str_get(fn)))
gt_xunlink(gt_str_get(fn));
gt_str_delete(fn);
}
bool gt_pckbuckettable_exists(const char *indexname)
{
GtStr *tmpfilename;
bool retval;
tmpfilename = gt_str_new_cstr(indexname);
gt_str_append_cstr(tmpfilename,PCKBUCKETTABLE);
retval = gt_file_exists(gt_str_get(tmpfilename));
gt_str_delete(tmpfilename);
return retval;
}
static off_t index_size(const char *prefix, const char *suffix)
{
off_t size = 0;
GtStr *index_name = gt_str_new_cstr(prefix);
gt_str_append_cstr(index_name, suffix);
if (gt_file_exists(gt_str_get(index_name))) {
size = gt_file_size(gt_str_get(index_name));
}
gt_str_delete(index_name);
return size;
}
GtFile* gt_output_file_xopen_forcecheck(const char *path, const char *mode,
bool force, GtError *err)
{
gt_error_check(err);
gt_assert(path && mode);
if (!force && gt_file_exists(path)) {
gt_error_set(err, "file \"%s\" exists already, use option -%s to overwrite",
path, GT_FORCE_OPT_CSTR);
return NULL;
}
return gt_file_xopen(path, mode);
}
static int gff3_in_stream_lua_new_sorted(lua_State *L)
{
GtNodeStream **gs;
const char *filename;
gt_assert(L);
/* get/check parameters */
filename = luaL_checkstring(L, 1);
luaL_argcheck(L, gt_file_exists(filename), 1, "file does not exist");
/* construct object */
gs = lua_newuserdata(L, sizeof (GtNodeStream*));
*gs = gt_gff3_in_stream_new_sorted(filename);
gt_assert(*gs);
luaL_getmetatable(L, GENOME_STREAM_METATABLE);
lua_setmetatable(L, -2);
return 1;
}
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;
}
static int determine_outfp(void *data, GtError *err)
{
GtOutputFileInfo *ofi = (GtOutputFileInfo*) data;
GtFileMode file_mode;
int had_err = 0;
gt_error_check(err);
gt_assert(ofi);
if (!gt_str_length(ofi->output_filename))
*ofi->outfp = NULL; /* no output file given -> use stdout */
else { /* outputfile given -> create generic file pointer */
gt_assert(!(ofi->gzip && ofi->bzip2));
if (ofi->gzip)
file_mode = GT_FILE_MODE_GZIP;
else if (ofi->bzip2)
file_mode = GT_FILE_MODE_BZIP2;
else
file_mode = GT_FILE_MODE_UNCOMPRESSED;
if (file_mode != GT_FILE_MODE_UNCOMPRESSED &&
strcmp(gt_str_get(ofi->output_filename) +
gt_str_length(ofi->output_filename) -
strlen(gt_file_mode_suffix(file_mode)),
gt_file_mode_suffix(file_mode))) {
gt_warning("output file '%s' doesn't have correct suffix '%s', appending "
"it", gt_str_get(ofi->output_filename),
gt_file_mode_suffix(file_mode));
gt_str_append_cstr(ofi->output_filename, gt_file_mode_suffix(file_mode));
}
if (!ofi->force && gt_file_exists(gt_str_get(ofi->output_filename))) {
gt_error_set(err, "file \"%s\" exists already, use option -%s to "
"overwrite", gt_str_get(ofi->output_filename),
GT_FORCE_OPT_CSTR);
had_err = -1;
}
if (!had_err) {
*ofi->outfp = gt_file_xopen_file_mode(file_mode,
gt_str_get(ofi->output_filename),
"w");
gt_assert(*ofi->outfp);
}
}
return had_err;
}
int gt_ltrdigest_arguments_check(GT_UNUSED int rest_argc, void *tool_arguments,
GtError* err)
{
GtLTRdigestOptions *arguments = tool_arguments;
int had_err = 0;
if (arguments->nthreads > 0) {
gt_warning("The '-threads' option is deprecated. Please use the '-j'"
"option of the 'gt' call instead, e.g.:\n"
" gt -j %lu ltrdigest ...", arguments->nthreads);
}
/* -trnas */
if (!had_err && arguments->trna_lib && gt_str_length(arguments->trna_lib) > 0)
{
if (!gt_file_exists(gt_str_get(arguments->trna_lib)))
{
gt_error_set(err, "File '%s' does not exist!",
gt_str_get(arguments->trna_lib));
had_err = -1;
}
}
if (!had_err)
{
GtHMM *hmm;
GtAlphabet *alpha;
alpha = gt_alphabet_new_dna();
hmm = gt_ppt_hmm_new(alpha, &arguments->ppt_opts);
if (!hmm)
{
gt_error_set(err, "PPT HMM parameters are not valid!");
had_err = -1;
}
else
gt_hmm_delete(hmm);
gt_alphabet_delete(alpha);
}
return had_err;
}
GtTypeChecker* gt_typecheck_info_create_type_checker(const GtTypecheckInfo *tci,
GtError *err)
{
GtTypeChecker *type_checker = NULL;
int had_err = 0;
gt_error_check(err);
gt_assert(tci);
if (tci->typecheck_built_in)
type_checker = gt_type_checker_builtin_new();
else {
GtStr *obo_file;
gt_assert(gt_option_is_set(tci->typecheck_option));
if (!gt_str_length(tci->typecheck)) {
/* a. */
if (!(obo_file = get_obo_path(err)))
had_err = -1;
if (!had_err)
gt_str_append_cstr(obo_file, "sofa.obo");
}
else if (gt_file_exists(gt_str_get(tci->typecheck))) {
/* b. */
obo_file = gt_str_new_cstr(gt_str_get(tci->typecheck));
}
else {
/* c. */
if (!(obo_file = get_obo_path(err)))
had_err = -1;
if (!had_err) {
gt_str_append_str(obo_file, tci->typecheck);
gt_str_append_cstr(obo_file, ".obo");
}
}
if (!had_err)
type_checker = gt_type_checker_obo_new(gt_str_get(obo_file), err);
gt_str_delete(obo_file);
}
return type_checker;
}
static bool read_fingerprints(GtMD5Tab *md5_tab,
const char *fingerprints_filename,
bool use_file_locking)
{
bool reading_succeeded = true;
size_t len;
gt_assert(md5_tab && fingerprints_filename);
/* open file */
gt_assert(gt_file_exists(fingerprints_filename));
if (use_file_locking) {
md5_tab->fingerprints_file = gt_fa_xfopen(fingerprints_filename, "r");
gt_fa_lock_shared(md5_tab->fingerprints_file);
}
md5_tab->fingerprints = gt_fa_xmmap_read(fingerprints_filename, &len);
if (len != md5_tab->num_of_md5s * 33) {
gt_fa_xmunmap(md5_tab->fingerprints);
md5_tab->fingerprints = NULL;
gt_fa_unlock(md5_tab->fingerprints_file);
gt_fa_xfclose(md5_tab->fingerprints_file);
md5_tab->fingerprints_file = NULL;
reading_succeeded = false;
}
return reading_succeeded;
}
int gt_ltrdigest_arguments_check(GT_UNUSED int rest_argc, void *tool_arguments,
GtError* err)
{
GtLTRdigestOptions *arguments = tool_arguments;
int had_err = 0;
if (arguments->nthreads > 0) {
gt_warning("The '-threads' option is deprecated. Please use the '-j'"
"option of the 'gt' call instead, e.g.:\n"
" gt -j "GT_WU" ltrdigest ...", arguments->nthreads);
}
/* -trnas */
if (!had_err && arguments->trna_lib && gt_str_length(arguments->trna_lib) > 0)
{
if (!gt_file_exists(gt_str_get(arguments->trna_lib)))
{
gt_error_set(err, "File '%s' does not exist!",
gt_str_get(arguments->trna_lib));
had_err = -1;
}
}
return had_err;
}
GtXRFChecker* gt_xrfcheck_info_create_xrf_checker(const GtXRFCheckInfo *xci,
GtError *err)
{
GtXRFChecker *xrf_checker = NULL;
int had_err = 0;
GtStr *xrf_file;
gt_error_check(err);
gt_assert(xci);
gt_assert(gt_option_is_set(xci->xrfcheck_option));
if (!gt_str_length(xci->xrfcheck)) {
/* a. */
if (!(xrf_file = get_xrf_path(err)))
had_err = -1;
if (!had_err)
gt_str_append_cstr(xrf_file, "GO.xrf_abbr");
}
else if (gt_file_exists(gt_str_get(xci->xrfcheck))) {
/* b. */
xrf_file = gt_str_new_cstr(gt_str_get(xci->xrfcheck));
}
else {
/* c. */
if (!(xrf_file = get_xrf_path(err)))
had_err = -1;
if (!had_err) {
gt_str_append_str(xrf_file, xci->xrfcheck);
gt_str_append_cstr(xrf_file, ".xrf_abbr");
}
}
if (!had_err)
xrf_checker = gt_xrf_checker_new(gt_str_get(xrf_file), err);
gt_str_delete(xrf_file);
return xrf_checker;
}
GtPdomModelSet* gt_pdom_model_set_new(GtStrArray *hmmfiles, GtError *err)
{
GtStr *concat_dbnames, *cmdline, *indexfilename = NULL;
GtUword i;
char *md5_hash, ch;
const char *tmpdir;
int had_err = 0, rval;
FILE *dest;
GtPdomModelSet *pdom_model_set;
gt_assert(hmmfiles);
gt_error_check(err);
rval = system("hmmpress -h > /dev/null");
if (rval == -1) {
gt_error_set(err, "error executing system(hmmpress)");
return NULL;
}
#ifndef _WIN32
if (WEXITSTATUS(rval) != 0) {
gt_error_set(err, "cannot find the hmmpress executable in PATH");
return NULL;
}
#else
/* XXX */
gt_error_set(err, "hmmpress for Windows not implemented");
return NULL;
#endif
pdom_model_set = gt_calloc((size_t) 1, sizeof (GtPdomModelSet));
concat_dbnames = gt_str_new();
for (i = 0; !had_err && i < gt_str_array_size(hmmfiles); i++) {
const char *filename = gt_str_array_get(hmmfiles, i);
if (!gt_file_exists(filename)) {
gt_error_set(err, "invalid HMM file: %s", filename);
gt_str_delete(concat_dbnames);
gt_free(pdom_model_set);
return NULL;
} else {
gt_str_append_cstr(concat_dbnames, filename);
}
}
if (!had_err) {
pdom_model_set->filename = gt_str_new();
if (!(tmpdir = getenv("TMPDIR")))
tmpdir = "/tmp";
gt_str_append_cstr(pdom_model_set->filename, tmpdir);
gt_str_append_char(pdom_model_set->filename, GT_PATH_SEPARATOR);
md5_hash = gt_md5_fingerprint(gt_str_get(concat_dbnames),
gt_str_length(concat_dbnames));
gt_str_append_cstr(pdom_model_set->filename, md5_hash);
gt_free(md5_hash);
gt_str_delete(concat_dbnames);
indexfilename = gt_str_new_cstr(gt_str_get(pdom_model_set->filename));
gt_str_append_cstr(indexfilename, GT_HMM_INDEX_SUFFIX);
}
if (!gt_file_exists(gt_str_get(indexfilename))) {
dest = fopen(gt_str_get(pdom_model_set->filename), "w+");
if (!dest) {
gt_error_set(err, "could not create file %s",
gt_str_get(pdom_model_set->filename));
had_err = -1;
}
if (!had_err) {
for (i = 0; !had_err && i < gt_str_array_size(hmmfiles); i++) {
FILE *source;
const char *filename = gt_str_array_get(hmmfiles, i);
source = fopen(filename, "r");
if (!source) {
gt_error_set(err, "could not open HMM file %s", filename);
had_err = -1;
}
if (!had_err) {
while (( ch = fgetc(source)) != EOF)
(void) fputc(ch, dest);
(void) fclose(source);
}
}
(void) fclose(dest);
}
/* XXX: read hmmer path from env */
cmdline = gt_str_new_cstr("hmmpress -f ");
gt_str_append_str(cmdline, pdom_model_set->filename);
gt_str_append_cstr(cmdline, "> /dev/null"); /* XXX: portability? */
rval = system(gt_str_get(cmdline));
gt_str_delete(cmdline);
if (rval == -1) {
gt_error_set(err, "error executing system(hmmpress)");
return NULL;
}
#ifndef _WIN32
if (WEXITSTATUS(rval) != 0) {
gt_error_set(err, "an error occurred during HMM preprocessing");
had_err = -1;
}
#else
gt_error_set(err, "WEXITSTATUS not implemented on Windows");
had_err = -1;
#endif
}
if (had_err) {
gt_pdom_model_set_delete(pdom_model_set);
pdom_model_set = NULL;
}
gt_str_delete(indexfilename);
return pdom_model_set;
}
GtR* gtr_new(GtError *err)
{
GtR *gtr;
char *seedstr = NULL;
int had_err = 0;
#ifndef WITHOUT_CAIRO
GtStr *style_file = NULL;
#endif
gtr = gt_calloc(1, sizeof (GtR));
if ((seedstr = getenv("GT_SEED"))) {
if (gt_parse_uint(>r->seed, seedstr) != 0) {
gt_error_set(err, "invalid seed in GT_SEED environment variable: %s",
seedstr);
had_err = -1;
}
} else gtr->seed = 0;
if (!had_err) {
gtr->debugfp = gt_str_new();
gtr->testspacepeak = gt_str_new();
gtr->test_only = gt_str_new();
gtr->manoutdir = gt_str_new();
gtr->L = luaL_newstate();
if (!gtr->L) {
gt_error_set(err, "out of memory (cannot create new lua state)");
had_err = -1;
}
}
if (!had_err) {
luaL_openlibs(gtr->L); /* open the standard libraries */
gt_lua_open_lib(gtr->L); /* open the GenomeTools library */
lua_pushcfunction(gtr->L, luaopen_lpeg);
lua_pushstring(gtr->L, "lpeg");
lua_call(gtr->L, 1, 0); /* open LPeg library */
lua_pushcfunction(gtr->L, luaopen_md5_core);
lua_pushstring(gtr->L, "md5");
lua_call(gtr->L, 1, 0); /* open MD5 library */
lua_pushcfunction(gtr->L, luaopen_lfs);
lua_pushstring(gtr->L, "lfs");
lua_call(gtr->L, 1, 0); /* open Lua filesystem */
lua_pushcfunction(gtr->L, luaopen_des56);
lua_pushstring(gtr->L, "des56");
lua_call(gtr->L, 1, 0); /* open DES56 library */
had_err = gt_lua_set_modules_path(gtr->L, err);
}
#ifndef WITHOUT_CAIRO
if (!had_err) {
lua_settop(gtr->L, 0);
if (!(gtr->style = gt_style_new_with_state(gtr->L)))
had_err = -1;
}
if (!had_err) {
if (!(style_file = gt_get_gtdata_path(gt_error_get_progname(err), err)))
had_err = -1;
}
if (!had_err) {
gt_str_append_cstr(style_file, "/sketch/default.style");
if (gt_file_exists(gt_str_get(style_file))) {
if (gt_style_load_file(gtr->style, gt_str_get(style_file), err))
had_err = -1;
else
gt_lua_put_style_in_registry(gtr->L, gtr->style);
}
}
gt_str_delete(style_file);
#endif
if (had_err) {
gt_free(gtr);
return NULL;
}
return gtr;
}
static int bioseq_fill(GtBioseq *bs, bool recreate, GtError *err)
{
GtStr *bioseq_index_file = NULL,
*bioseq_ois_file = NULL,
*bioseq_sds_file = NULL,
*bioseq_md5_file = NULL,
*bioseq_des_file = NULL;
int had_err = 0;
GtStr *bioseq_basename;
gt_assert(!bs->encseq);
if (bs->use_stdin)
bioseq_basename = gt_str_new_cstr("stdin");
else
bioseq_basename = bs->sequence_file;
/* construct file names */
bioseq_index_file = gt_str_clone(bioseq_basename);
gt_str_append_cstr(bioseq_index_file, GT_ENCSEQFILESUFFIX);
bioseq_ois_file = gt_str_clone(bioseq_basename);
gt_str_append_cstr(bioseq_ois_file, GT_OISTABFILESUFFIX);
bioseq_sds_file = gt_str_clone(bioseq_basename);
gt_str_append_cstr(bioseq_sds_file, GT_SDSTABFILESUFFIX);
bioseq_md5_file = gt_str_clone(bioseq_basename);
gt_str_append_cstr(bioseq_md5_file, GT_MD5TABFILESUFFIX);
bioseq_des_file = gt_str_clone(bioseq_basename);
gt_str_append_cstr(bioseq_des_file, GT_DESTABFILESUFFIX);
/* construct the bioseq files if necessary */
if (recreate || bs->use_stdin ||
!gt_file_exists(gt_str_get(bioseq_index_file)) ||
!gt_file_exists(gt_str_get(bioseq_ois_file)) ||
!gt_file_exists(gt_str_get(bioseq_sds_file)) ||
!gt_file_exists(gt_str_get(bioseq_md5_file)) ||
!gt_file_exists(gt_str_get(bioseq_des_file)) ||
gt_file_is_newer(gt_str_get(bs->sequence_file),
gt_str_get(bioseq_index_file))) {
had_err = construct_bioseq_files(bs, bioseq_basename, err);
}
if (!had_err) {
GtEncseqLoader *el = gt_encseq_loader_new();
gt_encseq_loader_disable_autosupport(el);
gt_encseq_loader_require_lossless_support(el);
gt_encseq_loader_require_description_support(el);
gt_encseq_loader_require_md5_support(el);
gt_encseq_loader_require_multiseq_support(el);
bs->encseq = gt_encseq_loader_load(el, gt_str_get(bioseq_basename), err);
if (bs->encseq == NULL) {
had_err = -1;
gt_assert(gt_error_is_set(err));
}
gt_encseq_loader_delete(el);
}
if (!had_err) {
gt_assert(bs->encseq);
}
/* free */
if (bs->use_stdin)
gt_str_delete(bioseq_basename);
gt_str_delete(bioseq_index_file);
gt_str_delete(bioseq_ois_file);
gt_str_delete(bioseq_md5_file);
gt_str_delete(bioseq_sds_file);
gt_str_delete(bioseq_des_file);
return had_err;
}
static int gt_sketch_runner(int argc, const char **argv, int parsed_args,
void *tool_arguments, GT_UNUSED GtError *err)
{
GtSketchArguments *arguments = tool_arguments;
GtNodeStream *in_stream = NULL,
*add_introns_stream = NULL,
*gff3_out_stream = NULL,
*feature_stream = NULL,
*sort_stream = NULL,
*last_stream;
GtFeatureIndex *features = NULL;
const char *file;
char *seqid = NULL;
GtRange qry_range, sequence_region_range;
GtArray *results = NULL;
GtStyle *sty = NULL;
GtStr *prog, *defaultstylefile = NULL;
GtDiagram *d = NULL;
GtLayout *l = NULL;
GtImageInfo* ii = NULL;
GtCanvas *canvas = NULL;
GtUword height;
bool has_seqid;
int had_err = 0;
gt_error_check(err);
gt_assert(arguments);
prog = gt_str_new();
gt_str_append_cstr_nt(prog, argv[0],
gt_cstr_length_up_to_char(argv[0], ' '));
defaultstylefile = gt_get_gtdata_path(gt_str_get(prog), err);
gt_str_delete(prog);
if (!defaultstylefile)
had_err = -1;
if (!had_err) {
gt_str_append_cstr(defaultstylefile, "/sketch/default.style");
}
file = argv[parsed_args];
if (!had_err) {
/* create feature index */
features = gt_feature_index_memory_new();
parsed_args++;
/* create an input stream */
if (strcmp(gt_str_get(arguments->input), "gff") == 0)
{
in_stream = gt_gff3_in_stream_new_unsorted(argc - parsed_args,
argv + parsed_args);
if (arguments->verbose)
gt_gff3_in_stream_show_progress_bar((GtGFF3InStream*) in_stream);
} else if (strcmp(gt_str_get(arguments->input), "bed") == 0)
{
if (argc - parsed_args == 0)
in_stream = gt_bed_in_stream_new(NULL);
else
in_stream = gt_bed_in_stream_new(argv[parsed_args]);
} else if (strcmp(gt_str_get(arguments->input), "gtf") == 0)
{
if (argc - parsed_args == 0)
in_stream = gt_gtf_in_stream_new(NULL);
else
in_stream = gt_gtf_in_stream_new(argv[parsed_args]);
}
last_stream = in_stream;
/* create add introns stream if -addintrons was used */
if (arguments->addintrons) {
sort_stream = gt_sort_stream_new(last_stream);
add_introns_stream = gt_add_introns_stream_new(sort_stream);
last_stream = add_introns_stream;
}
/* create gff3 output stream if -pipe was used */
if (arguments->pipe) {
gff3_out_stream = gt_gff3_out_stream_new(last_stream, NULL);
last_stream = gff3_out_stream;
}
/* create feature stream */
feature_stream = gt_feature_stream_new(last_stream, features);
/* pull the features through the stream and free them afterwards */
had_err = gt_node_stream_pull(feature_stream, err);
gt_node_stream_delete(feature_stream);
gt_node_stream_delete(gff3_out_stream);
gt_node_stream_delete(sort_stream);
gt_node_stream_delete(add_introns_stream);
gt_node_stream_delete(in_stream);
}
if (!had_err) {
had_err = gt_feature_index_has_seqid(features,
&has_seqid,
gt_str_get(arguments->seqid),
err);
}
/* if seqid is empty, take first one added to index */
if (!had_err && strcmp(gt_str_get(arguments->seqid),"") == 0) {
seqid = gt_feature_index_get_first_seqid(features, err);
if (seqid == NULL) {
gt_error_set(err, "GFF input file must contain a sequence region!");
had_err = -1;
}
}
else if (!had_err && !has_seqid) {
gt_error_set(err, "sequence region '%s' does not exist in GFF input file",
gt_str_get(arguments->seqid));
had_err = -1;
}
else if (!had_err)
seqid = gt_str_get(arguments->seqid);
results = gt_array_new(sizeof (GtGenomeNode*));
if (!had_err) {
had_err = gt_feature_index_get_range_for_seqid(features,
&sequence_region_range,
seqid,
err);
}
if (!had_err) {
qry_range.start = (arguments->start == GT_UNDEF_UWORD ?
sequence_region_range.start :
arguments->start);
qry_range.end = (arguments->end == GT_UNDEF_UWORD ?
sequence_region_range.end :
arguments->end);
}
if (!had_err) {
if (arguments->verbose)
fprintf(stderr, "# of results: "GT_WU"\n", gt_array_size(results));
/* find and load style file */
if (!(sty = gt_style_new(err)))
had_err = -1;
if (gt_str_length(arguments->stylefile) == 0) {
gt_str_append_str(arguments->stylefile, defaultstylefile);
} else {
if (!had_err && gt_file_exists(gt_str_get(arguments->stylefile))) {
if (arguments->unsafe)
gt_style_unsafe_mode(sty);
}
else
{
had_err = -1;
gt_error_set(err, "style file '%s' does not exist!",
gt_str_get(arguments->stylefile));
}
}
if (!had_err)
had_err = gt_style_load_file(sty, gt_str_get(arguments->stylefile), err);
}
if (!had_err) {
/* create and write image file */
if (!(d = gt_diagram_new(features, seqid, &qry_range, sty, err)))
had_err = -1;
if (!had_err && arguments->flattenfiles)
gt_diagram_set_track_selector_func(d, flattened_file_track_selector,
NULL);
if (had_err || !(l = gt_layout_new(d, arguments->width, sty, err)))
had_err = -1;
if (!had_err)
had_err = gt_layout_get_height(l, &height, err);
if (!had_err) {
ii = gt_image_info_new();
if (strcmp(gt_str_get(arguments->format),"pdf")==0) {
canvas = gt_canvas_cairo_file_new(sty, GT_GRAPHICS_PDF,
arguments->width,
height, ii, err);
}
else if (strcmp(gt_str_get(arguments->format),"ps")==0) {
canvas = gt_canvas_cairo_file_new(sty, GT_GRAPHICS_PS,
arguments->width,
height, ii, err);
}
else if (strcmp(gt_str_get(arguments->format),"svg")==0) {
canvas = gt_canvas_cairo_file_new(sty, GT_GRAPHICS_SVG,
arguments->width,
height, ii, err);
}
else {
canvas = gt_canvas_cairo_file_new(sty, GT_GRAPHICS_PNG,
arguments->width,
height, ii, err);
}
if (!canvas)
had_err = -1;
if (!had_err) {
had_err = gt_layout_sketch(l, canvas, err);
}
if (!had_err) {
if (arguments->showrecmaps) {
GtUword i;
const GtRecMap *rm;
for (i = 0; i < gt_image_info_num_of_rec_maps(ii) ;i++) {
char buf[BUFSIZ];
rm = gt_image_info_get_rec_map(ii, i);
(void) gt_rec_map_format_html_imagemap_coords(rm, buf, BUFSIZ);
printf("%s, %s\n",
buf,
gt_feature_node_get_type(gt_rec_map_get_genome_feature(rm)));
}
}
if (arguments->use_streams) {
GtFile *outfile;
GtStr *str = gt_str_new();
gt_canvas_cairo_file_to_stream((GtCanvasCairoFile*) canvas, str);
outfile = gt_file_open(GT_FILE_MODE_UNCOMPRESSED, file, "w+", err);
if (outfile) {
gt_file_xwrite(outfile, gt_str_get_mem(str), gt_str_length(str));
gt_file_delete(outfile);
} else {
had_err = -1;
}
gt_str_delete(str);
} else {
had_err = gt_canvas_cairo_file_to_file((GtCanvasCairoFile*) canvas,
file,
err);
}
}
}
}
/* free */
gt_free(seqid);
gt_canvas_delete(canvas);
gt_layout_delete(l);
gt_image_info_delete(ii);
gt_style_delete(sty);
gt_diagram_delete(d);
gt_array_delete(results);
gt_str_delete(defaultstylefile);
gt_feature_index_delete(features);
return had_err;
}
int gtr_run(GtR *gtr, int argc, const char **argv, GtError *err)
{
GtToolfunc toolfunc;
GtTool *tool = NULL;
char **nargv = NULL;
void *mem, *map;
int had_err = 0;
gt_error_check(err);
gt_assert(gtr);
if (gtr->debug)
enable_logging(gt_str_get(gtr->debugfp), >r->logfp);
if (gtr->quiet)
gt_warning_disable();
gtr->seed = gt_ya_rand_init(gtr->seed);
gt_log_log("seed=%u", gtr->seed);
if (gtr->list)
return list_tools(gtr);
if (gt_str_length(gtr->manoutdir) > 0)
return create_manpages(gtr, gt_str_get(gtr->manoutdir), err);
if (gtr->check64bit)
return check64bit();
if (gtr->test)
return run_tests(gtr, err);
if (gt_str_length(gtr->testspacepeak)) {
mem = gt_malloc(1 << 26); /* alloc 64 MB */;
map = gt_fa_xmmap_read(gt_str_get(gtr->testspacepeak), NULL);
gt_fa_xmunmap(map);
gt_free(mem);
}
if (argc == 0 && !gtr->interactive) {
gt_error_set(err, "neither tool nor script specified; option -help lists "
"possible tools");
had_err = -1;
}
if (!had_err && argc) {
if (!gtr->tools || !gt_toolbox_has_tool(gtr->tools, argv[0])) {
/* no tool found -> try to open script */
if (gt_file_exists(argv[0])) {
/* export script */
gt_lua_set_script_dir(gtr->L, argv[0]);
/* run script */
nargv = gt_cstr_array_prefix_first(argv, gt_error_get_progname(err));
gt_lua_set_arg(gtr->L, nargv[0], (const char**) nargv+1);
if (luaL_dofile(gtr->L, argv[0])) {
/* error */
gt_assert(lua_isstring(gtr->L, -1)); /* error message on top */
gt_error_set(err, "could not execute script %s",
lua_tostring(gtr->L, -1));
had_err = -1;
lua_pop(gtr->L, 1); /* pop error message */
}
}
else {
/* neither tool nor script found */
gt_error_set(err, "neither tool nor script '%s' found; option -help "
"lists possible tools", argv[0]);
had_err = -1;
}
}
else {
/* run tool */
if (!(toolfunc = gt_toolbox_get(gtr->tools, argv[0]))) {
tool = gt_toolbox_get_tool(gtr->tools, argv[0]);
gt_assert(tool);
}
nargv = gt_cstr_array_prefix_first(argv, gt_error_get_progname(err));
gt_error_set_progname(err, nargv[0]);
if (toolfunc)
had_err = toolfunc(argc, (const char**) nargv, err);
else
had_err = gt_tool_run(tool, argc, (const char**) nargv, err);
}
}
gt_cstr_array_delete(nargv);
if (!had_err && gtr->interactive) {
gt_showshortversion(gt_error_get_progname(err));
gt_lua_set_arg(gtr->L, gt_error_get_progname(err), argv);
run_interactive_lua_interpreter(gtr->L);
}
if (had_err)
return EXIT_FAILURE;
return EXIT_SUCCESS;
}
int gt_pbs_unit_test(GtError *err)
{
int had_err = 0;
GtLTRElement element;
GtPBSOptions o;
GtStr *tmpfilename;
FILE *tmpfp;
GtPBSResults *res;
GtPBSHit *hit;
double score1, score2;
GtRange rng;
char *rev_seq,
*seq,
tmp[BUFSIZ];
const char *fullseq = "aaaaaaaaaaaaaaaaaaaa"
"tatagcactgcatttcgaatatagtttcgaatatagcactgcatttcgaa"
"tatagcactgcatttcgaatatagtttcgaatatagcactgcatttcgaa"
"acatactaggatgctag" /* <- PBS forward */
"aatatagtttcgaatatagcactgcatttcgaa"
"tatagcactgcatttcgaatatagtttcgaatatagcactgcatttcgaa"
"tatagcactgcatttcgaatatagtttcgaatatagcactgcatttcgaa"
"tatagcactgcatttcgaatatagtttcgaatatagcactgcatttcgaa"
"tatagcactgcatttcgaatatagtttcgaatatagcactgcatttcgaa"
"tatagcactgcatttcgaatatagtttcgaatatagcactgcatttcgaa"
"tatagcactgcatttcgaatatagtttcgaatatagcactgcatttcgaa"
"tatagcactgcatttcgaatatagtttcgaatatag"
/* PBS reverse -> */ "gatcctaaggctac"
"tatagcactgcatttcgaatatagtttcgaatatagcactgcatttcgaa"
"tatagcactgcatttcgaatatagtttcgaatatagcactgcatttcgaa"
"aaaaaaaaaaaaaaaaaaaa";
/* notice previous errors */
gt_error_check(err);
/* create temporary tRNA library file */
tmpfilename = gt_str_new();
tmpfp = gt_xtmpfp(tmpfilename);
fprintf(tmpfp, ">test1\nccccccccccccccctagcatcctagtatgtccc\n"
">test2\ncccccccccgatcctagggctaccctttc\n");
gt_fa_xfclose(tmpfp);
ensure(had_err, gt_file_exists(gt_str_get(tmpfilename)));
/* setup testing parameters */
o.radius = 30;
o.max_edist = 1;
o.alilen.start = 11;
o.alilen.end = 30;
o.offsetlen.start = 0;
o.offsetlen.end = 5;
o.trnaoffsetlen.start = 0;
o.trnaoffsetlen.end = 40;
o.ali_score_match = 5;
o.ali_score_mismatch = -10;
o.ali_score_insertion = o.ali_score_deletion = -20;
o.trna_lib = gt_bioseq_new(gt_str_get(tmpfilename), err);
ensure(had_err, gt_bioseq_number_of_sequences(o.trna_lib) == 2);
element.leftLTR_5 = 20;
element.leftLTR_3 = 119;
element.rightLTR_5 = 520;
element.rightLTR_3 = 619;
/* setup sequences */
seq = gt_malloc(600 * sizeof (char));
rev_seq = gt_malloc(600 * sizeof (char));
memcpy(seq, fullseq + 20, 600);
memcpy(rev_seq, fullseq + 20, 600);
gt_reverse_complement(rev_seq, 600, err);
/* try to find PBS in sequences */
res = gt_pbs_find(seq, rev_seq, &element, &o, err);
ensure(had_err, res != NULL);
ensure(had_err, gt_pbs_results_get_number_of_hits(res) == 2);
/* check first hit on forward strand */
hit = gt_pbs_results_get_ranked_hit(res, 0);
ensure(had_err, hit != NULL);
ensure(had_err, gt_pbs_hit_get_alignment_length(hit) == 17);
ensure(had_err, gt_pbs_hit_get_edist(hit) == 0);
ensure(had_err, gt_pbs_hit_get_offset(hit) == 0);
ensure(had_err, gt_pbs_hit_get_tstart(hit) == 3);
ensure(had_err, strcmp(gt_pbs_hit_get_trna(hit), "test1") == 0);
rng = gt_pbs_hit_get_coords(hit);
ensure(had_err, rng.start == 120);
ensure(had_err, rng.end == 136);
score1 = gt_pbs_hit_get_score(hit);
ensure(had_err, gt_pbs_hit_get_strand(hit) == GT_STRAND_FORWARD);
memset(tmp, 0, BUFSIZ-1);
memcpy(tmp, fullseq + (rng.start * sizeof (char)),
(rng.end - rng.start + 1) * sizeof (char));
ensure(had_err, strcmp(tmp, "acatactaggatgctag" ) == 0);
/* check second hit on reverse strand */
hit = gt_pbs_results_get_ranked_hit(res, 1);
ensure(had_err, hit != NULL);
ensure(had_err, gt_pbs_hit_get_alignment_length(hit) == 14);
ensure(had_err, gt_pbs_hit_get_edist(hit) == 1);
ensure(had_err, gt_pbs_hit_get_offset(hit) == 0);
ensure(had_err, gt_pbs_hit_get_tstart(hit) == 6);
ensure(had_err, strcmp(gt_pbs_hit_get_trna(hit), "test2") == 0);
rng = gt_pbs_hit_get_coords(hit);
ensure(had_err, rng.start == 506);
ensure(had_err, rng.end == 519);
score2 = gt_pbs_hit_get_score(hit);
ensure(had_err, gt_double_compare(score1, score2) > 0);
ensure(had_err, gt_pbs_hit_get_strand(hit) == GT_STRAND_REVERSE);
memset(tmp, 0, BUFSIZ-1);
memcpy(tmp, fullseq + (rng.start * sizeof (char)),
(rng.end - rng.start + 1) * sizeof (char));
ensure(had_err, strcmp(tmp, "gatcctaaggctac" ) == 0);
/* clean up */
gt_xremove(gt_str_get(tmpfilename));
ensure(had_err, !gt_file_exists(gt_str_get(tmpfilename)));
gt_str_delete(tmpfilename);
gt_bioseq_delete(o.trna_lib);
gt_free(rev_seq);
gt_free(seq);
gt_pbs_results_delete(res);
return had_err;
}
GthBSSMParam* gth_bssm_param_load(const char *filename, GtError *err)
{
GthBSSMParam *bssm_param = NULL;
GtStr *path = gt_str_new();
int had_err = 0;
gt_error_check(err);
if (gt_file_exists(filename))
gt_str_append_cstr(path, filename);
else {
if (strchr(filename, GT_PATH_SEPARATOR)) {
gt_error_set(err, "filename \"%s\" contains illegal symbol '%c': the "
"path list specified by environment variable \"%s\" "
"cannot be searched for it", filename,
GT_PATH_SEPARATOR, BSSMENVNAME);
had_err = -1;
}
/* check for file path in environment variable */
if (!had_err)
had_err = gt_file_find_in_env(path, filename, BSSMENVNAME, err);
if (!had_err && !gt_str_length(path)) {
gt_error_set(err, "file \"%s\" not found in directory list specified "
"by environment variable %s", filename, BSSMENVNAME);
had_err = -1;
}
if (!had_err) {
/* path found -> append filename */
gt_str_append_char(path, GT_PATH_SEPARATOR);
gt_str_append_cstr(path, filename);
}
else {
/* check for file path relative to binary */
int new_err = gt_file_find_exec_in_path(path, gt_error_get_progname(err),
NULL);
if (!new_err) {
gt_assert(gt_str_length(path));
gt_str_append_char(path, GT_PATH_SEPARATOR);
gt_str_append_cstr(path, "bssm");
gt_str_append_char(path, GT_PATH_SEPARATOR);
gt_str_append_cstr(path, filename);
if (gt_file_exists(gt_str_get(path))) {
gt_error_unset(err);
had_err = 0;
}
}
}
}
if (!had_err) {
if (!(bssm_param = bssm_param_plain_read(gt_str_get(path), err)))
had_err = -1;
if (had_err) {
/* loading new plain text format didn't work -> try old binary format */
if ((bssm_param = load_old_binary_format(path, filename, NULL))) {
/* loading binary format worked -> unset error */
gt_error_unset(err);
had_err = 0;
}
}
}
gt_str_delete(path);
if (had_err) {
gth_bssm_param_delete(bssm_param);
return NULL;
}
return bssm_param;
}
static int gt_speck_runner(int argc, const char **argv, int parsed_args,
void *tool_arguments, GtError *err)
{
GtNodeStream *gff3_in_stream = NULL, *checker_stream = NULL,
*a_in_stream = NULL, *a_out_stream = NULL,
*feature_stream = NULL, *sort_stream = NULL,
*last_stream = NULL;
GtNodeVisitor *spec_visitor = NULL;
GtSpecResults *res = NULL;
GtFeatureIndex *fi = NULL;
GtTypeChecker *type_checker = NULL;
GtTimer *t = NULL;
GtRegionMapping *rm = NULL;
GtArray *arr = gt_array_new(sizeof (GtFeatureNode*));
GtStr *prog, *speclib;
SpeccheckArguments *arguments = tool_arguments;
int had_err = 0;
gt_error_check(err);
res = gt_spec_results_new();
gt_assert(res);
if (gt_file_exists(gt_str_get(arguments->format))) {
speclib = gt_str_ref(arguments->format);
} else {
prog = gt_str_new();
gt_str_append_cstr_nt(prog, gt_error_get_progname(err),
gt_cstr_length_up_to_char(gt_error_get_progname(err), ' '));
speclib = gt_get_gtdata_path(gt_str_get(prog), NULL);
gt_str_delete(prog);
gt_str_append_cstr(speclib, "/spec/output_drivers/");
gt_str_append_str(speclib, arguments->format);
if (!gt_file_exists(gt_str_get(speclib))) {
gt_error_set(err, "output driver file \"%s\" does not exist",
gt_str_get(speclib));
had_err = -1;
}
}
if (!had_err) {
spec_visitor = gt_spec_visitor_new(gt_str_get(arguments->specfile), res,
err);
if (!spec_visitor) {
gt_spec_results_delete(res);
return -1;
}
}
t = gt_timer_new();
gt_assert(t);
/* add region mapping if given */
if (!had_err && gt_seqid2file_option_used(arguments->s2fi)) {
rm = gt_seqid2file_region_mapping_new(arguments->s2fi, err);
if (!rm)
had_err = -1;
if (!had_err)
gt_spec_visitor_add_region_mapping((GtSpecVisitor*) spec_visitor, rm);
}
/* set type checker if necessary */
if (!had_err && gt_typecheck_info_option_used(arguments->tci)) {
type_checker = gt_typecheck_info_create_type_checker(arguments->tci, err);
if (!type_checker)
had_err = -1;
if (!had_err)
gt_spec_visitor_add_type_checker((GtSpecVisitor*) spec_visitor,
type_checker);
}
if (!had_err) {
/* set runtime error behaviour */
if (arguments->fail_hard)
gt_spec_visitor_fail_on_runtime_error((GtSpecVisitor*) spec_visitor);
else
gt_spec_visitor_report_runtime_errors((GtSpecVisitor*) spec_visitor);
/* redirect warnings */
gt_warning_set_handler(gt_speck_record_warning, res);
last_stream = gff3_in_stream = gt_gff3_in_stream_new_unsorted(
argc - parsed_args,
argv + parsed_args);
gt_assert(gff3_in_stream);
gt_gff3_in_stream_enable_tidy_mode((GtGFF3InStream*) gff3_in_stream);
/* insert sort stream if requested */
if (arguments->sort) {
last_stream = sort_stream = gt_sort_stream_new(last_stream);
}
/* if -provideindex is given, collect input features and index them first */
if (arguments->provideindex) {
fi = gt_feature_index_memory_new();
gt_assert(fi);
last_stream = feature_stream = gt_feature_stream_new(last_stream, fi);
gt_assert(feature_stream);
last_stream = a_out_stream = gt_array_out_stream_all_new(last_stream, arr,
err);
if (!a_out_stream)
had_err = -1;
gt_timer_start(t);
if (!had_err)
had_err = gt_node_stream_pull(last_stream, err);
if (!had_err) {
gt_spec_visitor_add_feature_index((GtSpecVisitor*) spec_visitor,
gt_feature_index_ref(fi));
last_stream = a_in_stream = gt_array_in_stream_new(arr, NULL, err);
if (!a_in_stream)
had_err = -1;
}
} else {
gt_timer_start(t);
}
if (!had_err) {
checker_stream = gt_visitor_stream_new(last_stream, spec_visitor);
gt_assert(checker_stream);
}
/* perform checking */
if (!had_err)
had_err = gt_node_stream_pull(checker_stream, err);
gt_timer_stop(t);
/* reset warnings output */
gt_warning_set_handler(gt_warning_default_handler, NULL);
/* output results */
if (!had_err) {
GtStr *runtime = gt_str_new();
gt_timer_get_formatted(t, GT_WD ".%06ld", runtime);
had_err = gt_spec_results_render_template(res, gt_str_get(speclib),
arguments->outfp,
gt_str_get(arguments->specfile),
arguments->verbose,
arguments->colored,
gt_str_get(runtime), err);
gt_str_delete(runtime);
}
}
/* free */
gt_node_stream_delete(gff3_in_stream);
gt_node_stream_delete(a_in_stream);
gt_node_stream_delete(a_out_stream);
gt_node_stream_delete(checker_stream);
gt_node_stream_delete(feature_stream);
gt_node_stream_delete(sort_stream);
gt_spec_results_delete(res);
gt_feature_index_delete(fi);
gt_type_checker_delete(type_checker);
gt_timer_delete(t);
gt_array_delete(arr);
gt_str_delete(speclib);
return had_err;
}
