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