static void prima_prune_nearby(AjPList pairlist, ajint *npair, ajint range)
{
PPair pair;
ajint count;
ajint fst;
ajint fst2;
ajint blim;
ajint blim2;
ajint elim;
ajint elim2;
ajint i;
ajint j;
ajint len;
for(i=0;i<*npair;++i)
{
for(j=0;j<i;++j) /* Ignore those already processed */
{
ajListPop(pairlist,(void **)&pair);
ajListPushAppend(pairlist,(void *)pair);
}
ajListPop(pairlist,(void **)&pair);/* Get next high scoring pair */
len = pair->f->primerlen;
fst = pair->f->start + len -1;
blim = fst-range;
elim = fst+range;
len = pair->r->primerlen;
blim2 = pair->r->start - range;
elim2 = pair->r->start + range;
ajListPushAppend(pairlist,(void *)pair);
count = *npair;
for(j=i+1;j<*npair;++j)
{
ajListPop(pairlist,(void **)&pair);
fst2=pair->f->start+pair->f->primerlen-1;
if((fst2<blim || fst2>elim) && (pair->r->start<blim2 ||
pair->r->start>elim2))
ajListPushAppend(pairlist,(void *)pair);
else
{
prima_PrimerDel(&pair->f);
prima_PrimerDel(&pair->r);
AJFREE(pair);
--count;
}
}
*npair = count;
}
return;
}
static void jaspscan_GetFileList(const AjPStr dir, const AjPStr jaspdir,
const char *wild, AjPList list)
{
AjPList tlist = NULL;
AjPStr jdir = NULL;
AjPStr wstr = NULL;
AjPStr str = NULL;
tlist = ajListNew();
jdir = ajStrNew();
wstr = ajStrNew();
ajFmtPrintS(&jdir,"%S%S",dir,jaspdir);
if(!ajDirnameFixExists(&jdir))
ajFatal("EMBOSS_DATA undefined or 'jaspextract' needs to be run");
ajFmtPrintS(&wstr,"%s%s",wild,J_EXT);
ajFilelistAddPathWild(tlist,jdir,wstr);
if(!ajListGetLength(tlist))
ajWarn("Matrix file(s) %S not found",wstr);
while(ajListPop(tlist,(void **)&str))
ajListPushAppend(list,(void *)str);
ajStrDel(&wstr);
ajStrDel(&jdir);
ajListFree(&tlist);
return;
}
static void tfscan_print_hits(AjPList *l,
ajint hits, AjPReport outf,
const AjPTable t,
const AjPSeq seq, ajuint minlength,
const AjPTable btable)
{
ajint i;
EmbPMatMatch m;
const AjPStr acc = NULL;
const AjPStr bf = NULL;
AjPFeattable ftable = NULL;
AjPFeature gf = NULL;
AjPStr type = ajStrNewC("SO:0000235");
AjPStr tmpstr = NULL;
ftable = ajFeattableNewSeq(seq);
/*ajFmtPrintF(outf,"TFSCAN of %s from %d to %d\n\n",ajStrGetPtr(name),
begin,end);*/
for(i=0;i<hits;++i)
{
ajListPop(*l,(void **)&m);
acc = ajTableFetchS(t, m->seqname);
if(m->len >= minlength)
{
/*ajFmtPrintF(outf,"%-20s %-8s %-5d %-5d %s\n",
ajStrGetPtr(m->seqname),
ajStrGetPtr(acc),m->start,
m->start+m->len-1,ajStrGetPtr(s));*/
if(m->forward)
gf = ajFeatNew(ftable, ajUtilGetProgram(), type,
m->start,
m->start+m->len-1,
(float) m->score,
'+',0);
else
gf = ajFeatNew(ftable, ajUtilGetProgram(), type,
m->start,
m->start+m->len-1,
(float) m->score,
'-',0);
ajFmtPrintS(&tmpstr, "*acc %S", acc);
ajFeatTagAddSS(gf, NULL, tmpstr);
bf = ajTableFetchS(btable, m->seqname);
ajFmtPrintS(&tmpstr, "*factor %S", bf);
ajFeatTagAddSS(gf, NULL, tmpstr);
}
embMatMatchDel(&m);
}
ajReportWrite(outf, ftable, seq);
ajFeattableDel(&ftable);
ajStrDel(&tmpstr);
ajStrDel(&type);
return;
}
void ajRefseqDel(AjPRefseq *Prefseq)
{
AjPRefseq refseq;
AjPSeqRange tmprange;
if(!Prefseq) return;
if(!(*Prefseq)) return;
refseq = *Prefseq;
ajStrDel(&refseq->Id);
ajStrDel(&refseq->Db);
ajStrDel(&refseq->Setdb);
ajStrDel(&refseq->Full);
ajStrDel(&refseq->Qry);
ajStrDel(&refseq->Formatstr);
ajStrDel(&refseq->Filename);
ajStrDel(&refseq->TextPtr);
ajStrDel(&refseq->Desc);
ajStrDel(&refseq->Seq);
while(ajListPop(refseq->Seqlist,(void **)&tmprange))
ajSeqrangeDel(&tmprange);
ajListFree(&refseq->Seqlist);
AJFREE(*Prefseq);
*Prefseq = NULL;
return;
}
static void assemblyexceptionadaptorClearIdentifierCache(void **key,
void **value,
void *cl)
{
EnsPAssemblyexception ae = NULL;
if(!key)
return;
if(!*key)
return;
if(!value)
return;
if(!*value)
return;
(void) cl;
AJFREE(*key);
while(ajListPop(*((AjPList *) value), (void **) &ae))
ensAssemblyexceptionDel(&ae);
ajListFree((AjPList *) value);
return;
}
static void jaspextract_getjaspdirs(AjPList jdirlist)
{
const AjPStr datadir = NULL;
AjPStr line = NULL;
ajuint n = 0;
ajuint i = 0;
datadir = ajDatafileValuePath();
if(!datadir)
ajFatal("jaspextract: Cannot determine the EMBOSS data directory");
n = ajFilelistAddPathDir(jdirlist, datadir);
for(i=0; i < n; ++i)
{
ajListPop(jdirlist,(void **)&line);
if(ajStrFindC(line,"JASPAR_") != -1)
ajListPushAppend(jdirlist,(void *)line);
else
ajStrDel(&line);
}
return;
}
static void silent_split_hits(AjPList *hits, AjPList *silents,
AjPList *nonsilents, AjBool allmut)
{
PSilent res;
while(ajListPop(*hits,(void **)&res))
{
if(res->issilent)
{
ajListPushAppend(*silents,(void *)res);
continue;
}
if(allmut)
ajListPushAppend(*nonsilents,(void *)res);
else
{
ajStrDel(&res->code);
ajStrDel(&res->site);
ajStrDel(&res->seqaa);
ajStrDel(&res->reaa);
AJFREE(res);
}
}
return;
}
static void prima_TwoSortscorepos(AjPList *pairlist)
{
PPair tmp = NULL;
AjPList intlist = NULL;
AjPList filist = NULL;
PPair save = NULL;
float score = 0.0;
ajListSort(*pairlist,prima_Compare);
intlist = ajListNew();
filist = ajListNew();
score = (float) -1.0;
while(ajListPop(*pairlist,(void **)&tmp))
{
if(tmp->f->score == score)
{
ajListPush(intlist,(void *)tmp);
continue;
}
save = tmp;
ajListSort(intlist,prima_PosCompare);
score = tmp->f->score;
prima_RevSort(&intlist);
while(ajListPop(intlist,(void **)&tmp))
ajListPushAppend(filist,(void *)tmp);
ajListPush(intlist,(void *)save);
}
ajListSort(intlist,prima_PosCompare);
prima_RevSort(&intlist);
while(ajListPop(intlist,(void **)&tmp))
ajListPushAppend(filist,(void *)tmp);
ajListFree(&intlist);
ajListFree(pairlist);
*pairlist = filist;
return;
}
static void prima_check_overlap(AjPList pairlist, ajint *npair, ajint overlap)
{
PPair pair;
ajint i;
ajint j;
ajint end;
ajint limit;
ajint count;
for(i=0;i<*npair;++i)
{
for(j=0;j<i;++j)
{
ajListPop(pairlist,(void **)&pair);
ajListPushAppend(pairlist,(void *)pair);
}
ajListPop(pairlist,(void **)&pair);
end = pair->r->start;
limit = end-overlap;
ajListPushAppend(pairlist,(void *)pair);
count = *npair;
for(j=i+1;j<*npair;++j)
{
ajListPop(pairlist,(void **)&pair);
if(pair->f->start+pair->f->primerlen-1 < limit)
{
prima_PrimerDel(&pair->f);
prima_PrimerDel(&pair->r);
AJFREE(pair);
--count;
}
else
ajListPushAppend(pairlist,(void *)pair);
}
*npair = count;
}
return;
}
static void jaspextract_writematrixfile(const AjPTable mtable,
const AjPStr directory)
{
AjPStr wild = NULL;
AjPList flist = NULL;
AjPStr key = NULL;
AjPStr fname = NULL;
AjPStr dest = NULL;
const AjPStr value = NULL;
AjPFile outf = NULL;
const char *p = NULL;
char *q = NULL;
wild = ajStrNewC("*.pfm");
flist = ajListNew();
key = ajStrNew();
dest = ajStrNew();
ajFmtPrintS(&dest,"%S%c%s",directory,SLASH_CHAR,MATRIXFILE);
outf = ajFileNewOutNameS(dest);
if(!outf)
ajFatal("Cannot open output file %S",dest);
ajFilelistAddPathWild(flist, directory, wild);
while(ajListPop(flist,(void**)&fname))
{
ajFilenameTrimPath(&fname);
p = ajStrGetPtr(fname);
q = strrchr(p,(int)'.');
ajStrAssignSubC(&key,p,0,q-p-1);
value = ajTableFetchS(mtable, key);
if(value)
ajFmtPrintF(outf,"%S",value);
ajStrDel(&fname);
}
ajFileClose(&outf);
ajStrDel(&wild);
ajStrDel(&dest);
ajStrDel(&key);
ajListFree(&flist);
return;
}
/* @prog scopparse ************************************************************
**
** Converts raw scop classification files to a file in embl-like format.
**
******************************************************************************/
int main(int argc, char **argv)
{
AjPFile inf1 = NULL;
AjPFile inf2 = NULL;
AjPFile outf = NULL;
AjPList list = NULL;
AjPScop tmp = NULL;
AjBool nosegments = ajFalse;
AjBool nomultichain = ajFalse;
AjBool nominor = ajFalse;
/* Read data from acd. */
embInitPV("scopparse", argc, argv, "DOMAINATRIX",VERSION);
inf1 = ajAcdGetInfile("classfile");
inf2 = ajAcdGetInfile("desinfile");
outf = ajAcdGetOutfile("dcffile");
nosegments = ajAcdGetBoolean("nosegments");
nomultichain = ajAcdGetBoolean("nomultichain");
nominor = ajAcdGetBoolean("nominor");
/*
ajFmtPrint("nosegments: %B\n", nosegments);
ajFmtPrint("nomultichain: %B\n", nomultichain);
ajFmtPrint("nominor: %B\n", nominor);
*/
/* Main body of code. */
list = ajScopReadAllRawNew(inf1, inf2, nomultichain);
while(ajListPop(list, (void **) &tmp))
{
if(((!nosegments) || (tmp->N == 1)) &&
((!nominor) || ((tmp->Sunid_Class == 46456) || /* All alpha*/
(tmp->Sunid_Class == 48724) || /* All beta */
(tmp->Sunid_Class == 51349) || /* a/b */
(tmp->Sunid_Class == 53931)))) /* a+b */
ajScopWrite(outf, tmp);
ajScopDel(&tmp);
}
/* Memory management. */
ajFileClose(&outf);
ajFileClose(&inf1);
ajFileClose(&inf2);
ajListFree(&list);
ajExit();
return 0;
}
static void prima_RevSort(AjPList *alist)
{
PPair tmp = NULL;
AjPList intlist = NULL;
AjPList filist = NULL;
PPair save = NULL;
ajint pos = -1;
intlist = ajListNew();
filist = ajListNew();
pos = -1;
while(ajListPop(*alist,(void **)&tmp))
{
if(tmp->f->start+tmp->f->primerlen == pos)
{
ajListPush(intlist,(void *)tmp);
continue;
}
save = tmp;
ajListSort(intlist,prima_PosEndCompare);
pos = tmp->f->start+tmp->f->primerlen;
while(ajListPop(intlist,(void **)&tmp))
ajListPushAppend(filist,(void *)tmp);
ajListPush(intlist,(void *)save);
}
ajListSort(intlist,prima_PosEndCompare);
while(ajListPop(intlist,(void **)&tmp))
ajListPushAppend(filist,(void *)tmp);
ajListFree(&intlist);
ajListFree(alist);
*alist = filist;
return;
}
static void silent_relistdel(AjPList* relist)
{
PRinfo rlp = NULL;
while(ajListPop(*relist,(void **)&rlp))
{
ajStrDel(&rlp->code);
ajStrDel(&rlp->site);
AJFREE(rlp);
}
ajListFree(relist);
}
static void silent_fmt_hits(AjPList hits, AjPFeattable feat,
AjBool silent, AjBool rev)
{
PSilent res;
AjPFeature sf = NULL;
AjPStr tmpFeatStr = NULL;
ajListSort(hits,silent_basecompare);
while(ajListPop(hits,(void **)&res))
{
if (rev)
sf = ajFeatNewIIRev(feat,
res->match, res->match+ajStrGetLen(res->site)-1);
else
sf = ajFeatNewII(feat,
res->match, res->match+ajStrGetLen(res->site)-1);
if (silent)
{
ajFmtPrintS(&tmpFeatStr, "*silent Yes");
ajFeatTagAdd (sf, NULL, tmpFeatStr);
}
ajFmtPrintS(&tmpFeatStr, "*enzyme %S", res->code);
ajFeatTagAdd (sf, NULL, tmpFeatStr);
ajFmtPrintS(&tmpFeatStr, "*rspattern %S", res->site);
ajFeatTagAdd (sf, NULL, tmpFeatStr);
ajFmtPrintS(&tmpFeatStr, "*baseposn %d", res->base);
ajFeatTagAdd (sf, NULL, tmpFeatStr);
ajFmtPrintS(&tmpFeatStr, "*aa %S.%S", res->seqaa, res->reaa);
ajFeatTagAdd (sf, NULL, tmpFeatStr);
ajFmtPrintS(&tmpFeatStr, "*mutation %c->%c", res->obase,res->nbase);
ajFeatTagAdd (sf, NULL, tmpFeatStr);
ajStrDel(&res->code);
ajStrDel(&res->site);
ajStrDel(&res->seqaa);
ajStrDel(&res->reaa);
AJFREE(res);
}
ajStrDel(&tmpFeatStr);
return;
}
void ajPatlistSeqDel (AjPPatlistSeq* pthys)
{
AjPPatlistSeq thys = NULL;
AjPPatternSeq patternseq = NULL;
thys = *pthys;
while (ajListPop(thys->Patlist, (void **)&patternseq))
ajPatternSeqDel(&patternseq);
if (thys->Iter)
ajListIterDel(&thys->Iter);
ajListFree(&thys->Patlist);
AJFREE(*pthys);
return;
}
void ajRefseqClear(AjPRefseq refseq)
{
AjPSeqRange tmprange = NULL;
if(MAJSTRGETLEN(refseq->Id))
ajStrSetClear(&refseq->Id);
if(MAJSTRGETLEN(refseq->Db))
ajStrSetClear(&refseq->Db);
if(MAJSTRGETLEN(refseq->Setdb))
ajStrSetClear(&refseq->Setdb);
if(MAJSTRGETLEN(refseq->Full))
ajStrSetClear(&refseq->Full);
if(MAJSTRGETLEN(refseq->Qry))
ajStrSetClear(&refseq->Qry);
if(MAJSTRGETLEN(refseq->Formatstr))
ajStrSetClear(&refseq->Formatstr);
if(MAJSTRGETLEN(refseq->Filename))
ajStrSetClear(&refseq->Filename);
ajStrDel(&refseq->TextPtr);
ajStrDel(&refseq->Desc);
ajStrDel(&refseq->Seq);
while(ajListPop(refseq->Seqlist,(void **)&tmprange))
ajSeqrangeDel(&tmprange);
ajListFree(&refseq->Seqlist);
refseq->Count = 0;
refseq->Fpos = 0L;
refseq->Format = 0;
return;
}
int main(int argc, char **argv)
{
AjPFile listf = NULL; /* File to be read - caths.list.v2.4. */
AjPFile domf = NULL; /* File to be read - domlist.v2.4. */
AjPFile namesf = NULL; /* File to be read - CAT.names.all.v2.4. */
AjPFile outf = NULL; /* Output file. */
AjPFile logf = NULL; /* Log file. */
AjPList list = NULL; /* List of CATH objects. */
AjPCath tmp = NULL; /* Temp. pointer. */
embInitPV("cathparse", argc, argv, "DOMAINATRIX",VERSION);
listf = ajAcdGetInfile("listfile");
domf = ajAcdGetInfile("domfile");
namesf = ajAcdGetInfile("namesfile");
outf = ajAcdGetOutfile("outfile");
logf = ajAcdGetOutfile("logfile");
list = ajCathReadAllRawNew(listf, domf, namesf, logf);
while(ajListPop(list, (void **) &tmp))
{
ajCathWrite(outf, tmp);
ajCathDel(&tmp);
}
/* Close CATH parsable files and output file */
ajFileClose(&listf);
ajFileClose(&domf);
ajFileClose(&namesf);
ajFileClose(&outf);
ajFileClose(&logf);
ajListFree(&list);
ajExit();
return 0;
}
static void digest_report_hits(AjPFeattable TabRpt, AjPList l, ajint be,
const char* s)
{
AjPFeature gf = NULL;
EmbPPropFrag fr;
AjPStr t;
ajint len;
AjPStr tmpStr = NULL;
size_t stlen;
t = ajStrNew();
stlen = strlen(s);
len = (ajint) stlen;
while(ajListPop(l,(void **)&fr))
{
ajStrAssignSubC(&t,s,fr->start,fr->end);
gf = ajFeatNewII(TabRpt,fr->start+be,fr->end+be);
ajFmtPrintS(&tmpStr, "*molwt %.3f", fr->molwt);
ajFeatTagAdd(gf, NULL, tmpStr);
if(fr->start>0)
{
ajFmtPrintS(&tmpStr, "*cterm %c", *(s+(fr->start)-1));
ajFeatTagAdd(gf, NULL, tmpStr);
}
if(fr->end<len-1)
{
ajFmtPrintS(&tmpStr, "*nterm %c", *(s+(fr->end+1)));
ajFeatTagAdd(gf, NULL, tmpStr);
}
AJFREE(fr);
}
ajStrDel(&t);
ajStrDel(&tmpStr);
return;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPFile outf;
AjPSeq seq = NULL;
AjPList xrefs = NULL;
ajuint nrefs;
AjPSeqXref xref = NULL;
embInit("seqxref", argc, argv);
outf = ajAcdGetOutfile("outfile");
seqall = ajAcdGetSeqall("sequence");
xrefs = ajListNew();
while(ajSeqallNext(seqall, &seq))
{
nrefs = ajSeqGetXrefs(seq, xrefs);
ajSeqxreflistSort(xrefs);
ajFmtPrintF(outf, "#%S: %u\n", ajSeqGetUsaS(seq), nrefs);
while(ajListPop(xrefs, (void**)&xref))
{
ajFmtPrintF(outf, "%S:%S\n", xref->Db, xref->Id);
ajSeqxrefDel(&xref);
}
}
ajListFree(&xrefs);
ajSeqDel(&seq);
ajFileClose(&outf);
ajSeqallDel(&seqall);
embExit();
return 0;
}
void ajPatlistRegexDel (AjPPatlistRegex* pthys)
{
AjPPatlistRegex thys = NULL;
AjPPatternRegex patternregex = NULL;
thys = *pthys;
while (ajListPop(thys->Patlist, (void **)&patternregex))
{
ajDebug("ajPatlistRegexDel list size: %d\n",
ajListGetLength(thys->Patlist));
ajPatternRegexDel(&patternregex);
}
if (thys->Iter)
ajListIterDel(&thys->Iter);
ajListFree(&thys->Patlist);
AJFREE(*pthys);
return;
}
static void digest_print_hits(AjPList l, AjPFile outf, ajint be, const char *s)
{
EmbPPropFrag fr;
AjPStr t;
ajint len;
size_t stlen;
t = ajStrNew();
stlen = strlen(s);
len = (ajint) stlen;
ajFmtPrintF(outf,
"Start End Molwt Sequence (up to 38 residues)\n");
while(ajListPop(l,(void **)&fr))
{
ajStrAssignSubC(&t,s,fr->start,fr->end);
ajFmtPrintF(outf,"%-8d%-8d%-10.3f ",fr->start+be,fr->end+be,
fr->molwt);
if(fr->start>0)
ajFmtPrintF(outf,"(%c) ",*(s+(fr->start)-1));
else
ajFmtPrintF(outf," () ");
ajFmtPrintF(outf,"%-.38s ",ajStrGetPtr(t));
if(fr->end<len-1)
ajFmtPrintF(outf,"(%c) ",*(s+(fr->end+1)));
else
ajFmtPrintF(outf," () ");
if(fr->end-fr->start+1>38)
ajFmtPrintF(outf,"...");
ajFmtPrintF(outf,"\n");
AJFREE(fr);
}
ajStrDel(&t);
return;
}
int main(int argc, char **argv)
{
AjPStr directory = NULL;
AjPTable mtable = NULL;
AjPList jdirlist = NULL;
AjPStr jdirloc = NULL;
embInit("jaspextract",argc,argv);
directory = ajAcdGetDirectoryName("directory");
mtable = ajTablestrNewLen(PFMNUMGUESS);
jdirlist = ajListNew();
jaspextract_openoutdirs();
jaspextract_copyfiles(directory);
jaspextract_readmatrixlist(mtable, directory);
jaspextract_getjaspdirs(jdirlist);
while(ajListPop(jdirlist,(void **)&jdirloc))
{
jaspextract_writematrixfile(mtable, jdirloc);
ajStrDel(&jdirloc);
}
ajTablestrFree(&mtable);
ajStrDel(&directory);
ajListFree(&jdirlist);
embExit();
return 0;
}
static void jaspscan_ParseInput(const AjPStr dir, const AjPStr jaspdir,
const AjPStr mats, const AjPStr excl,
ajuint *recurs, AjPList ret)
{
ajuint nm = 0;
ajuint ne = 0;
AjPStr *carr = NULL;
AjPStr *earr = NULL;
AjPFile inf = NULL;
AjPStr line = NULL;
AjPStr comm = NULL;
AjPStr val = NULL;
ajuint i;
ajuint j;
char c;
ajuint rlen = 0;
if(*recurs > JASPSCAN_RECURS)
ajFatal("Too many recursion levels in matrix list files");
line = ajStrNew();
comm = ajStrNew();
if(mats)
{
nm = ajArrCommaList(mats,&carr);
for(i=0; i < nm; ++i)
{
if(ajStrGetCharFirst(carr[i]) != '@')
ajStrFmtUpper(&carr[i]);
if(ajStrMatchC(carr[i],"ALL"))
{
jaspscan_GetFileList(dir, jaspdir, "*", ret);
ajListSortUnique(ret, ajStrVcmp, jaspscan_strdel);
}
else if(ajStrGetCharFirst(carr[i]) == '@')
{
ajStrTrimStartC(&carr[i],"@");
inf = ajFileNewInNameS(carr[i]);
if(!inf)
ajFatal("Cannot open list file %S",carr[i]);
while(ajReadlineTrim(inf,&line))
{
ajStrRemoveWhite(&line);
c = ajStrGetCharFirst(line);
if(c == '#' || c== '!')
continue;
if(ajStrGetLen(comm))
ajStrAppendC(&comm,",");
ajStrFmtUpper(&line);
ajStrAppendS(&comm,line);
}
*recurs += 1;
jaspscan_ParseInput(dir,jaspdir,comm,NULL,recurs,ret);
*recurs -= 1;
ajListSortUnique(ret, ajStrVcmp, jaspscan_strdel);
ajFileClose(&inf);
}
else
{
jaspscan_GetFileList(dir,jaspdir,ajStrGetPtr(carr[i]),ret);
ajListSortUnique(ret, ajStrVcmp, jaspscan_strdel);
}
}
for(i=0; i < nm; ++i)
ajStrDel(&carr[i]);
AJFREE(carr);
}
if(excl)
{
ne = ajArrCommaList(excl,&earr);
for(i=0; i < ne; ++i)
{
if(ajStrGetCharFirst(earr[i]) != '@')
ajStrFmtUpper(&earr[i]);
if(ajStrGetCharFirst(earr[i]) == '@')
{
ajStrTrimStartC(&earr[i],"@");
inf = ajFileNewInNameS(earr[i]);
if(!inf)
ajFatal("Cannot open list file %S",earr[i]);
while(ajReadlineTrim(inf,&line))
{
ajStrRemoveWhite(&line);
c = ajStrGetCharFirst(line);
if(c == '#' || c== '!')
continue;
if(ajStrGetLen(comm))
ajStrAppendC(&comm,",");
ajStrFmtUpper(&line);
ajStrAppendS(&comm,line);
}
*recurs += 1;
jaspscan_ParseInput(dir,jaspdir,NULL,comm,recurs,ret);
*recurs -= 1;
ajListSortUnique(ret, ajStrVcmp, jaspscan_strdel);
ajFileClose(&inf);
}
else
{
ajStrAssignS(&line,earr[i]);
ajStrAppendC(&line,J_EXT);
rlen = ajListGetLength(ret);
for(j=0; j < rlen; ++j)
{
ajListPop(ret,(void **)&val);
if(ajStrSuffixS(val,line))
ajStrDel(&val);
else
ajListPushAppend(ret,(void *)val);
}
}
}
for(i=0; i < ne; ++i)
ajStrDel(&earr[i]);
AJFREE(earr);
}
ajStrDel(&line);
ajStrDel(&comm);
return;
}
int main(int argc, char **argv)
{
/* Variable declarations */
AjPOutfile outfile = NULL;
AjPTaxall taxall = NULL;
AjPTax tax = NULL;
AjPTax taxtest = NULL;
AjPList taxlist = ajListNew();
AjPTable foundtable = NULL;
ajuint ifound = 0;
ajuint ikeep = 0;
/* ACD processing */
embInit("taxgetspecies", argc, argv);
taxall = ajAcdGetTaxonall("taxons");
outfile = ajAcdGetOuttaxon("outfile");
foundtable = ajTablestrNew(600);
while(ajTaxallNext(taxall, &tax))
{
ajListPushAppend(taxlist, ajTaxNewTax(tax));
ajTaxGetTree(tax, taxlist);
while(ajListGetLength(taxlist))
{
ajListPop(taxlist, (void**) &taxtest);
if(!ajStrMatchC(ajTaxGetRank(taxtest), "species"))
{
ajTaxDel(&taxtest);
continue;
}
ifound++;
if(!ajTableMatchS(foundtable, taxtest->Id))
{
ajTaxoutWrite(outfile, taxtest);
ajTablePut(foundtable, ajStrNewS(taxtest->Id),
(void *) 1);
ikeep++;
}
ajTaxDel(&taxtest);
}
}
if(!ifound)
ajErr("No matching terms");
/* Memory clean-up and exit */
ajListFree(&taxlist);
ajTaxallDel(&taxall);
ajTaxDel(&tax);
ajOutfileClose(&outfile);
ajTablestrFreeKey(&foundtable);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPReport report = NULL;
AjPStr jaspdir = NULL;
AjPStr menu = NULL;
AjPStr substr = NULL;
AjPStr mats = NULL;
AjPStr excl = NULL;
float thresh = 0.;
ajuint recurs = 0;
AjPStr dir = NULL;
AjPStr mfname = NULL;
AjPList flist = NULL;
AjPList hits = NULL;
AjPStr head = NULL;
ajint begin;
ajint end;
ajuint mno;
char cp;
ajuint i;
AjPTable mattab = NULL;
AjPFeattable TabRpt = NULL;
AjBool both = ajFalse;
embInit("jaspscan", argc, argv);
seqall = ajAcdGetSeqall("sequence");
menu = ajAcdGetListSingle("menu");
mats = ajAcdGetString("matrices");
excl = ajAcdGetString("exclude");
thresh = ajAcdGetFloat("threshold");
report = ajAcdGetReport("outfile");
both = ajAcdGetBoolean("both");
jaspdir = ajStrNew();
substr = ajStrNew();
flist = ajListNew();
hits = ajListNew();
dir = ajStrNew();
head = ajStrNew();
cp = ajStrGetCharFirst(menu);
if(cp=='C')
ajStrAssignC(&jaspdir,J_COR);
else if(cp=='F')
ajStrAssignC(&jaspdir,J_FAM);
else if(cp=='P')
ajStrAssignC(&jaspdir,J_PHY);
else if(cp=='N')
ajStrAssignC(&jaspdir,J_CNE);
else if(cp=='O')
ajStrAssignC(&jaspdir,J_POL);
else if(cp=='S')
ajStrAssignC(&jaspdir,J_SPL);
else
ajFatal("Invalid JASPAR database selection");
ajStrAssignS(&dir, ajDatafileValuePath());
if(!ajStrGetLen(dir))
ajFatal("EMBOSS DATA directory couldn't be determined");
jaspscan_ParseInput(dir, jaspdir, mats, excl, &recurs, flist);
mno = ajListGetLength(flist);
if(cp == 'C')
mattab = jaspscan_ReadCoreList(jaspdir);
if(cp == 'F')
mattab = jaspscan_ReadFamList(jaspdir);
if(cp == 'P')
mattab = jaspscan_ReadCoreList(jaspdir);
if(cp == 'N')
mattab = jaspscan_ReadCoreList(jaspdir);
if(cp == 'O')
mattab = jaspscan_ReadCoreList(jaspdir);
if(cp == 'S')
mattab = jaspscan_ReadCoreList(jaspdir);
ajFmtPrintS(&head,"Database scanned: %S Threshold: %.3f",jaspdir,thresh);
ajReportSetHeaderS(report,head);
while(ajSeqallNext(seqall, &seq))
{
begin = ajSeqallGetseqBegin(seqall);
end = ajSeqallGetseqEnd(seqall);
ajStrAssignSubC(&substr,ajSeqGetSeqC(seq),begin-1,end-1);
ajStrFmtUpper(&substr);
TabRpt = ajFeattableNewSeq(seq);
for(i=0; i < mno; ++i)
{
ajListPop(flist,(void **)&mfname);
jaspscan_scan(substr,begin,mfname, cp, thresh, both, hits);
ajListPushAppend(flist, (void **)mfname);
}
jaspscan_ReportHits(TabRpt,mattab,hits);
ajReportWrite(report, TabRpt, seq);
ajFeattableDel(&TabRpt);
}
while(ajListPop(flist,(void **)&mfname))
ajStrDel(&mfname);
ajStrDel(&dir);
ajStrDel(&menu);
ajStrDel(&excl);
ajStrDel(&substr);
ajStrDel(&mats);
ajStrDel(&head);
ajStrDel(&jaspdir);
ajSeqDel(&seq);
ajTableMapDel(mattab,jaspscan_ClearTable,NULL);
ajTableFree(&mattab);
ajListFree(&flist);
ajListFree(&hits);
ajSeqallDel(&seqall);
ajReportDel(&report);
embExit();
return 0;
}
static void jaspscan_ReportHits(AjPFeattable TabRpt, const AjPTable mattab,
AjPList hits)
{
PJsphits hit = NULL;
PJspmat info = NULL;
AjPFeature feat = NULL;
AjPStr str = NULL;
float fnum = 0.;
str = ajStrNew();
while(ajListPop(hits,(void **)&hit))
{
if(hit->start <= hit->end)
feat = ajFeatNewII(TabRpt,hit->start,hit->end);
else
feat = ajFeatNewIIRev(TabRpt,hit->start,hit->end);
ajFmtPrintS(&str,"*pc %.3f",hit->scorepc);
ajFeatTagAdd(feat, NULL, str);
ajFmtPrintS(&str,"*id %S",hit->matname);
ajFeatTagAdd(feat, NULL, str);
info = ajTableFetch(mattab,hit->matname);
if(!info)
ajWarn("No info for matrix %S",hit->matname);
if(ajStrGetLen(info->name))
{
ajFmtPrintS(&str,"*name %S",info->name);
ajFeatTagAdd(feat, NULL, str);
}
if(ajStrGetLen(info->species))
{
ajFmtPrintS(&str,"*species %S",info->species);
ajFeatTagAdd(feat, NULL, str);
}
if(ajStrGetLen(info->klass))
{
ajFmtPrintS(&str,"*class %S",info->klass);
ajFeatTagAdd(feat, NULL, str);
}
if(ajStrGetLen(info->sgroup))
{
ajFmtPrintS(&str,"*supergroup %S",info->sgroup);
ajFeatTagAdd(feat, NULL, str);
}
if(ajStrGetLen(info->protseq))
{
ajFmtPrintS(&str,"*pseq %S",info->protseq);
ajFeatTagAdd(feat, NULL, str);
}
if(ajStrGetLen(info->exp))
{
ajFmtPrintS(&str,"*exp %S",info->exp);
ajFeatTagAdd(feat, NULL, str);
}
if(ajStrGetLen(info->pmid))
{
ajFmtPrintS(&str,"*pmid %S",info->pmid);
ajFeatTagAdd(feat, NULL, str);
}
if(ajStrGetLen(info->num))
{
ajStrToFloat(info->num,&fnum);
ajFmtPrintS(&str,"*info %.3f",fnum);
ajFeatTagAdd(feat, NULL, str);
}
if(ajStrGetLen(info->jaspar))
{
ajFmtPrintS(&str,"*jaspar %S",info->jaspar);
ajFeatTagAdd(feat, NULL, str);
}
if(ajStrGetLen(info->transfac))
{
ajFmtPrintS(&str,"*transfac %S",info->transfac);
ajFeatTagAdd(feat, NULL, str);
}
if(ajStrGetLen(info->mcs))
{
ajStrToFloat(info->mcs,&fnum);
ajFmtPrintS(&str,"*mcs %.3f",fnum);
ajFeatTagAdd(feat, NULL, str);
}
if(ajStrGetLen(info->models))
{
ajFmtPrintS(&str,"*built %S",info->models);
ajFeatTagAdd(feat, NULL, str);
}
jaspscan_hitsdel(&hit);
}
ajStrDel(&str);
return;
}
int main(int argc, char **argv)
{
ajint begin, end;
AjPSeqall seqall;
AjPSeq seq;
EmbPShow ss;
AjPFile outfile;
AjPStr tablename;
ajint table;
AjPRange uppercase;
AjPRange highlight;
AjBool threeletter;
AjBool numberseq;
AjBool nameseq;
ajint width;
ajint length;
ajint margin;
AjBool description;
ajint offset;
AjBool html;
AjPStr descriptionline;
ajint orfminsize;
AjPTrn trnTable;
AjBool translation;
AjBool reverse;
AjBool cutlist;
AjBool flat;
EmbPMatMatch mm = NULL;
AjPStr *framelist;
AjBool frames[6]; /* frames to be translated 1 to 3, -1 to -3 */
/* stuff for tables and lists of enzymes and hits */
ajint default_mincuts = 1;
ajint default_maxcuts = 2000000000;
AjPTable hittable; /* enzyme hits */
/* stuff lifted from Alan's 'restrict.c' */
AjPStr enzymes = NULL;
ajint mincuts;
ajint maxcuts;
ajint sitelen;
AjBool single;
AjBool blunt;
AjBool sticky;
AjBool ambiguity;
AjBool plasmid;
AjBool commercial;
AjBool limit;
AjBool methyl;
AjPFile enzfile = NULL;
AjPFile equfile = NULL;
AjPFile methfile = NULL;
AjPTable retable = NULL;
ajint hits;
AjPList restrictlist = NULL;
embInit("remap", argc, argv);
seqall = ajAcdGetSeqall("sequence");
outfile = ajAcdGetOutfile("outfile");
tablename = ajAcdGetListSingle("table");
uppercase = ajAcdGetRange("uppercase");
highlight = ajAcdGetRange("highlight");
threeletter = ajAcdGetBoolean("threeletter");
numberseq = ajAcdGetBoolean("number");
width = ajAcdGetInt("width");
length = ajAcdGetInt("length");
margin = ajAcdGetInt("margin");
nameseq = ajAcdGetBoolean("name");
description = ajAcdGetBoolean("description");
offset = ajAcdGetInt("offset");
html = ajAcdGetBoolean("html");
orfminsize = ajAcdGetInt("orfminsize");
translation = ajAcdGetBoolean("translation");
reverse = ajAcdGetBoolean("reverse");
cutlist = ajAcdGetBoolean("cutlist");
flat = ajAcdGetBoolean("flatreformat");
framelist = ajAcdGetList("frame");
/* restriction enzyme stuff */
mincuts = ajAcdGetInt("mincuts");
maxcuts = ajAcdGetInt("maxcuts");
sitelen = ajAcdGetInt("sitelen");
single = ajAcdGetBoolean("single");
blunt = ajAcdGetBoolean("blunt");
sticky = ajAcdGetBoolean("sticky");
ambiguity = ajAcdGetBoolean("ambiguity");
plasmid = ajAcdGetBoolean("plasmid");
commercial = ajAcdGetBoolean("commercial");
limit = ajAcdGetBoolean("limit");
enzymes = ajAcdGetString("enzymes");
methfile = ajAcdGetDatafile("mfile");
methyl = ajAcdGetBoolean("methylation");
if(!blunt && !sticky)
ajFatal("Blunt/Sticky end cutters shouldn't both be disabled.");
/* get the number of the genetic code used */
ajStrToInt(tablename, &table);
trnTable = ajTrnNewI(table);
/* read the local file of enzymes names */
remap_read_file_of_enzyme_names(&enzymes);
/* get the frames to be translated */
remap_GetFrames(framelist, frames);
while(ajSeqallNext(seqall, &seq))
{
/* get begin and end positions */
begin = ajSeqGetBegin(seq)-1;
end = ajSeqGetEnd(seq)-1;
/* do the name and description */
if(nameseq)
{
if(html)
ajFmtPrintF(outfile, "<H2>%S</H2>\n",
ajSeqGetNameS(seq));
else
ajFmtPrintF(outfile, "%S\n", ajSeqGetNameS(seq));
}
if(description)
{
/*
** wrap the description line at the width of the sequence
** plus margin
*/
if(html)
ajFmtPrintF(outfile, "<H3>%S</H3>\n",
ajSeqGetDescS(seq));
else
{
descriptionline = ajStrNew();
ajStrAssignS(&descriptionline, ajSeqGetDescS(seq));
ajStrFmtWrap(&descriptionline, width+margin);
ajFmtPrintF(outfile, "%S\n", descriptionline);
ajStrDel(&descriptionline);
}
}
/* get the restriction cut sites */
/*
** most of this is lifted from the program 'restrict.c' by Alan
** Bleasby
*/
if(single)
maxcuts=mincuts=1;
retable = ajTablestrNew(EQUGUESS);
enzfile = ajDatafileNewInNameC(ENZDATA);
if(!enzfile)
ajFatal("Cannot locate enzyme file. Run REBASEEXTRACT");
if(limit)
{
equfile = ajDatafileNewInNameC(EQUDATA);
if(!equfile)
limit = ajFalse;
else
remap_read_equiv(&equfile, &retable, commercial);
}
ajFileSeek(enzfile, 0L, 0);
restrictlist = ajListNew();
/* search for hits, but don't use mincuts and maxcuts criteria yet */
hits = embPatRestrictMatch(seq, begin+1, end+1, enzfile, methfile,
enzymes, sitelen,plasmid, ambiguity,
default_mincuts, default_maxcuts, blunt,
sticky, commercial, methyl,
restrictlist);
ajDebug("Remap found %d hits\n", hits);
if(hits)
{
/* this bit is lifted from printHits */
embPatRestrictRestrict(restrictlist, hits, !limit,
ajFalse);
if(limit)
remap_RestrictPreferred(restrictlist,retable);
}
ajFileClose(&enzfile);
ajFileClose(&methfile);
/*
** Remove those violating the mincuts and maxcuts
** criteria, but save them in hittable for printing out later.
** Keep a count of how many hits each enzyme gets in hittable.
*/
hittable = ajTablestrNewCase(TABLEGUESS);
remap_RemoveMinMax(restrictlist, hittable, mincuts, maxcuts);
/* make the Show Object */
ss = embShowNew(seq, begin, end, width, length, margin, html, offset);
if(html)
ajFmtPrintF(outfile, "<PRE>");
/* create the format to display */
embShowAddBlank(ss);
embShowAddRE(ss, 1, restrictlist, plasmid, flat);
embShowAddSeq(ss, numberseq, threeletter, uppercase, highlight);
if(!numberseq)
embShowAddTicknum(ss);
embShowAddTicks(ss);
if(reverse)
{
embShowAddComp(ss, numberseq);
embShowAddRE(ss, -1, restrictlist, plasmid, flat);
}
if(translation)
{
if(reverse)
embShowAddBlank(ss);
if(frames[0])
embShowAddTran(ss, trnTable, 1, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
if(frames[1])
embShowAddTran(ss, trnTable, 2, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
if(frames[2])
embShowAddTran(ss, trnTable, 3, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
if(reverse)
{
embShowAddTicks(ss);
if(frames[5])
embShowAddTran(ss, trnTable, -3, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
if(frames[4])
embShowAddTran(ss, trnTable, -2, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
if(frames[3])
embShowAddTran(ss, trnTable, -1, threeletter,
numberseq, NULL, orfminsize,
AJFALSE, AJFALSE, AJFALSE, AJFALSE);
}
}
embShowPrint(outfile, ss);
/* display a list of the Enzymes that cut and don't cut */
if(cutlist)
{
remap_CutList(outfile, hittable,
limit, html, mincuts, maxcuts);
remap_NoCutList(outfile, hittable, html, enzymes, blunt,
sticky, sitelen, commercial, ambiguity,
limit, retable);
}
/* add a gratuitous newline at the end of the sequence */
ajFmtPrintF(outfile, "\n");
/* tidy up */
embShowDel(&ss);
while(ajListPop(restrictlist,(void **)&mm))
embMatMatchDel(&mm);
ajListFree(&restrictlist);
remap_DelTable(&hittable);
ajTablestrFree(&retable);
}
ajTrnDel(&trnTable);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajFileClose(&outfile);
ajStrDel(&tablename);
ajStrDel(&enzymes);
ajStrDelarray(&framelist);
ajRangeDel(&uppercase);
ajRangeDel(&highlight);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPList sigin = NULL; /* Signature input file names. */
AjPStr signame = NULL; /* Name of signature file. */
AjPFile sigf = NULL; /* Signature input file. */
EmbPSignature sig = NULL; /* Signature. */
AjPList siglist = NULL; /* List of signatures. */
AjIList sigiter = NULL; /* Iterator for siglist. */
AjBool sigok = ajFalse; /* True if signature processed ok. */
EmbPHit hit = NULL; /* Hit to store signature-sequence match. */
AjPList hits = NULL; /* List of hits */
AjPList ligands = NULL; /* List of top-scoring ligands. */
AjPSeqall database=NULL; /* Protein sequences to match signature
against. */
AjPSeq seq = NULL; /* Current sequence. */
AjPMatrixf sub =NULL; /* Residue substitution matrix. */
float gapo =0.0; /* Gap insertion penalty. */
float gape =0.0; /* Gap extension penalty. */
AjPStr nterm=NULL; /* Holds N-terminal matching options from
acd. */
ajint ntermi=0; /* N-terminal option as int. */
AjPFile hitsf =NULL; /* Hits output file.
sequence matches. */
AjPDirout hitsdir=NULL; /* Directory of hits files (output). */
AjPFile alignf =NULL; /* Alignment output file. */
AjPDirout aligndir=NULL; /* Directory of alignment files (output). */
AjPFile resultsf =NULL; /* Results file (output). */
AjPDirout resultsdir=NULL; /* Directory of results files (output). */
AjPStr mode = NULL; /* Mode, 1: Patch score mode, 2:
Site score mode. */
ajint modei = 0; /* Selected mode as integer. */
SigPLighit lighit = NULL;
embInitPV("sigscanlig", argc, argv, "SIGNATURE",VERSION);
/* GET VALUES FROM ACD */
sigin = ajAcdGetDirlist("siginfilesdir");
database = ajAcdGetSeqall("dbseqall");
sub = ajAcdGetMatrixf("sub");
gapo = ajAcdGetFloat("gapo");
gape = ajAcdGetFloat("gape");
nterm = ajAcdGetListSingle("nterm");
hitsdir = ajAcdGetOutdir("hitsoutdir");
aligndir = ajAcdGetOutdir("alignoutdir");
resultsdir = ajAcdGetOutdir("resultsoutdir");
mode = ajAcdGetListSingle("mode");
/*Assign N-terminal matching option etc. */
ajFmtScanS(nterm, "%d", &ntermi);
modei = (ajint) ajStrGetCharFirst(mode)-48;
/* READ & PROCESS SIGNATURES */
siglist = ajListNew();
while(ajListPop(sigin, (void **) &signame))
{
/* Read signature files, compile signatures and populate list. */
sigok = ajFalse;
if((sigf = ajFileNewInNameS(signame)))
if((sig = embSignatureReadNew(sigf)))
if(embSignatureCompile(&sig, gapo, gape, sub))
{
sigok=ajTrue;
ajListPushAppend(siglist, sig);
/*
ajFmtPrint("Id: %S\nDomid: %S\nLigid: %S\nns: %d\n"
"sn: %d\nnp: %d\npn: %d\nminpatch: %d\n"
"maxgap: %d\n",
sig->Id, sig->Domid, sig->Ligid, sig->ns,
sig->sn, sig->np, sig->pn, sig->minpatch,
sig->maxgap); */
}
if(!sigok)
{
ajWarn("Could not process %S", signame);
embSignatureDel(&sig);
ajFileClose(&sigf);
ajStrDel(&signame);
continue;
}
ajFileClose(&sigf);
ajStrDel(&signame);
}
ajListFree(&sigin);
/* ALIGN EACH QUERY SEQUENCE TO LIST OF SIGNATURE */
while(ajSeqallNext(database, &seq))
{
/* Do sequence-signature alignment and save results */
hits = ajListNew();
sigiter = ajListIterNew(siglist);
while((sig = (EmbPSignature) ajListIterGet(sigiter)))
{
if(embSignatureAlignSeq(sig, seq, &hit, ntermi))
{
hit->Sig = sig;
ajListPushAppend(hits, hit);
hit=NULL; /* To force reallocation by embSignatureAlignSeq */
}
/* There has to be a hit for each signature for correct
generation of the LHF by sigscanlig_WriteFasta. So push
an empty hit if necessary. 'hit'=NULL forces
reallocation by embSignatureAlignSeq. */
/*
else
{
hit = embHitNew();
ajListPushAppend(hits, hit);
hit=NULL;
}
*/
}
ajListIterDel(&sigiter);
/* Rank-order the list of hits by score */
ajListSort(hits, embMatchinvScore);
/* Write ligand hits & alignment files (output) */
hitsf = ajFileNewOutNameDirS(ajSeqGetNameS(seq), hitsdir);
alignf = ajFileNewOutNameDirS(ajSeqGetNameS(seq), aligndir);
resultsf = ajFileNewOutNameDirS(ajSeqGetNameS(seq), resultsdir);
/* if((!sigscanlig_WriteFasta(hitsf, siglist, hits)))
ajFatal("Bad args to sigscanlig_WriteFasta"); */
if((!sigscanlig_WriteFasta(hitsf, hits)))
ajFatal("Bad args to sigscanlig_WriteFasta");
if((!sigscanlig_SignatureAlignWriteBlock(alignf, hits)))
ajFatal("Bad args to sigscanlig_SignatureAlignWriteBlock");
/* if((!sigscanlig_SignatureAlignWriteBlock(alignf, siglist, hits)))
ajFatal("Bad args to sigscanlig_SignatureAlignWriteBlock"); */
/* Sort list of hits by ligand type and site number.
Process list of ligands and print out. */
ajListSortTwo(hits, embMatchLigid, embMatchSN);
if(modei==1)
ligands = sigscanlig_score_ligands_patch(hits);
else if(modei==2)
ligands = sigscanlig_score_ligands_site(hits);
else
ajFatal("Unrecognised mode");
sigscanlig_WriteResults(ligands, resultsf);
ajFileClose(&hitsf);
ajFileClose(&alignf);
ajFileClose(&resultsf);
/* Memory management */
while(ajListPop(hits, (void **) &hit))
embHitDel(&hit);
ajListFree(&hits);
while(ajListPop(ligands, (void **) &lighit))
sigscanlig_LigHitDel(&lighit);
ajListFree(&ligands);
}
/* MEMORY MANAGEMENT */
while(ajListPop(siglist, (void **) &sig))
embSignatureDel(&sig);
ajListFree(&siglist);
ajSeqallDel(&database);
ajMatrixfDel(&sub);
ajStrDel(&nterm);
ajDiroutDel(&hitsdir);
ajDiroutDel(&aligndir);
ajDiroutDel(&resultsdir);
ajStrDel(&mode);
embExit();
return 0;
}
void ajResourceClear(AjPResource resource)
{
AjPReslink lnk = NULL;
AjPResquery qry = NULL;
AjPResterm resterm = NULL;
AjPStr ptr = NULL;
if(MAJSTRGETLEN(resource->Id))
ajStrSetClear(&resource->Id);
if(ajListGetLength(resource->Idalt))
while(ajListstrPop(resource->Idalt,&ptr))
ajStrDel(&ptr);
if(MAJSTRGETLEN(resource->Acc))
ajStrSetClear(&resource->Acc);
if(MAJSTRGETLEN(resource->Name))
ajStrSetClear(&resource->Name);
if(MAJSTRGETLEN(resource->Desc))
ajStrSetClear(&resource->Desc);
if(MAJSTRGETLEN(resource->Url))
ajStrSetClear(&resource->Url);
if(MAJSTRGETLEN(resource->Urllink))
ajStrSetClear(&resource->Urllink);
if(MAJSTRGETLEN(resource->Urlrest))
ajStrSetClear(&resource->Urlrest);
if(MAJSTRGETLEN(resource->Urlsoap))
ajStrSetClear(&resource->Urlsoap);
if(ajListGetLength(resource->Cat))
while(ajListstrPop(resource->Cat,&ptr))
ajStrDel(&ptr);
if(ajListGetLength(resource->Taxon))
while(ajListPop(resource->Taxon,(void**)&resterm))
ajRestermDel(&resterm);
if(ajListGetLength(resource->Edamdat))
while(ajListPop(resource->Edamdat,(void**)&resterm))
ajRestermDel(&resterm);
if(ajListGetLength(resource->Edamfmt))
while(ajListPop(resource->Edamfmt,(void**)&resterm))
ajRestermDel(&resterm);
if(ajListGetLength(resource->Edamid))
while(ajListPop(resource->Edamid,(void**)&resterm))
ajRestermDel(&resterm);
if(ajListGetLength(resource->Edamtpc))
while(ajListPop(resource->Edamtpc,(void**)&resterm))
ajRestermDel(&resterm);
if(ajListGetLength(resource->Xref))
while(ajListPop(resource->Xref,(void**)&lnk))
ajReslinkDel(&lnk);
if(ajListGetLength(resource->Query))
while(ajListPop(resource->Query,(void**)&qry))
ajResqueryDel(&qry);
if(ajListGetLength(resource->Example))
while(ajListstrPop(resource->Example,&ptr))
ajStrDel(&ptr);
if(MAJSTRGETLEN(resource->Db))
ajStrSetClear(&resource->Db);
if(MAJSTRGETLEN(resource->Setdb))
ajStrSetClear(&resource->Setdb);
if(MAJSTRGETLEN(resource->Full))
ajStrSetClear(&resource->Full);
if(MAJSTRGETLEN(resource->Qry))
ajStrSetClear(&resource->Qry);
if(MAJSTRGETLEN(resource->Formatstr))
ajStrSetClear(&resource->Formatstr);
if(MAJSTRGETLEN(resource->Filename))
ajStrSetClear(&resource->Filename);
ajStrDel(&resource->TextPtr);
resource->Count = 0;
resource->Fpos = 0L;
resource->Format = 0;
return;
}
static void jaspextract_copyfiles(AjPStr directory)
{
AjPStr matrixfile = NULL;
AjPList flist = NULL;
AjPStr wild = NULL;
AjPStr entry = NULL;
AjPStr bname = NULL;
AjPStr line = NULL;
AjPStr dest = NULL;
const AjPStr datadir = NULL;
ajuint preflen = 0;
ajuint i = 0;
const char *p = NULL;
AjPFile inf = NULL;
AjPFile outf = NULL;
matrixfile = ajStrNew();
flist = ajListNew();
wild = ajStrNewC("*.pfm");
bname = ajStrNew();
line = ajStrNew();
dest = ajStrNew();
datadir = ajDatafileValuePath();
if(!datadir)
ajFatal("jaspextract: Cannot determine the EMBOSS data directory");
ajFmtPrintS(&matrixfile,"%S%s",directory,MATRIXFILE);
if(!ajFilenameExistsRead(matrixfile))
ajFatal("jaspextract: Directory (%S) doesn't appear to be a JASPAR "
"one\nNo matrix_list.txt file found",directory);
ajFilelistAddPathWild(flist, directory, wild);
while(ajListPop(flist,(void **)&entry))
{
ajStrAssignS(&bname,entry);
ajFilenameTrimPath(&bname);
i = 0;
while(Jprefix[i].Prefix)
{
if(!ajStrPrefixC(bname,Jprefix[i].Prefix))
{
++i;
continue;
}
preflen = strlen(Jprefix[i].Prefix);
p = ajStrGetPtr(bname);
if(p[preflen]>='0' && p[preflen]<='9')
break;
++i;
}
if(!Jprefix[i].Prefix)
{
ajStrDel(&entry);
continue;
}
ajFmtPrintS(&dest,"%S%s%c%S",datadir,Jprefix[i].Directory,SLASH_CHAR,
bname);
outf = ajFileNewOutNameS(dest);
if(!outf)
ajFatal("Cannot open output file %S",dest);
/* Avoid UNIX copy for portability */
inf = ajFileNewInNameS(entry);
if(!inf)
ajFatal("Cannot open input file: %S",entry);
while(ajReadlineTrim(inf,&line))
ajFmtPrintF(outf,"%S\n",line);
ajFileClose(&inf);
ajFileClose(&outf);
ajStrDel(&entry);
}
ajListFree(&flist);
ajStrDel(&wild);
ajStrDel(&dest);
ajStrDel(&line);
ajStrDel(&bname);
ajStrDel(&matrixfile);
return;
}
