static int scanuintintline(uint32_t *lengthofkey,
Smallorbigint *smallorbigint,
const char *linebuffer,
unsigned long linelength,
GtError *err)
{
int64_t readint;
unsigned long i;
bool found = false;
int retval = 0;
gt_error_check(err);
for (i=0; i<linelength; i++)
{
if (linebuffer[i] == '=')
{
*lengthofkey = (uint32_t) i;
found = true;
if (sscanf((const char *) (linebuffer + i + 1),
FormatScanint64_t,
SCANint64_tcast(&readint)) != 1 ||
readint < (int64_t) 0)
{
gt_error_set(err,"cannot find non-negative integer in \"%*.*s\"",
(int) (linelength - (i+1)),
(int) (linelength - (i+1)),
linebuffer + i + 1);
return -1;
}
if (readint <= (int64_t) UINT32_MAX)
{
smallorbigint->smallvalue = (uint32_t) readint;
retval = 0;
} else
{
smallorbigint->bigvalue = (uint64_t) readint;
retval = 1;
}
break;
}
}
if (!found)
{
gt_error_set(err,"missing equality symbol in \"%*.*s\"",
(int) linelength,
(int) linelength,
linebuffer);
return -2;
}
return retval;
}
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 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 int create_block_features(GtBEDParser *bed_parser, GtFeatureNode *fn,
unsigned long block_count,
GtSplitter *size_splitter,
GtSplitter *start_splitter, GtIO *bed_file,
GtError *err)
{
unsigned long i;
int had_err = 0;
gt_assert(fn && block_count && size_splitter && start_splitter);
gt_assert(gt_splitter_size(size_splitter) == block_count);
gt_assert(gt_splitter_size(start_splitter) == block_count);
for (i = 0; !had_err && i < block_count; i++) {
unsigned long block_size, block_start, start, end;
GtGenomeNode *block;
const char *name;
if (gt_parse_ulong(&block_size, gt_splitter_get_token(size_splitter, i))) {
gt_error_set(err, "file \"%s\": line %lu: could not parse blockSize '%s'",
gt_io_get_filename(bed_file),
gt_io_get_line_number(bed_file),
gt_splitter_get_token(size_splitter, i));
had_err = -1;
}
if (!had_err && gt_parse_ulong(&block_start,
gt_splitter_get_token(start_splitter, i))) {
gt_error_set(err, "file \"%s\": line %lu: could not parse blockStart "
"'%s'", gt_io_get_filename(bed_file),
gt_io_get_line_number(bed_file),
gt_splitter_get_token(start_splitter, i));
had_err = -1;
}
if (!had_err) {
start = gt_genome_node_get_start((GtGenomeNode*) fn) + block_start;
end = start + block_size - 1;
block = gt_feature_node_new(gt_genome_node_get_seqid((GtGenomeNode*) fn),
bed_parser->block_type
? bed_parser->block_type
: BED_BLOCK_TYPE,
start, end, gt_feature_node_get_strand(fn));
if ((name = gt_feature_node_get_attribute(fn, "Name")))
gt_feature_node_add_attribute((GtFeatureNode*) block, "Name", name);
gt_feature_node_set_score((GtFeatureNode*) block,
gt_feature_node_get_score(fn));
gt_feature_node_set_strand((GtFeatureNode*) block,
gt_feature_node_get_strand(fn));
gt_feature_node_add_child(fn, (GtFeatureNode*) block);
}
}
return had_err;
}
static GtTranslationScheme* getschemetable(unsigned int transnum, GtError *err)
{
if (transnum >= GT_SIZEOFTRANSRANGE) {
gt_error_set(err, "'%u' is not a valid translation table number!",
transnum);
return NULL;
}
if (transnum2index[transnum] == GT_UNDEFTRANSNUM) {
gt_error_set(err, "'%u' is not a valid translation table number!",
transnum);
return NULL;
}
gt_assert(transnum != GT_UNDEFTRANSNUM);
return schemetable + transnum2index[transnum];
}
/*call makeblastdb with given path to <dbfile>*/
static inline int gt_condenser_search_create_blastdb(const char* dbfile,
const char *dbtype,
GtError *err) {
int had_err = 0,
pipe_status;
GtStr *call = gt_str_new_cstr("makeblastdb -dbtype ");
char *call_str;
FILE* fpipe;
gt_str_append_cstr(call, dbtype);
gt_str_append_cstr(call, " -in ");
gt_str_append_cstr(call, dbfile);
call_str = gt_str_get(call);
gt_log_log("executed call: %s", call_str);
if ((fpipe = popen(call_str, "r")) == NULL) {
gt_error_set(err, "Could not open pipe to call makeblastdb");
had_err = -1;
}
if (!had_err) {
char *newline = NULL;
char line[BUFSIZ + 1];
line[BUFSIZ] = '\0';
while (fgets(line, (int) BUFSIZ, fpipe) != NULL) {
if ((newline = strrchr(line, '\n')) != NULL) {
*newline = '\0';
newline = NULL;
}
gt_log_log("%.*s", BUFSIZ, line);
}
}
gt_str_delete(call);
if (!had_err) {
pipe_status = pclose(fpipe);
if (pipe_status != 0) {
had_err = -1;
if (errno == ECHILD)
gt_error_set(err, "Error calling makeblastdb.");
#ifndef _WIN32
else if (WEXITSTATUS(pipe_status) == 127)
gt_error_set(err, "shell returned 127, makeblastdb not installed?");
else
gt_error_set(err, "makeblastdb error, returned %d",
WEXITSTATUS(pipe_status));
#endif
}
}
return had_err;
}
int gt_script_filter_run(GtScriptFilter *sf, GtFeatureNode *gf,
bool *select_node, GtError *err)
{
int had_err = 0;
#ifndef NDEBUG
int stack_size;
#endif
GtGenomeNode *gn_lua;
#ifndef NDEBUG
stack_size = lua_gettop(sf->L);
#endif
if (!had_err) {
lua_getglobal(sf->L, "filter");
if (lua_isnil(sf->L, -1)) {
gt_error_set(err, "function 'filter' is not defined");
had_err = -1;
lua_pop(sf->L, 1);
}
}
if (!had_err) {
gn_lua = gt_genome_node_ref((GtGenomeNode*) gf);
gt_lua_genome_node_push(sf->L, gn_lua);
if (lua_pcall(sf->L, 1, 1, 0) != 0) {
gt_error_set(err, "error running function 'filter': %s",
lua_tostring(sf->L, -1));
lua_pop(sf->L, 1);
had_err = -1;
}
}
if (!had_err && !lua_isboolean(sf->L, -1)) {
gt_error_set(err, "function 'filter' must return boolean");
lua_pop(sf->L, 1);
had_err = -1;
}
if (!had_err) {
*select_node = lua_toboolean(sf->L, -1);
lua_pop(sf->L, 1);
}
gt_assert(lua_gettop(sf->L) == stack_size);
return had_err;
}
static int gt_cntlist_parse_bin(FILE *infp, bool alloc_cntlist,
GtBitsequence **cntlist, GtUword *nofreads, GtError *err)
{
int had_err = gt_cntlist_parse_bin_or_bit_header(infp, nofreads, err);
if (had_err == 0)
{
size_t n;
GtUword seqnum;
gt_assert(cntlist != NULL);
if (alloc_cntlist)
GT_INITBITTAB(*cntlist, *nofreads);
while (true)
{
n = fread(&seqnum, sizeof (GtUword), (size_t)1, infp);
if (n != (size_t)1)
{
if (!feof(infp))
{
gt_error_set(err, "contained reads file: unrecognized format");
had_err = -1;
}
break;
}
GT_SETIBIT(*cntlist, seqnum);
}
}
return had_err;
}
GtIntset *gt_intset_io(GtIntset *intset, FILE *fp, GtError *err)
{
int had_err = 0;
GtUword type;
if (intset == NULL) {
had_err = gt_intset_read_type_rewind(fp, &type, err);
if (!had_err && gt_intset_8_file_is_type(type))
intset = gt_intset_8_io(intset, fp, err);
else {
if (!had_err && gt_intset_16_file_is_type(type))
intset = gt_intset_16_io(intset, fp, err);
else {
if (!had_err && gt_intset_32_file_is_type(type))
intset = gt_intset_32_io(intset, fp, err);
else {
if (!gt_error_is_set(err))
gt_error_set(err, "could not identify intset type from file");
}
}
}
}
else {
gt_assert(intset->c_class != NULL);
gt_assert(intset->c_class->io_func != NULL);
intset = intset->c_class->io_func(intset, fp, err);
}
return intset;
}
static int gt_intset_read_type_rewind(FILE *fp, GtUword *type, GtError *err)
{
int had_err = 0;
fpos_t pos;
if (fgetpos(fp, &pos) != 0) {
gt_error_set(err, "fgetpos failed");
had_err = 1;
}
if (!had_err)
had_err = gt_io_error_fread(type, sizeof (*type), (size_t) 1, fp, err);
if (!had_err && fsetpos(fp, &pos) != 0) {
gt_error_set(err, "fsetpos failed");
had_err = 1;
}
return had_err;
}
GtRDB* gt_rdb_mysql_new(const char *server,
unsigned int port,
const char *database,
const char *username,
const char *password,
GtError *err)
{
GtRDBMySQL *rdbm;
GtRDB *rdb = gt_rdb_create(gt_rdb_mysql_class());
rdbm = gt_rdb_mysql_cast(rdb);
mysql_init(&rdbm->conn);
mysql_options(&rdbm->conn, MYSQL_READ_DEFAULT_GROUP, "genometools");
if (!mysql_real_connect(&rdbm->conn, server, username, password, database,
port, NULL,
CLIENT_COMPRESS | CLIENT_MULTI_STATEMENTS))
{
gt_error_set(err, "cannot connect to database: %s",
mysql_error(&rdbm->conn));
mysql_close(&rdbm->conn);
gt_rdb_delete(rdb);
return NULL;
}
rdbm->database = gt_str_new_cstr(database);
return rdb;
}
static const char *desc2key(unsigned long *keylen,const char *desc,
GtError *err)
{
unsigned long i, firstpipe = 0, secondpipe = 0;
gt_error_check(err);
for (i=0; desc[i] != '\0'; i++)
{
if (desc[i] == '|')
{
if (firstpipe > 0)
{
gt_assert(i>0);
secondpipe = i;
break;
}
gt_assert(i>0);
firstpipe = i;
}
}
if (firstpipe == 0 || secondpipe == 0)
{
gt_error_set(err,"Cannot find key in description \"%s\"",desc);
return NULL;
}
gt_assert(firstpipe < secondpipe);
*keylen = secondpipe - firstpipe - 1;
return desc + firstpipe + 1;
}
static int gt_rdb_stmt_mysql_get_double(GtRDBStmt *st, GtUword field_no,
double *result, GtError *err)
{
GtRDBStmtMySQL *stm;
MYSQL_BIND res_bind;
int had_err = 0;
double res_double = GT_UNDEF_DOUBLE;
my_bool error, is_null;
gt_assert(st && result);
gt_error_check(err);
stm = gt_rdb_stmt_mysql_cast(st);
CHECK_INIT_STATEMENT
if (!had_err) {
memset(&res_bind, 0, sizeof (res_bind));
res_bind.buffer_type = MYSQL_TYPE_DOUBLE;
res_bind.buffer = &res_double;
res_bind.error = &error;
res_bind.is_null = &is_null;
if ((had_err = mysql_stmt_fetch_column(stm->stmt, &res_bind, field_no, 0)))
gt_error_set(err, GT_MYSQL_ERRMSG, had_err, mysql_stmt_error(stm->stmt));
}
if (!had_err)
*result = res_double;
return had_err;
}
void *gt_Sfxmappedrange_map_entire(GtSfxmappedrange *sfxmappedrange,
GtError *err)
{
size_t mappedsize;
gt_assert(sfxmappedrange != NULL);
sfxmappedrange->entire = gt_fa_mmap_read(gt_str_get(sfxmappedrange->filename),
&mappedsize,err);
if (sfxmappedrange->entire == NULL)
{
return NULL;
}
if (mappedsize != gt_Sfxmappedrange_size_entire(sfxmappedrange))
{
gt_error_set(err,
"map file %s: mapped size = "GT_WU" != "
GT_WU" = expected size",
gt_str_get(sfxmappedrange->filename), (GtUword) mappedsize,
(GtUword) gt_Sfxmappedrange_size_entire(sfxmappedrange));
gt_fa_xmunmap(sfxmappedrange->entire);
sfxmappedrange->entire = NULL;
return NULL;
}
gt_log_log("map %s completely ("GT_WU" units of size %u)",
gt_str_get(sfxmappedrange->tablename),
(GtUword) sfxmappedrange->numofunits,
(unsigned int) sfxmappedrange->sizeofunit);
return sfxmappedrange->entire;
}
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;
}
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;
}
extern EISeq *
createEncIdxSeqGen(Seqpos totalLen, const GtStr *projectName,
MRAEnc *alphabet, const struct seqStats *stats,
SeqDataReader seqGenerator,
const struct seqBaseParam *params,
size_t numExtHeaders, const uint16_t *headerIDs,
const uint32_t *extHeaderSizes,
headerWriteFunc *extHeaderCallbacks,
void **headerCBData,
bitInsertFunc biFunc, BitOffset cwExtBitsPerPos,
varExtBitsEstimator biVarBits, void *cbState, GtError *err)
{
EISeq *seqIdx = NULL;
switch (params->encType)
{
case BWT_ON_BLOCK_ENC:
seqIdx = newGenBlockEncIdxSeq(totalLen, projectName, alphabet, stats,
seqGenerator, params, numExtHeaders,
headerIDs, extHeaderSizes, extHeaderCallbacks,
headerCBData, biFunc, cwExtBitsPerPos,
biVarBits, cbState, err);
break;
default:
gt_error_set(err, "Illegal/unknown/unimplemented encoding requested!");
break;
}
return seqIdx;
}
int gt_bioseq_iterator_next(GtBioseqIterator *bsi, GtBioseq **bioseq,
GtError *err)
{
int had_err = 0;
gt_error_check(err);
gt_assert(bsi && bioseq);
if (bsi->current_file < bsi->seqfile_counter) {
if (bsi->sequence_files[bsi->current_file] &&
!strcmp(bsi->sequence_files[bsi->current_file], "-")) {
if (bsi->stdin_was_used) {
gt_error_set(err, "multiple specification of sequence file \"-\"");
had_err = -1;
}
else
bsi->stdin_was_used = true;
}
if (!had_err) {
if (bsi->sequence_files[bsi->current_file])
*bioseq = gt_bioseq_new(bsi->sequence_files[bsi->current_file], err);
else
*bioseq = gt_bioseq_new("-", err);
if (*bioseq)
bsi->current_file++;
else
had_err = -1;
}
}
else
*bioseq = NULL;
return had_err;
}
static int assigncorrecttype(GtMapspecification *mapspec,
void *ptr,
GtUword byteoffset,
GtError *err)
{
void *voidptr;
int had_err = 0;
gt_error_check(err);
switch (mapspec->typespec)
{
case GtCharType:
ASSIGNPTR2STARTPTR(char);
break;
case GtFilelengthvaluesType:
ASSIGNPTR2STARTPTR(GtFilelengthvalues);
break;
case GtUcharType:
ASSIGNPTR2STARTPTR(GtUchar);
break;
case Uint16Type:
ASSIGNPTR2STARTPTR(uint16_t);
break;
case Uint32Type:
ASSIGNPTR2STARTPTR(uint32_t);
break;
case GtUlongType:
ASSIGNPTR2STARTPTR(GtUword);
break;
case Uint64Type:
ASSIGNPTR2STARTPTR(uint64_t);
break;
case GtBitsequenceType:
ASSIGNPTR2STARTPTR(GtBitsequence);
break;
case GtUlongBoundType:
ASSIGNPTR2STARTPTR(GtUlongBound);
break;
case GtPairBwtidxType:
ASSIGNPTR2STARTPTR(GtPairBwtidx);
break;
case GtTwobitencodingType:
ASSIGNPTR2STARTPTR(GtTwobitencoding);
break;
case GtSpecialcharinfoType:
ASSIGNPTR2STARTPTR(GtSpecialcharinfo);
break;
case GtBitElemType:
ASSIGNPTR2STARTPTR(BitElem);
break;
case GtUintType:
ASSIGNPTR2STARTPTR(unsigned int);
break;
default:
gt_error_set(err, "no assignment specification for size " GT_WU,
(GtUword) mapspec->sizeofunit);
had_err = -1;
}
return had_err;
}
static int insertfirstsuffixes(Mergertrierep *trierep,
unsigned long *nextpostable,
Suffixarray *suffixarraytable,
unsigned int numofindexes,
GtError *err)
{
unsigned int idx;
unsigned long suftabvalue;
int retval;
gt_error_check(err);
for (idx=0; idx<numofindexes; idx++)
{
retval
= gt_readnextfromstream_GtUlong(&suftabvalue,
&suffixarraytable[idx].suftabstream_GtUlong);
if (retval == 0)
{
gt_error_set(err,"file %s: line %d: unexpected end of file when "
"reading suftab",__FILE__,__LINE__);
return -2;
}
nextpostable[idx]++;
fillandinsert(trierep,
idx,
suftabvalue,
trierep->root,
(uint64_t) idx);
}
return 0;
}
static int readkeysize(const char *indexname,GtError *err)
{
FILE *fp;
bool haserr = false;
char cc;
gt_error_check(err);
fp = gt_fa_fopen_with_suffix(indexname,GT_KEYSTABFILESUFFIX,"rb",err);
if (fp == NULL)
{
haserr = true;
}
if (!haserr)
{
GT_UNUSED size_t ret;
ret = fread(&cc,sizeof cc, (size_t) 1, fp);
if (ferror(fp))
{
gt_error_set(err,"error when trying to read first byte of file %s%s: %s",
indexname,GT_KEYSTABFILESUFFIX,strerror(errno));
haserr = true;
}
}
gt_assert(cc >= 0);
gt_fa_xfclose(fp);
return haserr ? -1 : (int) cc;
}
static int parse_bed_range(GtRange *range, GtStr *start, GtStr *end,
GtWord offset, GtIO *bed_file, bool thick,
GtError *err)
{
int had_err;
gt_error_check(err);
had_err = gt_parse_range(range, gt_str_get(start), gt_str_get(end),
gt_io_get_line_number(bed_file),
gt_io_get_filename(bed_file), err);
/* BED has a weird numbering scheme: positions are 0-based, but the end
position is not part of the feature. Transform to 1-based coordinates. */
range->start++;
/* Ranges defining a 'thick' region sometimes come with length 0 to
designate that there are no thick regions. So do not fail here and
handle that case later. */
if (!thick) {
if (!had_err && range->start > range->end) {
gt_error_set(err, "file \"%s\": line "GT_WU": BED feature has length 0",
gt_io_get_filename(bed_file),
gt_io_get_line_number(bed_file));
had_err = -1;
}
}
if (offset)
*range = gt_range_offset(range, offset);
return had_err;
}
static int gt_bioseq_col_grep_desc(GtSeqCol *sc, char **seq,
GtUword start, GtUword end,
GtStr *seqid, GtError *err)
{
GtUword filenum = 0, seqnum = 0, seqlength;
int had_err;
GtBioseqCol *bsc;
bsc = gt_bioseq_col_cast(sc);
gt_error_check(err);
gt_assert(bsc && seq && seqid);
had_err = grep_desc(bsc, &filenum, &seqnum, seqid, err);
if (!had_err) {
seqlength = gt_bioseq_get_sequence_length(bsc->bioseqs[filenum], seqnum);
if (start > seqlength - 1 || end > seqlength - 1) {
had_err = -1;
gt_error_set(err, "trying to extract range "GT_WU"-"GT_WU" on sequence "
"``%s'' which is not covered by that sequence (only "
""GT_WU" characters in size). Has the sequence-region "
"to sequence mapping been defined correctly?",
start, end, gt_str_get(seqid), seqlength);
}
}
if (!had_err) {
*seq = gt_bioseq_get_sequence_range(bsc->bioseqs[filenum], seqnum,
start, end);
}
return had_err;
}
static int gt_rdb_stmt_mysql_get_string(GtRDBStmt *st, GtUword field_no,
GtStr *result, GtError *err)
{
GtRDBStmtMySQL *stm;
int had_err = 0;
gt_assert(st && result);
gt_error_check(err);
stm = gt_rdb_stmt_mysql_cast(st);
CHECK_INIT_STATEMENT
if (!had_err
&& stm->results[field_no].buffer_type != MYSQL_TYPE_STRING
&& stm->results[field_no].buffer_type != MYSQL_TYPE_VAR_STRING
&& stm->results[field_no].buffer_type != MYSQL_TYPE_BLOB
&& stm->results[field_no].buffer_type != MYSQL_TYPE_TINY_BLOB
&& stm->results[field_no].buffer_type != MYSQL_TYPE_MEDIUM_BLOB
&& stm->results[field_no].buffer_type != MYSQL_TYPE_LONG_BLOB
&& stm->results[field_no].buffer_type != MYSQL_TYPE_BIT)
{
gt_error_set(err, "incompatible type!");
had_err = -1;
}
if (!had_err) {
gt_str_reset(result);
gt_str_append_cstr_nt(result,
(char*)stm->results[field_no].buffer,
*stm->results[field_no].length);
}
return had_err;
}
static int gt_condenser_runner(int argc, const char **argv, int parsed_args,
void *tool_arguments, GT_UNUSED GtError *err)
{
GtToolbox *condenser_toolbox = tool_arguments;
GtTool *tool;
int had_err = 0;
char **nargv = NULL;
gt_error_check(err);
gt_assert(condenser_toolbox);
/* get condenser tools */
tool = gt_toolbox_get_tool(condenser_toolbox, argv[parsed_args]);
if (!tool) {
gt_error_set(err, "condenser tool '%s' not found; option -help lists "
"possible tools", argv[parsed_args]);
had_err = -1;
}
/* call condenser tool */
if (!had_err) {
gt_assert(tool);
nargv = gt_cstr_array_prefix_first(argv + parsed_args,
gt_error_get_progname(err));
gt_error_set_progname(err, nargv[0]);
had_err = gt_tool_run(tool, argc - parsed_args, (const char**) nargv, err);
}
/* free */
gt_cstr_array_delete(nargv);
return had_err;
}
int gth_bssm_param_save(GthBSSMParam *bssm_param, const char *filename,
GtError *err)
{
FILE *file;
int had_err = 0;
gt_error_check(err);
file = gt_fa_xfopen(filename, "w");
gt_assert(file);
/* check if at least one model is set */
if (!bssm_param->gt_donor_model_set &&
!bssm_param->gc_donor_model_set &&
!bssm_param->ag_acceptor_model_set) {
gt_error_set(err, "BSSM parameter to write contain no model");
had_err = -1;
}
if (!had_err)
bssm_param_plain_write(bssm_param, file);
gt_fa_xfclose(file);
return had_err;
}
static int seqid_info_get(SeqidInfo *seqid_info, GtUword *seqnum,
GtUword *filenum, GtRange *outrange,
const GtRange *inrange,
GT_UNUSED const char *filename,
const char *seqid, GtError *err)
{
SeqidInfoElem *seqid_info_elem;
GtUword i;
gt_error_check(err);
gt_assert(seqid_info && seqnum && outrange && inrange);
for (i = 0; i < gt_array_size(seqid_info); i++) {
seqid_info_elem = gt_array_get(seqid_info, i);
if (seqid_info_elem->descrange.end == GT_UNDEF_UWORD ||
gt_range_contains(&seqid_info_elem->descrange, inrange)) {
*seqnum = seqid_info_elem->seqnum;
*filenum = seqid_info_elem->filenum;
*outrange = seqid_info_elem->descrange;
return 0;
}
}
gt_error_set(err,
"cannot find a sequence with ID \"%s\" "
"{range " GT_WU "," GT_WU ")",
seqid, inrange->start, inrange->end);
return -1;
}
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;
}
static int decode_sequence_file(const char *seqfile,
GtEncseqDecodeArguments *args,
GtError *err)
{
GtEncseqLoader *encseq_loader;
GtEncseq *encseq;
int had_err = 0;
gt_error_check(err);
gt_assert(seqfile);
encseq_loader = gt_encseq_loader_new();
if (!had_err && gt_encseq_options_lossless_value(args->eopts)) {
gt_encseq_loader_require_lossless_support(encseq_loader);
}
if (!(encseq = gt_encseq_loader_load(encseq_loader, seqfile, err)))
had_err = -1;
if (!had_err && gt_encseq_options_mirrored_value(args->eopts)) {
if (!gt_alphabet_is_dna(gt_encseq_alphabet(encseq))) {
gt_error_set(err, "mirroring is only defined on DNA sequences");
had_err = -1;
}
if (!had_err)
had_err = gt_encseq_mirror(encseq, err);
}
if (!had_err)
had_err = output_sequence(encseq, args, seqfile, err);
gt_encseq_delete(encseq);
gt_encseq_loader_delete(encseq_loader);
return had_err;
}
static int bssm_model_read(GthBSSMModel *bssm_model, FILE *file, GtError *err)
{
int had_err = 0;
gt_error_check(err);
gt_xfread(&bssm_model->hypothesis_num, sizeof (GtUword), 1, file);
if (bssm_model->hypothesis_num != HYPOTHESIS7 &&
bssm_model->hypothesis_num != HYPOTHESIS2) {
gt_error_set(err, "BSSM model contains unknown hypothesis number");
had_err = -1;
}
if (!had_err) {
gt_xfread(&bssm_model->window_size_left, sizeof (GtUword), 1, file);
gt_xfread(&bssm_model->window_size_right, sizeof (GtUword), 1, file);
switch (bssm_model->hypothesis_num) {
case HYPOTHESIS2:
gt_xfread(&bssm_model->hypotables.hypo2table, sizeof (Hypo2table), 1,
file);
break;
case HYPOTHESIS7:
gt_xfread(&bssm_model->hypotables.hypo7table, sizeof (Hypo7table), 1,
file);
break;
default:
gt_assert(0);
}
}
return had_err;
}
