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 gt_fasta_reader_rec_run(GtFastaReader *fasta_reader,
GtFastaReaderProcDescription
proc_description,
GtFastaReaderProcSequencePart
proc_sequence_part,
GtFastaReaderProcSequenceLength
proc_sequence_length, void *data,
GtError *err)
{
GtFastaReaderRec *fr = gt_fasta_reader_rec_cast(fasta_reader);
GtStr *description, *sequence;
int had_err = 0;
gt_error_check(err);
/* at least one function has to be defined */
gt_assert(proc_description || proc_sequence_part || proc_sequence_length);
/* init */
description = gt_str_new();
sequence = gt_str_new();
/* make sure file is not empty */
if (!gt_io_has_char(fr->seqio)) {
gt_error_set(err, "sequence file \"%s\" is empty",
gt_io_get_filename(fr->seqio));
had_err = -1;
}
/* parse file */
while (!had_err && gt_io_has_char(fr->seqio)) {
/* reset */
gt_str_reset(description);
gt_str_reset(sequence);
/* parse entry */
had_err = parse_fasta_entry(description, sequence, fr->seqio, err);
/* process entry */
if (!had_err && proc_description) {
had_err = proc_description(gt_str_get(description),
gt_str_length(description), data, err);
}
if (!had_err && proc_sequence_part) {
had_err = proc_sequence_part(gt_str_get(sequence),
gt_str_length(sequence), data, err);
}
if (!had_err && proc_sequence_length)
had_err = proc_sequence_length(gt_str_length(sequence), data, err);
}
/* free */
gt_str_delete(description);
gt_str_delete(sequence);
return had_err;
}
int gt_extract_and_translate_feature_sequence(GtFeatureNode *feature_node,
const char *type,
bool join,
GtRegionMapping *rm,
GtTransTable *ttable,
GtStr *translation_fr1,
GtStr *translation_fr2,
GtStr *translation_fr3,
GtError *err)
{
GtTranslator *tr = NULL;
GtTranslatorStatus status;
GtCodonIterator *ci = NULL;
unsigned int frame, phase_offset = 0;
char translated;
int had_err = 0;
GtStr *sequence = gt_str_new();
gt_assert(feature_node && type);
had_err = gt_extract_feature_sequence_generic(sequence,
(GtGenomeNode*) feature_node,
type, join, NULL, NULL,
&phase_offset, rm, err);
/* do translation if we have at least one codon */
if (!had_err && gt_str_length(sequence) > phase_offset + 2) {
ci = gt_codon_iterator_simple_new(gt_str_get(sequence) + phase_offset,
gt_str_length(sequence) - phase_offset,
NULL);
tr = gt_translator_new(ci);
if (ttable)
gt_translator_set_translation_table(tr, ttable);
status = gt_translator_next(tr, &translated, &frame, NULL);
while (status == GT_TRANSLATOR_OK) {
if (frame == 0 && translation_fr1)
gt_str_append_char(translation_fr1, translated);
else if (frame == 1 && translation_fr2)
gt_str_append_char(translation_fr2, translated);
else if (frame == 2 && translation_fr3)
gt_str_append_char(translation_fr3, translated);
status = gt_translator_next(tr, &translated, &frame, NULL);
}
if (status == GT_TRANSLATOR_ERROR)
had_err = -1;
}
gt_translator_delete(tr);
gt_codon_iterator_delete(ci);
gt_str_delete(sequence);
return had_err;
}
static int gt_genomediff_arguments_check(int rest_argc,
void *tool_arguments,
GtError *err)
{
GtGenomediffArguments *arguments = tool_arguments;
bool prepared_index;
int had_err = 0;
gt_error_check(err);
gt_assert(arguments);
if (rest_argc == 0) {
gt_error_set(err, "give at least one file (base)name!");
had_err = -1;
}
if (!had_err) {
if (strcmp("esa", gt_str_get(arguments->indextype)) == 0)
arguments->with_esa = true;
else if (strcmp("pck", gt_str_get(arguments->indextype)) == 0)
arguments->with_pck = true;
}
prepared_index = (arguments->with_esa || arguments->with_pck);
if (!had_err && arguments->user_max_depth != -1 && !arguments->with_pck)
gt_warning("option -maxdepth does only apply to -indextype pck");
if (!had_err &&
prepared_index && gt_encseq_options_mirrored_value(arguments->loadopts))
gt_warning("option -mirrored is ignored with esa and pck index");
if (!had_err && prepared_index && rest_argc > 1) {
gt_error_set(err, "there should be only one basename argument with "
"-indextype esa|pck");
had_err = -1;
}
if (rest_argc == 1 && gt_str_length(arguments->indexname) != 0) {
gt_error_set(err, "Option -indexname is only needed with sequence files, "
"if one file is given as argument, this should be an index.");
had_err = -1;
}
if (!had_err && rest_argc > 1 && gt_str_length(arguments->indexname) == 0) {
gt_error_set(err, "more than one input file given, please use -indexname "
"for basename of indices created during run.");
had_err = -1;
}
if (!had_err)
arguments->with_units = gt_option_is_set(arguments->ref_unitfile);
return had_err;
}
static inline int parse_fastq_block(GtSeqIteratorFastQ *seqit, GtError *err)
{
int had_err = 0;
gt_assert(seqit);
gt_error_check(err);
/* parse @<seqname> */
had_err = parse_fastq_seqname(seqit,
seqit->descbuffer,
GT_FASTQ_BLOCK_START_CHAR,
err);
if (!had_err) {
/* parse sequence */
had_err = parse_fastq_sequence(seqit, err);
gt_fastq_premature_end_check(had_err, seqit);
}
if (!had_err) {
/* parse +[seqname] */
had_err = parse_fastq_seqname(seqit,
seqit->qdescbuffer,
GT_FASTQ_QUAL_SEPARATOR_CHAR,
err);
gt_fastq_premature_end_check(had_err, seqit);
}
if (!had_err
&& gt_str_length(seqit->qdescbuffer)
&& gt_str_cmp(seqit->descbuffer, seqit->qdescbuffer) != 0)
{
gt_error_set(err, "sequence description '%s' is not equal to "
"qualities description '%s' in line %lu",
gt_str_get(seqit->descbuffer),
gt_str_get(seqit->qdescbuffer),
seqit->curline-1);
return -2;
}
if (!had_err) {
/* parse qualities */
had_err = parse_fastq_qualities(seqit, err);
if (gt_str_length(seqit->qualsbuffer)
!= gt_str_length(seqit->sequencebuffer))
{
gt_error_set(err, "lengths of character sequence and qualities "
"sequence differ (%lu <-> %lu)",
gt_str_length(seqit->qualsbuffer),
gt_str_length(seqit->sequencebuffer));
return -2;
}
}
return had_err;
}
static inline int parse_fastq_seqname(GtSeqIteratorFastQ *seqit,
GtStr *buffer,
char startchar,
GtError *err)
{
char currentchar;
bool firstsymbol = true;
gt_error_check(err);
gt_assert(seqit && buffer);
gt_assert(gt_str_length(buffer) == 0);
if ((currentchar = fastq_buf_getchar(seqit)) == EOF)
return EOF;
seqit->currentread++;
if (currentchar != startchar) {
gt_error_set(err, "'%c' expected, '%c' encountered instead in line %lu",
startchar,
currentchar,
seqit->curline);
return -2;
}
while (currentchar != GT_FASTQ_NEWLINESYMBOL) {
if (!firstsymbol)
gt_str_append_char(buffer, currentchar);
else
firstsymbol = false;
if ((currentchar = fastq_buf_getchar(seqit)) == EOF)
return EOF;
seqit->currentread++;
}
seqit->curline++;
return 0;
}
static int gt_splitfasta_runner(GT_UNUSED int argc, const char **argv,
int parsed_args, void *tool_arguments,
GtError *err)
{
SplitfastaArguments *arguments = tool_arguments;
unsigned int num_files;
int had_err;
off_t file_size;
const char* filename;
gt_error_check(err);
gt_assert(arguments);
num_files = arguments->num_files;
filename = argv[parsed_args];
if (gt_str_length(arguments->splitdesc)) {
had_err = split_description(filename, arguments->splitdesc,
arguments->width, arguments->force, err);
}
else {
unsigned long max_filesize;
if (num_files) {
/* set the maxfile size based on requested number of files */
file_size = gt_file_estimate_size(filename);
max_filesize= file_size / num_files ;
}
else
max_filesize= arguments->max_filesize_in_MB << 20;
had_err = split_fasta_file(filename, max_filesize, arguments->force, err);
}
return had_err;
}
static int gt_cge_spacedseed_arguments_check(int rest_argc,
void *tool_arguments,
GtError *err)
{
Cge_spacedseed_options *arguments = tool_arguments;
if (gt_str_length(arguments->str_inputindex) == 0)
{
gt_error_set(err,"missing indexname");
return -1;
}
if (gt_option_is_set(arguments->refoptionesaindex))
{
arguments->withesa = true;
} else
{
gt_assert(gt_option_is_set(arguments->refoptionpckindex));
arguments->withesa = false;
}
if (rest_argc != 0)
{
gt_error_set(err,"superfluous file arguments");
return -1;
}
return 0;
}
static GtUword applycheckfunctiontosimpleoptions(
Checkcmppairfuntype checkfunction,
const Cmppairwiseopt *opt)
{
if (gt_str_array_size(opt->strings) > 0)
{
bool forward = true;
while (true)
{
checkfunction(forward,
(const GtUchar *) gt_str_array_get(opt->strings,0),
(GtUword) strlen(gt_str_array_get(opt->strings,0)),
(const GtUchar *) gt_str_array_get(opt->strings,1UL),
(GtUword) strlen(gt_str_array_get(opt->strings,1UL)));
if (!forward)
{
break;
}
forward = false;
}
return 2UL; /* number of testcases */
}
if (gt_str_array_size(opt->files) > 0)
{
if (opt->fasta)
{
GtUword i, j;
for (i = 0; i < gt_str_array_size(opt->fastasequences0); i++)
{
for (j = 0; j < gt_str_array_size(opt->fastasequences1); j++)
{
checkfunction(true,
(const GtUchar *) gt_str_array_get(opt->fastasequences0,i),
(GtUword) strlen(gt_str_array_get(opt->fastasequences0,i)),
(const GtUchar *) gt_str_array_get(opt->fastasequences1,j),
(GtUword) strlen(gt_str_array_get(opt->fastasequences1,j)));
}
}
}
else
{
gt_runcheckfunctionontwofiles(checkfunction,
gt_str_array_get(opt->files,0),
gt_str_array_get(opt->files,1UL));
}
return 2UL;
}
if (opt->charlistlen != NULL)
{
return gt_runcheckfunctiononalphalen(checkfunction,
gt_str_get(opt->charlistlen->charlist),
opt->charlistlen->len);
}
if (gt_str_length(opt->text) > 0)
{
return gt_runcheckfunctionontext(checkfunction, gt_str_get(opt->text));
}
gt_assert(false);
return 0;
}
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]);
}
}
const char* gth_sa_gff3_target_attribute(GthSA *sa, bool md5ids)
{
gt_assert(sa);
if (!sa->gff3_target_attribute && (md5ids || gt_str_length(sa->ref_id)))
set_gff3_target_attribute(sa, md5ids);
return gt_str_get(sa->gff3_target_attribute);
}
static int gt_extractseq_runner(int argc, const char **argv, int parsed_args,
void *tool_arguments, GtError *err)
{
ExtractSeqArguments *arguments = tool_arguments;
int had_err = 0;
gt_error_check(err);
gt_assert(arguments);
if (gt_str_length(arguments->fastakeyfile)) {
had_err = process_fastakeyfile(arguments->fastakeyfile, argc - parsed_args,
argv + parsed_args, arguments->width,
arguments->outfp, err);
}
else {
GtBioseqIterator *bsi;
GtBioseq *bs;
bsi = gt_bioseq_iterator_new(argc - parsed_args, argv + parsed_args);
while (!had_err &&
!(had_err = gt_bioseq_iterator_next(bsi, &bs, err)) && bs) {
if (arguments->frompos) {
had_err = extractseq_pos(arguments->outfp, bs, arguments->frompos,
arguments->topos, arguments->width, err);
}
else {
had_err = extractseq_match(arguments->outfp, bs,
gt_str_get(arguments->pattern),
arguments->width, err);
}
gt_bioseq_delete(bs);
}
gt_bioseq_iterator_delete(bsi);
}
return had_err;
}
static int select_visitor_region_node(GtNodeVisitor *nv, GtRegionNode *rn,
GT_UNUSED GtError *err)
{
GtSelectVisitor *select_visitor;
gt_error_check(err);
select_visitor = select_visitor_cast(nv);
if (!gt_str_length(select_visitor->seqid) || /* no seqid was specified */
!gt_str_cmp(select_visitor->seqid, /* or seqids are equal */
gt_genome_node_get_seqid((GtGenomeNode*) rn))) {
if (select_visitor->contain_range.start != GT_UNDEF_ULONG) {
GtRange range = gt_genome_node_get_range((GtGenomeNode*) rn);
if (gt_range_overlap(&range, &select_visitor->contain_range)) {
/* an overlapping contain range was defined -> update range */
range.start = MAX(range.start, select_visitor->contain_range.start);
range.end = MIN(range.end, select_visitor->contain_range.end);
gt_genome_node_set_range((GtGenomeNode*) rn, &range);
gt_queue_add(select_visitor->node_buffer, rn);
}
else /* contain range does not overlap with <rn> range -> delete <rn> */
gt_genome_node_delete((GtGenomeNode*) rn);
}
else
gt_queue_add(select_visitor->node_buffer, rn);
}
else
gt_genome_node_delete((GtGenomeNode*) rn);
return 0;
}
static int feature_node_lua_extract_sequence(lua_State *L)
{
GtGenomeNode **gn;
GtFeatureNode *fn;
const char *type;
bool join;
GtRegionMapping **region_mapping;
GtStr *sequence;
GtError *err;
gn = check_genome_node(L, 1);
/* make sure we get a feature node */
fn = gt_feature_node_try_cast(*gn);
luaL_argcheck(L, fn, 1, "not a feature node");
type = luaL_checkstring(L, 2);
join = lua_toboolean(L, 3);
region_mapping = check_region_mapping(L, 4);
err = gt_error_new();
sequence = gt_str_new();
if (gt_extract_feature_sequence(sequence, *gn, type, join, NULL, NULL,
*region_mapping, err)) {
gt_str_delete(sequence);
return gt_lua_error(L, err);
}
if (gt_str_length(sequence))
lua_pushstring(L, gt_str_get(sequence));
else
lua_pushnil(L);
gt_str_delete(sequence);
gt_error_delete(err);
return 1;
}
static void showsimpleoptions(const Cmppairwiseopt *opt)
{
if (gt_str_array_size(opt->strings) > 0)
{
if (!opt->showedist)
printf("# two strings \"%s\" \"%s\"\n", gt_str_array_get(opt->strings,0),
gt_str_array_get(opt->strings,1UL));
return;
}
if (gt_str_array_size(opt->files) > 0)
{
printf("# two files \"%s\" \"%s\"\n", gt_str_array_get(opt->files,0),
gt_str_array_get(opt->files,1UL));
return;
}
if (opt->charlistlen != NULL)
{
printf("# alphalen \"%s\" " GT_WU "\n",
gt_str_get(opt->charlistlen->charlist),
opt->charlistlen->len);
return;
}
if (gt_str_length(opt->text) > 0)
{
printf("# text \"%s\"\n", gt_str_get(opt->text));
return;
}
}
bool gt_splicedseq_pos_is_border(const Splicedseq *ss, unsigned long pos)
{
gt_assert(ss &&
gt_str_length(ss->splicedseq) == gt_array_size(ss->positionmapping));
gt_assert(pos < gt_str_length(ss->splicedseq)); /* legal position */
if (ss->forward && pos + 1 < gt_array_size(ss->positionmapping) &&
*(unsigned long*) gt_array_get(ss->positionmapping, pos) + 1 !=
*(unsigned long*) gt_array_get(ss->positionmapping, pos+1)) {
return true;
}
if (!ss->forward && pos &&
*(unsigned long*) gt_array_get(ss->positionmapping, pos-1) - 1 !=
*(unsigned long*) gt_array_get(ss->positionmapping, pos)) {
return true;
}
return false;
}
static int gt_seqtranslate_do_translation(GtTranslateArguments *arguments,
const char *sequence,
GtUword length,
const char *desc,
GtStr **translations,
bool rev,
GtError *err)
{
GtTranslator *tr;
GT_UNUSED GtTranslatorStatus trst;
GtCodonIterator *ci;
char translated;
int had_err = 0;
GtStr *str;
unsigned int frame,
i;
ci = gt_codon_iterator_simple_new(sequence, length, err);
tr = gt_translator_new(ci);
trst = gt_translator_next(tr, &translated, &frame, err);
while (trst == GT_TRANSLATOR_OK) {
gt_str_append_char(translations[frame], translated);
trst = gt_translator_next(tr, &translated, &frame, err);
}
gt_codon_iterator_delete(ci);
gt_translator_delete(tr);
if (trst == GT_TRANSLATOR_ERROR)
return -1;
str = gt_str_new();
for (i = 0; i < 3; i++) {
if (gt_str_length(translations[i]) > 0) {
gt_str_append_cstr(str, desc);
gt_str_append_cstr(str, " (");
gt_str_append_ulong(str, i+1);
gt_str_append_cstr(str, rev ? "-" : "+");
gt_str_append_cstr(str, ")");
gt_fasta_show_entry(gt_str_get(str), gt_str_get(translations[i]),
gt_str_length(translations[i]),
arguments->fasta_width, arguments->outfp);
gt_str_reset(translations[i]);
gt_str_reset(str);
}
}
gt_str_delete(str);
return had_err;
}
static int gt_compreads_compress_runner(GT_UNUSED int argc,
GT_UNUSED const char **argv,
GT_UNUSED int parsed_args,
void *tool_arguments, GtError *err)
{
GtCsrHcrEncodeArguments *arguments = tool_arguments;
int had_err = 0;
GtAlphabet *alpha = NULL;
GtHcrEncoder *hcre = NULL;
GtTimer *timer = NULL;
gt_error_check(err);
gt_assert(arguments);
if (gt_showtime_enabled()) {
timer = gt_timer_new_with_progress_description("start");
gt_timer_start(timer);
gt_assert(timer);
}
if (gt_str_length(arguments->smap) > 0) {
alpha = gt_alphabet_new_from_file_no_suffix(gt_str_get(arguments->smap),
err);
if (!alpha)
had_err = 1;
}
else {
alpha = gt_alphabet_new_dna();
if (!alpha)
had_err = 1;
}
if (!had_err) {
if (timer != NULL)
gt_timer_show_progress(timer, "encoding", stdout);
hcre = gt_hcr_encoder_new(arguments->files, alpha, arguments->descs,
arguments->qrng, timer, err);
if (!hcre)
had_err = 1;
else {
if (arguments->pagewise)
gt_hcr_encoder_set_sampling_page(hcre);
else if (arguments->regular)
gt_hcr_encoder_set_sampling_regular(hcre);
gt_hcr_encoder_set_sampling_rate(hcre, arguments->srate);
if (gt_hcr_encoder_encode(hcre, gt_str_get(arguments->name),
timer, err) != 0)
had_err = 1;
}
gt_hcr_encoder_delete(hcre);
}
gt_alphabet_delete(alpha);
if (timer != NULL) {
gt_timer_show_progress_final(timer, stdout);
gt_timer_delete(timer);
}
return had_err;
}
static int gt_encseq_encode_runner(GT_UNUSED int argc, const char **argv,
int parsed_args, GT_UNUSED void *tool_arguments,
GtError *err)
{
int had_err = 0,
i;
GtEncseqEncodeArguments *arguments =
(GtEncseqEncodeArguments*) tool_arguments;
GtStrArray *infiles;
gt_error_check(err);
infiles = gt_str_array_new();
for (i = parsed_args; i < argc; i++) {
gt_str_array_add_cstr(infiles, argv[i]);
}
if (gt_str_length(arguments->indexname) == 0UL) {
if (gt_str_array_size(infiles) > 1UL) {
gt_error_set(err,"if more than one input file is given, then "
"option -indexname is mandatory");
had_err = -1;
} else {
char *basenameptr;
basenameptr = gt_basename(gt_str_array_get(infiles, 0UL));
gt_str_set(arguments->indexname, basenameptr);
gt_free(basenameptr);
}
}
if (!had_err) {
gt_assert(gt_str_length(arguments->indexname) > 0UL);
had_err = encode_sequence_files(infiles,
arguments->eopts,
gt_str_get(arguments->indexname),
arguments->verbose,
arguments->no_esq_header,
err);
}
if (!had_err && arguments->showstats)
show_encoded_statistics(infiles, gt_str_get(arguments->indexname));
gt_str_array_delete(infiles);
return had_err;
}
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');
}
}
static int process_gt_strand_arg(GtStr *gt_strand_char, GtStrand *strand,
const char *optstr, GtError *err)
{
int had_err = 0;
gt_error_check(err);
if (gt_str_length(gt_strand_char)) {
GtStrand tmpstrand = gt_strand_get(gt_str_get(gt_strand_char)[0]);
if ((gt_str_length(gt_strand_char) > 1) ||
(tmpstrand == GT_NUM_OF_STRAND_TYPES)) {
gt_error_set(err, "argument to option -%s must be one of '"
GT_STRAND_CHARS"'", optstr);
had_err = -1;
}
if (!had_err)
*strand = tmpstrand;
}
return had_err;
}
static int file_find_in_env_generic(GtStr *path, const char *file,
const char *env, FileExistsFunc file_exists,
GtError *err)
{
char *pathvariable, *pathcomponent = NULL;
GtSplitter *splitter = NULL;
GtUword i;
int had_err = 0;
gt_error_check(err);
gt_assert(file);
gt_assert(file_exists);
/* check if 'file' has dirname */
gt_file_dirname(path, file);
if (gt_str_length(path))
return had_err;
/* 'file' has no dirname -> scan $env */
pathvariable = getenv(env);
if (pathvariable != NULL)
pathvariable = gt_cstr_dup(pathvariable); /* make writeable copy */
else {
gt_error_set(err, "environment variable $%s is not defined", env);
had_err = -1;
}
if (!had_err) {
splitter = gt_splitter_new();
gt_splitter_split(splitter, pathvariable,
(GtUword) strlen(pathvariable), GT_PATH_VAR_SEPARATOR);
for (i = 0; i < gt_splitter_size(splitter); i++) {
pathcomponent = gt_splitter_get_token(splitter, i);
gt_str_reset(path);
gt_str_append_cstr(path, pathcomponent);
gt_str_append_char(path, GT_PATH_SEPARATOR);
gt_str_append_cstr(path, file);
if (file_exists(gt_str_get(path)))
break;
}
if (i < gt_splitter_size(splitter)) {
/* file found in path */
gt_str_reset(path);
gt_str_append_cstr(path, pathcomponent);
}
else {
/* file not found in path */
gt_str_reset(path);
}
}
/* free */
gt_free(pathvariable);
gt_splitter_delete(splitter);
return had_err;
}
void gt_alphabet_output(const GtAlphabet *alphabet, FILE *fpout)
{
GtStr *buf;
gt_assert(alphabet && fpout);
buf = gt_str_new();
gt_alphabet_to_str(alphabet, buf);
gt_xfwrite(gt_str_get(buf), sizeof (char), (size_t) gt_str_length(buf),
fpout);
gt_str_delete(buf);
}
static int construct_bioseq_files(GtBioseq *bs, GtStr *bioseq_indexname,
GtError *err)
{
GtStr *sequence_filename;
GtEncseqEncoder *ee;
GtStrArray *indexfn;
int had_err = 0;
gt_error_check(err);
/* register the signal handler to remove incomplete files upon termination */
if (!bs->use_stdin) {
gt_bioseq_index_filename = gt_str_get(bs->sequence_file);
gt_sig_register_all(remove_bioseq_files);
}
/* if stdin is used as input, we need to create a tempfile containing the
sequence as GtEncseq cannot be built from stdin directly */
if (bs->use_stdin) {
GtStr *tmpfilename;
FILE *tmpfile = NULL;
int i;
char buf[BUFSIZ];
tmpfilename = gt_str_new();
tmpfile = gt_xtmpfp(tmpfilename);
gt_assert(tmpfile);
i = 1;
while (i > 0) {
i = fread(buf, 1, BUFSIZ, stdin);
if (i > 0) fwrite(buf, 1, i, tmpfile);
}
gt_fa_xfclose(tmpfile);
sequence_filename = tmpfilename;
} else {
sequence_filename = gt_str_ref(bs->sequence_file);
}
gt_assert(gt_str_length(sequence_filename) > 0);
ee = gt_encseq_encoder_new();
gt_encseq_encoder_enable_description_support(ee);
gt_encseq_encoder_enable_md5_support(ee);
gt_encseq_encoder_enable_multiseq_support(ee);
gt_encseq_encoder_enable_lossless_support(ee);
indexfn = gt_str_array_new();
gt_str_array_add(indexfn, sequence_filename);
gt_str_delete(sequence_filename);
had_err = gt_encseq_encoder_encode(ee, indexfn,
gt_str_get(bioseq_indexname), err);
/* unregister the signal handler */
if (!bs->use_stdin)
gt_sig_unregister_all();
gt_str_array_delete(indexfn);
gt_encseq_encoder_delete(ee);
return had_err;
}
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 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;
}
static int parse_fasta_sequence(GtStr *sequence, GtIO *seqio, GtError *err)
{
char cc;
gt_error_check(err);
gt_assert(sequence && seqio);
gt_assert(!gt_str_length(sequence));
/* read sequence */
while (!gt_io_get_char(seqio, &cc) && cc != FASTA_SEPARATOR) {
if (cc != '\n' && cc != ' ')
gt_str_append_char(sequence, cc);
}
if (!gt_str_length(sequence)) {
gt_error_set(err, "empty sequence given in line %lu",
gt_io_get_line_number(seqio));
return -1;
}
if (cc == FASTA_SEPARATOR)
gt_io_unget_char(seqio, FASTA_SEPARATOR);
return 0;
}
static void seqid_store_add(SeqidStore *ss, GtUword filenum,
GtUword seqnum, GtStr *seqid,
GtUword offset)
{
gt_assert(ss && seqid);
gt_assert(gt_str_length(seqid)); /* is not empty */
gt_assert(filenum < ss->num_of_files);
gt_assert(seqnum < ss->num_of_sequences[filenum]);
gt_assert(!ss->store[filenum][seqnum]); /* is unused */
ss->store[filenum][seqnum] = gt_str_clone(seqid);
ss->offsets[filenum][seqnum] = offset == GT_UNDEF_UWORD ? 1 : offset;
}
static int extracttarget_from_seqfiles(const char *target,
GtStrArray *seqfiles,
GtError *err)
{
GtStr *unescaped_target;
char *escaped_target;
GtSplitter *splitter;
unsigned long i;
int had_err = 0;
gt_error_check(err);
gt_assert(target && seqfiles);
splitter = gt_splitter_new();
unescaped_target = gt_str_new();
escaped_target = gt_cstr_dup(target);
gt_splitter_split(splitter, escaped_target, strlen(escaped_target), ',');
for (i = 0; !had_err && i < gt_splitter_size(splitter); i++) {
GtSplitter *blank_splitter;
char *token = gt_splitter_get_token(splitter, i);
blank_splitter = gt_splitter_new();
gt_splitter_split(blank_splitter, token, strlen(token), ' ');
had_err = gt_gff3_unescape(unescaped_target,
gt_splitter_get_token(blank_splitter, 0),
strlen(gt_splitter_get_token(blank_splitter, 0)),
err);
if (!had_err) {
unsigned long j;
for (j = 0; j < gt_str_array_size(seqfiles); j++) {
unsigned long k;
GtBioseq *bioseq;
if (!(bioseq = gt_bioseq_new(gt_str_array_get(seqfiles, j), err))) {
had_err = -1;
break;
}
for (k = 0; k < gt_bioseq_number_of_sequences(bioseq); k++) {
TargetInfo target_info;
const char *desc = gt_bioseq_get_description(bioseq, k);
target_info.bioseq = bioseq;
target_info.seqnum = k;
gt_string_matching_bmh(desc, strlen(desc),
gt_str_get(unescaped_target),
gt_str_length(unescaped_target), show_target,
&target_info);
}
gt_bioseq_delete(bioseq);
}
}
gt_splitter_delete(blank_splitter);
}
gt_free(escaped_target);
gt_str_delete(unescaped_target);
gt_splitter_delete(splitter);
return had_err;
}
static GtStr* seqid_store_get(SeqidStore *ss, GtUword filenum,
GtUword seqnum)
{
GtStr *seqid;
gt_assert(ss);
gt_assert(filenum < ss->num_of_files);
gt_assert(seqnum < ss->num_of_sequences[filenum]);
gt_assert(ss->store[filenum][seqnum]); /* is used */
seqid = ss->store[filenum][seqnum];
gt_assert(gt_str_length(seqid)); /* is not empty */
return seqid;
}
