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;
}
