int gt_lua_set_modules_path(lua_State *L, GtError *err)
{
GtStr *modules_path = NULL, *external_modules_path = NULL,
*package_path = NULL;
int had_err = 0;
gt_error_check(err);
gt_assert(L);
if (!(modules_path = gt_get_gtdata_path(gt_error_get_progname(err), err)))
had_err = -1;
if (!had_err) {
external_modules_path = gt_str_clone(modules_path);
gt_str_append_cstr(modules_path, "/modules/?.lua");
gt_str_append_cstr(external_modules_path, "/modules/external/?.lua");
lua_getglobal(L, "package");
gt_assert(lua_istable(L, -1));
lua_getfield(L, -1, "path");
gt_assert(lua_isstring(L, -1));
package_path = gt_str_new_cstr(lua_tostring(L, -1));
lua_pop(L, 1);
gt_str_append_char(package_path, ';');
gt_str_append_str(package_path, modules_path);
gt_str_append_char(package_path, ';');
gt_str_append_str(package_path, external_modules_path);
lua_pushstring(L, gt_str_get(package_path));
lua_setfield(L, -2, "path");
lua_pop(L, 1);
}
gt_str_delete(package_path);
gt_str_delete(modules_path);
gt_str_delete(external_modules_path);
return had_err;
}
static void build_key(GtStr *key, GtFeatureNode *feature, GtStr *target_id)
{
gt_assert(key && feature && target_id);
gt_str_reset(key);
gt_str_append_str(key, gt_genome_node_get_seqid((GtGenomeNode*) feature));
gt_str_append_char(key, '\t'); /* cannot occur in seqid or target_id */
gt_str_append_str(key, target_id);
}
static int gt_readjoiner_assembly_build_contained_reads_list(
GtReadjoinerAssemblyArguments *arguments, GtBitsequence **contained,
GtError *err)
{
int had_err = 0;
unsigned int i;
GtUword nofreads, nofreads_i;
GtStr *filename;
filename = gt_str_clone(arguments->readset);
gt_str_append_cstr(filename, ".0" GT_READJOINER_SUFFIX_CNTLIST);
had_err = gt_cntlist_parse(gt_str_get(filename), true, contained,
&nofreads, err);
for (i = 1U; i < arguments->nspmfiles && had_err == 0; i++)
{
gt_str_reset(filename);
gt_str_append_str(filename, arguments->readset);
gt_str_append_char(filename, '.');
gt_str_append_uint(filename, i);
gt_str_append_cstr(filename, GT_READJOINER_SUFFIX_CNTLIST);
had_err = gt_cntlist_parse(gt_str_get(filename), false, contained,
&nofreads_i, err);
gt_assert(had_err || nofreads == nofreads_i);
}
gt_str_delete(filename);
return had_err;
}
void gt_gff3_output_leading_str(GtFeatureNode *fn, GtStr *outstr)
{
GtGenomeNode *gn;
gt_assert(fn && outstr);
gn = (GtGenomeNode*) fn;
gt_str_append_str(outstr, gt_genome_node_get_seqid(gn));
gt_str_append_char(outstr, '\t');
gt_str_append_cstr(outstr, gt_feature_node_get_source(fn));
gt_str_append_char(outstr, '\t');
gt_str_append_cstr(outstr, gt_feature_node_get_type(fn));
gt_str_append_char(outstr, '\t');
gt_str_append_uword(outstr, gt_genome_node_get_start(gn));
gt_str_append_char(outstr, '\t');
gt_str_append_uword(outstr, gt_genome_node_get_end(gn));
gt_str_append_char(outstr, '\t');
if (gt_feature_node_score_is_defined(fn)) {
char buf[BUFSIZ];
(void) snprintf(buf, BUFSIZ, "%.3g", gt_feature_node_get_score(fn));
gt_str_append_cstr(outstr, buf);
} else
gt_str_append_char(outstr, '.');
gt_str_append_char(outstr, '\t');
gt_str_append_char(outstr, GT_STRAND_CHARS[gt_feature_node_get_strand(fn)]);
gt_str_append_char(outstr, '\t');
gt_str_append_char(outstr, GT_PHASE_CHARS[gt_feature_node_get_phase(fn)]);
gt_str_append_char(outstr, '\t');
}
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);
}
static void set_gff3_target_attribute(GthSA *sa, bool md5ids)
{
gt_assert(sa && !sa->gff3_target_attribute);
sa->gff3_target_attribute = gt_str_new();
if (md5ids) {
gt_assert(sa->ref_md5);
gt_str_append_cstr(sa->gff3_target_attribute, GT_MD5_SEQID_PREFIX);
gt_str_append_str(sa->gff3_target_attribute, sa->ref_md5);
gt_str_append_char(sa->gff3_target_attribute, ':');
}
gt_gff3_escape(sa->gff3_target_attribute, gt_str_get(sa->ref_id),
gt_str_length(sa->ref_id));
gt_str_append_char(sa->gff3_target_attribute, ' ');
gt_str_append_uword(sa->gff3_target_attribute,
gth_sa_referencecutoff_start(sa) + 1); /* XXX: use
reference
dpstartpos */
gt_str_append_char(sa->gff3_target_attribute, ' ');
gt_str_append_uword(sa->gff3_target_attribute,
gth_sa_ref_total_length(sa) - /* XXX */
gth_sa_referencecutoff_end(sa));
gt_str_append_char(sa->gff3_target_attribute, ' ');
if (sa->ref_strand_forward) {
gt_str_append_char(sa->gff3_target_attribute,
GT_STRAND_CHARS[GT_STRAND_FORWARD]);
}
else {
gt_str_append_char(sa->gff3_target_attribute,
GT_STRAND_CHARS[GT_STRAND_REVERSE]);
}
}
static void construct_description(GtStr *description, const char *type,
GtUword counter, bool join,
bool translate, GtStr *seqid,
GtStrArray *target_ids)
{
gt_assert(!gt_str_length(description));
gt_str_append_cstr(description, type);
gt_str_append_char(description, '_');
gt_str_append_ulong(description, counter);
if (join)
gt_str_append_cstr(description, " (joined)");
if (translate)
gt_str_append_cstr(description, " (translated)");
if (seqid) {
gt_assert(gt_str_length(seqid));
gt_str_append_cstr(description, " [seqid ");
gt_str_append_str(description, seqid);
gt_str_append_char(description, ']');
}
if (target_ids && gt_str_array_size(target_ids)) {
GtUword i;
gt_str_append_cstr(description, " [target IDs ");
gt_str_append_cstr(description, gt_str_array_get(target_ids, 0));
for (i = 1; i < gt_str_array_size(target_ids); i++) {
gt_str_append_char(description, ',');
gt_str_append_cstr(description, gt_str_array_get(target_ids, i));
}
gt_str_append_char(description, ']');
}
}
static int update_bioseq_if_necessary(GtRegionMapping *rm, GtStr *seqid,
GtError *err)
{
int had_err = 0;
gt_error_check(err);
gt_assert(rm && seqid);
if (!rm->sequence_file || gt_str_cmp(rm->sequence_name, seqid)) {
gt_str_delete(rm->sequence_file);
rm->sequence_file = region_mapping_map(rm, gt_str_get(seqid), err);
if (!rm->sequence_file)
had_err = -1;
else {
if (!rm->sequence_name)
rm->sequence_name = gt_str_new();
else
gt_str_reset(rm->sequence_name);
gt_str_append_str(rm->sequence_name, seqid);
gt_bioseq_delete(rm->bioseq);
rm->bioseq = gt_bioseq_new_str(rm->sequence_file, err);
if (!rm->bioseq)
had_err = -1;
}
}
return had_err;
}
static bool id_string_is_unique(GtStr *id, GtStr *buf, GtCstrTable *tab,
GtUword i)
{
gt_str_reset(buf);
gt_str_append_str(buf, id);
make_unique_id_string(buf, i);
return !gt_cstr_table_get(tab, gt_str_get(buf));
}
void gt_alphabet_to_str(const GtAlphabet *alphabet, GtStr *dest)
{
GtUchar chartoshow, currentcc, previouscc = 0, firstinline = 0;
unsigned int cnum, linenum = 0;
bool afternewline = true;
gt_assert(alphabet && dest);
if (alphabet->alphadef != NULL) {
gt_assert(gt_str_length(alphabet->alphadef));
gt_str_append_str(dest, alphabet->alphadef);
} else {
for (cnum=0; cnum < alphabet->domainsize; cnum++)
{
currentcc = alphabet->mapdomain[cnum];
if (cnum > 0)
{
if (alphabet->symbolmap[currentcc] != alphabet->symbolmap[previouscc])
{
if (linenum < alphabet->mapsize-1)
{
chartoshow = alphabet->characters[linenum];
} else
{
chartoshow = alphabet->wildcardshow;
}
if (firstinline != chartoshow)
{
gt_str_append_char(dest, (char) chartoshow);
}
gt_str_append_char(dest, '\n');
afternewline = true;
linenum++;
} else
{
afternewline = false;
}
}
gt_str_append_char(dest, (char) currentcc);
if (afternewline)
{
firstinline = currentcc;
}
previouscc = currentcc;
}
if (linenum < alphabet->mapsize-1)
{
chartoshow = alphabet->characters[linenum];
} else
{
chartoshow = alphabet->wildcardshow;
}
if (firstinline != chartoshow)
{
gt_str_append_char(dest, (char) chartoshow);
}
gt_str_append_char(dest, '\n');
}
}
bool gt_tool_iterator_next(GtToolIterator *tool_iterator, const char **name,
GtTool **tool)
{
ToolIterationInfo tii;
gt_assert(tool_iterator && name && tool);
if (gt_array_size(tool_iterator->tool_stack)) {
ToolEntry *entry = gt_array_pop(tool_iterator->tool_stack);
*name = entry->name;
*tool = entry->tool;
if (tool_iterator->prefixptr) {
gt_str_reset(tool_iterator->prefixptr);
if (entry->prefix) {
gt_str_append_str(tool_iterator->prefixptr, entry->prefix);
gt_str_append_char(tool_iterator->prefixptr, tool_iterator->prefixsep);
}
}
if (gt_tool_is_toolbox(entry->tool)) {
GtToolbox *toolbox;
GtArray *toollist;
GtStr *myprefix;
myprefix =
gt_str_new_cstr(entry->prefix ? gt_str_get(entry->prefix) : "");
gt_str_append_cstr(myprefix, entry->name);
toolbox = gt_tool_get_toolbox(entry->tool);
toollist = gt_array_new(sizeof (ToolEntry));
tii.arr = toollist;
tii.str = myprefix;
gt_toolbox_iterate(toolbox, add_tool_to_stack, &tii);
if (gt_array_size(toollist)) {
gt_array_reverse(toollist); /* alphabetical order */
gt_array_add_array(tool_iterator->tool_stack, toollist);
}
gt_array_delete(toollist);
gt_str_delete(myprefix);
} else
gt_str_delete(entry->prefix);
return true;
}
else
return false;
}
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;
}
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;
}
void gt_graphics_cairo_save_to_stream(const GtGraphics *gg, GtStr *stream)
{
const GtGraphicsCairo *g = (const GtGraphicsCairo*) gg;
GT_UNUSED cairo_status_t rval;
cairo_surface_t *bgsurf = NULL;
cairo_t *bgc = NULL;
gt_assert(g && stream);
/* do nothing if no surface was created */
if (g->from_context)
return;
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_stream(bgsurf, str_write_func, stream);
gt_assert(rval == CAIRO_STATUS_SUCCESS); /* str_write_func() is sane */
cairo_destroy(bgc);
cairo_surface_destroy(bgsurf);
break;
default:
cairo_show_page(g->cr);
cairo_surface_flush(g->surf);
cairo_surface_finish(g->surf);
gt_str_reset(stream);
gt_str_append_str(stream, g->outbuf);
gt_assert(gt_str_length(stream) > 0);
}
}
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;
}
static int gt_genomediff_runner(int argc, const char **argv,
int parsed_args, void *tool_arguments,
GtError *err)
{
bool mirrored = false;
int had_err = 0,
i;
GtEncseq *encseq = NULL;
GtGenomediffArguments *arguments = tool_arguments;
GtLogger *logger;
GtShuUnitFileInfo *unit_info = NULL;
GtTimer *timer = NULL;
gt_error_check(err);
gt_assert(arguments);
logger = gt_logger_new(arguments->verbose,
GT_LOGGER_DEFLT_PREFIX,
stdout);
gt_assert(logger);
for (i = parsed_args; i < argc; i++) {
gt_str_array_add_cstr(arguments->filenames, argv[i]);
}
if (gt_showtime_enabled()) {
timer = gt_timer_new_with_progress_description("start");
gt_timer_start(timer);
gt_assert(timer);
}
if (arguments->with_units) {
gt_logger_log(logger, "unitfile option set, filename is %s\n",
gt_str_get(arguments->unitfile));
}
if (timer != NULL)
gt_timer_show_progress(timer, "start shu search", stdout);
if (gt_str_array_size(arguments->filenames) > 1UL) {
GtEncseqEncoder *ee = gt_encseq_encoder_new();
gt_encseq_encoder_set_timer(ee, timer);
gt_encseq_encoder_set_logger(ee, logger);
/* kr only makes sense for dna, so we can check this already with ee */
gt_encseq_encoder_set_input_dna(ee);
had_err = gt_encseq_encoder_encode(ee, arguments->filenames,
gt_str_get(arguments->indexname), err);
gt_encseq_encoder_delete(ee);
}
else {
gt_str_append_str(arguments->indexname,
gt_str_array_get_str(arguments->filenames, 0));
if (arguments->with_esa || arguments->with_pck) {
GtStr *current_line = gt_str_new();
FILE *prj_fp;
const char *buffer;
char **elements = NULL;
prj_fp = gt_fa_fopen_with_suffix(gt_str_get(arguments->indexname),
GT_PROJECTFILESUFFIX,"rb",err);
if (prj_fp == NULL)
had_err = -1;
while (!had_err && gt_str_read_next_line(current_line, prj_fp) != EOF) {
buffer = gt_str_get(current_line);
if (elements != NULL) {
gt_free(elements[0]);
gt_free(elements[1]);
}
gt_free(elements);
elements = gt_cstr_split(buffer, '=');
gt_log_log("%s", elements[0]);
if (strcmp("mirrored", elements[0]) == 0) {
gt_log_log("%s", elements[1]);
if (strcmp("1", elements[1]) == 0) {
mirrored = true;
gt_log_log("sequences are treated as mirrored");
}
}
gt_str_reset(current_line);
}
gt_str_delete(current_line);
if (elements != NULL) {
gt_free(elements[0]);
gt_free(elements[1]);
}
gt_free(elements);
gt_fa_xfclose(prj_fp);
}
}
if (!had_err) {
GtEncseqLoader *el = gt_encseq_loader_new_from_options(arguments->loadopts,
err);
if (mirrored)
gt_encseq_loader_mirror(el);
encseq =
gt_encseq_loader_load(el, gt_str_get(arguments->indexname), err);
gt_encseq_loader_delete(el);
}
if (encseq == NULL)
had_err = -1;
if (!had_err) {
unit_info = gt_shu_unit_info_new(encseq);
if (arguments->with_units)
had_err = gt_shu_unit_file_info_read(arguments->unitfile, unit_info,
logger, err);
}
if (!had_err) {
uint64_t **shusums = NULL;
if (arguments->with_esa || arguments->with_pck) {
shusums = gt_genomediff_shulen_sum(arguments, unit_info,
logger, timer, err);
if (shusums == NULL)
had_err = -1;
}
else {
const bool doesa = true;
GenomediffInfo gd_info;
Suffixeratoroptions sopts;
sopts.beverbose = arguments->verbose;
sopts.indexname = arguments->indexname;
sopts.db = NULL;
sopts.encopts = NULL;
sopts.genomediff = true;
sopts.inputindex = arguments->indexname;
sopts.loadopts = arguments->loadopts;
sopts.showprogress = false;
sopts.idxopts = arguments->idxopts;
gt_assert(unit_info != NULL);
gt_array2dim_calloc(shusums, unit_info->num_of_genomes,
unit_info->num_of_genomes);
gd_info.shulensums = shusums;
gd_info.unit_info = unit_info;
had_err = gt_runsuffixerator(doesa, &sopts, &gd_info, logger, err);
}
if (!had_err && shusums != NULL) {
had_err = gt_genomediff_kr_calc(shusums, arguments, unit_info,
arguments->with_pck, logger, timer, err);
gt_array2dim_delete(shusums);
}
}
if (timer != NULL) {
gt_timer_show_progress_final(timer, stdout);
gt_timer_delete(timer);
}
gt_logger_delete(logger);
gt_encseq_delete(encseq);
gt_shu_unit_info_delete(unit_info);
return had_err;
}
static int write_pdom(GtLTRdigestFileOutStream *ls, GtArray *pdoms,
const char *pdomname, GT_UNUSED GtRegionMapping *rmap,
char *desc, GtError *err)
{
int had_err = 0;
GtFile *seqfile = NULL,
*alifile = NULL,
*aafile = NULL;
GtUword i = 0,
seq_length = 0;
GtStr *pdom_seq,
*pdom_aaseq;
gt_error_check(err);
pdom_seq = gt_str_new();
pdom_aaseq = gt_str_new();
/* get protein domain output file */
seqfile = (GtFile*) gt_hashmap_get(ls->pdomout_files, pdomname);
if (seqfile == NULL)
{
/* no file opened for this domain yet, do it */
char buffer[GT_MAXFILENAMELEN];
(void) snprintf(buffer, (size_t) (GT_MAXFILENAMELEN-1), "%s_pdom_%s.fas",
ls->fileprefix, pdomname);
seqfile = gt_file_xopen(buffer, "w+");
gt_hashmap_add(ls->pdomout_files, gt_cstr_dup(pdomname), seqfile);
}
/* get protein alignment output file */
if (ls->write_pdom_alignments)
{
alifile = (GtFile*) gt_hashmap_get(ls->pdomali_files, pdomname);
if (alifile == NULL)
{
/* no file opened for this domain yet, do it */
char buffer[GT_MAXFILENAMELEN];
(void) snprintf(buffer, (size_t) (GT_MAXFILENAMELEN-1), "%s_pdom_%s.ali",
ls->fileprefix, pdomname);
alifile = gt_file_xopen(buffer, "w+");
gt_hashmap_add(ls->pdomali_files, gt_cstr_dup(pdomname), alifile);
}
}
/* get amino acid sequence output file */
if (ls->write_pdom_aaseqs)
{
aafile = (GtFile*) gt_hashmap_get(ls->pdomaa_files, pdomname);
if (aafile == NULL)
{
/* no file opened for this domain yet, do it */
char buffer[GT_MAXFILENAMELEN];
(void) snprintf(buffer, (size_t) (GT_MAXFILENAMELEN-1),
"%s_pdom_%s_aa.fas",
ls->fileprefix, pdomname);
aafile = gt_file_xopen(buffer, "w+");
gt_hashmap_add(ls->pdomaa_files, gt_cstr_dup(pdomname), aafile);
}
}
if (gt_array_size(pdoms) > 1UL)
{
for (i=1UL; i<gt_array_size(pdoms); i++)
{
gt_assert(gt_genome_node_cmp(*(GtGenomeNode**)gt_array_get(pdoms, i),
*(GtGenomeNode**)gt_array_get(pdoms, i-1))
>= 0);
}
if (gt_feature_node_get_strand(*(GtFeatureNode**) gt_array_get(pdoms, 0UL))
== GT_STRAND_REVERSE)
{
gt_array_reverse(pdoms);
}
}
/* output protein domain data */
for (i=0;i<gt_array_size(pdoms);i++)
{
GtRange pdom_rng;
GtStr *ali,
*aaseq;
GtFeatureNode *fn;
int rval;
fn = *(GtFeatureNode**) gt_array_get(pdoms, i);
ali = gt_genome_node_get_user_data((GtGenomeNode*) fn, "pdom_alignment");
aaseq = gt_genome_node_get_user_data((GtGenomeNode*) fn, "pdom_aaseq");
pdom_rng = gt_genome_node_get_range((GtGenomeNode*) fn);
rval = gt_extract_feature_sequence(pdom_seq, (GtGenomeNode*) fn,
gt_symbol(gt_ft_protein_match), false,
NULL, NULL, rmap, err);
if (rval)
{
had_err = -1;
break;
}
if (ls->write_pdom_alignments && ali)
{
char buf[BUFSIZ];
/* write away alignment */
(void) snprintf(buf, BUFSIZ-1, "Protein domain alignment in translated "
"sequence for candidate\n'%s':\n\n",
desc);
gt_file_xwrite(alifile, buf, (size_t) strlen(buf) * sizeof (char));
gt_file_xwrite(alifile, gt_str_get(ali),
(size_t) gt_str_length(ali) * sizeof (char));
gt_file_xwrite(alifile, "---\n\n", 5 * sizeof (char));
}
if (ls->write_pdom_aaseqs && aaseq)
{
/* append amino acid sequence */
gt_str_append_str(pdom_aaseq, aaseq);
}
gt_genome_node_release_user_data((GtGenomeNode*) fn, "pdom_alignment");
gt_genome_node_release_user_data((GtGenomeNode*) fn, "pdom_aaseq");
seq_length += gt_range_length(&pdom_rng);
}
if (!had_err)
{
gt_fasta_show_entry(desc,
gt_str_get(pdom_seq),
seq_length,
GT_FSWIDTH,
seqfile);
if (ls->write_pdom_aaseqs)
{
gt_fasta_show_entry(desc,
gt_str_get(pdom_aaseq),
gt_str_length(pdom_aaseq),
GT_FSWIDTH,
aafile);
}
}
gt_str_delete(pdom_seq);
gt_str_delete(pdom_aaseq);
return had_err;
}
static int grep_desc(GtBioseqCol *bsc, GtUword *filenum,
GtUword *seqnum, GtStr *seqid, GtError *err)
{
GtUword i, j, num_matches = 0;
const GtSeqInfo *seq_info_ptr;
GtSeqInfo seq_info;
GtStr *pattern, *escaped;
bool match = false;
int had_err = 0;
gt_error_check(err);
gt_assert(bsc && filenum && seqnum && seqid);
/* create cache */
if (!bsc->grep_cache)
bsc->grep_cache = gt_seq_info_cache_new();
/* try to read from cache */
seq_info_ptr = gt_seq_info_cache_get(bsc->grep_cache, gt_str_get(seqid));
if (seq_info_ptr) {
*filenum = seq_info_ptr->filenum;
*seqnum = seq_info_ptr->seqnum;
return 0;
}
pattern = gt_str_new();
escaped = gt_str_new();
gt_grep_escape_extended(escaped, gt_str_get(seqid), gt_str_length(seqid));
if (bsc->matchdescstart)
gt_str_append_cstr(pattern, "^");
gt_str_append_str(pattern, escaped);
if (bsc->matchdescstart)
gt_str_append_cstr(pattern, "([[:space:]]|$)");
for (i = 0; !had_err && i < bsc->num_of_seqfiles; i++) {
GtBioseq *bioseq = bsc->bioseqs[i];
for (j = 0; !had_err && j < gt_bioseq_number_of_sequences(bioseq); j++) {
const char *desc = gt_bioseq_get_description(bioseq, j);
had_err = gt_grep(&match, gt_str_get(pattern), desc, err);
if (!had_err && match) {
num_matches++;
if (num_matches > 1) {
gt_error_set(err, "query seqid '%s' could match more than one "
"sequence description", gt_str_get(seqid));
had_err = -1;
break;
}
*filenum = i;
*seqnum = j;
/* cache results */
seq_info.filenum = i;
seq_info.seqnum = j;
gt_seq_info_cache_add(bsc->grep_cache, gt_str_get(seqid), &seq_info);
}
}
if (match)
break;
}
gt_str_delete(pattern);
gt_str_delete(escaped);
if (!had_err && num_matches == 0) {
gt_error_set(err, "no description matched sequence ID '%s'",
gt_str_get(seqid));
had_err = -1;
}
return had_err;
}
static int update_seq_col_if_necessary(GtRegionMapping *rm, GtStr *seqid,
GtError *err)
{
int had_err = 0;
gt_error_check(err);
gt_assert(rm && seqid);
/* for mappings, we need to load the changed sequence, if needed... */
if (rm->mapping) {
if (!rm->sequence_file || (gt_str_cmp(rm->sequence_name, seqid))) {
gt_str_delete(rm->sequence_file);
/* ignore MD5 hashes when using region mappings */
if (gt_md5_seqid_has_prefix(gt_str_get(seqid))) {
rm->sequence_file = region_mapping_map(rm,
gt_str_get(seqid)
+GT_MD5_SEQID_TOTAL_LEN,
err);
} else
rm->sequence_file = region_mapping_map(rm, gt_str_get(seqid), err);
if (!rm->sequence_file)
had_err = -1;
else {
/* load new seqcol */
if (!rm->sequence_filenames)
rm->sequence_filenames = gt_str_array_new();
else
gt_str_array_reset(rm->sequence_filenames);
gt_str_array_add(rm->sequence_filenames, rm->sequence_file);
if (!rm->sequence_name)
rm->sequence_name = gt_str_new();
else
gt_str_reset(rm->sequence_name);
gt_str_append_str(rm->sequence_name, seqid);
gt_seq_col_delete(rm->seq_col);
rm->seq_col = gt_bioseq_col_new(rm->sequence_filenames, err);
if (!rm->seq_col)
had_err = -1;
}
}
} else {
/* ...otherwise, just make sure the seqcol is loaded */
if (!rm->seq_col) {
if (rm->encseq) {
if (!(rm->seq_col = gt_encseq_col_new(rm->encseq, err)))
had_err = -1;
} else {
gt_assert(rm->sequence_filenames);
if (!(rm->seq_col = gt_bioseq_col_new(rm->sequence_filenames, err)))
had_err = -1;
}
}
if (!had_err && rm->usedesc) {
if (rm->seqid2seqnum_mapping)
gt_seqid2seqnum_mapping_delete(rm->seqid2seqnum_mapping);
rm->seqid2seqnum_mapping =
gt_seqid2seqnum_mapping_new_seqcol(rm->seq_col, err);
if (!rm->seqid2seqnum_mapping) {
had_err = -1;
}
}
}
return had_err;
}
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;
}
int mg_curl(ParseStruct *parsestruct_ptr,
GtUword hit_counter, GtError * err)
{
int had_err = 0,
curl_errornr = 0;
/* Laenge der aus dem XML-File stammenden Hit-DNA-Sequenz */
GtUword seq_len;
GtWord numb_from = 0, numb_to = 0, numb_diff = 0;
GtStr *seq_var,
*http_adr;
MemoryStruct memorystruct;
/* char-Zeiger auf die HTTP-Adresse des cgi-Skriptes efetch von NCBI */
char *http_adr_ptr,
*seq_pos; /* char-Zeiger, wird benutzt zum
Auslesen der Sequenzinformation
aus dem XML-File, welche
Ergebnis der efetch-Anfrage ist */
const char *curlerror;
/* Curl-Handle */
CURL *curl_handle;
/* char-Zeiger auf die Daten ist NULL */
memorystruct.memory = NULL;
/* noch keine Daten eingetragen bzw. abgespeichert */
memorystruct.size = 0;
/* Zwischenspeicher fuer die Sequnezinformation, da die GtStrArray-Klasse
keine Funktion zum begrenzten Einfuegen eines Strings zur Verfuegung
stellt; setzen des ersten Teils der HTTP-Adresse */
seq_var = gt_str_new();
http_adr =
gt_str_new_cstr
("http://www.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=");
/* Check der Umgebungsvariablen */
gt_error_check(err);
curl_global_init(CURL_GLOBAL_ALL);
/* initialisieren der curl-session */
curl_handle = curl_easy_init();
/* Zusammensetzen der http-Adresse durch Anhaengen der query-GI-Nummer,
des Hit-from, des Hit-to Wertes und des Rueckgabetyps an den ersten
Teil der HTTP-Adresse */
gt_str_append_str(http_adr, ARGUMENTSSTRUCT(curl_fcgi_db));
gt_str_append_cstr(http_adr, "&id=gi|");
gt_str_append_str(http_adr, parsestruct_ptr->hit_gi_nr_tmp);
gt_str_append_cstr(http_adr, "&seq_start=");
gt_str_append_cstr(http_adr,
gt_str_array_get(MATRIXSTRUCT(hit_from), hit_counter));
gt_str_append_cstr(http_adr, "&seq_stop=");
gt_str_append_cstr(http_adr,
gt_str_array_get(MATRIXSTRUCT(hit_to), hit_counter));
gt_str_append_cstr(http_adr, "&retmode=xml");
/* char-Zeiger wird benoetigt, da curl_easy_setopt als 3. Parameter
einen char-Zeiger erwartet */
http_adr_ptr = gt_str_get(http_adr);
/* festlegen, welche HTTP-Adresse aufgerufen werden soll */
curl_easy_setopt(curl_handle, CURLOPT_URL, http_adr_ptr);
/* die empfangenen Daten werden an die Funktion WriteMemoryCallback
gesendet, wo Speicherplatz reserviert und die Daten in diesen
Speicherbereich kopiert werden */
curl_easy_setopt(curl_handle, CURLOPT_WRITEFUNCTION,
WriteMemoryCallback);
/* Die Daten werden in die Struktur eingetragen */
curl_easy_setopt(curl_handle, CURLOPT_WRITEDATA, (void *) &memorystruct);
/* setzen des user-agent field, da einige Server diesen voraussetzen */
curl_easy_setopt(curl_handle, CURLOPT_USERAGENT, "libcurl-agent/1.0");
/* Anfrage wird ausgefuehrt */
curl_errornr = curl_easy_perform(curl_handle);
curlerror = curl_easy_strerror(curl_errornr);
if (curl_errornr)
{
gt_error_set(err,
"an error occurred during curl-processing (error-code %d):\
\"%s\"", curl_errornr, curlerror);
had_err = -1;
}
if (!had_err)
{
/* Die Hit-DNA steht zwischen dem <GBSeq_sequence> und dem
</GBSeq_sequence> XML-Tag, Zeiger auf das < Zeichen von
<GBSeq_sequence> */
seq_pos = strstr(memorystruct.memory, "<GBSeq_sequence>");
if (!seq_pos)
{
gt_error_set(err,
"an error occurred while retrieving sequence-information\
with the following request: \"%s\"", http_adr_ptr);
had_err = -1;
}
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;
}
static int gt_extract_feature_sequence_generic(GtStr *sequence,
GtGenomeNode *gn,
const char *type, bool join, GtStr *seqid,
GtStrArray *target_ids,
unsigned int *out_phase_offset,
GtRegionMapping *region_mapping, GtError *err)
{
GtFeatureNode *fn;
GtRange range;
unsigned int phase_offset = 0;
char *outsequence;
const char *target;
int had_err = 0;
gt_error_check(err);
fn = gt_genome_node_cast(gt_feature_node_class(), gn);
gt_assert(fn);
if (seqid)
gt_str_append_str(seqid, gt_genome_node_get_seqid(gn));
if (target_ids &&
(target = gt_feature_node_get_attribute(fn, GT_GFF_TARGET))) {
had_err = gt_gff3_parser_parse_all_target_attributes(target, false,
target_ids, NULL,
NULL, "", 0, err);
}
if (!had_err) {
if (join) {
GtFeatureNodeIterator *fni;
GtFeatureNode *child;
bool reverse_strand = false,
first_child = true,
first_child_of_type_seen = false;
GtPhase phase = GT_PHASE_UNDEFINED;
/* in this case we have to traverse the children */
fni = gt_feature_node_iterator_new_direct(gt_feature_node_cast(gn));
while (!had_err && (child = gt_feature_node_iterator_next(fni))) {
if (first_child) {
if (target_ids &&
(target = gt_feature_node_get_attribute(child, GT_GFF_TARGET))) {
gt_str_array_reset(target_ids);
had_err = gt_gff3_parser_parse_all_target_attributes(target, false,
target_ids,
NULL,
NULL, "", 0,
err);
}
first_child = false;
}
if (!had_err) {
if (extract_join_feature((GtGenomeNode*) child, type, region_mapping,
sequence, &reverse_strand,
&first_child_of_type_seen,
&phase, err)) {
had_err = -1;
}
if (phase != GT_PHASE_UNDEFINED) {
phase_offset = (int) phase;
}
}
}
gt_feature_node_iterator_delete(fni);
gt_assert(phase_offset <= (unsigned int) GT_PHASE_UNDEFINED);
if (!had_err && gt_str_length(sequence)) {
if (reverse_strand) {
had_err = gt_reverse_complement(gt_str_get(sequence),
gt_str_length(sequence), err);
}
}
}
else if (gt_feature_node_get_type(fn) == type) {
GtPhase phase = gt_feature_node_get_phase(fn);
gt_assert(!had_err);
if (phase != GT_PHASE_UNDEFINED)
phase_offset = (unsigned int) phase;
/* otherwise we only have to look at this feature */
range = gt_genome_node_get_range(gn);
gt_assert(range.start); /* 1-based coordinates */
had_err = gt_region_mapping_get_sequence(region_mapping, &outsequence,
gt_genome_node_get_seqid(gn),
range.start, range.end, err);
if (!had_err) {
gt_str_append_cstr_nt(sequence, outsequence, gt_range_length(&range));
gt_free(outsequence);
if (gt_feature_node_get_strand(fn) == GT_STRAND_REVERSE) {
had_err = gt_reverse_complement(gt_str_get(sequence),
gt_str_length(sequence), err);
}
}
}
}
if (out_phase_offset && phase_offset != GT_PHASE_UNDEFINED) {
*out_phase_offset = phase_offset;
}
return had_err;
}
