AjBool ajReadlinePos(AjPFile file, AjPStr* Pdest, ajlong* Ppos) { const char *cp; char *buff; ajint isize; ajint ilen; ajint jlen; ajint ipos; ajuint buffsize; size_t iread; const char* pnewline = NULL; MAJSTRDEL(Pdest); if(file->Buffsize) buffsize = file->Buffsize; else buffsize = ajFileValueBuffsize(); if(!file->Buff) ajStrAssignResC(&file->Buff, buffsize, ""); else if(buffsize > MAJSTRGETRES(file->Buff)) ajStrSetRes(&file->Buff, buffsize); if(MAJSTRGETUSE(file->Buff) == 1) buff = MAJSTRGETPTR(file->Buff); else buff = ajStrGetuniquePtr(&file->Buff); isize = MAJSTRGETRES(file->Buff); ilen = 0; ipos = 0; if(!file->fp) ajWarn("ajFileGets file not found"); *Ppos = file->Filepos; while(buff) { if(file->End) { ajStrAssignClear(Pdest); ajDebug("at EOF: File already read to end %F\n", file); return ajFalse; } #ifndef __ppc__ if(file->Readblock) { if(file->Blockpos >= file->Blocklen) { iread = fread(file->Readblock, 1, file->Blocksize, file->fp); if(!iread && ferror(file->fp)) ajFatal("fread failed with error:%d '%s'", ferror(file->fp), strerror(ferror(file->fp))); file->Blockpos = 0; file->Blocklen = iread; file->Readblock[iread] = '\0'; /*ajDebug("++ fread %u Ppos:%Ld\n", iread, *Ppos);*/ } if(file->Blockpos < file->Blocklen) { /* we know we have something in Readblock to process */ pnewline = strchr(&file->Readblock[file->Blockpos], '\n'); if(pnewline) jlen = pnewline - &file->Readblock[file->Blockpos] + 1; else jlen = file->Blocklen - file->Blockpos; /*ajDebug("ipos:%d jlen:%d pnewline:%p " "Readblock:%p blockpos:%d blocklen:%d\n", ipos, jlen, pnewline, file->Readblock, file->Blockpos, file->Blocklen);*/ memmove(&buff[ipos], &file->Readblock[file->Blockpos], jlen); buff[ipos+jlen]='\0'; cp = &buff[ipos]; file->Blockpos += jlen; } else { jlen = 0; cp = NULL; } } else { cp = fgets(&buff[ipos], isize, file->fp); jlen = strlen(&buff[ipos]); } #else cp = ajSysFuncFgets(&buff[ipos], isize, file->fp); jlen = strlen(&buff[ipos]); #endif if(!cp && !ipos) { if(feof(file->fp)) { file->End = ajTrue; ajStrAssignClear(Pdest); ajDebug("EOF ajFileGetsL file %F\n", file); return ajFalse; } else ajFatal("Error reading from file '%S'\n", ajFileGetNameS(file)); } ilen += jlen; file->Filepos += jlen; /* ** We need to read again if: ** We have read the entire buffer ** and we don't have a newline at the end ** (must be careful about that - we may just have read enough) */ if(((file->Readblock && !pnewline) ||(jlen == (isize-1))) && (buff[ilen-1] != '\n')) { MAJSTRSETVALIDLEN(&file->Buff, ilen); /* fix before resizing! */ ajStrSetResRound(&file->Buff, ilen+buffsize+1); /*ajDebug("more to do: jlen: %d ipos: %d isize: %d ilen: %d " "Size: %d\n", jlen, ipos, isize, ilen, ajStrGetRes(file->Buff));*/ ipos += jlen; buff = ajStrGetuniquePtr(&file->Buff); isize = ajStrGetRes(file->Buff) - ipos; /*ajDebug("expand to: ipos: %d isize: %d Size: %d\n", ipos, isize, ajStrGetRes(file>Buff));*/ } else buff = NULL; } MAJSTRSETVALIDLEN(&file->Buff, ilen); if (ajStrGetCharLast(file->Buff) != '\n') { /*ajDebug("Appending missing newline to '%S'\n", file->Buff);*/ ajStrAppendK(&file->Buff, '\n'); } ajStrAssignRef(Pdest, file->Buff); /* if(file->Readblock) ajDebug("ajFileGetsL done blocklen:%d blockpos:%d readlen:%u\n", file->Blocklen, file->Blockpos, ajStrGetLen(file->Buff)); */ return ajTrue; }
AjBool ajBuffreadLinePos(AjPFilebuff buff, AjPStr* Pdest, ajlong* Ppos) { AjBool ok; /* read from the buffer if it is not empty */ *Ppos = 0; if(buff->Pos < buff->Size) { ajStrAssignS(Pdest, buff->Curr->Line); *Ppos = buff->Curr->Fpos; buff->Prev = buff->Curr; buff->Curr = buff->Curr->Next; buff->Pos++; return ajTrue; } /* file has been closed */ if(!buff->File->Handle) return ajFalse; /* buffer used up - try reading from the file */ ok = ajReadlinePos(buff->File, Pdest, &buff->Fpos); if(!ok) { if(buff->File->End) { if(buff->Size) { /* we have data in the buffer - fail */ ajDebug("End of file - data in buffer - return ajFalse\n"); return ajFalse; } else { /* buffer clear - try another file */ if(ajFileReopenNext(buff->File)) { /* OK - read the new file */ ok = ajBuffreadLinePos(buff, Pdest, Ppos); ajDebug("End of file - trying next file ok: %B " "fpos: %Ld %Ld\n", ok, *Ppos, buff->Fpos); return ok; } else { /* no new file, fail again */ ajDebug("End of file - no new file to read - " "return ajFalse\n"); return ajFalse; } } } else ajFatal("Error reading from file '%S'\n", ajFileGetNameS(buff->File)); } if(buff->Nobuff) { *Ppos = buff->Fpos; /*ajDebug("ajBuffreadLinePos unbuffered fpos: %Ld\n", *Ppos);*/ return ajTrue; } filebuffLineAdd(buff, *Pdest); *Ppos = buff->Fpos; return ajTrue; }
int main(int argc, char **argv) { AjPSeqset seqset = NULL; AjPStr cl = NULL; AjPSeqout seqout = NULL; float cutoff = 0.; AjBool best = ajFalse; AjBool gff = ajFalse; AjBool two = ajFalse; AjBool kinase = ajFalse; AjPStr rsd = NULL; AjBool addseq = ajFalse; AjBool plot = ajFalse; const AjPStr ofn = NULL; AjPStr fn = NULL; AjPStr stmp = NULL; AjPFile outf = NULL; embInitPV("enetphos", argc, argv, "CBSTOOLS", VERSION); seqset = ajAcdGetSeqset("sequence"); outf = ajAcdGetOutfile("outfile"); plot = ajAcdGetBoolean("plot"); best = ajAcdGetBoolean("best"); gff = ajAcdGetBoolean("gff"); two = ajAcdGetBoolean("two"); kinase = ajAcdGetBoolean("kinase"); addseq = ajAcdGetBoolean("addseq"); cutoff = ajAcdGetFloat("cutoff"); rsd = ajAcdGetListSingle("residue"); cl = ajStrNewC("netphos "); fn = ajStrNew(); stmp = ajStrNew(); ajFilenameSetTempname(&fn); seqout = ajSeqoutNew(); if(!ajSeqoutOpenFilename(seqout, fn)) ajFatal("Cannot open temporary file %S",fn); ajSeqoutSetFormatC(seqout, "fasta"); ajSeqoutWriteSet(seqout,seqset); ajSeqoutClose(seqout); if(ajStrMatchC(rsd,"serine")) ajStrAppendC(&cl," -s"); else if(ajStrMatchC(rsd,"threonine")) ajStrAppendC(&cl," -t"); else if(ajStrMatchC(rsd,"tyrosine")) ajStrAppendC(&cl," -y"); if(plot) ajStrAppendC(&cl," -g"); if(two) ajStrAppendC(&cl," -2"); if(best) ajStrAppendC(&cl," -b"); if(gff) ajStrAppendC(&cl," -f gff"); if(kinase) ajStrAppendC(&cl," -k"); if(addseq) ajStrAppendC(&cl," -S"); ajFmtPrintS(&stmp," -c %f",cutoff); ajStrAppendS(&cl,stmp); ajFmtPrintS(&stmp," %S",fn); ajStrAppendS(&cl,stmp); ofn = ajFileGetNameS(outf); ajFmtPrintS(&stmp," > %S",ofn); ajStrAppendS(&cl,stmp); ajFileClose(&outf); #if 0 ajFmtPrint("%S\n",cl); #endif #if 1 if(system(ajStrGetPtr(cl)) == -1) ajFatal("Command %S failed",cl); #endif ajSysFileUnlink(fn); ajStrDel(&cl); ajStrDel(&fn); ajStrDel(&stmp); ajStrDel(&rsd); ajSeqoutDel(&seqout); ajSeqsetDel(&seqset); embExit(); return 0; }
int main(int argc, char **argv) { /* ACD data item variables */ AjPFile oldhmmfile = NULL; AjPStr format = NULL; AjPFile newhmmfile = NULL; /* Housekeeping variables */ AjPStr cmd = NULL; char option; /* ACD file processing */ embInitPV("ehmmconvert",argc,argv,"HMMERNEW",VERSION); oldhmmfile = ajAcdGetInfile("oldhmmfile"); format = ajAcdGetListSingle("format"); newhmmfile = ajAcdGetOutfile("newhmmfile"); /* MAIN APPLICATION CODE */ cmd = ajStrNew(); /* 1. Build hmmconvert command line */ /* Command line is built in this order: i. Application name. ii. HMMER 'options' (in order they appear in ACD file) iii.HMMER 'options' (that don't appear in ACD file) iv. HMMER & new parameters. */ ajStrAssignS(&cmd, ajAcdGetpathC("hmmconvert")); /* ACD option only allows one selection */ option = ajStrGetCharFirst(format); if(option == 'A') ajStrAppendC(&cmd, " -a "); else if(option == 'B') ajStrAppendC(&cmd, " -b "); else if(option == 'G') ajStrAppendC(&cmd, " -p "); else if(option == 'X') ajStrAppendC(&cmd, " -P "); /* -A (append) always set but file will be wiped by EMBOSS first unless append: "Y" is set for "newhmmfile" in the ACD file. */ /* hmmer cannot append to empty file, so only set the -A (append) option if file was opened for appending to (and therefore was not wiped by EMBOSS) and is not zero size. */ if(ajFileIsAppend(newhmmfile) && (ajFilenameGetSize(ajFileGetNameS(newhmmfile))!=-1)) ajStrAppendC(&cmd, " -A "); ajStrAppendC(&cmd, " -F "); ajFmtPrintAppS(&cmd, " %s %s", ajFileGetNameC(oldhmmfile), ajFileGetNameC(newhmmfile)); /* 2. Close ACD files. */ ajFileClose(&oldhmmfile); ajFileClose(&newhmmfile); /* 3. Call hmmconvert */ ajFmtPrint("\n%S\n\n", cmd); ajSysExecS(cmd); /* 4. Exit cleanly */ ajStrDel(&cmd); ajStrDel(&format); embExit(); return 0; }
int main(int argc, char **argv) { /* ACD data item variables */ AjPSeqset dataset = NULL; AjPFile bfile = NULL; AjPFile plib = NULL; AjPStr mod = NULL; ajint nmotifs = 0; AjBool text = ajFalse; AjPStr prior = NULL; float evt = 0.0; ajint nsites = 0; ajint minsites = 0; ajint maxsites = 0; float wnsites = 0.0; ajint w = 0; ajint minw = 0; ajint maxw = 0; AjBool nomatrim = ajFalse; ajint wg = 0; ajint ws = 0; AjBool noendgaps = ajFalse; AjBool revcomp = ajFalse; AjBool pal = ajFalse; AjBool nostatus = ajFalse; ajint maxiter = 0; float distance = 0.0; float b = 0.0; float spfuzz = 0.0; AjPStr spmap = NULL; AjPStr cons = NULL; ajint maxsize = 0; ajint p = 0; ajint time = 0; AjPStr sf = NULL; ajint heapsize = 64; AjBool xbranch = ajFalse; AjBool wbranch = ajFalse; ajint bfactor = 0; AjPFile outtext = NULL; /* Housekeeping variables */ AjPStr cmd = NULL; AjPStr ssname = NULL; AjPSeqout outseq = NULL; AjPStr tmp = NULL; char option; /* ACD file processing */ embInitPV("ememetext",argc,argv,"MEME",VERSION); dataset = ajAcdGetSeqset("dataset"); bfile = ajAcdGetInfile("bfile"); plib = ajAcdGetInfile("plibfile"); mod = ajAcdGetSelectSingle("mod"); nmotifs = ajAcdGetInt("nmotifs"); text = ajAcdGetBoolean("text"); prior = ajAcdGetSelectSingle("prior"); evt = ajAcdGetFloat("evt"); nsites = ajAcdGetInt("nsites"); minsites = ajAcdGetInt("minsites"); maxsites = ajAcdGetInt("maxsites"); wnsites = ajAcdGetFloat("wnsites"); w = ajAcdGetInt("w"); minw = ajAcdGetInt("minw"); maxw = ajAcdGetInt("maxw"); nomatrim = ajAcdGetBoolean("nomatrim"); wg = ajAcdGetInt("wg"); ws = ajAcdGetInt("ws"); noendgaps = ajAcdGetBoolean("noendgaps"); revcomp = ajAcdGetBoolean("revcomp"); pal = ajAcdGetBoolean("pal"); nostatus = ajAcdGetBoolean("nostatus"); maxiter = ajAcdGetInt("maxiter"); distance = ajAcdGetFloat("distance"); b = ajAcdGetFloat("b"); spfuzz = ajAcdGetFloat("spfuzz"); spmap = ajAcdGetSelectSingle("spmap"); cons = ajAcdGetString("cons"); maxsize = ajAcdGetInt("maxsize"); p = ajAcdGetInt("p"); time = ajAcdGetInt("time"); sf = ajAcdGetString("sf"); heapsize = ajAcdGetInt("heapsize"); xbranch = ajAcdGetBoolean("xbranch"); wbranch = ajAcdGetBoolean("wbranch"); bfactor = ajAcdGetInt("bfactor"); outtext = ajAcdGetOutfile("outtext"); outseq = ajAcdGetSeqoutset("outseq"); /* MAIN APPLICATION CODE */ /* 1. Housekeeping */ cmd = ajStrNew(); tmp = ajStrNew(); /* 2. Re-write dataset to a temporary file in a format (fasta) MEME ** can understand. ** Can't just pass the name of dataset to MEME as the name provided ** might be a USA which MEME would not understand. */ ssname = ajStrNewS(ajFileGetNameS(outseq->File)); ajSeqoutSetFormatC(outseq, "fasta"); ajSeqoutWriteSet(outseq, dataset); ajSeqoutClose(outseq); ajSeqoutDel(&outseq); /* 3. Build ememe command line */ /* Command line is built in this order: i. Application name. ii. Original MEME options (in order they appear in ACD file) iii.Original MEME options (that don't appear in ACD file) iv. EMBASSY MEME new qualifiers and parameters. */ ajStrAssignS(&cmd, ajAcdGetpathC("meme")); ajFmtPrintAppS(&cmd, " %S", ssname); if(bfile) ajFmtPrintAppS(&cmd, " -bfile %s ", ajFileGetNameC(bfile)); if(plib) ajFmtPrintAppS(&cmd, " -plib %s ", ajFileGetNameC(plib)); option = ajStrGetCharFirst(mod); if(option == 'o') ajStrAppendC(&cmd, " -mod oops "); else if(option == 'z') ajStrAppendC(&cmd, " -mod zoops "); else if(option == 'a') ajStrAppendC(&cmd, " -mod anr "); if(nmotifs != 1) ajFmtPrintAppS(&cmd, " -nmotifs %d ", nmotifs); if(text) ajFmtPrintAppS(&cmd, " -text "); ajFmtPrintAppS(&cmd, " -prior %S ", prior); if(evt != -1) ajFmtPrintAppS(&cmd, " -evt %f ", evt); if(nsites != -1) ajFmtPrintAppS(&cmd, " -nsites %d ", nsites); else { if(minsites != -1) ajFmtPrintAppS(&cmd, " -minsites %d ", minsites); if(maxsites != -1) ajFmtPrintAppS(&cmd, " -maxsites %d ", maxsites); } if(wnsites < 0.7999 || wnsites > .8001) ajFmtPrintAppS(&cmd, " -wnsites %f ", wnsites); if(w != -1) ajFmtPrintAppS(&cmd, " -w %d ", w); if(minw != 8) ajFmtPrintAppS(&cmd, " -minw %d ", minw); if(maxw != 50) ajFmtPrintAppS(&cmd, " -maxw %d ", maxw); if(nomatrim) ajFmtPrintAppS(&cmd, " -nomatrim "); if(wg != 11) ajFmtPrintAppS(&cmd, " -wg %d ", wg); if(ws != 1) ajFmtPrintAppS(&cmd, " -ws %d ", ws); if(noendgaps) ajFmtPrintAppS(&cmd, " -noendgaps "); if(revcomp) ajFmtPrintAppS(&cmd, " -revcomp "); if(pal && ajSeqsetIsNuc(dataset)) ajFmtPrintAppS(&cmd, " -pal "); if(nostatus) ajFmtPrintAppS(&cmd, " -nostatus "); if(maxiter != 50) ajFmtPrintAppS(&cmd, " -maxiter %d ", maxiter); if(distance < 0.00099 || distance > 0.00101) ajFmtPrintAppS(&cmd, " -distance %f ", distance); if(b != -1) ajFmtPrintAppS(&cmd, " -b %f ", b); if(spfuzz != -1) ajFmtPrintAppS(&cmd, " -spfuzz %f ", spfuzz); if(!ajStrMatchC(spmap,"default")) ajFmtPrintAppS(&cmd, " -spmap %S ", spmap); if(MAJSTRGETLEN(cons)) ajFmtPrintAppS(&cmd, "-cons %S", cons); if(maxsize != -1) ajFmtPrintAppS(&cmd, " -maxsize %d ", maxsize); if(p > 0) ajFmtPrintAppS(&cmd, " -p %d ", p); if(time > 0) ajFmtPrintAppS(&cmd, " -time %d ", time); if(MAJSTRGETLEN(sf)) ajFmtPrintAppS(&cmd, " -sf %S", sf); if(heapsize != 64) ajFmtPrintAppS(&cmd, " -heapsize %d ", heapsize); if(xbranch) ajFmtPrintAppS(&cmd, " -x_branch"); if(wbranch) ajFmtPrintAppS(&cmd, " -w_branch"); if(bfactor != 3) ajFmtPrintAppS(&cmd, " -bfactor %d ", bfactor); if(ajSeqsetIsProt(dataset)) ajFmtPrintAppS(&cmd, "-protein "); else ajFmtPrintAppS(&cmd, "-dna "); ajFmtPrintAppS(&cmd, " -text"); ajFmtPrintAppS(&cmd, " > %S ", ajFileGetNameS(outtext)); /* 4. Close files from ACD before calling meme */ ajFileClose(&bfile); ajFileClose(&plib); /* 5. Call meme */ /* ajFmtPrint("\n%S\n", cmd); */ system(ajStrGetPtr(cmd)); /* 6. Exit cleanly */ ajSeqsetDel(&dataset); ajStrDel(&cons); ajStrDel(&sf); ajStrDel(&mod); ajStrDel(&prior); ajStrDel(&spmap); ajStrDel(&cmd); ajStrDel(&ssname); ajStrDel(&tmp); ajFileClose(&bfile); ajFileClose(&plib); ajFileClose(&outtext); ajSeqoutDel(&outseq); embExit(); return 0; }
int main(int argc, char** argv) { AjPFile outf = NULL; AjPFile cachef = NULL; AjIList iterator = NULL; AjPList aliases = NULL; AjPList dbas = NULL; AjPList species = NULL; AjPStr alias = NULL; AjPStr dbname = NULL; AjPStr spname = NULL; AjPStr svrname = NULL; AjPStr svrurl = NULL; AjPStr dbcurl = NULL; AjPTime svrtime = NULL; EnsEDatabaseadaptorGroup dbag = ensEDatabaseadaptorGroupNULL; EnsPDatabaseadaptor dba = NULL; EnsPDatabaseconnection dbc = NULL; embInit("cacheensembl", argc, argv); ensInit(); svrname = ajAcdGetString("servername"); outf = ajAcdGetOutfile("outfile"); cachef = ajAcdGetOutfile("cachefile"); dbcurl = ajStrNew(); svrurl = ajStrNew(); dbname = ajStrNew(); ajNamSvrGetUrl(svrname, &svrurl); if(!svrurl) ajFatal("Could not resolve server name '%S'.", svrname); dbc = ensDatabaseconnectionNewUrl(svrurl); ensRegistryLoadDatabaseconnection(dbc); ensDatabaseconnectionDel(&dbc); /* Write the server file header. */ svrtime = ajTimeNewTodayFmt("cachefile"); ajFmtPrintF(cachef, "# %S %D\n", ajFileGetNameS(cachef), svrtime); ajTimeDel(&svrtime); ajFmtPrintF(cachef, "# Automatically generated by cacheensembl " "for server '%S'.\n\n", svrname); /* ** Get all Ensembl Database Adaptor objects and write them as ** EMBOSS Database definitions. */ aliases = ajListstrNew(); dbas = ajListNew(); species = ajListstrNew(); ensRegistryRetrieveAllSpecies(species); while(ajListstrPop(species, &spname)) { ensRegistryGetAllDatabaseadaptors(ensEDatabaseadaptorGroupNULL, spname, dbas); while(ajListPop(dbas, (void**) &dba)) { dbag = ensDatabaseadaptorGetGroup(dba); if(dbag == ensEDatabaseadaptorGroupNULL) { ajDebug("cacheensembl main got unexpected " "Ensembl Database Adaptor Group %d.\n", dbag); continue; } ajStrAssignS(&dbname, ensDatabaseadaptorGetSpecies(dba)); if(dbag != ensEDatabaseadaptorGroupCore) { ajStrAppendC(&dbname, "_"); ajStrAppendC(&dbname, ensDatabaseadaptorGroupToChar(dbag)); } dbc = ensDatabaseadaptorGetDatabaseconnection(dba); ensDatabaseconnectionFetchUrl(dbc, &dbcurl); if(outf) ajFmtPrintF(outf, "%S\n", dbname); ajFmtPrintF(cachef, "DBNAME %S [\n", dbname); ajFmtPrintF(cachef, " release: \"%s\"\n", ensSoftwareGetVersion()); ajFmtPrintF(cachef, " server: \"%S\"\n", svrname); ajFmtPrintF(cachef, " url: \"%S\"\n", dbcurl); ajFmtPrintF(cachef, "]\n"); ajFmtPrintF(cachef, "\n"); if(dbag != ensEDatabaseadaptorGroupCore) continue; ensRegistryAliasFetchAllbySpecies( ensDatabaseadaptorGetSpecies(dba), aliases); /* ** Format all aliases to lower case, ** sort them alphabetically and remove duplicates. */ iterator = ajListIterNew(aliases); while(!ajListIterDone(iterator)) { alias = ajListstrIterGet(iterator); ajStrFmtLower(&alias); } ajListIterDel(&iterator); ajListSortUnique(aliases, cacheensembl_stringcompare, cacheensembl_stringdelete); alias = NULL; if(ajListGetLength(aliases) > 0) { while(ajListstrPop(aliases, &alias)) { /* ** Reject any aliases with other than alpha-numeric ** characters like white space. */ if(ajStrIsAlnum(alias)) ajFmtPrintF(cachef, "ALIAS %S %S\n", alias, ensDatabaseadaptorGetSpecies(dba)); ajStrDel(&alias); } ajFmtPrintF(cachef, "\n"); } /* Ensembl Database Adaptor objects *must not* be deleted. */ } ajStrDel(&spname); } ajListstrFree(&aliases); ajListFree(&dbas); ajStrDel(&dbcurl); ajStrDel(&svrurl); ajStrDel(&dbname); ajStrDel(&svrname); ajFileClose(&outf); ajFileClose(&cachef); embExit(); return EXIT_SUCCESS; }
int main(int argc, char **argv) { AjPSeqset seqset = NULL; AjPStr cl = NULL; AjPSeqout seqout = NULL; AjBool pc = ajFalse; AjBool sigp = ajFalse; AjBool plot = ajFalse; const AjPStr ofn = NULL; AjPStr fn = NULL; AjPStr stmp = NULL; AjPFile outf = NULL; embInitPV("eprop", argc, argv, "CBSTOOLS", VERSION); seqset = ajAcdGetSeqset("sequence"); outf = ajAcdGetOutfile("outfile"); plot = ajAcdGetBoolean("plot"); pc = ajAcdGetBoolean("pcprediction"); sigp = ajAcdGetBoolean("signalp"); cl = ajStrNewC("prop "); fn = ajStrNew(); stmp = ajStrNew(); ajFilenameSetTempname(&fn); seqout = ajSeqoutNew(); if(!ajSeqoutOpenFilename(seqout, fn)) ajFatal("Cannot open temporary file %S",fn); ajSeqoutSetFormatC(seqout, "fasta"); ajSeqoutWriteSet(seqout,seqset); ajSeqoutClose(seqout); if(plot) ajStrAppendC(&cl," -g"); if(pc) ajStrAppendC(&cl," -p"); if(sigp) ajStrAppendC(&cl," -s"); ajFmtPrintS(&stmp," %S",fn); ajStrAppendS(&cl,stmp); ofn = ajFileGetNameS(outf); ajFmtPrintS(&stmp," > %S",ofn); ajStrAppendS(&cl,stmp); ajFileClose(&outf); #if 0 ajFmtPrint("%S\n",cl); #endif #if 1 if(system(ajStrGetPtr(cl)) == -1) ajFatal("Command %S failed",cl); #endif ajSysFileUnlink(fn); ajStrDel(&cl); ajStrDel(&fn); ajStrDel(&stmp); ajSeqoutDel(&seqout); ajSeqsetDel(&seqset); embExit(); return 0; }
int main(int argc, char **argv) { const char *hmmfile; /* file to read HMMs from */ HMMFILE *hmmfp; /* opened hmmfile for reading */ const char *seqfile; /* file to read target sequence from */ char **rseq; /* raw, unaligned sequences */ SQINFO *sqinfo; /* info associated with sequences */ char **dsq; /* digitized raw sequences */ int nseq; /* number of sequences */ char **aseq; /* aligned sequences */ AINFO ainfo; /* alignment information */ float *wgt; /* per-sequence weights */ int i; struct plan7_s *hmm; /* HMM to align to */ struct p7trace_s **tr; /* traces for aligned sequences */ int be_quiet; /* TRUE to suppress verbose banner */ int matchonly; /* TRUE to show only match state syms */ const char *outfile; /* optional alignment output file */ FILE *ofp; /* handle on alignment output file */ AjPFile ajwithali; /* name of additional alignment file to align */ AjPFile ajmapali; /* name of additional alignment file to map */ AjBool ajmatch=ajFalse; AjPFile outf=NULL; AjPStr outfname=NULL; AjPFile inf=NULL; AjPStr infname=NULL; AjPSeqset seqset=NULL; AjPStr ajseqfile=NULL; char* mapali=NULL; char* withali=NULL; #ifdef MEMDEBUG unsigned long histid1, histid2, orig_size, current_size; orig_size = malloc_inuse(&histid1); fprintf(stderr, "[... memory debugging is ON ...]\n"); #endif /*********************************************** * Parse command line ***********************************************/ matchonly = FALSE; outfile = NULL; be_quiet = FALSE; withali = NULL; mapali = NULL; embInitPV("ohmmalign",argc,argv,"HMMER",VERSION); ajmatch = ajAcdGetBoolean("matchonly"); if(ajmatch) matchonly=TRUE; else matchonly=FALSE; ajmapali = ajAcdGetInfile("mapalifile"); if (ajmapali) mapali = ajCharNewS(ajFileGetNameS(ajmapali)); ajFileClose(&ajmapali); ajwithali = ajAcdGetInfile("withalifile"); if (ajwithali) withali = ajCharNewS(ajFileGetNameS(ajwithali)); ajFileClose(&ajwithali); be_quiet=TRUE; outf = ajAcdGetOutfile("outfile"); outfname = ajStrNewC((char *)ajFileGetNameC(outf)); if(*ajStrGetPtr(outfname)>31) ajFileClose(&outf); outfile = ajStrGetPtr(outfname); inf = ajAcdGetInfile("hmmfile"); infname = ajStrNewC((char *)ajFileGetNameC(inf)); ajFileClose(&inf); hmmfile = ajStrGetPtr(infname); seqset = ajAcdGetSeqset("sequences"); ajseqfile = ajStrNewC(ajStrGetPtr(seqset->Filename)); seqfile = ajStrGetPtr(ajseqfile); /*********************************************** * Open HMM file (might be in HMMERDB or current directory). * Read a single HMM from it. * * Currently hmmalign disallows the J state and * only allows one domain per sequence. To preserve * the S/W entry information, the J state is explicitly * disallowed, rather than calling a Plan7*Config() function. * this is a workaround in 2.1 for the 2.0.x "yo!" bug. ***********************************************/ if ((hmmfp = HMMFileOpen(hmmfile, "HMMERDB")) == NULL) ajFatal("Failed to open HMM file %s\n", hmmfile); if (!HMMFileRead(hmmfp, &hmm)) ajFatal("Failed to read any HMMs from %s\n", hmmfile); HMMFileClose(hmmfp); if (hmm == NULL) ajFatal("HMM file %s corrupt or in incorrect format? Parse failed", hmmfile); hmm->xt[XTE][MOVE] = 1.; /* only 1 domain/sequence ("global" alignment) */ hmm->xt[XTE][LOOP] = 0.; P7Logoddsify(hmm, TRUE); /* do we have the map we might need? */ if (mapali != NULL && ! (hmm->flags & PLAN7_MAP)) ajFatal("HMMER: HMM file %s has no map; you can't use --mapali.", hmmfile); /*********************************************** * Open sequence file in current directory. * Read all seqs from it. ***********************************************/ /* if (! SeqfileFormat(seqfile, &format, NULL)) switch (squid_errno) { case SQERR_NOFILE: ajFatal("Sequence file %s could not be opened for reading", seqfile); case SQERR_FORMAT: default: ajFatal("Failed to determine format of sequence file %s", seqfile); } if (! ReadMultipleRseqs(seqfile, format, &rseq, &sqinfo, &nseq)) ajFatal("Failed to read any sequences from file %s", seqfile); */ emboss_rseqs(seqset,&rseq,&sqinfo,&nseq); /*********************************************** * Show the banner ***********************************************/ be_quiet=TRUE; if (! be_quiet) { /* Banner(stdout, banner); */ printf( "HMM file: %s\n", hmmfile); printf( "Sequence file: %s\n", seqfile); printf("- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n\n"); } /*********************************************** * Do the work ***********************************************/ /* Allocations and initializations. */ dsq = MallocOrDie(sizeof(char *) * nseq); tr = MallocOrDie(sizeof(struct p7trace_s *) * nseq); /* Align each sequence to the model, collect traces */ for (i = 0; i < nseq; i++) { dsq[i] = DigitizeSequence(rseq[i], sqinfo[i].len); if (P7ViterbiSize(sqinfo[i].len, hmm->M) <= RAMLIMIT) (void) P7Viterbi(dsq[i], sqinfo[i].len, hmm, &(tr[i])); else (void) P7SmallViterbi(dsq[i], sqinfo[i].len, hmm, &(tr[i])); } /* Include an aligned alignment, if desired. */ if (mapali != NULL) include_alignment(mapali, hmm, TRUE, &rseq, &dsq, &sqinfo, &tr, &nseq); if (withali != NULL) include_alignment(withali, hmm, FALSE, &rseq, &dsq, &sqinfo, &tr, &nseq); /* Turn traces into a multiple alignment */ wgt = MallocOrDie(sizeof(float) * nseq); FSet(wgt, nseq, 1.0); P7Traces2Alignment(dsq, sqinfo, wgt, nseq, hmm->M, tr, matchonly, &aseq, &ainfo); /*********************************************** * Output the alignment ***********************************************/ if (outfile != NULL && (ofp = fopen(outfile, "w")) != NULL) { WriteSELEX(ofp, aseq, &ainfo, 50); printf("Alignment saved in file %s\n", outfile); fclose(ofp); } else WriteSELEX(stdout, aseq, &ainfo, 50); /*********************************************** * Cleanup and exit ***********************************************/ for (i = 0; i < nseq; i++) { P7FreeTrace(tr[i]); FreeSequence(rseq[i], &(sqinfo[i])); free(dsq[i]); } FreeAlignment(aseq, &ainfo); FreePlan7(hmm); free(sqinfo); free(rseq); free(dsq); free(wgt); free(tr); SqdClean(); ajStrDel(&outfname); ajStrDel(&infname); ajStrDel(&ajseqfile); #ifdef MEMDEBUG current_size = malloc_inuse(&histid2); if (current_size != orig_size) malloc_list(2, histid1, histid2); else fprintf(stderr, "[No memory leaks.]\n"); #endif ajSeqsetDel(&seqset); ajFileClose(&ajwithali); ajFileClose(&ajmapali); embExit(); return 0; }
int main(int argc, char **argv) { AjPStr cl = NULL; AjPSeqset seqset = NULL; AjPSeqout seqout = NULL; AjPStr stmp = NULL; AjPStr email = NULL; AjPStr fmt = NULL; AjPStr trtab = NULL; const AjPStr ofn = NULL; AjPStr *applist = NULL; AjBool crc = ajFalse; AjBool alt = ajFalse; AjBool iprlook = ajFalse; AjBool goterms = ajFalse; ajint trlen = 0; ajuint i = 0; ajuint lcnt = 0; AjPStr fn = NULL; AjPFile outf = NULL; embInitPV("eiprscan", argc, argv, "IPRSCAN", VERSION); seqset = ajAcdGetSeqset("sequence"); email = ajAcdGetString("email"); crc = ajAcdGetBoolean("crc"); applist = ajAcdGetList("appl"); fmt = ajAcdGetListSingle("format"); trtab = ajAcdGetListSingle("trtable"); trlen = ajAcdGetInt("trlen"); alt = ajAcdGetBoolean("altjobs"); iprlook = ajAcdGetBoolean("iprlookup"); goterms = ajAcdGetBoolean("goterms"); outf = ajAcdGetOutfile("outfile"); stmp = ajStrNew(); cl = ajStrNewC("iprscan -cli"); fn = ajStrNew(); ajFilenameSetTempname(&fn); seqout = ajSeqoutNew(); if(!ajSeqoutOpenFilename(seqout, fn)) ajFatal("Cannot open temporary file %S",fn); ajSeqoutSetFormatC(seqout, "fasta"); ajSeqoutWriteSet(seqout,seqset); ajSeqoutClose(seqout); ajFmtPrintS(&stmp," -i %S",fn); ajStrAppendS(&cl,stmp); if(!ajSeqsetIsProt(seqset)) ajStrAppendC(&cl," -seqtype n"); if(!crc) ajStrAppendC(&cl," -nocrc"); if(ajStrGetLen(email)) { ajFmtPrintS(&stmp," -email %S",email); ajStrAppendS(&cl,stmp); } i = 0; lcnt = 0; while(applist[i]) { ++lcnt; ++i; } i = 0; while(applist[i]) { if(ajStrMatchC(applist[i],"all")) { if(lcnt != 1) ajFatal("Cannot specify 'all' with multiple " "applications"); ++i; continue; } ajFmtPrintS(&stmp," -appl %S",applist[i]); ajStrAppendS(&cl,stmp); ++i; } ajFmtPrintS(&stmp," -format %S",fmt); ajStrAppendS(&cl,stmp); ajFmtPrintS(&stmp," -trtable %S",trtab); ajStrAppendS(&cl,stmp); ajFmtPrintS(&stmp," -trlen %d",trlen); ajStrAppendS(&cl,stmp); if(alt) ajStrAppendC(&cl," -altjobs"); if(iprlook) ajStrAppendC(&cl," -iprlookup"); if(goterms) ajStrAppendC(&cl," -goterms"); ofn = ajFileGetNameS(outf); ajFmtPrintS(&stmp," -o %S",ofn); ajFileClose(&outf); ajStrAppendS(&cl,stmp); #if 0 ajFmtPrint("%S\n",cl); #endif #if 1 system(ajStrGetPtr(cl)); #endif ajSysFileUnlink(fn); ajStrDel(&cl); ajStrDel(&fn); ajStrDel(&stmp); ajStrDel(&email); ajStrDel(&fmt); ajStrDel(&trtab); ajStrDelarray(&applist); ajSeqoutDel(&seqout); ajSeqsetDel(&seqset); embExit(); return 0; }