static GtCodonIteratorStatus gt_codon_iterator_encseq_next(GtCodonIterator *ci,
char *n1,
char *n2,
char *n3,
unsigned int *frame,
GT_UNUSED GtError
*err)
{
GtCodonIteratorEncseq *cie;
gt_assert(n1 && n2 && n3 && frame);
gt_error_check(err);
if (ci->pvt->curpos+2 >= ci->pvt->length)
return GT_CODON_ITERATOR_END;
cie = gt_codon_iterator_encseq_cast(ci);
*n1 = gt_encseq_get_decoded_char(cie->encseq,
ci->pvt->startpos+ci->pvt->curpos,
cie->readmode);
*n2 = gt_encseq_get_decoded_char(cie->encseq,
ci->pvt->startpos+ci->pvt->curpos+1,
cie->readmode);
*n3 = gt_encseq_get_decoded_char(cie->encseq,
ci->pvt->startpos+ci->pvt->curpos+2,
cie->readmode);
*frame = ci->pvt->curpos % GT_CODON_LENGTH;
ci->pvt->curpos++;
return GT_CODON_ITERATOR_OK;
}
static void gt_hpol_processor_refregioncheck(
GtAlignedSegment *as, void *data)
{
GtHpolProcessor *hpp = data;
unsigned long rlen, i, startpos;
char *r;
bool haserr = false;
gt_assert(hpp != NULL);
gt_aligned_segment_ungap_refregion(as);
gt_aligned_segment_assign_refregion_chars(as, hpp->encseq);
r = gt_aligned_segment_refregion(as);
rlen = (unsigned long)strlen(r);
startpos = gt_aligned_segment_refregion_startpos(as);
for (i = 0; i < rlen; i++)
{
if (r[i] != gt_encseq_get_decoded_char(hpp->encseq, startpos + i,
GT_READMODE_FORWARD))
{
haserr = true;
}
}
if (haserr)
{
char *s;
gt_aligned_segment_ungap_seq_and_qual(as);
s = gt_aligned_segment_seq(as);
fprintf(stderr, "segment = %s\n", s);
fprintf(stderr, "refregion = %s\n", r);
fprintf(stderr, " ");
for (i = 0; i < rlen; i++)
{
if (r[i] != gt_encseq_get_decoded_char(hpp->encseq, startpos + i,
GT_READMODE_FORWARD))
fprintf(stderr, "X");
else
fprintf(stderr, " ");
}
fprintf(stderr, "\n");
fprintf(stderr, "cognate = ");
for (i = 0; i < rlen; i++)
{
fprintf(stderr, "%c", gt_encseq_get_decoded_char(hpp->encseq,
startpos + i, GT_READMODE_FORWARD));
}
fprintf(stderr, "\n");
fprintf(stderr, "[startpos = %lu]\n", startpos);
exit(EXIT_FAILURE);
}
}
char gt_bioseq_get_char(const GtBioseq *bs, GtUword index,
GtUword position)
{
GtUword startpos;
gt_assert(bs);
gt_assert(index < gt_encseq_num_of_sequences(bs->encseq));
startpos = gt_encseq_seqstartpos(bs->encseq, index);
return gt_encseq_get_decoded_char(bs->encseq, startpos + position,
GT_READMODE_FORWARD);
}
static int encseq_lua_get_decoded_char(lua_State *L)
{
GtEncseq **encseq;
GtUword pos;
int readmode;
char cc;
encseq = check_encseq(L, 1);
pos = luaL_checknumber(L, 2);
readmode = luaL_checknumber(L, 3);
luaL_argcheck(L, pos < gt_encseq_total_length(*encseq), 2,
"cannot exceed total length of encoded sequence");
cc = gt_encseq_get_decoded_char(*encseq, pos, readmode);
lua_pushlstring(L, &cc, sizeof (char));
return 1;
}
static int output_sequence(GtEncseq *encseq, GtEncseqDecodeArguments *args,
const char *filename, GtError *err)
{
GtUword i, j, sfrom, sto;
int had_err = 0;
bool has_desc;
GtEncseqReader *esr;
gt_assert(encseq);
if (!(has_desc = gt_encseq_has_description_support(encseq)))
gt_warning("Missing description support for file %s", filename);
if (strcmp(gt_str_get(args->mode), "fasta") == 0) {
/* specify a single sequence to extract */
if (args->seq != GT_UNDEF_UWORD) {
if (args->seq >= gt_encseq_num_of_sequences(encseq)) {
gt_error_set(err,
"requested sequence "GT_WU" exceeds number of sequences "
"("GT_WU")", args->seq,
gt_encseq_num_of_sequences(encseq));
return -1;
}
sfrom = args->seq;
sto = args->seq + 1;
} else if (args->seqrng.start != GT_UNDEF_UWORD
&& args->seqrng.end != GT_UNDEF_UWORD) {
/* specify a sequence range to extract */
if (args->seqrng.start >= gt_encseq_num_of_sequences(encseq)
|| args->seqrng.end >= gt_encseq_num_of_sequences(encseq)) {
gt_error_set(err,
"range "GT_WU"-"GT_WU" includes a sequence number "
"exceeding the total number of sequences ("GT_WU")",
args->seqrng.start,
args->seqrng.end,
gt_encseq_num_of_sequences(encseq));
return -1;
}
sfrom = args->seqrng.start;
sto = args->seqrng.end + 1;
} else {
/* extract all sequences */
sfrom = 0;
sto = gt_encseq_num_of_sequences(encseq);
}
for (i = sfrom; i < sto; i++) {
GtUword desclen, startpos, len;
char buf[BUFSIZ];
const char *desc = NULL;
/* XXX: maybe make this distinction in the functions via readmode? */
if (!GT_ISDIRREVERSE(args->rm)) {
startpos = gt_encseq_seqstartpos(encseq, i);
len = gt_encseq_seqlength(encseq, i);
if (has_desc) {
desc = gt_encseq_description(encseq, &desclen, i);
} else {
(void) snprintf(buf, BUFSIZ, "sequence "GT_WU"", i);
desclen = strlen(buf);
desc = buf;
}
} else {
startpos = gt_encseq_seqstartpos(encseq, i);
len = gt_encseq_seqlength(encseq,
gt_encseq_num_of_sequences(encseq)-1-i);
startpos = gt_encseq_total_length(encseq)
- (gt_encseq_seqstartpos(encseq,
gt_encseq_num_of_sequences(
encseq)-1-i) + len);
if (has_desc) {
desc = gt_encseq_description(encseq,
&desclen,
gt_encseq_num_of_sequences(encseq)-1-i);
} else {
(void) snprintf(buf, BUFSIZ, "sequence "GT_WU"", i);
desclen = strlen(buf);
desc = buf;
}
}
gt_assert(desc);
/* output description */
gt_xfputc(GT_FASTA_SEPARATOR, stdout);
gt_xfwrite(desc, 1, desclen, stdout);
gt_xfputc('\n', stdout);
/* XXX: make this more efficient by writing in a buffer first and then
showing the result */
if (args->singlechars) {
for (j = 0; j < len; j++) {
gt_xfputc(gt_encseq_get_decoded_char(encseq,
startpos + j,
args->rm),
stdout);
}
} else {
esr = gt_encseq_create_reader_with_readmode(encseq, args->rm, startpos);
for (j = 0; j < len; j++) {
gt_xfputc(gt_encseq_reader_next_decoded_char(esr), stdout);
}
gt_encseq_reader_delete(esr);
}
gt_xfputc('\n', stdout);
}
}
if (strcmp(gt_str_get(args->mode), "concat") == 0) {
GtUword from = 0,
to = gt_encseq_total_length(encseq) - 1;
if (args->rng.start != GT_UNDEF_UWORD && args->rng.end != GT_UNDEF_UWORD) {
if (args->rng.end > to) {
had_err = -1;
gt_error_set(err,
"end of range ("GT_WU") exceeds encoded sequence length "
"("GT_WU")", args->rng.end, to);
}
if (!had_err) {
from = args->rng.start;
to = args->rng.end;
}
}
if (!had_err) {
if (args->singlechars) {
for (j = from; j <= to; j++) {
char cc = gt_encseq_get_decoded_char(encseq, j, args->rm);
if (cc == (char) SEPARATOR)
cc = gt_str_get(args->sepchar)[0];
gt_xfputc(cc, stdout);
}
} else {
esr = gt_encseq_create_reader_with_readmode(encseq, args->rm, from);
if (esr) {
for (j = from; j <= to; j++) {
char cc = gt_encseq_reader_next_decoded_char(esr);
if (cc == (char) SEPARATOR)
cc = gt_str_get(args->sepchar)[0];
gt_xfputc(cc, stdout);
}
gt_encseq_reader_delete(esr);
}
}
gt_xfputc('\n', stdout);
}
}
return had_err;
}
