void freesuffixarray(Suffixarray *suffixarray) { gt_fa_xmunmap((void *) suffixarray->suftab); suffixarray->suftab = NULL; gt_fa_xmunmap((void *) suffixarray->lcptab); suffixarray->lcptab = NULL; gt_fa_xmunmap((void *) suffixarray->llvtab); suffixarray->llvtab = NULL; gt_fa_xmunmap((void *) suffixarray->bwttab); suffixarray->bwttab = NULL; gt_fa_xfclose(suffixarray->suftabstream.fp); suffixarray->suftabstream.fp = NULL; FREESPACE(suffixarray->suftabstream.bufferedfilespace); gt_fa_xfclose(suffixarray->lcptabstream.fp); suffixarray->lcptabstream.fp = NULL; FREESPACE(suffixarray->lcptabstream.bufferedfilespace); gt_fa_xfclose(suffixarray->llvtabstream.fp); suffixarray->llvtabstream.fp = NULL; FREESPACE(suffixarray->llvtabstream.bufferedfilespace); gt_fa_xfclose(suffixarray->bwttabstream.fp); suffixarray->bwttabstream.fp = NULL; FREESPACE(suffixarray->bwttabstream.bufferedfilespace); encodedsequence_free(&suffixarray->encseq); if (suffixarray->bcktab != NULL) { bcktab_delete(&suffixarray->bcktab); } }
void gt_freesuffixarray(Suffixarray *suffixarray) { gt_fa_xmunmap((void *) suffixarray->suftab); suffixarray->suftab = NULL; gt_fa_xmunmap((void *) suffixarray->lcptab); suffixarray->lcptab = NULL; gt_fa_xmunmap((void *) suffixarray->llvtab); suffixarray->llvtab = NULL; gt_fa_xmunmap((void *) suffixarray->bwttab); suffixarray->bwttab = NULL; gt_fa_xfclose(suffixarray->suftabstream_GtUword.fp); suffixarray->suftabstream_GtUword.fp = NULL; gt_free(suffixarray->suftabstream_GtUword.bufferedfilespace); #if defined (_LP64) || defined (_WIN64) gt_fa_xfclose(suffixarray->suftabstream_uint32_t.fp); suffixarray->suftabstream_uint32_t.fp = NULL; gt_free(suffixarray->suftabstream_uint32_t.bufferedfilespace); #endif gt_fa_xfclose(suffixarray->lcptabstream.fp); suffixarray->lcptabstream.fp = NULL; gt_free(suffixarray->lcptabstream.bufferedfilespace); gt_fa_xfclose(suffixarray->llvtabstream.fp); suffixarray->llvtabstream.fp = NULL; gt_free(suffixarray->llvtabstream.bufferedfilespace); gt_fa_xfclose(suffixarray->bwttabstream.fp); suffixarray->bwttabstream.fp = NULL; gt_free(suffixarray->bwttabstream.bufferedfilespace); gt_encseq_delete(suffixarray->encseq); suffixarray->encseq = NULL; if (suffixarray->bcktab != NULL) { gt_bcktab_delete(suffixarray->bcktab); suffixarray->bcktab = NULL; } }
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; }
int gt_extractkeysfromfastaindex(const char *indexname, const GtStr *fileofkeystoextract, unsigned long linewidth,GtError *err) { GtEncseq *encseq = NULL; GtEncseqLoader *el = NULL; bool haserr = false; unsigned long numofdbsequences = 0, keysize = 0; el = gt_encseq_loader_new(); encseq = gt_encseq_loader_load(el, indexname, err); gt_encseq_loader_delete(el); if (encseq == NULL) { haserr = true; } if (!haserr) { int retval; numofdbsequences = gt_encseq_num_of_sequences(encseq); retval = readkeysize(indexname,err); if (retval < 0) { haserr = true; } keysize = (unsigned long) retval; } if (!haserr) { char *keytab; unsigned long keytablength; keytablength = 1UL + numofdbsequences * (keysize+1); keytab = gt_fa_mmap_check_size_with_suffix(indexname, GT_KEYSTABFILESUFFIX, keytablength, sizeof (GtUchar), err); if (keytab == NULL) { haserr = true; } else { if (itersearchoverallkeys(encseq,keytab,numofdbsequences, keysize,fileofkeystoextract, linewidth,err) != 0) { haserr = true; } } gt_fa_xmunmap(keytab); } if (encseq != NULL) { gt_encseq_delete(encseq); encseq = NULL; } return haserr ? -1 : 0; }
Tyrcountinfo *gt_tyrcountinfo_new(const Tyrindex *tyrindex, const char *tyrindexname, GtError *err) { size_t numofbytes; void *tmp; bool haserr = false; Tyrcountinfo *tyrcountinfo; gt_error_check(err); tyrcountinfo = gt_malloc(sizeof *tyrcountinfo); tyrcountinfo->indexfilename = tyrindexname; tyrcountinfo->mappedmctfileptr = gt_fa_mmap_read_with_suffix(tyrindexname,COUNTSSUFFIX,&numofbytes,err); if (tyrcountinfo->mappedmctfileptr == NULL) { tyrcountinfo->smallcounts = NULL; haserr = true; } else { tyrcountinfo->smallcounts = (GtUchar *) tyrcountinfo->mappedmctfileptr; tmp = &tyrcountinfo->smallcounts[tyrindex->numofmers]; tyrcountinfo->largecounts = (Largecount *) tmp; if (numofbytes < tyrindex->numofmers) { gt_error_set(err,"size of file \"%s.%s\" is smaller than minimum size " ""GT_WU"",tyrindexname,COUNTSSUFFIX, (GtUword) tyrindex->numofmers); haserr = true; } } if (!haserr && (numofbytes - tyrindex->numofmers) % sizeof (Largecount) != 0) { gt_error_set(err,"(numofbytes - numofmers) = "GT_WU " must be a multiple of "GT_WU, (GtUword) (numofbytes - tyrindex->numofmers), (GtUword) sizeof (Largecount)); haserr = true; } if (!haserr) { tyrcountinfo->numoflargecounts = (GtUword) (numofbytes - tyrindex->numofmers)/ (GtUword) sizeof (Largecount); } if (haserr) { if (tyrcountinfo->mappedmctfileptr != NULL) { gt_fa_xmunmap(tyrcountinfo->mappedmctfileptr); tyrcountinfo->mappedmctfileptr = NULL; } gt_free(tyrcountinfo); } return haserr ? NULL : tyrcountinfo; }
void gt_tyrindex_delete(Tyrindex **tyrindexptr) { Tyrindex *tyrindex = *tyrindexptr; gt_fa_xmunmap(tyrindex->mappedfileptr); tyrindex->mappedfileptr = NULL; gt_free(tyrindex); *tyrindexptr = NULL; }
void gt_suffixsortspace_delete(GtSuffixsortspace *suffixsortspace, GT_UNUSED bool checklongestdefined) { if (suffixsortspace != NULL) { gt_assert(!checklongestdefined || suffixsortspace->longestidx.defined); if (suffixsortspace->unmapsortspace) { gt_fa_xmunmap(suffixsortspace->ulongtab); gt_fa_xmunmap(suffixsortspace->uinttab); } else { gt_free(suffixsortspace->uinttab); gt_free(suffixsortspace->ulongtab); } gt_free(suffixsortspace); } }
void gt_Sfxmappedrange_unmap(GtSfxmappedrange *sfxmappedrange) { gt_assert(sfxmappedrange != NULL); if (sfxmappedrange->ptr != NULL) { gt_fa_xmunmap(sfxmappedrange->ptr); } sfxmappedrange->ptr = 0; }
void gt_tyrcountinfo_delete(Tyrcountinfo **tyrcountinfoptr) { Tyrcountinfo *tyrcountinfo = *tyrcountinfoptr; gt_fa_xmunmap(tyrcountinfo->mappedmctfileptr); tyrcountinfo->mappedmctfileptr = NULL; gt_free(tyrcountinfo); *tyrcountinfoptr = NULL; }
static void reset_data_iterator_to_pos(HcrHuffDataIterator *data_iter, size_t pos) { gt_assert(data_iter); gt_assert(pos < data_iter->end); gt_assert(data_iter->start <= pos); gt_fa_xmunmap(data_iter->data); data_iter->data = NULL; data_iter->pos = pos; }
static int get_next_file_chunk_for_huffman(GtBitsequence **bits, GtUword *length, GtUword *offset, GtUword *pad_length, void *meminfo) { const int empty = 0, success = 1; HcrHuffDataIterator *data_iter; gt_assert(meminfo); gt_assert(bits && length && offset && pad_length); data_iter = (HcrHuffDataIterator*) meminfo; gt_log_log("pos in iter: "GT_WU"", (GtUword) data_iter->pos); if (data_iter->pos < data_iter->end) { gt_fa_xmunmap(data_iter->data); data_iter->data = NULL; data_iter->data = gt_fa_xmmap_read_range(data_iter->path, (size_t) data_iter->blocksize, data_iter->pos); data_iter->pos += data_iter->blocksize; if (data_iter->pos > data_iter->end) { gt_safe_assign(*length, (data_iter->blocksize - (data_iter->pos - data_iter->end))); *length /= sizeof (GtBitsequence); } else *length = data_iter->bitseq_per_chunk; *offset = 0; *pad_length = 0; *bits = data_iter->data; return success; } gt_fa_xmunmap(data_iter->data); data_iter->data = NULL; *bits = NULL; *length = 0; *offset = 0; *pad_length = 0; return empty; }
static void reset_data_iterator_to_pos(HcrHuffDataIterator *data_iter, size_t pos) { gt_assert(data_iter); gt_assert(pos < data_iter->end); gt_assert(data_iter->start <= pos); gt_fa_xmunmap(data_iter->data); gt_log_log("reset to pos: "GT_WU"", (GtUword) pos); data_iter->data = NULL; data_iter->pos = pos; }
static void reset_data_iterator_to_pos(HcrHuffDataIterator *data_iter, size_t pos) { gt_assert(data_iter); gt_assert(pos < data_iter->end); gt_assert(data_iter->start <= pos); gt_fa_xmunmap(data_iter->data); gt_log_log("reset to pos: %lu", (unsigned long) pos); data_iter->data = NULL; data_iter->pos = pos; }
void gt_freefmindex(Fmindex *fmindex) { if (fmindex->mappedptr != NULL) { gt_fa_xmunmap(fmindex->mappedptr); } if (fmindex->bwtformatching != NULL) { gt_encseq_delete(fmindex->bwtformatching); fmindex->bwtformatching = NULL; } gt_alphabet_delete((GtAlphabet *) fmindex->alphabet); }
void gt_Sfxmappedrange_delete(GtSfxmappedrange *sfxmappedrange) { if (sfxmappedrange == NULL) { return; } gt_log_log("delete table %s",gt_str_get(sfxmappedrange->tablename)); gt_fa_xmunmap(sfxmappedrange->ptr); sfxmappedrange->ptr = NULL; gt_fa_xmunmap(sfxmappedrange->entire); sfxmappedrange->entire = NULL; if (sfxmappedrange->usedptrptr != NULL) { *sfxmappedrange->usedptrptr = NULL; } if (sfxmappedrange->filename != NULL) { gt_log_log("remove \"%s\"",gt_str_get(sfxmappedrange->filename)); gt_xunlink(gt_str_get(sfxmappedrange->filename)); } gt_str_delete(sfxmappedrange->tablename); gt_str_delete(sfxmappedrange->filename); gt_free(sfxmappedrange); }
void gt_runcheckfunctionontwofiles(Checkcmppairfuntype checkfunction, const char *file1, const char *file2) { const GtUchar *useq = NULL, *vseq = NULL; size_t ulen, vlen; bool forward = true; GtError *err; err = gt_error_new(); useq = (const GtUchar *) gt_fa_mmap_read(file1,&ulen,err); if (useq == NULL) { fprintf(stderr, "error: %s\n", gt_error_get(err)); exit(GT_EXIT_PROGRAMMING_ERROR); } vseq = (const GtUchar *) gt_fa_mmap_read(file2,&vlen,err); if (vseq == NULL) { fprintf(stderr, "error: %s\n", gt_error_get(err)); exit(GT_EXIT_PROGRAMMING_ERROR); } gt_error_delete(err); while (true) { checkfunction(forward,useq,(GtUword) ulen, vseq,(GtUword) vlen); if (!forward) { break; } forward = false; } gt_fa_xmunmap((void *) useq); gt_fa_xmunmap((void *) vseq); }
void pckbuckettable_free(Pckbuckettable *pckbt) { if (pckbt->mapptr == NULL) { gt_free(pckbt->mbtab[0]); } else { gt_fa_xmunmap(pckbt->mapptr); } pckbt->mbtab[0] = NULL; gt_free(pckbt->mbtab); pckbt->mbtab = NULL; gt_free(pckbt->basepower); pckbt->basepower = NULL; gt_free(pckbt); }
void gt_pckbuckettable_delete(Pckbuckettable *pckbt) { gt_assert(pckbt != NULL); if (pckbt->mapptr == NULL) { gt_free(pckbt->mbtab[0]); } else { gt_fa_xmunmap(pckbt->mapptr); } pckbt->mbtab[0] = NULL; gt_free(pckbt->mbtab); pckbt->mbtab = NULL; gt_free(pckbt->basepower); pckbt->basepower = NULL; gt_free(pckbt); }
void gt_md5_tab_delete(GtMD5Tab *md5_tab) { GtUword i; if (!md5_tab) return; if (md5_tab->reference_count) { md5_tab->reference_count--; return; } gt_fa_xmunmap(md5_tab->fingerprints); gt_fa_unlock(md5_tab->fingerprints_file); gt_fa_xfclose(md5_tab->fingerprints_file); gt_hashmap_delete(md5_tab->md5map); if (md5_tab->owns_md5s) { for (i = 0; i < md5_tab->num_of_md5s; i++) gt_free(md5_tab->md5_fingerprints[i]); gt_free(md5_tab->md5_fingerprints); } gt_free(md5_tab); }
void *genericmaptable(const GtStr *indexname, const char *suffix, unsigned long expectedunits, size_t sizeofunit, GtError *err) { size_t numofbytes; void *ptr = genericmaponlytable(indexname,suffix,&numofbytes,err); if (ptr == NULL) { return NULL; } if (checkmappedfilesize(indexname,suffix, numofbytes,expectedunits,sizeofunit,err) != 0) { gt_fa_xmunmap(ptr); return NULL; } return ptr; }
static bool read_fingerprints(GtMD5Tab *md5_tab, const char *fingerprints_filename, bool use_file_locking) { bool reading_succeeded = true; size_t len; gt_assert(md5_tab && fingerprints_filename); /* open file */ gt_assert(gt_file_exists(fingerprints_filename)); if (use_file_locking) { md5_tab->fingerprints_file = gt_fa_xfopen(fingerprints_filename, "r"); gt_fa_lock_shared(md5_tab->fingerprints_file); } md5_tab->fingerprints = gt_fa_xmmap_read(fingerprints_filename, &len); if (len != md5_tab->num_of_md5s * 33) { gt_fa_xmunmap(md5_tab->fingerprints); md5_tab->fingerprints = NULL; gt_fa_unlock(md5_tab->fingerprints_file); gt_fa_xfclose(md5_tab->fingerprints_file); md5_tab->fingerprints_file = NULL; reading_succeeded = false; } return reading_succeeded; }
void *gt_Sfxmappedrange_map(GtSfxmappedrange *sfxmappedrange, GtUword minindex, GtUword maxindex) { gt_assert(sfxmappedrange != NULL); if (sfxmappedrange->ptr != NULL) { gt_fa_xmunmap(sfxmappedrange->ptr); } if (sfxmappedrange->transformfunc != NULL) { sfxmappedrange->transformfunc(&minindex,&maxindex, sfxmappedrange->transformfunc_data); } if (minindex <= maxindex) { GtMappedrange lbrange; GtUword unitoffset; size_t sizeoftable; gt_Sfxmapped_offset_end(&lbrange, sfxmappedrange->sizeofunit, sfxmappedrange->pagesize, minindex, maxindex); sizeoftable = gt_Sfxmappedrange_size_entire(sfxmappedrange); gt_log_log("mapped %s["GT_WU".."GT_WU"] for %s (%.1f%% of all)", gt_str_get(sfxmappedrange->tablename), lbrange.mapoffset, lbrange.mapend, sfxmappedrange->writable ? "writing" : "reading", (lbrange.mapend - lbrange.mapoffset + 1 >= (GtUword) sizeoftable) ? 100.0 : 100.0 * (lbrange.mapend - lbrange.mapoffset + 1)/ sizeoftable); gt_assert(lbrange.mapoffset <= lbrange.mapend); gt_assert(lbrange.mapoffset <= minindex * sfxmappedrange->sizeofunit); gt_assert(maxindex * sfxmappedrange->sizeofunit <= lbrange.mapend); gt_assert(lbrange.mapoffset % sfxmappedrange->pagesize == 0); if (sfxmappedrange->writable) { sfxmappedrange->ptr = gt_fa_xmmap_write_range(gt_str_get(sfxmappedrange->filename), (size_t) (lbrange.mapend-lbrange.mapoffset+1), (size_t) lbrange.mapoffset); } else { sfxmappedrange->ptr = gt_fa_xmmap_read_range (gt_str_get(sfxmappedrange->filename), (size_t) (lbrange.mapend-lbrange.mapoffset+1), (size_t) lbrange.mapoffset); } sfxmappedrange->indexrange_defined = true; sfxmappedrange->currentmaxindex = maxindex; sfxmappedrange->currentminindex = minindex; unitoffset = lbrange.mapoffset / sfxmappedrange->sizeofunit; switch (sfxmappedrange->type) { case GtSfxGtBitsequence: return ((GtBitsequence *) sfxmappedrange->ptr) - unitoffset; case GtSfxuint32_t: return ((uint32_t *) sfxmappedrange->ptr) - unitoffset; case GtSfxunsignedlong: return ((GtUword *) sfxmappedrange->ptr) - unitoffset; default: gt_assert(false); break; } gt_assert(false); } sfxmappedrange->ptr = NULL; sfxmappedrange->indexrange_defined = true; sfxmappedrange->currentmaxindex = maxindex; sfxmappedrange->currentminindex = minindex; return NULL; }
static void data_iterator_delete(HcrHuffDataIterator *data_iter) { if (data_iter != NULL) gt_fa_xmunmap(data_iter->data); gt_free(data_iter); }
Tyrindex *gt_tyrindex_new(const char *tyrindexname,GtError *err) { bool haserr = false; size_t numofbytes, rest; Tyrindex *tyrindex; gt_error_check(err); tyrindex = gt_malloc(sizeof *tyrindex); tyrindex->indexfilename = tyrindexname; tyrindex->mappedfileptr = gt_fa_mmap_read_with_suffix(tyrindexname,MERSUFFIX, &numofbytes,err); if (tyrindex->mappedfileptr == NULL) { haserr = true; } if (!haserr) { tyrindex->mertable = (GtUchar *) tyrindex->mappedfileptr; rest = sizeof (GtUword) * EXTRAINTEGERS; if (rest > numofbytes) { gt_error_set(err,"index must contain at least "GT_WU" bytes", (GtUword) rest); haserr = true; } } if (!haserr) { gt_assert(tyrindex->mertable != NULL); tyrindex->mersize = gt_decodesingleinteger(tyrindex->mertable + numofbytes - rest); tyrindex->alphasize = (unsigned int) gt_decodesingleinteger(tyrindex->mertable + numofbytes - rest + sizeof (GtUword)); tyrindex->merbytes = MERBYTES(tyrindex->mersize); if ((numofbytes - rest) % tyrindex->merbytes != 0) { gt_error_set(err,"size of index is "GT_WU " which is not a multiple of "GT_WU, (GtUword) (numofbytes - rest), tyrindex->merbytes); haserr = true; } } if (!haserr) { tyrindex->numofmers = (numofbytes - rest) / tyrindex->merbytes; gt_assert(tyrindex->mertable != NULL); if (tyrindex->numofmers == 0) { tyrindex->lastmer = tyrindex->mertable - 1; } else { tyrindex->lastmer = tyrindex->mertable + numofbytes - rest - tyrindex->merbytes; } } if (haserr) { if (tyrindex->mappedfileptr != NULL) { gt_fa_xmunmap(tyrindex->mappedfileptr); tyrindex->mappedfileptr = NULL; } gt_free(tyrindex); } return haserr ? NULL : tyrindex; }
int gtr_run(GtR *gtr, int argc, const char **argv, GtError *err) { GtToolfunc toolfunc; GtTool *tool = NULL; char **nargv = NULL; void *mem, *map; int had_err = 0; gt_error_check(err); gt_assert(gtr); if (gtr->debug) enable_logging(gt_str_get(gtr->debugfp), >r->logfp); if (gtr->quiet) gt_warning_disable(); gtr->seed = gt_ya_rand_init(gtr->seed); gt_log_log("seed=%u", gtr->seed); if (gtr->list) return list_tools(gtr); if (gt_str_length(gtr->manoutdir) > 0) return create_manpages(gtr, gt_str_get(gtr->manoutdir), err); if (gtr->check64bit) return check64bit(); if (gtr->test) return run_tests(gtr, err); if (gt_str_length(gtr->testspacepeak)) { mem = gt_malloc(1 << 26); /* alloc 64 MB */; map = gt_fa_xmmap_read(gt_str_get(gtr->testspacepeak), NULL); gt_fa_xmunmap(map); gt_free(mem); } if (argc == 0 && !gtr->interactive) { gt_error_set(err, "neither tool nor script specified; option -help lists " "possible tools"); had_err = -1; } if (!had_err && argc) { if (!gtr->tools || !gt_toolbox_has_tool(gtr->tools, argv[0])) { /* no tool found -> try to open script */ if (gt_file_exists(argv[0])) { /* export script */ gt_lua_set_script_dir(gtr->L, argv[0]); /* run script */ nargv = gt_cstr_array_prefix_first(argv, gt_error_get_progname(err)); gt_lua_set_arg(gtr->L, nargv[0], (const char**) nargv+1); if (luaL_dofile(gtr->L, argv[0])) { /* error */ gt_assert(lua_isstring(gtr->L, -1)); /* error message on top */ gt_error_set(err, "could not execute script %s", lua_tostring(gtr->L, -1)); had_err = -1; lua_pop(gtr->L, 1); /* pop error message */ } } else { /* neither tool nor script found */ gt_error_set(err, "neither tool nor script '%s' found; option -help " "lists possible tools", argv[0]); had_err = -1; } } else { /* run tool */ if (!(toolfunc = gt_toolbox_get(gtr->tools, argv[0]))) { tool = gt_toolbox_get_tool(gtr->tools, argv[0]); gt_assert(tool); } nargv = gt_cstr_array_prefix_first(argv, gt_error_get_progname(err)); gt_error_set_progname(err, nargv[0]); if (toolfunc) had_err = toolfunc(argc, (const char**) nargv, err); else had_err = gt_tool_run(tool, argc, (const char**) nargv, err); } } gt_cstr_array_delete(nargv); if (!had_err && gtr->interactive) { gt_showshortversion(gt_error_get_progname(err)); gt_lua_set_arg(gtr->L, gt_error_get_progname(err), argv); run_interactive_lua_interpreter(gtr->L); } if (had_err) return EXIT_FAILURE; return EXIT_SUCCESS; }