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; }
static void* gt_linspace_align_arguments_new(void) { GtLinspaceArguments *arguments = gt_calloc((size_t) 1, sizeof *arguments); arguments->outputfile = gt_str_new(); arguments->strings = gt_str_array_new(); arguments->files = gt_str_array_new(); arguments->linearcosts = gt_str_array_new(); arguments->affinecosts = gt_str_array_new(); arguments->diagonalbonds = gt_str_array_new(); return arguments; }
static int add_to_current(GtDiagram *d, GtFeatureNode *node, GtFeatureNode *parent, GtError *err) { GtBlock *block; NodeInfoElement *ni; GtStyleQueryStatus rval; GtStr *caption = NULL; bool status = true; const char *nnid_p = NULL, *nnid_n = NULL, *nodetype; gt_assert(d && node); nodetype = gt_feature_node_get_type(node); if (get_caption_display_status(d, nodetype, &status, err) < 0) { return -1; } /* Get nodeinfo element and set itself as parent */ ni = nodeinfo_get(d, node); gt_log_log("adding %s to self", nodetype); ni->parent = node; /* create new GtBlock tuple and add to node info */ block = gt_block_new_from_node(node); caption = gt_str_new(); rval = gt_style_get_str(d->style, nodetype, "block_caption", caption, node, err); if (rval == GT_STYLE_QUERY_ERROR) { gt_str_delete(caption); gt_block_delete(block); return -1; } else if (rval == GT_STYLE_QUERY_NOT_SET) { nnid_p = get_node_name_or_id(parent); nnid_n = get_node_name_or_id(node); if ((nnid_p || nnid_n) && status) { if (parent) { if (nnid_p && gt_feature_node_has_children(parent)) gt_str_append_cstr(caption, nnid_p); else gt_str_append_cstr(caption, "-"); gt_str_append_cstr(caption, "/"); } if (nnid_n) gt_str_append_cstr(caption, nnid_n); } else { gt_str_delete(caption); caption = NULL; } } gt_block_set_caption(block, caption); gt_block_insert_element(block, node); nodeinfo_add_block(ni, gt_feature_node_get_type(node), GT_UNDEF_REPR, block); return 0; }
static void *gt_tyr_occratio_arguments_new(void) { Tyr_occratio_options *arguments = gt_malloc(sizeof (Tyr_occratio_options)); arguments->mersizesstrings = gt_str_array_new(); arguments->outputspec = gt_str_array_new(); arguments->str_inputindex = gt_str_new(); arguments->outputvector = NULL; arguments->outputmode = 0; return arguments; }
static void filter_targetbest(GtFeatureNode *current_feature, GtDlist *trees, GtHashmap *target_to_elem) { unsigned long num_of_targets; GtDlistelem *previous_elem; GtStr *first_target_id; const char *target; int had_err; gt_assert(current_feature && trees); target = gt_feature_node_get_attribute(current_feature, TARGET_STRING); gt_assert(target); first_target_id = gt_str_new(); had_err = gt_gff3_parser_parse_target_attributes(target, &num_of_targets, first_target_id, NULL, NULL, "", 0, NULL); gt_assert(!had_err); if (num_of_targets == 1) { GtStr *key = gt_str_new(); build_key(key, current_feature, first_target_id); if (!(previous_elem = gt_hashmap_get(target_to_elem, gt_str_get(key)))) { /* element with this target_id not included yet -> include it */ include_feature(trees, target_to_elem, current_feature, key); } else { GtFeatureNode *previous_feature = gt_dlistelem_get_data(previous_elem); /* element with this target_id included already -> compare them */ if (gt_feature_node_get_score(current_feature) > gt_feature_node_get_score(previous_feature)) { /* current feature is better -> replace previous feature */ replace_previous_elem(previous_elem, current_feature, trees, target_to_elem, key); } else /* current feature is not better -> remove it */ gt_genome_node_delete((GtGenomeNode*) current_feature); } gt_str_delete(key); } else gt_dlist_add(trees, current_feature); gt_str_delete(first_target_id); }
static void* gt_matstat_arguments_new_generic(bool doms) { Gfmsubcallinfo *arguments = gt_calloc((size_t) 1, sizeof *arguments); arguments->minlength.defined = false; arguments->maxlength.defined = false; arguments->showmode = 0; arguments->indexname = gt_str_new(); arguments->queryfilenames = gt_str_array_new(); arguments->flagsoutputoption = gt_str_array_new(); arguments->doms = doms; return arguments; }
GthSA* gth_sa_new(void) { GthSA *sa; /* allocating space */ sa = gt_calloc(1, sizeof *sa); /* initialize strings */ sa->gen_id = gt_str_new(); sa->ref_id = gt_str_new(); /* initialize all arrays */ sa->backtrace_path = gth_backtrace_path_new(GT_UNDEF_UWORD, GT_UNDEF_UWORD, 0, /* ref_dp_start */ GT_UNDEF_UWORD); sa->exons = gt_array_new(sizeof (Exoninfo)); sa->introns = gt_array_new(sizeof (Introninfo)); return sa; }
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; }
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; }
void gt_graphics_cairo_initialize(GtGraphics *gg, GtGraphicsOutType type, unsigned int width, unsigned int height) { GtGraphicsCairo *g = gt_graphics_cairo_cast(gg); g->outbuf = gt_str_new(); switch (type) { case GT_GRAPHICS_PDF: #ifdef CAIRO_HAS_PDF_SURFACE g->surf = cairo_pdf_surface_create_for_stream(str_write_func, g->outbuf, width, height); break; #endif case GT_GRAPHICS_PS: #ifdef CAIRO_HAS_PS_SURFACE g->surf = cairo_ps_surface_create_for_stream(str_write_func, g->outbuf, width, height); break; #endif case GT_GRAPHICS_SVG: #ifdef CAIRO_HAS_SVG_SURFACE g->surf = cairo_svg_surface_create_for_stream(str_write_func, g->outbuf, width, height); break; #endif case GT_GRAPHICS_PNG: default: g->surf = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, width, height); break; } gt_assert(g->surf && cairo_surface_status(g->surf) == CAIRO_STATUS_SUCCESS); g->cr = cairo_create(g->surf); gt_assert(cairo_status(g->cr) == CAIRO_STATUS_SUCCESS); /* set background default to transparent */ g->bg_color.red = g->bg_color.green = 0.0; g->bg_color.blue = g->bg_color.alpha = 0.0; g->width = width; g->height = height; g->margin_x = g->margin_y = 20; cairo_set_line_join(g->cr, CAIRO_LINE_JOIN_ROUND); cairo_set_line_cap(g->cr, CAIRO_LINE_CAP_ROUND); cairo_select_font_face(g->cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL); g->type = type; }
static void* test_symbol(GT_UNUSED void *data) { GtStr *symbol; GtUword i; symbol = gt_str_new(); for (i = 0; i < NUMBER_OF_SYMBOLS; i++) { gt_str_reset(symbol); gt_str_append_ulong(symbol, gt_rand_max(MAX_SYMBOL)); gt_symbol(gt_str_get(symbol)); gt_assert(!strcmp(gt_symbol(gt_str_get(symbol)), gt_str_get(symbol))); } gt_str_delete(symbol); return NULL; }
static int hmmsearch_call_coarse_search(GtCondenseq* ces, char *hmmsearch_path, char *table_filename, char *hmm_filename, GtLogger *logger, GtError *err) { int had_err = 0; char **hmmargs = NULL, *hmmenv[] = { NULL }; GtStr *coarse_fas = gt_condenseq_unique_fasta_file(ces); GtSafePipe *pipe = NULL; gt_assert(coarse_fas != NULL); /* Array has to end with NULL */ hmmargs = gt_calloc((size_t) 8, sizeof (*hmmargs)); hmmargs[0] = hmmsearch_path; hmmargs[1] = gt_cstr_dup("--noali"); hmmargs[2] = gt_cstr_dup("--notextw"); hmmargs[3] = gt_cstr_dup("--domtblout"); hmmargs[4] = table_filename; hmmargs[5] = hmm_filename; hmmargs[6] = gt_str_get(coarse_fas); gt_logger_log(logger, "calling: %s", hmmsearch_path); pipe = gt_safe_popen(hmmsearch_path, hmmargs, hmmenv, err); if (pipe == NULL) had_err = -1; gt_free(hmmargs[1]); gt_free(hmmargs[2]); gt_free(hmmargs[3]); gt_free(hmmargs); gt_str_delete(coarse_fas); /* pipe test for splint */ if (!had_err && pipe != NULL) { if (gt_log_enabled()) { GtStr *line = gt_str_new(); while (gt_str_read_next_line(line, pipe->read_fd) == 0) { gt_log_log("%s", gt_str_get(line)); gt_str_reset(line); } gt_str_delete(line); } (void) gt_safe_pclose(pipe); } return had_err; }
static int hmmsearch_call_fine_search(GtStr *table_filename, char *fine_fasta_filename, char *hmmsearch_path, char *hmm_filename, GtLogger *logger, GtError *err) { int had_err = 0; GtSafePipe *pipe = NULL; char **hmmargs = NULL, *hmmenv[] = { NULL }; size_t hmmargc = (size_t) 4; unsigned int hmmidx = 0; if (table_filename != NULL) { hmmargc += (size_t) 2; } hmmargs = gt_calloc(hmmargc, sizeof (*hmmargs)); hmmargs[hmmidx++] = hmmsearch_path; if (table_filename != NULL) { hmmargs[hmmidx++] = gt_cstr_dup("--tblout"); hmmargs[hmmidx++] = gt_str_get(table_filename); } hmmargs[hmmidx++] = hmm_filename; hmmargs[hmmidx++] = fine_fasta_filename; gt_assert(hmmargs[hmmidx] == NULL); gt_logger_log(logger, "calling: %s", hmmsearch_path); pipe = gt_safe_popen(hmmsearch_path, hmmargs, hmmenv, err); if (table_filename != NULL) gt_free(hmmargs[1]); gt_free(hmmargs); if (pipe == NULL) had_err = -1; if (!had_err) { GtStr *line = gt_str_new(); gt_assert(pipe != NULL); /* shut up splint */ while (gt_str_read_next_line(line, pipe->read_fd) == 0) { printf("%s\n", gt_str_get(line)); gt_str_reset(line); } gt_str_delete(line); (void) gt_safe_pclose(pipe); } return had_err; }
static GtIndexOptions* gt_index_options_new(void) { GtIndexOptions *oi = gt_malloc(sizeof *oi); oi->algbounds = gt_str_array_new(); oi->dir = gt_str_new_cstr("fwd"); oi->indexname = NULL; oi->kysargumentstring = gt_str_new(); oi->lcpdist = false; oi->maximumspace = 0UL; /* in bytes */ oi->memlimit = gt_str_new(); oi->numofparts = 1U; oi->option = NULL; oi->optionalgbounds = NULL; oi->optioncmpcharbychar = NULL; oi->optiondifferencecover = NULL; oi->optionmaxwidthrealmedian = NULL; oi->optionmemlimit = NULL; oi->optionoutbcktab = NULL; oi->optionoutbwttab = NULL; oi->optionoutlcptab = NULL; oi->optionoutsuftab = NULL; oi->optionparts = NULL; oi->optionprefixlength = NULL; oi->optionspmopt = NULL; oi->optionstorespecialcodes = NULL; oi->outbcktab = false; oi->outbwttab = false; oi->outkyssort = false; oi->outkystab = false; oi->outlcptab = false; oi->outsuftab = false; /* only defined for GT_INDEX_OPTIONS_ESA */ oi->prefixlength = GT_PREFIXLENGTH_AUTOMATIC; oi->swallow_tail = false; oi->type = GT_INDEX_OPTIONS_UNDEFINED; return oi; }
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 GtStr* get_xrf_path(GtError *err) { const char *progname; GtStr *xrf_path, *prog; gt_error_check(err); progname = gt_error_get_progname(err); gt_assert(progname != NULL); prog = gt_str_new(); gt_str_append_cstr_nt(prog, progname, gt_cstr_length_up_to_char(progname, ' ')); xrf_path = gt_get_gtdata_path(gt_str_get(prog), err); if (xrf_path) gt_str_append_cstr(xrf_path, "/xrf_abbr/"); gt_str_delete(prog); return xrf_path; }
GtSequenceBuffer* gt_sequence_buffer_fasta_new(const GtStrArray *sequences) { GtSequenceBuffer *sb; GtSequenceBufferFasta *sbf; sb = gt_sequence_buffer_create(gt_sequence_buffer_fasta_class()); sbf = gt_sequence_buffer_fasta_cast(sb); sb->pvt->filenametab = sequences; sbf->headerbuffer = gt_str_new(); sb->pvt->filenum = 0; sbf->firstoverallseq = true; sbf->firstseqinfile = true; sbf->nextfile = true; sb->pvt->nextread = sb->pvt->nextfree = 0; sb->pvt->complete = false; sb->pvt->lastspeciallength = 0; return sb; }
GtLeftborderOutbuffer *gt_leftborderbuffer_new(const char *name, GtFirstcodesspacelog *fcsl) { GtLeftborderOutbuffer *lbbuf = gt_malloc(sizeof (*lbbuf)); lbbuf->totalwrite = 0; lbbuf->outfilename = gt_str_new(); lbbuf->fp = gt_xtmpfp(lbbuf->outfilename); lbbuf->nextfree = 0; lbbuf->allocated = 1024UL; lbbuf->name = gt_str_new_cstr(name); lbbuf->spaceuint32_t = gt_malloc(sizeof (*lbbuf->spaceuint32_t) * lbbuf->allocated); GT_FCI_ADDWORKSPACE(fcsl,name, sizeof (*lbbuf->spaceuint32_t) * lbbuf->allocated); return lbbuf; }
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; }
GtAlphabet* gt_alphabet_new_from_file_no_suffix(const char *filename, GtError *err) { GtStr *transpath = NULL; bool haserr = false; GtAlphabet *alpha; gt_assert(filename); gt_error_check(err); alpha = gt_alphabet_new_empty(); if (!gt_file_exists(filename)) { GtStr *prog; const char *progname = gt_error_get_progname(err); gt_assert(progname != NULL); prog = gt_str_new(); gt_str_append_cstr_nt(prog, progname, gt_cstr_length_up_to_char(progname, ' ')); transpath = gt_get_gtdata_path(gt_str_get(prog), err); gt_str_delete(prog); gt_str_append_cstr(transpath, "/trans/"); gt_str_append_cstr(transpath, filename); } if (read_symbolmap(alpha, transpath == NULL ? filename : gt_str_get(transpath), err) != 0) { haserr = true; } gt_str_delete(transpath); if (alpha == NULL) { haserr = true; } if (haserr) { gt_alphabet_delete((GtAlphabet*) alpha); return NULL; } return alpha; }
int gt_mergeesa(int argc, const char **argv, GtError *err) { GtStr *storeindex; GtStrArray *indexnametab; bool haserr = false; int parsed_args; gt_error_check(err); storeindex = gt_str_new(); indexnametab = gt_str_array_new(); switch (parse_options(storeindex, indexnametab, &parsed_args, argc, argv, err)) { case GT_OPTION_PARSER_OK: break; case GT_OPTION_PARSER_ERROR: haserr = true; break; case GT_OPTION_PARSER_REQUESTS_EXIT: return 0; } if (!haserr) { GtUword i; GtLogger *logger; printf("# storeindex=%s\n",gt_str_get(storeindex)); for (i=0; i<gt_str_array_size(indexnametab); i++) { printf("# input=%s\n",gt_str_array_get(indexnametab,i)); } logger = gt_logger_new(false, GT_LOGGER_DEFLT_PREFIX, stdout); if (gt_performtheindexmerging(storeindex, indexnametab, logger, err) != 0) { haserr = true; } gt_logger_delete(logger); } gt_str_delete(storeindex); gt_str_array_delete(indexnametab); return haserr ? -1 : 0; }
static int gt_compreads_decompress_benchmark(GtHcrDecoder *hcrd, unsigned long amount, GtTimer *timer, GtError *err) { char qual[BUFSIZ] = {0}, seq[BUFSIZ] = {0}; int had_err = 0; unsigned long rand, max_rand = gt_hcr_decoder_num_of_reads(hcrd) - 1, count; GtStr *timer_comment = gt_str_new_cstr("extracting "); GtStr *desc = gt_str_new(); gt_str_append_ulong(timer_comment, amount); gt_str_append_cstr(timer_comment, " reads of "); gt_str_append_ulong(timer_comment, max_rand + 1); gt_str_append_cstr(timer_comment, "!"); if (timer == NULL) { timer = gt_timer_new_with_progress_description("extract random reads"); gt_timer_start(timer); } else { gt_timer_show_progress(timer, "extract random reads", stdout); } gt_log_log("%s",gt_str_get(timer_comment)); for (count = 0; count < amount; count++) { if (!had_err) { rand = gt_rand_max(max_rand); gt_log_log("get read: %lu", rand); had_err = gt_hcr_decoder_decode(hcrd, rand, seq, qual, desc, err); gt_log_log("%s",gt_str_get(desc)); gt_log_log("%s",seq); gt_log_log("%s",qual); } } gt_str_delete(timer_comment); gt_str_delete(desc); if (!gt_showtime_enabled()) gt_timer_delete(timer); return had_err; }
static int gt_shredder_runner(GT_UNUSED int argc, const char **argv, int parsed_args, void *tool_arguments, GtError *err) { GtShredderArguments *arguments = tool_arguments; GtBioseqIterator *bsi; unsigned long i; GtBioseq *bioseq; int had_err; GtStr *desc; gt_error_check(err); gt_assert(arguments); /* init */ desc = gt_str_new(); bsi = gt_bioseq_iterator_new(argc - parsed_args, argv + parsed_args); /* shredder */ while (!(had_err = gt_bioseq_iterator_next(bsi, &bioseq, err)) && bioseq) { for (i = 0; i < arguments->coverage; i++) { GtShredder *shredder; unsigned long fragment_length; const char *fragment; shredder = gt_shredder_new(bioseq, arguments->minlength, arguments->maxlength); gt_shredder_set_overlap(shredder, arguments->overlap); gt_shredder_set_sample_probability(shredder, arguments->sample_probability); while ((fragment = gt_shredder_shred(shredder, &fragment_length, desc))) { gt_str_append_cstr(desc, " [shreddered fragment]"); gt_fasta_show_entry(gt_str_get(desc), fragment, fragment_length, 0); } gt_shredder_delete(shredder); } gt_bioseq_delete(bioseq); } /* free */ gt_bioseq_iterator_delete(bsi); gt_str_delete(desc); return had_err; }
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 void gt_Sfxmappedrange_storetmp(GtSfxmappedrange *sfxmappedrange, GtSfxStoretype usedptrptr, GtSfxmappedrangetype type, bool writable) { FILE *outfp; gt_assert(sfxmappedrange != NULL); sfxmappedrange->ptr = NULL; sfxmappedrange->filename = gt_str_new(); sfxmappedrange->writable = writable; outfp = gt_xtmpfp(sfxmappedrange->filename); gt_assert(outfp != NULL); gt_log_log("write %s to file %s ("GT_WU" units of "GT_WU" bytes)", gt_str_get(sfxmappedrange->tablename), gt_str_get(sfxmappedrange->filename), (GtUword) sfxmappedrange->numofunits, (GtUword) sfxmappedrange->sizeofunit); switch (type) { case GtSfxGtBitsequence: gt_xfwrite(*(usedptrptr.bs),sfxmappedrange->sizeofunit, sfxmappedrange->numofunits,outfp); sfxmappedrange->usedptrptr = (void**) usedptrptr.bs; gt_free(*(usedptrptr.bs)); *(usedptrptr.bs) = NULL; break; case GtSfxunsignedlong: gt_xfwrite(*(usedptrptr.ulong),sfxmappedrange->sizeofunit, sfxmappedrange->numofunits,outfp); sfxmappedrange->usedptrptr = (void**) usedptrptr.ulong; gt_free(*(usedptrptr.ulong)); *(usedptrptr.ulong) = NULL; break; case GtSfxuint32_t: gt_xfwrite(*(usedptrptr.uint32),sfxmappedrange->sizeofunit, sfxmappedrange->numofunits,outfp); sfxmappedrange->usedptrptr = (void**) usedptrptr.uint32; gt_free(*(usedptrptr.uint32)); *(usedptrptr.uint32) = NULL; break; } gt_fa_fclose(outfp); }
/* 'static' function */ GtStrArray* gt_trans_table_get_scheme_descriptions() { GtUword i; GtTranslationScheme *scheme; GtStr *str; GtStrArray *sa = gt_str_array_new(); str = gt_str_new(); for (i = 1UL; i < (GtUword) GT_SIZEOFTRANSRANGE; i++) { if (transnum2index[i] == GT_UNDEFTRANSNUM) continue; scheme = schemetable + transnum2index[i]; gt_str_reset(str); gt_str_append_uint(str, scheme->identity); gt_str_append_cstr(str, ": "); gt_str_append_cstr(str, scheme->name); gt_str_array_add_cstr(sa, gt_str_get(str)); } gt_str_delete(str); return sa; }
static GtStr* make_id_unique(GtGFF3Visitor *gff3_visitor, GtFeatureNode *fn) { GtUword i = 1; GtStr *id = gt_str_new_cstr(gt_feature_node_get_attribute(fn, "ID")); if (gt_cstr_table_get(gff3_visitor->used_ids, gt_str_get(id))) { GtStr *buf = gt_str_new(); while (!id_string_is_unique(id, buf, gff3_visitor->used_ids, i++)); gt_warning("feature ID \"%s\" not unique: changing to %s", gt_str_get(id), gt_str_get(buf)); gt_str_set(id, gt_str_get(buf)); gt_str_delete(buf); } /* update table with the new id */ gt_cstr_table_add(gff3_visitor->used_ids, gt_str_get(id)); /* store (unique) id */ gt_hashmap_add(gff3_visitor->feature_node_to_unique_id_str, fn, id); return id; }
static void* gt_select_arguments_new(void) { SelectArguments *arguments = gt_calloc(1, sizeof *arguments); arguments->seqid = gt_str_new(); arguments->source = gt_str_new(); arguments->gt_strand_char = gt_str_new(); arguments->strand = GT_NUM_OF_STRAND_TYPES; arguments->targetgt_strand_char = gt_str_new(); arguments->targetstrand = GT_NUM_OF_STRAND_TYPES; arguments->ofi = gt_output_file_info_new(); arguments->filter_files = gt_str_array_new(); arguments->filter_logic = gt_str_new(); arguments->dropped_file = gt_str_new(); return arguments; }
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; }
static int assign_block_caption(GtDiagram *d, GtFeatureNode *node, GtFeatureNode *parent, GtBlock *block, GtError *err) { const char *nnid_p = NULL, *nnid_n = NULL; GtStr *caption = NULL; bool status = true; int rval; caption = gt_str_new(); rval = gt_style_get_str(d->style, gt_feature_node_get_type(node), "block_caption", caption, node, err); if (rval == GT_STYLE_QUERY_ERROR) { gt_str_delete(caption); return -1; } else if (rval == GT_STYLE_QUERY_NOT_SET) { nnid_p = get_node_name_or_id(parent); nnid_n = get_node_name_or_id(node); if ((nnid_p || nnid_n) && status) { if (parent) { if (nnid_p && gt_feature_node_has_children(parent)) gt_str_append_cstr(caption, nnid_p); else gt_str_append_cstr(caption, "-"); gt_str_append_cstr(caption, "/"); } if (nnid_n) gt_str_append_cstr(caption, nnid_n); } else { gt_str_delete(caption); caption = NULL; } } gt_block_set_caption(block, caption); return 0; }