static int gff3_visitor_meta_node(GtNodeVisitor *nv, GtMetaNode *mn, GT_UNUSED GtError *err) { GtGFF3Visitor *gff3_visitor; gt_error_check(err); gff3_visitor = gff3_visitor_cast(nv); gt_assert(nv && mn); if (!gff3_visitor->version_string_shown) { if (strncmp(gt_meta_node_get_directive(mn), GT_GFF_VERSION_DIRECTIVE, strlen(GT_GFF_VERSION_DIRECTIVE)) == 0 || strncmp(gt_meta_node_get_directive(mn), GT_GVF_VERSION_DIRECTIVE, strlen(GT_GVF_VERSION_DIRECTIVE)) == 0) { gff3_visitor->version_string_shown = true; } else { gff3_version_string(nv); } } if (!gff3_visitor->outstr) { gt_file_xprintf(gff3_visitor->outfp, "##%s %s\n", gt_meta_node_get_directive(mn), gt_meta_node_get_data(mn)); } else { gt_str_append_cstr(gff3_visitor->outstr, "##"); gt_str_append_cstr(gff3_visitor->outstr, gt_meta_node_get_directive(mn)); gt_str_append_char(gff3_visitor->outstr, ' '); gt_str_append_cstr(gff3_visitor->outstr, gt_meta_node_get_data(mn)); gt_str_append_char(gff3_visitor->outstr, '\n'); } return 0; }
static int gff3_visitor_region_node(GtNodeVisitor *nv, GtRegionNode *rn, GT_UNUSED GtError *err) { GtGFF3Visitor *gff3_visitor; gt_error_check(err); gff3_visitor = gff3_visitor_cast(nv); gt_assert(nv && rn); gff3_version_string(nv); if (!gff3_visitor->outstr) { gt_file_xprintf(gff3_visitor->outfp, "%s %s "GT_WU" "GT_WU"\n", GT_GFF_SEQUENCE_REGION, gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) rn)), gt_genome_node_get_start((GtGenomeNode*) rn), gt_genome_node_get_end((GtGenomeNode*) rn)); } else { gt_str_append_cstr(gff3_visitor->outstr, GT_GFF_SEQUENCE_REGION); gt_str_append_cstr(gff3_visitor->outstr, " "); gt_str_append_cstr(gff3_visitor->outstr, gt_str_get(gt_genome_node_get_seqid((GtGenomeNode*) rn))); gt_str_append_char(gff3_visitor->outstr, ' '); gt_str_append_ulong(gff3_visitor->outstr, gt_genome_node_get_start((GtGenomeNode*) rn)); gt_str_append_char(gff3_visitor->outstr, ' '); gt_str_append_ulong(gff3_visitor->outstr, gt_genome_node_get_end((GtGenomeNode*) rn)); gt_str_append_char(gff3_visitor->outstr, '\n'); } return 0; }
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 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 gt_ltrdigest_pdom_visitor_attach_hit(GtLTRdigestPdomVisitor *lv, GtHMMERModelHit *modelhit, GtHMMERSingleHit *singlehit) { GT_UNUSED GtUword i; GtGenomeNode *gf; int had_err = 0; GtRange rrng; gt_assert(lv && singlehit); rrng = gt_ltrdigest_pdom_visitor_coords(lv, singlehit); if (gt_array_size(singlehit->chains) > 0 || lv->output_all_chains) { char buf[32]; gf = gt_feature_node_new(gt_genome_node_get_seqid((GtGenomeNode*) lv->ltr_retrotrans), gt_ft_protein_match, rrng.start, rrng.end, singlehit->strand); gt_genome_node_add_user_data((GtGenomeNode*) gf, "pdom_alignment", gt_str_ref(singlehit->alignment), (GtFree) gt_str_delete); gt_genome_node_add_user_data((GtGenomeNode*) gf, "pdom_aaseq", gt_str_ref(singlehit->aastring), (GtFree) gt_str_delete); gt_feature_node_set_source((GtFeatureNode*) gf, lv->tag); gt_feature_node_set_score((GtFeatureNode*) gf, (float) singlehit->evalue); (void) snprintf(buf, (size_t) 32, "%d", (int) singlehit->frame); gt_feature_node_add_attribute((GtFeatureNode*) gf, "reading_frame", buf); if (modelhit->modelname != NULL) { gt_feature_node_add_attribute((GtFeatureNode*) gf, "name", modelhit->modelname); } if (gt_array_size(singlehit->chains) > 1UL && lv->output_all_chains) { GtStr *buffer; GtUword j; gt_assert(singlehit->chains != NULL); buffer = gt_str_new(); for (j = 0UL; j < gt_array_size(singlehit->chains); j++) { gt_str_append_cstr(buffer, modelhit->modelname); gt_str_append_char(buffer, ':'); gt_str_append_ulong(buffer, *(GtUword*) gt_array_get(singlehit->chains, j)); if (j != gt_array_size(singlehit->chains) - 1) { gt_str_append_char(buffer, ','); } } gt_feature_node_set_attribute((GtFeatureNode*) gf, "chains", gt_str_get(buffer)); gt_str_delete(buffer); } gt_feature_node_add_child(lv->ltr_retrotrans, (GtFeatureNode*) gf); } gt_array_delete(singlehit->chains); singlehit->chains = NULL; 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 gt_ltrdigest_pdom_visitor_parse_alignments(GT_UNUSED GtLTRdigestPdomVisitor *lv, GtHMMERParseStatus *status, char *buf, FILE *instream, GtError *err) { int had_err = 0, cur_domain = GT_UNDEF_INT, line = -1; GtHMMERSingleHit *hit = NULL; gt_assert(lv && instream && status); gt_error_check(err); had_err = pdom_parser_get_next_line(buf, instream, err); gt_assert(buf != NULL); while (!had_err && strncmp("Internal pipeline statistics", buf, (size_t) 28) && strncmp(">>", buf, (size_t) 2)) { if ((buf[2] == '=' && buf[3] == '=')) { buf[17] = '\0'; cur_domain = atoi(buf+12); gt_assert(cur_domain != GT_UNDEF_INT && cur_domain > 0); hit = gt_hmmer_parse_status_get_hit(status, (unsigned long) cur_domain - 1); gt_assert(hit && !hit->alignment); hit->alignment = gt_str_new(); hit->aastring = gt_str_new(); line = -2; } else { gt_assert(hit && hit->alignment); gt_str_append_cstr(hit->alignment, buf); gt_str_append_char(hit->alignment, '\n'); switch (line % 4) { case 1: gt_str_append_char(hit->alignment, '\n'); break; case 0: { char *b = buf; b = strtok(buf, " "); gt_assert(strspn(b, "012+-") == (size_t) 2); b = strtok(NULL, " "); gt_assert(strlen(b) > 0); b = strtok(NULL, " "); gt_ltrdigest_pdom_visitor_add_aaseq(b, hit->aastring); } break; } line++; } had_err = pdom_parser_get_next_line(buf, instream, err); } 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 void gt_ltrdigest_pdom_visitor_add_aaseq(const char *str, GtStr *dest) { unsigned long i; gt_assert(str && dest); for (i = 0; str[i] != '\0'; i++) { if (!gt_ltrdigest_pdom_visitor_isgap(str[i])) { /* replace stop codons by 'X'es */ if (str[i] == '*') { gt_str_append_char(dest, 'X'); } else { gt_str_append_char(dest, toupper(str[i])); } } } }
static int gff3_visitor_sequence_node(GtNodeVisitor *nv, GtSequenceNode *sn, GT_UNUSED GtError *err) { GtGFF3Visitor *gff3_visitor; gt_error_check(err); gff3_visitor = gff3_visitor_cast(nv); gt_assert(nv && sn); gff3_version_string(nv); if (!gff3_visitor->fasta_directive_shown) { if (!gff3_visitor->outstr) gt_file_xprintf(gff3_visitor->outfp, "%s\n", GT_GFF_FASTA_DIRECTIVE); else { gt_str_append_cstr(gff3_visitor->outstr, GT_GFF_FASTA_DIRECTIVE); gt_str_append_char(gff3_visitor->outstr, '\n'); } gff3_visitor->fasta_directive_shown = true; } if (!gff3_visitor->outstr) { gt_fasta_show_entry(gt_sequence_node_get_description(sn), gt_sequence_node_get_sequence(sn), gt_sequence_node_get_sequence_length(sn), gff3_visitor->fasta_width, gff3_visitor->outfp); } else { gt_fasta_show_entry_str(gt_sequence_node_get_description(sn), gt_sequence_node_get_sequence(sn), gt_sequence_node_get_sequence_length(sn), gff3_visitor->fasta_width, gff3_visitor->outstr); } return 0; }
static int translate_dna_lua(lua_State *L) { GtStr *protein; GtTranslator *tr; int rval; char translated; unsigned int frame; const char *dna = luaL_checkstring(L, 1); protein = gt_str_new(); GtCodonIterator *ci = gt_codon_iterator_simple_new(dna, strlen(dna), NULL); tr = gt_translator_new(ci); rval = gt_translator_next(tr, &translated, &frame, NULL); while (!rval && translated) { gt_str_append_char(protein, translated); rval = gt_translator_next(tr, &translated, &frame, NULL); } lua_pushstring(L, gt_str_get(protein)); gt_str_delete(protein); gt_translator_delete(tr); gt_codon_iterator_delete(ci); return 1; }
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 create_manpage(const char *outdir, const char *toolname, GtOptionParser *option_parser, GtError *err) { GtFile *outfile = NULL; GtStr *man, *pathbuf; char *utoolname; int had_err = 0; gt_error_check(err); gt_assert(outdir && toolname && option_parser); man = gt_str_new(); pathbuf = gt_str_new_cstr(outdir); utoolname = gt_cstr_dup(toolname); gt_cstr_rep(utoolname, ' ', '_'); if (!gt_file_exists(gt_str_get(pathbuf))) gt_xmkdir(gt_str_get(pathbuf)); gt_str_append_char(pathbuf, GT_PATH_SEPARATOR); gt_str_append_cstr(pathbuf, utoolname); gt_str_append_cstr(pathbuf, ".mansrc"); gt_free(utoolname); if (!(outfile = gt_file_new(gt_str_get(pathbuf), "w+", err))) had_err = -1; if (!had_err) had_err = gt_option_parser_manpage(option_parser, toolname, man, err); if (!had_err) gt_file_xprintf(outfile, "%s", gt_str_get(man)); gt_file_delete(outfile); gt_str_delete(pathbuf); gt_str_delete(man); return had_err; }
static 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; }
static int quoted_word(GtStr *word, GtIO *bed_file, GtError *err) { bool break_while = false; int had_err; gt_error_check(err); gt_str_reset(word); had_err = gt_io_expect(bed_file, QUOTE_CHAR, err); while (!had_err) { switch (gt_io_peek(bed_file)) { case QUOTE_CHAR: case GT_CARRIAGE_RETURN: case GT_END_OF_LINE: case GT_END_OF_FILE: break_while = true; break; default: gt_str_append_char(word, gt_io_next(bed_file)); } if (break_while) break; } if (!had_err) had_err = gt_io_expect(bed_file, QUOTE_CHAR, err); return had_err; }
static int show_entry(GtStr *description, GtStr *sequence, bool translate, GtUword width, GtFile *outfp) { int had_err = 0; if (translate) { GtTranslatorStatus status; unsigned int frame; char translated; GtStr *protein = gt_str_new(); GtCodonIterator *ci = gt_codon_iterator_simple_new(gt_str_get(sequence), gt_str_length(sequence), NULL); GtTranslator* tr = gt_translator_new(ci); status = gt_translator_next(tr, &translated, &frame, NULL); while (status == GT_TRANSLATOR_OK) { if (frame == 0) gt_str_append_char(protein, translated); status = gt_translator_next(tr, &translated, &frame, NULL); } if (status == GT_TRANSLATOR_ERROR) had_err = -1; gt_fasta_show_entry(gt_str_get(description), gt_str_get(protein), gt_str_length(protein), width, outfp); gt_str_delete(protein); gt_translator_delete(tr); gt_codon_iterator_delete(ci); } else { gt_fasta_show_entry(gt_str_get(description), gt_str_get(sequence), gt_str_length(sequence), width, outfp); } return had_err; }
static int proc_any_char(GtIO *obo_file, GtStr *capture, bool be_permissive, GtError *err) { gt_error_check(err); gt_assert(obo_file && capture); if (!any_char(obo_file, be_permissive)) { if (gt_io_peek(obo_file) == GT_END_OF_FILE) { gt_error_set(err, "file \"%s\": line %lu: unexpected end-of-file", gt_io_get_filename(obo_file), gt_io_get_line_number(obo_file)); } else if ((gt_io_peek(obo_file) == GT_CARRIAGE_RETURN) || (gt_io_peek(obo_file) == GT_END_OF_LINE)) { gt_error_set(err, "file \"%s\": line %lu: unexpected newline", gt_io_get_filename(obo_file), gt_io_get_line_number(obo_file)); } else { gt_error_set(err, "file \"%s\": line %lu: unexpected character '%c'", gt_io_get_filename(obo_file), gt_io_get_line_number(obo_file), gt_io_peek(obo_file)); } return -1; } gt_str_append_char(capture, gt_io_next(obo_file)); return 0; }
static int gt_readjoiner_assembly_count_spm(const char *readset, bool eqlen, unsigned int minmatchlength, unsigned int nspmfiles, GtStrgraph *strgraph, GtBitsequence *contained, GtLogger *default_logger, GtError *err) { GtSpmprocSkipData skipdata; int had_err = 0; unsigned int i; GtStr *filename = gt_str_new(); gt_logger_log(default_logger, GT_READJOINER_ASSEMBLY_MSG_COUNTSPM); if (!eqlen) { skipdata.out.e.proc = gt_spmproc_strgraph_count; skipdata.to_skip = contained; skipdata.out.e.data = strgraph; } for (i = 0; i < nspmfiles; i++) { gt_str_append_cstr(filename, readset); gt_str_append_char(filename, '.'); gt_str_append_uint(filename, i); gt_str_append_cstr(filename, GT_READJOINER_SUFFIX_SPMLIST); had_err = gt_spmlist_parse(gt_str_get(filename), (GtUword)minmatchlength, eqlen ? gt_spmproc_strgraph_count : gt_spmproc_skip, eqlen ? (void*)strgraph : (void*)&skipdata, err); gt_str_reset(filename); } gt_str_delete(filename); 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 gff3_visitor_comment_node(GtNodeVisitor *nv, GtCommentNode *cn, GT_UNUSED GtError *err) { GtGFF3Visitor *gff3_visitor; gt_error_check(err); gff3_visitor = gff3_visitor_cast(nv); gt_assert(nv && cn); gff3_version_string(nv); if (!gff3_visitor->outstr) { gt_file_xprintf(gff3_visitor->outfp, "#%s\n", gt_comment_node_get_comment(cn)); } else { gt_str_append_char(gff3_visitor->outstr, '#'); gt_str_append_cstr(gff3_visitor->outstr, gt_comment_node_get_comment(cn)); gt_str_append_char(gff3_visitor->outstr, '\n'); } return 0; }
int gt_gthmkbssmfiles(int argc, const char **argv, GtError *err) { GtUword i; GtStr *filename; int parsed_args, had_err = 0; /* option parsing */ switch (gthmkbssmfiles_parse_options(&parsed_args, argc, argv, err)) { case GT_OPTION_PARSER_OK: break; case GT_OPTION_PARSER_ERROR: return -1; case GT_OPTION_PARSER_REQUESTS_EXIT: return 0; } gt_assert(parsed_args + 1 == argc); filename = gt_str_new(); for (i = 0; !had_err && i <= LASTSPECIESNUM; i++) { GthBSSMParam *bssm_param; gt_str_append_cstr(filename, argv[parsed_args]); gt_str_append_char(filename, GT_PATH_SEPARATOR); gt_str_append_cstr(filename, speciestab[i]); /* for files which are obsolete due to new model files produced by gthbssmbuild add an .old after the species name */ if (i >= 8) gt_str_append_cstr(filename, ".old"); gt_str_append_char(filename, '.'); gt_str_append_cstr(filename, BSSMFILEENDING); if (!(bssm_param = gth_bssm_param_extract(i, err))) had_err = -1; if (!had_err) had_err = gth_bssm_param_save(bssm_param, gt_str_get(filename), err); gth_bssm_param_delete(bssm_param); /* resetting filename */ gt_str_reset(filename); } gt_str_delete(filename); 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; }
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 show_attribute(const char *attr_name, const char *attr_value, void *data) { ShowAttributeInfo *info = (ShowAttributeInfo*) data; gt_assert(attr_name && attr_value && info); if (strcmp(attr_name, GT_GFF_ID) && strcmp(attr_name, GT_GFF_PARENT)) { if (*info->attribute_shown) { if (!info->outstr) gt_file_xfputc(';', info->outfp); else gt_str_append_char(info->outstr, ';'); } else *info->attribute_shown = true; if (!info->outstr) gt_file_xprintf(info->outfp, "%s=%s", attr_name, attr_value); else { gt_str_append_cstr(info->outstr, attr_name); gt_str_append_char(info->outstr, '='); gt_str_append_cstr(info->outstr, attr_value); } } }
static void show_parse_file_status(GthShowVerbose showverbose, GtUword filenum, GtUword numoffiles, const char *filename) { GtStr *buf = gt_str_new(); gt_str_append_cstr(buf, "process file "); gt_str_append_uword(buf, filenum + 1); gt_str_append_char(buf, GT_PATH_SEPARATOR); gt_str_append_uword(buf, numoffiles); gt_str_append_cstr(buf, ": "); gt_str_append_cstr(buf, filename); showverbose(gt_str_get(buf)); gt_str_delete(buf); }
static void gff3_version_string(GtNodeVisitor *nv) { GtGFF3Visitor *gff3_visitor = gff3_visitor_cast(nv); gt_assert(gff3_visitor); if (!gff3_visitor->version_string_shown) { if (!gff3_visitor->outstr) { gt_file_xprintf(gff3_visitor->outfp, "%s %u\n", GT_GFF_VERSION_PREFIX, GT_GFF_VERSION); } else { gt_str_append_cstr(gff3_visitor->outstr, GT_GFF_VERSION_PREFIX); gt_str_append_cstr(gff3_visitor->outstr, " "); gt_str_append_uint(gff3_visitor->outstr, GT_GFF_VERSION); gt_str_append_char(gff3_visitor->outstr, '\n'); } gff3_visitor->version_string_shown = true; } }
static void default_track_selector(GtBlock *block, GtStr *result, GT_UNUSED void *data) { GtGenomeNode *top; char *basename; gt_assert(block && result); gt_str_reset(result); top = (GtGenomeNode*) gt_block_get_top_level_feature(block); /* we take the basename of the filename to have nicer output in the generated graphic. this might lead to ``collapsed'' tracks, if two files with different paths have the same basename. */ basename = gt_basename(gt_genome_node_get_filename(top)); gt_str_append_cstr(result, basename); gt_free(basename); gt_str_append_char(result, GT_FILENAME_TYPE_SEPARATOR); gt_str_append_cstr(result, gt_block_get_type(block)); }
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 void word(GtStr *word, GtIO *bed_file) { gt_str_reset(word); for (;;) { switch (gt_io_peek(bed_file)) { case BLANK_CHAR: case TABULATOR_CHAR: case PAIR_SEPARATOR: case GT_CARRIAGE_RETURN: case GT_END_OF_LINE: case GT_END_OF_FILE: return; default: gt_str_append_char(word, gt_io_next(bed_file)); } } }
static int gff3_visitor_feature_node(GtNodeVisitor *nv, GtFeatureNode *fn, GtError *err) { GtGFF3Visitor *gff3_visitor; int had_err; gt_error_check(err); gff3_visitor = gff3_visitor_cast(nv); gff3_version_string(nv); had_err = gt_feature_node_traverse_children(fn, gff3_visitor, store_ids, true, err); if (!had_err) { if (gt_feature_node_is_tree(fn)) { had_err = gt_feature_node_traverse_children(fn, gff3_visitor, gff3_show_feature_node, true, err); } else { /* got a DAG -> traverse in topologically sorted depth first fashion to make sure that the 'Parent' attributes are shown in correct order */ had_err = gt_feature_node_traverse_children_top(fn, gff3_visitor, gff3_show_feature_node, err); } } /* reset hashmaps */ gt_hashmap_reset(gff3_visitor->feature_node_to_id_array); gt_hashmap_reset(gff3_visitor->feature_node_to_unique_id_str); /* show terminator, if the feature has children (otherwise it is clear that the feature is complete, because no ID attribute has been shown) */ if (gt_feature_node_has_children(fn) || (gff3_visitor->retain_ids && gt_feature_node_get_attribute(fn, "ID"))) { if (!gff3_visitor->outstr) gt_file_xprintf(gff3_visitor->outfp, "%s\n", GT_GFF_TERMINATOR); else { gt_str_append_cstr(gff3_visitor->outstr, GT_GFF_TERMINATOR); gt_str_append_char(gff3_visitor->outstr, '\n'); } } return had_err; }