int main(int argc, char **argv) { /* Variable Declarations */ AjPFile inf = NULL; AjPFile outf = NULL; AjPStr line = NULL; /* Line from inf */ AjPStr option = NULL; AjBool doall = AJFALSE; AjBool doend = AJFALSE; AjBool doexcess = AJFALSE; /* ACD File Processing */ embInit("nospace", argc, argv); inf = ajAcdGetInfile("infile"); outf = ajAcdGetOutfile("outfile"); option = ajAcdGetListSingle("menu"); if(ajStrMatchC(option, "all")) doall = ajTrue; else if(ajStrMatchC(option, "end")) doend = ajTrue; else if(ajStrMatchC(option, "excess")) doexcess = ajTrue; /* Application logic */ line = ajStrNew(); while(ajReadline(inf,&line)) { if(doall) ajStrRemoveWhite(&line); else if(doend) ajStrTrimWhiteEnd(&line); else if(doexcess) ajStrRemoveWhiteExcess(&line); ajFmtPrintF(outf, "%S\n", line); } /* Memory management and exit */ ajFileClose(&inf); ajFileClose(&outf); ajStrDel(&line); ajStrDel(&option); embExit(); return 0; }
static void emira_dolistsingles(AjPStr *cl, AjPTable table) { ajuint i; AjPStr squal = NULL; AjPStr prefix = NULL; AjPStr key = NULL; AjPStr value = NULL; prefix = ajStrNew(); key = ajStrNew(); i = 0; while(miralistsingles[i].qname) { squal = ajAcdGetListSingle(miralistsingles[i].qname); ajStrAssignC(&key,miralistsingles[i].qname); ajStrAssignC(&prefix,""); value = ajTableFetch(table, key); if(value) ajStrAssignS(&prefix,value); if(!ajStrMatchC(squal,miralistsingles[i].def)) ajFmtPrintAppS(cl," -%S%s=%S",prefix,miralistsingles[i].mname, squal); ajStrDel(&squal); ++i; } ajStrDel(&key); ajStrDel(&prefix); return; }
static AjBool dbxflat_NextEntry(EmbPBtreeEntry entry, AjPFile inf) { static AjBool init = AJFALSE; static ajint nparser = -1; ajint i; if(!init) { entry->fpos = 0L; for(i=0; parser[i].Name && nparser == -1; ++i) if(ajStrMatchC(entry->dbtype, parser[i].Name)) nparser = i; if(nparser == -1) ajFatal("Database format (%S) unknown",entry->dbtype); init = ajTrue; } if(!parser[nparser].Parser(entry,inf)) return ajFalse; return ajTrue; }
AjBool gFormatGenbank(AjPSeq seq, AjPStr *inseq){ AjPSeqout seqout = NULL; AjPFeattabOut featout = NULL; AjPFeattable feat = NULL; AjPStr seqline = NULL; AjPStr featline = NULL; AjPFile seqfile = NULL; AjPFile featfile = NULL; AjPStr filename = NULL; gAssignUniqueName(&filename); feat = ajSeqGetFeatCopy(seq); if(!feat) return ajFalse; seqout = ajSeqoutNew(); if(!ajSeqoutOpenFilename(seqout,filename)) embExitBad(); ajSeqoutSetFormatS(seqout,ajStrNewC("genbank")); ajSeqoutWriteSeq(seqout,seq); ajSeqoutClose(seqout); ajSeqoutDel(&seqout); seqfile = ajFileNewInNameS(filename); ajSysFileUnlinkS(filename); featout = ajFeattabOutNew(); if(!ajFeattabOutOpen(featout,filename)) return ajFalse; ajFeattableWriteGenbank(featout,feat); ajFeattableDel(&feat); //ajFeattabOutDel(&featout); ajFileClose(&(featout->Handle)); featfile = ajFileNewInNameS(filename); ajSysFileUnlinkS(filename); while(ajReadline(seqfile,&seqline)){ if(ajStrMatchC(seqline,"ORIGIN\n")){ while(ajReadline(featfile,&featline)){ ajStrAppendS(inseq, featline); } } ajStrAppendS(inseq, seqline); } ajStrDel(&seqline); ajStrDel(&featline); ajStrDel(&filename); ajFileClose(&seqfile); ajFileClose(&featfile); return ajTrue; }
static void remap_GetFrames(AjPStr const *framelist, AjBool *frames) { int i; /* reset the vector */ for(i=0; i<6; i++) frames[i] = ajFalse; for(i=0; framelist[i]; i++) { if(ajStrMatchC(framelist[i], "1")) frames[0] = ajTrue; else if(ajStrMatchC(framelist[i], "2")) frames[1] = ajTrue; else if(ajStrMatchC(framelist[i], "3")) frames[2] = ajTrue; else if(ajStrMatchC(framelist[i], "-1")) frames[3] = ajTrue; else if(ajStrMatchC(framelist[i], "-2")) frames[4] = ajTrue; else if(ajStrMatchC(framelist[i], "-3")) frames[5] = ajTrue; else if(ajStrMatchC(framelist[i], "F")) { frames[0] = ajTrue; frames[1] = ajTrue; frames[2] = ajTrue; } else if(ajStrMatchC(framelist[i], "R")) { frames[3] = ajTrue; frames[4] = ajTrue; frames[5] = ajTrue; } else if(ajStrMatchC(framelist[i], "6")) { frames[0] = ajTrue; frames[1] = ajTrue; frames[2] = ajTrue; frames[3] = ajTrue; frames[4] = ajTrue; frames[5] = ajTrue; } else ajErr("Unknown frame: '%S'", framelist[i]); } return; }
static AjPRegexp dbifasta_getExpr(const AjPStr idformat, ajuint *type) { AjPRegexp retexp = NULL; dbifastaGIdexp = ajRegCompC("^>([A-Za-z0-9_-]+:)?([.A-Za-z0-9_-]+)"); if(ajStrMatchC(idformat,"simple")) { *type = FASTATYPE_SIMPLE; retexp = ajRegCompC("^>([A-Za-z0-9_-]+:)?([.A-Za-z0-9_-]+)"); } else if(ajStrMatchC(idformat,"idacc")) { *type = FASTATYPE_IDACC; retexp = ajRegCompC( "^>([.A-Za-z0-9_-]+)+[ \t]+\\(?([A-Za-z0-9_-]+)\\)?"); } else if(ajStrMatchC(idformat,"accid")) { *type = FASTATYPE_ACCID; retexp = ajRegCompC("^>([A-Za-z0-9_-]+)+[ \t]+([A-Za-z0-9_-]+)"); } else if(ajStrMatchC(idformat,"gcgid")) { *type = FASTATYPE_GCGID; retexp = ajRegCompC("^>[A-Za-z0-9_-]+:([A-Za-z0-9_-]+)"); } else if(ajStrMatchC(idformat,"gcgidacc")) { *type = FASTATYPE_GCGIDACC; retexp = ajRegCompC( "^>[A-Za-z0-9_-]+:([A-Za-z0-9_-]+)[ \t]+([A-Za-z0-9-]+)"); } else if(ajStrMatchC(idformat,"gcgaccid")) { *type = FASTATYPE_GCGACCID; retexp = ajRegCompC( "^>[A-Za-z0-9_-]+:([A-Za-z0-9_-]+)[ \t]+([A-Za-z0-9-]+)"); } else if(ajStrMatchC(idformat,"ncbi")) { *type = FASTATYPE_NCBI; retexp = ajRegCompC("^>([A-Za-z0-9_-]+)"); /* dummy regexp */ } else if(ajStrMatchC(idformat,"dbid")) { *type = FASTATYPE_DBID; retexp = ajRegCompC("^>[A-Za-z0-9_-]+[ \t]+([A-Za-z0-9_-]+)"); } else return NULL; return retexp; }
EnsEAssemblyexceptionType ensAssemblyexceptionTypeFromStr(const AjPStr type) { register EnsEAssemblyexceptionType i = ensEAssemblyexceptionTypeNULL; EnsEAssemblyexceptionType etype = ensEAssemblyexceptionTypeNULL; for(i = ensEAssemblyexceptionTypeHAP; assemblyexceptionType[i]; i++) if(ajStrMatchC(type, assemblyexceptionType[i])) etype = i; if(!etype) ajDebug("ensAssemblyexceptionTypeFromStr encountered " "unexpected string '%S'.\n", type); return etype; }
static void emira_doinfiles(AjPStr *cl, AjPTable table) { ajuint i; AjPStr squal = NULL; AjPStr prefix = NULL; AjPStr key = NULL; AjPStr value = NULL; AjPFile infile = NULL; prefix = ajStrNew(); key = ajStrNew(); i = 0; while(mirainfiles[i].qname) { infile = ajAcdGetInfile(mirainfiles[i].qname); if(infile) squal = ajStrNewS(ajFileGetName(infile)); else squal = ajStrNewS(ajAcdGetValueDefault(mirainfiles[i].qname)); ajStrAssignC(&key,mirainfiles[i].mname); ajStrAssignC(&prefix,""); value = ajTableFetch(table, key); if(value) ajStrAssignS(&prefix,value); if(!ajStrMatchC(squal,mirainfiles[i].def)) ajFmtPrintAppS(cl," -%S%s=%S",prefix,mirainfiles[i].mname, squal); ajStrDel(&squal); ajFileClose(&infile); ++i; } ajStrDel(&key); ajStrDel(&prefix); return; }
int main(int argc, char **argv) { AjPDasServer server = NULL; AjPDasSource source = NULL; AjPDasSegment segment = NULL; AjPStr host = NULL; AjPStr path = NULL; AjPFile outf = NULL; ajint port = 80; AjBool sequencesourcesonly; AjBool entrypoints; AjBool showtestqueries; AjBool runtestqueries = ajTrue; AjBool quickexit = ajFalse; ajint itest=0; ajint j=0; ajint maxtests=0; ajint maxfeatures=0; ajint maxsegments=0; AjIList iter = NULL; AjIList coordsi = NULL; AjIList itereps = NULL; AjPFilebuff buff = NULL; AjPUrlref uo = NULL; AjPList segments = NULL; AjPStr ffname = NULL; AjPStr url = NULL; AjPStr dbhttpver = ajStrNew(); AjPStr dbname = ajStrNew(); AjPStr dbproxy = ajStrNew(); AjPStr servername = NULL; AjPTable titlecount = NULL; const ajuint* count; int k=0; embInit("dastest", argc, argv); host = ajAcdGetString("host"); path = ajAcdGetString("path"); port = ajAcdGetInt("port"); sequencesourcesonly = ajAcdGetBoolean("sequencesourcesonly"); entrypoints = ajAcdGetBoolean("entrypoints"); showtestqueries = ajAcdGetBoolean("showtestqueries"); runtestqueries = ajAcdGetBoolean("runtestqueries"); servername = ajAcdGetString("servername"); outf = ajAcdGetOutfile("outfile"); maxtests = ajAcdGetInt("maxtests"); maxfeatures = ajAcdGetInt("maxfeatures"); maxsegments = ajAcdGetInt("maxsegments"); server = ajDasServerNew(); if(runtestqueries) { url = ajStrNew(); if(!ajNamServer(servername)) { ajWarn("following das server is required to be defined " "for test queries..."); ajWarn("\nSERVER %S [\n" " type: \"sequence\"\n" " method: \"das\"\n" " url: \"http://%S%S\"\n" "]\n",servername, host,path); ajWarn("ignoring -runtestqueries option..."); runtestqueries = ajFalse; } else { ajNamSvrGetUrl(servername, &url); ajHttpUrlDeconstruct(url, &port, &host, &path); ajStrDel(&url); } } ajDasServerSethostS(server,host); ajDasServerSetport(server,port); if(ajStrGetCharLast(path)!='/') ajStrAppendK(&path,'/'); ajStrAppendC(&path,"sources"); ajDasServerSetpathS(server,path); ajFmtPrintF(outf,"host = %S\npath = %S\nport = %d\n", server->host, server->path, server->port); /* * TODO: stop using http-read but instead use * ajNamSvrListListDatabases(svrname, dbnames); */ buff = ajHttpRead(dbhttpver, dbname, dbproxy, host, port, path); if(!buff) ajExitAbort(); ajFilebuffHtmlNoheader(buff); ajDasParseRegistry(buff, server->sources); ajFmtPrintF(outf,"DAS sources and descriptions\n\n"); titlecount = dastestGetTitleCount(server); iter = ajListIterNew(server->sources); while(!ajListIterDone(iter) && !quickexit) { source = ajListIterGet(iter); if ((sequencesourcesonly && !source->sequence) || ajStrMatchC(source->title,"cath") || k++ <50) continue; ajFmtPrintF(outf,"%-30S %-50S\n%S\n",source->uri,source->title, source->description); if(entrypoints && source->entry_points) { uo = ajHttpUrlrefNew(); ajHttpUrlrefParseC(&uo, ajStrGetPtr(source->entry_points_uri)); if(ajStrGetLen(uo->Port)) ajStrToInt(uo->Port, &port); else port = 80; ajFilebuffDel(&buff); buff = ajHttpRead(dbhttpver, dbname, dbproxy, uo->Host, port, uo->Absolute); ajHttpUrlrefDel(&uo); if(!buff) continue; ajFilebuffHtmlNoheader(buff); segments = ajListNew(); ajDasParseEntrypoints(buff, segments); itereps = ajListIterNew(segments); ajFmtPrintF(outf, "Number of entry points %d\n", ajListGetLength(segments)); j=0; while(!ajListIterDone(itereps)) { segment = ajListIterGet(itereps); if (j++ < maxsegments) ajFmtPrintF(outf, "segment id:%S orientation:%S start:%d stop:%d\n", segment->id, segment->orientation, segment->start, segment->stop); ajDasSegmentDel(&segment); } ajListIterDel(&itereps); ajListFree(&segments); } if(showtestqueries || runtestqueries) { AjPDasCoordinate coord; coordsi = ajListIterNew(source->coordinates); while(!ajListIterDone(coordsi) && !quickexit) { coord = ajListIterGet(coordsi); ajDebug("coordinate uri:%S taxid:%S source:%S test_range:%S\n", coord->uri, coord->taxid, coord->source, coord->test_range); if(showtestqueries) { if(source->sequence) ajFmtPrintF(outf, "example/test entry = '%S?segment=%S'\n", source->sequence_query_uri,coord->test_range); if(source->features) ajFmtPrintF(outf, "example/test entry = '%S?segment=%S'\n", source->features_query_uri,coord->test_range); } if(runtestqueries) { AjPStr idqry = ajStrNew(); AjPStr entry = NULL; AjPSeq seq = NULL; ajint ibegin = 0; ajint iend = 0; AjPStr example = NULL; example = ajDasTestrangeParse(coord->test_range, &entry, &ibegin, &iend); if(ajStrGetLen(entry)) { count = ajTableFetchS(titlecount, source->title); dbname = ajDasSourceGetDBname(source, *count>1); if (source->features) { AjPStr qpath=NULL; uo = ajHttpUrlrefNew(); ajFmtPrintS(&idqry,"dasgff::%S:%S:%S", servername, dbname, entry); ajFmtPrintF(outf, "feature query: %S start:%d end:%d\n", idqry, ibegin, iend); ajHttpUrlrefParseC(&uo, ajStrGetPtr(source->features_query_uri)); ajHttpUrlrefSplitPort(uo); ajFmtPrintS(&qpath,"%S?segment=%S", uo->Absolute,entry); if(iend>0) ajFmtPrintAppS(&qpath,":%d,%d",ibegin, iend); if(ajStrGetLen(uo->Port)) ajStrToInt(uo->Port, &port); else port = 80; ajDebug("calling ajHttpRead to get the raw" " output; host:%S port:%d path:%S\n", uo->Host, port, qpath); ajFilebuffDel(&buff); buff = ajHttpRead(dbhttpver, dbname, dbproxy, uo->Host, port, qpath); if(buff) { AjPFeattable ft; ajFmtPrintS(&ffname, "%S.%S", source->uri, entry); ajFilebuffHtmlNoheader(buff); dastestSaveRawFeatures(buff, ffname); ajDebug("now using EMBOSS feature queries\n"); ft = dastestFeatureQuery(idqry, ibegin, iend); dastestSaveMappedFeatures(ft, ffname, outf, maxfeatures); ajStrDel(&ffname); ajFeattableDel(&ft); } ajHttpUrlrefDel(&uo); ajStrDel(&qpath); if(++itest>=maxtests) quickexit = ajTrue; } else if(source->sequence) { seq = ajSeqNewRes(iend-ibegin+1); ajFmtPrintS(&idqry,"%S:%S:%S", servername, dbname, entry); ajFmtPrintF(outf, "sequence query: %S start:%d end:%d\n", idqry, ibegin, iend); ajSeqGetFromUsaRange(idqry, ajFalse, ibegin, iend, seq); ajFmtPrintF(outf, "length of sequence returned: %d\n", ajSeqGetLen(seq)); if(ajSeqGetLen(seq)>0) ajFmtPrintF(outf, "sequence returned (first 100 bases):" " %-100.100s\n", ajSeqGetSeqC(seq)); ajSeqDel(&seq); } ajStrDel(&dbname); } ajStrDel(&entry); ajStrDel(&idqry); ajStrDel(&example); } } ajListIterDel(&coordsi); } } ajListIterDel(&iter); ajDasServerDel(&server); ajFilebuffDel(&buff); ajStrDel(&host); ajStrDel(&path); ajStrDel(&servername); ajStrDel(&dbhttpver); ajStrDel(&dbname); ajStrDel(&dbproxy); ajFileClose(&outf); ajTableDelValdel(&titlecount, ajMemFree); embExit(); return 0; }
int main(int argc, char *argv[]) { embInitPV("ggeneskew", argc, argv, "GEMBASSY", "1.0.3"); AjPSeqall seqall; AjPSeq seq; AjPStr inseq = NULL; ajint window = 0; ajint slide = 0; AjBool cumulative = ajFalse; AjBool gc3 = ajFalse; AjPStr basetype = NULL; AjBool accid = ajFalse; AjPStr restid = NULL; AjPStr seqid = NULL; AjPStr base = NULL; AjPStr url = NULL; AjPFile tmpfile = NULL; AjPStr tmpname = NULL; AjBool plot = 0; AjPFile outf = NULL; AjPFilebuff buff = NULL; AjPGraph mult = NULL; gPlotParams gpp; AjPStr title = NULL; seqall = ajAcdGetSeqall("sequence"); window = ajAcdGetInt("window"); slide = ajAcdGetInt("slide"); cumulative = ajAcdGetBoolean("cumulative"); gc3 = ajAcdGetBoolean("gctri"); basetype = ajAcdGetSelectSingle("base"); accid = ajAcdGetBoolean("accid"); plot = ajAcdGetToggle("plot"); outf = ajAcdGetOutfile("outfile"); mult = ajAcdGetGraphxy("graph"); if(ajStrMatchC(base, "none")) basetype = ajStrNewC(""); base = ajStrNewC("rest.g-language.org"); gAssignUniqueName(&tmpname); while(ajSeqallNext(seqall, &seq)) { inseq = NULL; if(!accid) { if(gFormatGenbank(seq, &inseq)) { gAssignUniqueName(&tmpname); tmpfile = ajFileNewOutNameS(tmpname); if(!tmpfile) { ajFmtError("Output file (%S) open error\n", tmpname); embExitBad(); } ajFmtPrintF(tmpfile, "%S", inseq); ajFileClose(&tmpfile); ajFmtPrintS(&url, "http://%S/upload/upl.pl", base); gFilePostSS(url, tmpname, &restid); ajStrDel(&url); ajSysFileUnlinkS(tmpname); } else { ajFmtError("Sequence does not have features\n" "Proceeding with sequence accession ID\n"); accid = ajTrue; } } ajStrAssignS(&seqid, ajSeqGetAccS(seq)); if(ajStrGetLen(seqid) == 0) { ajStrAssignS(&seqid, ajSeqGetNameS(seq)); } if(ajStrGetLen(seqid) == 0) { ajWarn("No valid header information\n"); } if(accid) { ajStrAssignS(&restid, seqid); if(ajStrGetLen(seqid) == 0) { ajDie("Cannot proceed without header with -accid\n"); } if(!gValID(seqid)) { ajDie("Invalid accession ID:%S, exiting\n", seqid); } } url = ajStrNew(); ajFmtPrintS(&url, "http://%S/%S/geneskew/window=%d/slide=%d/" "cumulative=%d/gc3=%d/base=%S/output=f/tag=gene", base, restid, window, slide, cumulative, gc3, basetype); if(plot) { title = ajStrNew(); ajStrAppendC(&title, argv[0]); ajStrAppendC(&title, " of "); ajStrAppendS(&title, seqid); gpp.title = ajStrNewS(title); gpp.xlab = ajStrNewC("gene skew"); gpp.ylab = ajStrNewC("bp"); if(!gFilebuffURLS(url, &buff)) { ajDie("File downloading error from:\n%S\n", url); } if(!gPlotFilebuff(buff, mult, &gpp)) { ajDie("Error in plotting\n"); } AJFREE(gpp.title); AJFREE(gpp.xlab); AJFREE(gpp.ylab); ajStrDel(&title); ajFilebuffDel(&buff); } else { ajFmtPrintF(outf, "Sequence: %S\n", seqid); if(!gFileOutURLS(url, &outf)) { ajDie("File downloading error from:\n%S\n", url); } } ajStrDel(&url); ajStrDel(&restid); ajStrDel(&seqid); ajStrDel(&inseq); } ajFileClose(&outf); ajSeqallDel(&seqall); ajSeqDel(&seq); ajStrDel(&base); embExit(); return 0; }
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[]) { embInitPV("gcircularmap", argc, argv, "GEMBASSY", "1.0.1"); struct soap soap; struct ns1__circular_USCOREmapInputParams params; AjPSeqall seqall; AjPSeq seq; AjPStr inseq = NULL; AjPStr seqid = NULL; AjBool accid = ajFalse; AjPFile outf = NULL; AjPStr filename = NULL; AjPStr outfname = NULL; AjPStr format = NULL; ajint i; char *in0; char *result; seqall = ajAcdGetSeqall("sequence"); filename = ajAcdGetString("goutfile"); accid = ajAcdGetBoolean("accid"); format = ajAcdGetString("format"); params.gmap = 0; i = 0; while(ajSeqallNext(seqall, &seq)) { soap_init(&soap); soap.send_timeout = 0; soap.recv_timeout = 0; inseq = NULL; ajStrAssignS(&seqid, ajSeqGetAccS(seq)); if(!ajStrGetLen(seqid)) ajStrAssignS(&seqid, ajSeqGetNameS(seq)); if(!ajStrGetLen(seqid)) { ajWarn("No valid header information\n"); } if(accid || !gFormatGenbank(seq, &inseq)) { if(!accid) ajWarn("Sequence does not have features\n" "Proceeding with sequence accession ID:%S\n", seqid); if(!gValID(seqid)) { ajDie("Invalid accession ID:%S, exiting\n", seqid); } ajStrAssignS(&inseq, seqid); } in0 = ajCharNewS(inseq); if(soap_call_ns1__circular_USCOREmap( &soap, NULL, NULL, in0, ¶ms, &result ) == SOAP_OK) { ++i; outfname = ajStrNewS(ajFmtStr("%S.%d.%S", filename, i, format)); outf = ajFileNewOutNameS(outfname); if(!outf) { ajDie("File open error\n"); } if(!ajStrMatchC(format, "svg")) { if(!gHttpConvertC(result, &outf, ajStrNewC("svg"), format)) { ajDie("File downloading error from:\n%s\n", result); } else { ajFmtPrint("Created %S\n", outfname); } } else { if(!gHttpGetBinC(result, &outf)) { ajDie("File downloading error from:\n%s\n", result); } else { ajFmtPrint("Created %S\n", outfname); } } ajStrDel(&outfname); } else { soap_print_fault(&soap, stderr); } soap_destroy(&soap); soap_end(&soap); soap_done(&soap); AJFREE(in0); ajStrDel(&inseq); } ajSeqallDel(&seqall); ajSeqDel(&seq); ajStrDel(&seqid); ajStrDel(&filename); embExit(); return 0; }
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; }
static EmbPEntry dbiblast_nextblastentry(PBlastDb db, ajint ifile, const AjPStr idformat, AjBool systemsort, AjPStr const * fields, ajint * maxFieldLen, ajuint* maxidlen, ajuint* countfield, AjPFile elistfile, AjPFile * alistfile) { ajint i; static ajint lastfile = -1; static ajint iparser = -1; static ajint called = 0; static ajuint tabhdr[TABLESIZE]; static ajint iload = TABLESIZE-1; static ajint irest = 0; static ajint ipos = 0; static ajint jpos = 0; ajint ir; ajint j; static ajint is = 0; char* token; static ajint nfields; ajint ifield; if(!called) { for(i=0; parser[i].Name; i++) if(ajStrMatchC(idformat, parser[i].Name)) { iparser = i; break; } if(iparser < 0) ajFatal("idformat '%S' unknown", idformat); ajDebug("idformat '%S' Parser %d\n", idformat, iparser); ajStrSetRes(&id, HDRSIZE); ajStrSetRes(&acc, HDRSIZE); ajStrSetRes(&hline, HDRSIZE); called = 1; } if(!fdl) { nfields=0; while(fields[nfields]) nfields++; if(nfields) AJCNEW(fdl, nfields); for(i=0; i < nfields; i++) fdl[i] = ajListNew(); } if(lastfile != ifile) { lastfile = ifile; ipos = 1; /* isize = 0;*/ irest = 0; iload = TABLESIZE-1; } if(!dbiblastEntry || !systemsort) dbiblastEntry = embDbiEntryNew(nfields); /* pick up the next entry, parse it and dump it */ if(ipos > db->Size) return NULL; if( ipos >= irest) { ajDebug("ipos: %d iload: %d irest: %d\n", ipos, iload, irest); irest = ipos + TABLESIZE - 2; if(irest > db->Size) { iload = db->Size - ipos + 1; irest = db->Size; } jpos=0; j = dbiblast_loadtable(tabhdr, iload, db, db->TopHdr, ipos-1); if(!j) ajDebug("No elements read"); } j = dbiblast_ncblreadhdr(&hline, db, tabhdr[jpos], tabhdr[jpos+1]); if(!parser[iparser].Parser(hline, alistfile, systemsort, fields, maxFieldLen, countfield, &id, fdl)) ajFatal("failed to parse '%S'", hline); ir = ipos; if(ajStrGetLen(id) > *maxidlen) *maxidlen = ajStrGetLen(id); if(systemsort) ajFmtPrintF(elistfile, "%S %d %d %d\n", id, ir, is, ifile+1); else { dbiblastEntry->entry = ajCharNewS(id); dbiblastEntry->rpos = ir; dbiblastEntry->spos = is; dbiblastEntry->filenum = ifile+1; /* field tokens as list, then move to dbiblastEntry->field */ for(ifield=0; ifield < nfields; ifield++) { dbiblastEntry->nfield[ifield] = ajListGetLength(fdl[ifield]); if(dbiblastEntry->nfield[ifield]) { AJCNEW(dbiblastEntry->field[ifield], dbiblastEntry->nfield[ifield]); i = 0; while(ajListPop(fdl[ifield], (void**) &token)) dbiblastEntry->field[ifield][i++] = token; } else dbiblastEntry->field[ifield] = NULL; } } ipos++; jpos++; return dbiblastEntry; }
static AjBool assemoutWriteNextBam(AjPOutfile outfile, const AjPAssem assem) { AjPFile outf = ajOutfileGetFile(outfile); AjPSeqBamHeader header = NULL; AjPAssemContig c = NULL; AjPSeqBam bam; AjPAssemRead r = NULL; AjPAssemContig* contigs = NULL; AjPAssemTag t = NULL; AjIList j = NULL; AjPSeqBamBgzf gzfile = NULL; AjPStr headertext=NULL; const AjPStr rgheadertext=NULL; AjBool ret = ajTrue; ajint i=0; ajulong ncontigs=0UL; if(!outf) return ajFalse; if(!assem) return ajFalse; if(!assem->Hasdata) { if(ajListGetLength(assem->ContigsOrder)) ncontigs = ajListToarray(assem->ContigsOrder, (void***)&contigs); else ncontigs = ajTableToarrayValues(assem->Contigs, (void***)&contigs); ajFmtPrintS(&headertext, "@HD\tVN:1.3\tSO:%s\n", ajAssemGetSortorderC(assem)); header = ajSeqBamHeaderNewN((ajuint) ncontigs); gzfile = ajSeqBamBgzfNew(ajFileGetFileptr(outf), "w"); outfile->OutData = gzfile; while (contigs[i]) /* contigs */ { c = contigs[i]; if(ajStrMatchC(c->Name, "*")) { i++; continue; } header->target_name[i] = strdup(ajStrGetPtr(c->Name)); header->target_len[i++] = c->Length; ajFmtPrintAppS(&headertext, "@SQ\tSN:%S\tLN:%d", c->Name, c->Length); if(c->URI) ajFmtPrintAppS(&headertext, "\tUR:%S", c->URI); if(c->MD5) ajFmtPrintAppS(&headertext, "\tM5:%S", c->MD5); if(c->Species) ajFmtPrintAppS(&headertext, "\tSP:%S", c->Species); ajFmtPrintAppS(&headertext, "\n"); j = ajListIterNewread(c->Tags); while (!ajListIterDone(j)) { t = ajListIterGet(j); ajFmtPrintAppS(&headertext, "@CO\t%S %u %u %S\n", t->Name, t->x1, t->y1, t->Comment); } ajListIterDel(&j); } rgheadertext = assemSAMGetReadgroupHeaderlines(assem); if(rgheadertext) ajStrAppendS(&headertext, rgheadertext); ajSeqBamHeaderSetTextC(header, ajStrGetPtr(headertext)); ajSeqBamHeaderWrite(gzfile, header); ajSeqBamHeaderDel(&header); ajStrDel(&headertext); AJFREE(contigs); if(!assem->BamHeader) return ajTrue; } /* data */ gzfile = outfile->OutData; AJNEW0(bam); bam->m_data=10; AJCNEW0(bam->data, bam->m_data); j = ajListIterNewread(assem->Reads); while (!ajListIterDone(j)) /* reads */ { r = ajListIterGet(j); assemoutWriteBamAlignment(gzfile, r, bam); } ajListIterDel(&j); AJFREE(bam->data); AJFREE(bam); /* ajSeqBamBgzfClose(gzfile);*/ return ret; }
static void jaspscan_coretoken(PJspmat info, const AjPStr str) { const char *p; const char *q; AjPStr key = NULL; AjPStr value = NULL; value = ajStrNew(); key = ajStrNew(); p = ajStrGetPtr(str); q = p; while(*q != '"' && *q != '\t') ++q; --q; ajStrAssignSubC(&key,p,0,q-p-1); while(*q != '"') ++q; if(*(q+1) != '"') { p = q + 1; ++q; while(*q != '"') ++q; ajStrAssignSubC(&value,p,0,q-p-1); if(ajStrMatchC(key,"acc")) ajStrAssignS(&info->protseq,value); if(ajStrMatchC(key,"medline")) ajStrAssignS(&info->pmid,value); if(ajStrMatchC(key,"species")) ajStrAssignS(&info->species,value); if(ajStrMatchC(key,"sysgroup")) ajStrAssignS(&info->sgroup,value); if(ajStrMatchC(key,"total_ic")) ajStrAssignS(&info->content,value); if(ajStrMatchC(key,"type")) ajStrAssignS(&info->exp,value); if(ajStrMatchC(key,"included_models")) ajStrAssignS(&info->models,value); if(ajStrMatchC(key,"MCS")) ajStrAssignS(&info->mcs,value); if(ajStrMatchC(key,"jaspar")) ajStrAssignS(&info->jaspar,value); if(ajStrMatchC(key,"transfac")) ajStrAssignS(&info->transfac,value); if(ajStrMatchC(key,"Description")) ajStrAssignS(&info->desc,value); if(ajStrMatchC(key,"description")) ajStrAssignS(&info->desc,value); if(ajStrMatchC(key,"comment")) ajStrAssignS(&info->comment,value); if(ajStrMatchC(key,"End relative to TSS")) ajStrAssignS(&info->erttss,value); if(ajStrMatchC(key,"Start relative to TSS")) ajStrAssignS(&info->srttss,value); if(ajStrMatchC(key,"consensus")) ajStrAssignS(&info->consens,value); } ajStrDel(&key); ajStrDel(&value); return; }
void emboss_getoptions(char *pgm, int argc, char *argv[]) { ajint numseqs=0; ajint numwts=0; AjPStr method = NULL; ancvar = false; dollo = true; jumble = false; njumble = 1; trout = true; usertree = false; goteof = false; weights = false; justwts = false; printdata = false; progress = true; treeprint = true; stepbox = false; ancseq = false; mulsets = false; msets = 1; embInitPV(pgm, argc, argv, "PHYLIPNEW",VERSION); phylostates = ajAcdGetDiscretestates("infile"); while (phylostates[numseqs]) numseqs++; phylotrees = ajAcdGetTree("intreefile"); if (phylotrees) { numtrees = 0; while (phylotrees[numtrees]) numtrees++; usertree = true; } phyloweights = ajAcdGetProperties("weights"); if (phyloweights) { weights = true; numwts = ajPhyloPropGetSize(phyloweights); } if (numseqs > 1) { mulsets = true; msets = numseqs; } else if (numwts > 1) { mulsets = true; msets = numwts; justwts = true; } method = ajAcdGetListSingle("method"); if(ajStrMatchC(method, "d")) dollo = true; else dollo = false; if(!usertree) { njumble = ajAcdGetInt("njumble"); if(njumble >0) { inseed = ajAcdGetInt("seed"); jumble = true; emboss_initseed(inseed, &inseed0, seed); } else njumble = 1; } if((mulsets) && (!jumble)) { jumble = true; inseed = ajAcdGetInt("seed"); emboss_initseed(inseed, &inseed0, seed); } phyloanc = ajAcdGetProperties("ancfile"); if(phyloanc) ancvar = true; threshold = ajAcdGetFloat("threshold"); printdata = ajAcdGetBoolean("printdata"); progress = ajAcdGetBoolean("progress"); treeprint = ajAcdGetBoolean("treeprint"); trout = ajAcdGetToggle("trout"); stepbox = ajAcdGetBoolean("stepbox"); ancseq = ajAcdGetBoolean("ancseq"); embossoutfile = ajAcdGetOutfile("outfile"); emboss_openfile(embossoutfile, &outfile, &outfilename); if(trout) { embossouttree = ajAcdGetOutfile("outtreefile"); emboss_openfile(embossouttree, &outtree, &outtreename); } printf("\nDollo and polymorphism parsimony algorithm, version %s\n\n", VERSION); fprintf(outfile,"\nDollo and polymorphism parsimony algorithm,"); fprintf(outfile," version %s\n\n",VERSION); } /* emboss_getoptions */
int main(int argc, char **argv) { AjPList idlist; AjPList* fieldList = NULL; AjBool systemsort; AjBool cleanup; ajuint maxindex; ajuint maxidlen = 0; ajuint maxlen; AjPFile elistfile = NULL; AjPFile* alistfile = NULL; AjPStr dbname = NULL; AjPStr release = NULL; AjPStr datestr = NULL; AjPStr sortopt = NULL; void **entryIds = NULL; AjPStr directory; AjPStr indexdir; AjPStr filename; AjPStr exclude; AjPStr curfilename = NULL; AjPFile libr=NULL; AjPStr idformat = NULL; EmbPEntry entry; ajuint idtype = 0; ajuint idCount = 0; ajuint idDone; AjPList listInputFiles = NULL; void ** inputFiles = NULL; ajuint nfiles; ajuint ifile; ajuint filesize; short recsize; ajuint maxfilelen = 20; char date[4] = { 0,0,0,0 }; AjPStr tmpfname = NULL; AjPStr* fields = NULL; AjPFile entFile = NULL; AjPStr* divfiles = NULL; AjPRegexp regIdExp = NULL; ajint* maxFieldLen = NULL; ajuint ifield = 0; ajuint nfields = 0; AjPFile logfile = NULL; ajuint* countField = NULL; ajuint* fieldTot = NULL; ajuint idCountFile = 0; ajuint i; embInit("dbifasta", argc, argv); idformat = ajAcdGetListSingle("idformat"); fields = ajAcdGetList("fields"); directory = ajAcdGetDirectoryName("directory"); indexdir = ajAcdGetOutdirName("indexoutdir"); filename = ajAcdGetString("filenames"); exclude = ajAcdGetString("exclude"); dbname = ajAcdGetString("dbname"); release = ajAcdGetString("release"); datestr = ajAcdGetString("date"); systemsort = ajAcdGetBoolean("systemsort"); cleanup = ajAcdGetBoolean("cleanup"); sortopt = ajAcdGetString("sortoptions"); maxindex = ajAcdGetInt("maxindex"); logfile = ajAcdGetOutfile("outfile"); while(fields[nfields]) /* array ends with a NULL */ nfields++; if(nfields) { AJCNEW(maxFieldLen, nfields); AJCNEW0(countField, nfields); AJCNEW0(fieldTot, nfields); for(ifield=0; ifield < nfields; ifield++) maxFieldLen[ifield] = (ajint)maxindex * -1; if(systemsort) AJCNEW(alistfile, nfields); else { AJCNEW(fieldList, nfields); for(ifield=0; ifield < nfields; ifield++) fieldList[ifield] = ajListNew(); } } if(ajStrMatchC(datestr, "00/00/00")) ajFmtPrintS(&datestr, "%D", ajTimeRefTodayFmt("dbindex")); ajStrRemoveWhite(&dbname); /* used for temp filenames */ embDbiDateSet(datestr, date); idlist = ajListNew(); regIdExp = dbifasta_getExpr(idformat, &idtype); ajDebug("reading '%S/%S'\n", directory, filename); ajDebug("writing '%S/'\n", indexdir); listInputFiles = embDbiFileListExc(directory, filename, exclude); ajListSort(listInputFiles, &ajStrVcmp); nfiles = (ajuint) ajListToarray(listInputFiles, &inputFiles); if(!nfiles) ajDie("No input files in '%S' matched filename '%S'", directory, filename); embDbiLogHeader(logfile, dbname, release, datestr, indexdir, maxindex); embDbiLogFields(logfile, fields, nfields); embDbiLogSource(logfile, directory, filename, exclude, (AjPStr*) inputFiles, nfiles); embDbiLogCmdline(logfile); AJCNEW0(divfiles, nfiles); /* ** process each input file, one at a time */ for(ifile=0; ifile < nfiles; ifile++) { ajStrAssignS(&curfilename,(AjPStr) inputFiles[ifile]); embDbiFlatOpenlib(curfilename, &libr); ajFilenameTrimPath(&curfilename); if(ajStrGetLen(curfilename) >= maxfilelen) maxfilelen = ajStrGetLen(curfilename) + 1; ajDebug("processing filename '%S' ...\n", curfilename); ajDebug("processing file '%F' ...\n", libr); ajStrAssignS(&divfiles[ifile], curfilename); if(systemsort) /* elistfile for entries, alist for fields */ elistfile = embDbiSortOpen(alistfile, ifile, dbname, fields, nfields); idCountFile = 0; for(i=0;i<nfields;i++) countField[i] = 0; while((entry=dbifasta_NextFlatEntry(libr, ifile, regIdExp, idtype, systemsort, fields, maxFieldLen, &maxidlen, countField, elistfile, alistfile))) { idCountFile++; if(!systemsort) /* save the entry data in lists */ embDbiMemEntry(idlist, fieldList, nfields, entry, ifile); entry = NULL; } idCount += idCountFile; if(systemsort) { embDbiSortClose(&elistfile, alistfile, nfields); AJFREE(entry); } else { embDbiEntryDel(&dbifastaGEntry); } embDbiLogFile(logfile, curfilename, idCountFile, fields, countField, nfields); } /* write the division.lkp file */ embDbiWriteDivision(indexdir, dbname, release, date, maxfilelen, nfiles, divfiles, NULL); /* Write the entryname.idx index */ ajStrAssignC(&tmpfname, "entrynam.idx"); entFile = ajFileNewOutNamePathS(tmpfname, indexdir); recsize = maxidlen+10; filesize = 300 + (idCount*(ajint)recsize); embDbiHeader(entFile, filesize, idCount, recsize, dbname, release, date); if(systemsort) idDone = embDbiSortWriteEntry(entFile, maxidlen, dbname, nfiles, cleanup, sortopt); else /* save entries in entryIds array */ { idDone = embDbiMemWriteEntry(entFile, maxidlen, idlist, &entryIds); if(idDone != idCount) ajFatal("Duplicates not allowed for in-memory processing"); } embDbiHeaderSize(entFile, 300+(idDone*(ajint)recsize), idDone); ajFileClose(&entFile); /* Write the fields index files */ for(ifield=0; ifield < nfields; ifield++) { if(maxindex) maxlen = maxindex; else { if(maxFieldLen[ifield] >= 0) maxlen = maxFieldLen[ifield]; else maxlen = - maxFieldLen[ifield]; } if(systemsort) fieldTot[ifield] = embDbiSortWriteFields(dbname, release, date, indexdir, fields[ifield], maxlen, nfiles, idCount, cleanup, sortopt); else fieldTot[ifield] = embDbiMemWriteFields(dbname, release, date, indexdir, fields[ifield], maxlen, fieldList[ifield], entryIds); } embDbiLogFinal(logfile,maxindex, maxFieldLen, fields, fieldTot, nfields, nfiles, idDone, idCount); if(systemsort) embDbiRmEntryFile(dbname, cleanup); ajStrDel(&idformat); ajStrDelarray(&fields); ajStrDel(&filename); ajStrDel(&exclude); ajStrDel(&dbname); ajStrDel(&release); ajStrDel(&datestr); ajStrDel(&sortopt); ajStrDel(&directory); ajStrDel(&indexdir); ajStrDel(&tmpfname); ajFileClose(&libr); ajFileClose(&logfile); for(i=0;i<nfields;i++) { if(systemsort) { ajFileClose(&alistfile[i]); } else { ajListMap(fieldList[i], &embDbiFieldDelMap, NULL); ajListFree(&fieldList[i]); } } AJFREE(alistfile); AJFREE(fieldList); AJFREE(maxFieldLen); AJFREE(countField); AJFREE(fieldTot); for(i=0;i<nfiles;i++) { ajStrDel(&divfiles[i]); } AJFREE(divfiles); AJFREE(inputFiles); embDbiEntryDel(&dbifastaGEntry); ajStrDel(&dbifastaGRline); ajStrDel(&dbifastaGTmpId); if(dbifastaGFdl) { for(i=0; i < nfields; i++) ajListFree(&dbifastaGFdl[i]); AJFREE(dbifastaGFdl); } ajListMap(idlist, &embDbiEntryDelMap, NULL); ajListFree(&idlist); ajListstrFreeData(&listInputFiles); AJFREE(entryIds); ajRegFree(&dbifastaGIdexp); ajRegFree(&dbifastaGWrdexp); ajRegFree(®IdExp); ajStrDel(&dbifastaGTmpAc); ajStrDel(&dbifastaGTmpSv); ajStrDel(&dbifastaGTmpGi); ajStrDel(&dbifastaGTmpDb); ajStrDel(&dbifastaGTmpDes); ajStrDel(&dbifastaGTmpFd); ajStrDel(&curfilename); embExit(); return 0; }
int main(int argc, char *argv[]) { embInitPV("genret", argc, argv, "GEMBASSY", "1.0.3"); AjPSeqall seqall; AjPSeq seq = NULL; AjPStr inseq = NULL; AjPStr gene = NULL; AjPStr access = NULL; AjBool accid = ajTrue; AjPStr argument = NULL; AjPFile outfile = NULL; AjPStr seqid = NULL; AjPStr restid = NULL; AjBool valid = ajFalse; AjBool isseq = ajFalse; AjBool isgbk = ajFalse; AjPFilebuff buff = NULL; AjPFile tmpfile = NULL; AjPStr tmpname = NULL; AjPStr regexstr = NULL; AjPStrTok token = NULL; AjPRegexp regex = NULL; AjPStr url = NULL; AjPStr base = NULL; AjPStr head = NULL; AjPStr line = NULL; seqall = ajAcdGetSeqall("sequence"); access = ajAcdGetString("access"); gene = ajAcdGetString("gene"); argument = ajAcdGetString("argument"); accid = ajAcdGetBoolean("accid"); outfile = ajAcdGetOutfile("outfile"); if( ajStrMatchC(access, "translation") || ajStrMatchC(access, "get_exon") || ajStrMatchC(access, "get_exons") || ajStrMatchC(access, "get_cdsseq") || ajStrMatchC(access, "get_gbkseq") || ajStrMatchC(access, "get_geneseq") || ajStrMatchC(access, "get_intron") || ajStrMatchC(access, "getseq") || ajStrMatchC(access, "seq") || ajStrMatchC(access, "around_startcodon") || ajStrMatchC(access, "around_stopcodon") || ajStrMatchC(access, "before_startcodon") || ajStrMatchC(access, "before_stopcodon") || ajStrMatchC(access, "after_startcodon") || ajStrMatchC(access, "after_stopcodon") ) { isseq = ajTrue; } else if(ajStrMatchC(access, "annotate") || ajStrMatchC(access, "output")) { isgbk = ajTrue; } else { ajFmtPrintF(outfile, "gene,%S\n", access); } base = ajStrNewC("rest.g-language.org"); ajStrExchangeCC(&argument, " ", "/"); ajStrExchangeCC(&argument, ",", "/"); ajStrExchangeCC(&argument, "\t", "/"); ajStrExchangeCC(&argument, "\r", "/"); ajStrExchangeCC(&argument, "\n", "/"); if(ajStrMatchC(gene, "*")) { ajStrInsertK(&gene, 0, '.'); } if(ajStrPrefixC(gene, "@") || ajStrPrefixC(gene, "list::")) { ajStrExchangeCC(&gene, "@", ""); ajStrExchangeCC(&gene, "list::", ""); ajStrAssignS(&tmpname, gene); tmpfile = ajFileNewInNameS(tmpname); if(!tmpfile) { ajDie("List file (%S) open error\n", tmpname); } gene = ajStrNew(); while(ajReadline(tmpfile, &line)) { ajStrAppendS(&gene, line); } ajFileClose(&tmpfile); ajStrDel(&tmpname); ajStrDel(&line); } tmpname = ajStrNew(); gAssignUniqueName(&tmpname); while(ajSeqallNext(seqall, &seq)) { inseq = ajStrNew(); if(!accid) { if(gFormatGenbank(seq, &inseq)) { tmpfile = ajFileNewOutNameS(tmpname); if(!tmpfile) { ajDie("Output file (%S) open error\n", tmpname); } ajFmtPrintF(tmpfile, "%S", inseq); ajFileClose(&tmpfile); ajFmtPrintS(&url, "http://%S/upload/upl.pl", base); gFilePostSS(url, tmpname, &restid); ajStrDel(&url); ajSysFileUnlinkS(tmpname); } else { ajWarn("Sequence does not have features\n" "Proceeding with sequence accession ID\n"); accid = ajTrue; } } ajStrAssignS(&seqid, ajSeqGetAccS(seq)); if(ajStrGetLen(seqid) == 0) { ajStrAssignS(&seqid, ajSeqGetNameS(seq)); } if(ajStrGetLen(seqid) == 0) { ajWarn("No valid header information\n"); } if(accid) { ajStrAssignS(&restid, seqid); if(ajStrGetLen(seqid) == 0) { ajDie("Cannot proceed without header with -accid\n"); } if(!gValID(seqid)) { ajDie("Invalid accession ID:%S, exiting\n", seqid); } } url = ajStrNew(); if(isgbk) { ajFmtPrintS(&url, "http://%S/%S/%S", base, restid, access); } else { ajFmtPrintS(&url, "http://%S/%S/*/%S/%S", base, restid, access, argument); } if(!gFilebuffURLS(url, &buff)) { ajDie("GET error from %S\n", url); } while(ajBuffreadLine(buff, &line)) { if(isgbk){ ajFmtPrintF(outfile, "%S", line); continue; } ajStrRemoveLastNewline(&line); regex = ajRegCompC("^>"); if(ajRegExec(regex, line)) { head = ajStrNew(); ajStrAssignS(&head, line); ajStrTrimStartC(&head, ">"); valid = ajFalse; token = ajStrTokenNewC(ajStrNewS(gene), " ,\t\r\n"); while(ajStrTokenNextParse(token, ®exstr)) { if(ajStrGetLen(regexstr)) { regex = ajRegComp(regexstr); if(ajRegExec(regex, line)) { valid = ajTrue; if(ajStrIsAlnum(regexstr)) { ajStrExchangeSC(&gene, regexstr, ""); } } ajRegFree(®ex); } } } else { if(valid) { if(isseq) { ajStrFmtWrap(&line, 60); ajFmtPrintF(outfile, ">%S\n%S\n", head, line); } else { ajFmtPrintF(outfile, "%S,%S\n", head, line); } valid = ajFalse; } } } ajFileClose(&outfile); ajStrDel(&restid); ajStrDel(&seqid); ajStrDel(&inseq); } ajSeqallDel(&seqall); ajSeqDel(&seq); ajStrDel(&access); ajStrDel(&gene); embExit(); }
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; }
static AjBool assemoutWriteBamAlignment(AjPSeqBamBgzf gzfile, const AjPAssemRead r, AjPSeqBam bam) { AjPSeqBamCore c; AjPAssemTag tag; unsigned char *dpos; const char *s; ajuint ilen; ajuint slen; ajuint i; AjIList l = NULL; /* optional fields */ ajint tagvalsize = 0; const unsigned char* tagval = 0; ajint intval =0; /* processing cigar strings*/ char *t; int op; long x; unsigned char bam_nt16_table[256] = { 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 1, 2, 4, 8, 15,15,15,15, 15,15,15,15, 15, 0 /*=*/,15,15, 15, 1,14, 2, 13,15,15, 4, 11,15,15,12, 15, 3,15,15, 15,15, 5, 6, 8,15, 7, 9, 15,10,15,15, 15,15,15,15, 15, 1,14, 2, 13,15,15, 4, 11,15,15,12, 15, 3,15,15, 15,15, 5, 6, 8,15, 7, 9, 15,10,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15, 15,15,15,15 }; /* bam_write1 for each alignment */ c = &bam->core; ilen = ajStrGetLen(r->Seq); c->tid = (int) r->Reference; if(r->Flag & BAM_FREVERSE) c->pos = r->y1-1; else c->pos = r->x1-1; /* BAM format is zero based; -1 is translated to 0, meaning unmapped */ c->bin = 0; c->qual = r->MapQ; c->l_qname = 1 + ajStrGetLen(r->Name); c->flag = r->Flag; c->n_cigar = 0; c->l_qseq = ilen; c->mtid = (int) r->Rnext; c->mpos = (int) r->Pnext-1; c->isize = r->Tlen; /* get cigar string length */ s = ajStrGetPtr(r->Cigar); if (strcmp(s,"*")) /* '*' means unavailable */ { for (; *s; ++s) { if ((isalpha((int)*s)) || (*s=='=')) ++c->n_cigar; else if (!isdigit((int)*s)) ajWarn("invalid CIGAR character: %c\n", *s); } } bam->data_len = c->n_cigar*4 + c->l_qname + (ilen + 1)/2 + ilen; /* allocation for optional tags are made as they are appended */ if(bam->data_len > bam->m_data) { AJCRESIZE0(bam->data,bam->m_data, bam->data_len); bam->m_data = bam->data_len; } dpos = bam->data; /* copy query name to bam->data */ memcpy(dpos, ajStrGetPtr(r->Name), c->l_qname); dpos += c->l_qname; /* copy cigar string to bam->data */ s = ajStrGetPtr(r->Cigar); for (i = 0; i != c->n_cigar; ++i) { x = strtol(s, &t, 10); op = toupper((int)*t); if (op == 'M') op = BAM_CMATCH; else if (op == 'I') op = BAM_CINS; else if (op == 'D') op = BAM_CDEL; else if (op == 'N') op = BAM_CREF_SKIP; else if (op == 'S') op = BAM_CSOFT_CLIP; else if (op == 'H') op = BAM_CHARD_CLIP; else if (op == 'P') op = BAM_CPAD; else if (op == '=') op = BAM_CEQUAL; else if (op == 'X') op = BAM_CDIFF; else ajWarn("invalid CIGAR operation: %c",op); s = t + 1; ((ajuint*)dpos)[i] = x << BAM_CIGAR_SHIFT | op; } if (*s && c->n_cigar) ajWarn("unmatched CIGAR operation: %c", *s); c->bin = ajSeqBamReg2bin(c->pos, ajSeqBamCalend(c, MAJSEQBAMCIGAR(bam))); dpos += c->n_cigar*4; /* copy sequence string to bam->data */ s = ajStrGetPtr(r->Seq); slen = (ilen+1)/2; for (i = 0; i < slen; ++i) dpos[i] = 0; for (i = 0; i < ilen; ++i) dpos[i/2] |= bam_nt16_table[(ajuint)s[i]] << 4*(1-i%2); dpos += slen; /* copy quality values to bam->data */ if(r->SeqQ && !ajStrMatchC(r->SeqQ, "*")) { s = ajStrGetPtr(r->SeqQ); for(i=0;i<ilen;i++) dpos[i]= s[i]-33; } else for(i=0;i<ilen;i++) dpos[i]= 0xff; l = ajListIterNewread(r->Tags); bam->l_aux=0; while (!ajListIterDone(l)) { tag = ajListIterGet(l); /* TODO: array type 'B' and other types */ if(tag->type == 'i' || tag->type == 'I') { tagvalsize = 4; ajStrToInt(tag->Comment, &intval); tagval = (unsigned char*)&intval; } else if(tag->type =='s' || tag->type =='S') { tagvalsize = 2; ajStrToInt(tag->Comment, &intval); tagval = (unsigned char*)&intval; } else if(tag->type =='c' || tag->type =='C') { tagvalsize = 1; ajStrToInt(tag->Comment, &intval); tagval = (unsigned char*)&intval; } else if(tag->type =='A') { tagvalsize = 1; tagval = (const unsigned char*)ajStrGetPtr(tag->Comment); } else if(tag->type =='Z') { tagvalsize = ajStrGetLen(tag->Comment)+1; tagval = (const unsigned char*)ajStrGetPtr(tag->Comment); } else { ajWarn("tag type '%c' not yet supported",tag->type); continue; } ajSeqBamAuxAppend(bam, ajStrGetPtr(tag->Name), tag->type, tagvalsize, tagval); } ajListIterDel(&l); ajSeqBamWrite(gzfile, bam); return ajTrue; }
AjBool ajResourceGetDbdata(const AjPResource resource, AjPQuery qry, AjBool findformat(const AjPStr format, ajint *iformat)) { AjIList iter; AjPResquery resqry = NULL; ajint format; AjBool ret = ajFalse; if(!resource) return ajFalse; qry->InDrcat = ajTrue; ajStrAssignC(&qry->DbType, ajNamQueryGetDatatypeC(qry)); ajDebug("ajResourceGetDbdata dbtype %S %d\n", qry->DbType, qry->DataType); if(qry->DataType == AJDATATYPE_URL) { ajStrAssignC(&qry->Method, "urlonly"); qry->QueryType = AJQUERY_ENTRY; qry->HasAcc = ajFalse; iter = ajListIterNewread(resource->Query); while(!ajListIterDone(iter)) { resqry = ajListIterGet(iter); ajDebug("ajResourceGetDbdata test fmt: '%S' edam: '%S'\n", resqry->Format, resqry->FormatTerm); if(ajStrMatchC(resqry->FormatTerm, "2331")) { ajDebug(" OK fmt: '%S' edam: '%S' url '%S'\n", resqry->Format, resqry->FormatTerm, resqry->Url); ajStrAssignS(&qry->Formatstr, resqry->FormatTerm); ajStrAssignS(&qry->DbUrl, resqry->Url); ret = ajTrue; } } ajListIterDel(&iter); } else { ajStrAssignC(&qry->Method, "url"); qry->QueryType = AJQUERY_ENTRY; qry->HasAcc = ajFalse; iter = ajListIterNewread(resource->Query); while(!ajListIterDone(iter)) { resqry = ajListIterGet(iter); ajDebug("ajResourceGetDbdata test fmt: '%S' edam: '%S'\n", resqry->Format, resqry->FormatTerm); if(findformat(resqry->Format, &format)) { ajDebug(" OK fmt: '%S' url '%S'\n", resqry->Format, resqry->Url); ajStrAssignS(&qry->Formatstr, resqry->Format); ajStrAssignS(&qry->DbUrl, resqry->Url); ret = ajTrue; } if(ajStrGetLen(resqry->FormatTerm) && findformat(resqry->FormatTerm, &format)) { ajDebug(" OK edam: '%S' url '%S'\n", resqry->FormatTerm, resqry->Url); ajStrAssignS(&qry->Formatstr, resqry->FormatTerm); ajStrAssignS(&qry->DbUrl, resqry->Url); ret = ajTrue; } } ajListIterDel(&iter); } return ret; }
int main(int argc, char **argv) { /* ACD data item variables */ AjPSeqset alignfile = NULL; AjPFile prior = NULL; AjPFile null = NULL; AjPFile pam = NULL; float pamwgt = 0.0; AjPStr nhmm = NULL; AjPStr strategy = NULL; ajint pbswitch = 0; float archpri = 0.0; AjBool binary = ajFalse; AjBool fast = ajFalse; float gapmax = 0.0; AjBool hand = ajFalse; float idlevel = 0.0; AjBool noeff = ajFalse; float swentry = 0.0; float swexit = 0.0; AjBool verbosity = ajFalse; AjPStr weighting = NULL; AjPFile hmmfile = NULL; AjPFile o = NULL; AjPFile cfile = NULL; /* Housekeeping variables */ AjPStr cmd = NULL; AjPStr rnd1 = NULL; AjPStr rnd2 = NULL; AjPStr tmp = NULL; AjPStr fmt = NULL; char option; AjBool fmtok = ajFalse; AjPStr hmmfilename = NULL; /* ACD file processing */ embInitPV("ehmmbuild",argc,argv,"HMMERNEW",VERSION); alignfile = ajAcdGetSeqset("alignfile"); prior = ajAcdGetInfile("prior"); null = ajAcdGetInfile("null"); pam = ajAcdGetInfile("pam"); pamwgt = ajAcdGetFloat("pamwgt"); nhmm = ajAcdGetString("nhmm"); strategy = ajAcdGetListSingle("strategy"); pbswitch = ajAcdGetInt("pbswitch"); archpri = ajAcdGetFloat("archpri"); binary = ajAcdGetBoolean("binary"); fast = ajAcdGetBoolean("fast"); gapmax = ajAcdGetFloat("gapmax"); hand = ajAcdGetBoolean("hand"); idlevel = ajAcdGetFloat("sidlevel"); noeff = ajAcdGetBoolean("noeff"); swentry = ajAcdGetFloat("swentry"); swexit = ajAcdGetFloat("swexit"); verbosity = ajAcdGetBoolean("verbosity"); weighting = ajAcdGetListSingle("weighting"); hmmfile = ajAcdGetOutfile("hmmfile"); o = ajAcdGetOutfile("o"); cfile = ajAcdGetOutfile("cfile"); /* MAIN APPLICATION CODE */ /* 1. Housekeeping */ cmd = ajStrNew(); rnd1 = ajStrNew(); rnd2 = ajStrNew(); tmp = ajStrNew(); fmt = ajStrNew(); hmmfilename = ajStrNew(); ajStrAssignC(&hmmfilename, ajFileGetNameC(hmmfile)); /* 2. Ensure alignfile is in format HMMER can understand. These include FASTA, GENBANK,EMBL, GCG, PIR, STOCKHOLM, SELEX, MSF,CLUSTAL and PHYLIP. EMBOSS name definitions are taken from seqInFormatDef in ajseqread.c and seqOutFormat in ajseqwrite.c */ fmtok=ajFalse; ajStrAssignS(&fmt, ajSeqsetGetFormat(alignfile)); if(ajStrMatchC(fmt, "fasta") || ajStrMatchC(fmt, "genbank") || ajStrMatchC(fmt, "embl") || ajStrMatchC(fmt, "gcg") || ajStrMatchC(fmt, "pir") || ajStrMatchC(fmt, "stockholm")|| ajStrMatchC(fmt, "selex") || ajStrMatchC(fmt, "msf") || ajStrMatchC(fmt, "clustal") || ajStrMatchC(fmt, "phylip")) fmtok = ajTrue; /* This could be replaced with code to reformat the file. */ if(!fmtok) ajFatal("Input alignment ('alignfile' ACD option) is not in format " "HMMER understands. Please use a a file in FASTA, GENBANK, " "EMBL, GCG, PIR, STOCKHOLM, SELEX, MSF,CLUSTAL or PHYLIP format."); /* 3. Build hmmbuild 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("hmmbuild")); if(prior) ajFmtPrintAppS(&cmd, " --prior %s ", ajFileGetNameC(prior)); if(null) ajFmtPrintS(&cmd, " --null %s ", ajFileGetNameC(null)); if(pam) ajFmtPrintAppS(&cmd, " --pam %s --pamwgt %f ", ajFileGetNameC(pam), pamwgt); ajFmtPrintAppS(&cmd, " -n %S ", nhmm); /* ACD option only allows one selection */ option = ajStrGetCharFirst(strategy); if(option == 'F') ajStrAppendC(&cmd, " -f "); else if(option == 'G') ajStrAppendC(&cmd, " -g "); else if(option == 'S') ajStrAppendC(&cmd, " -s "); /* else go with default ('D' option in ACD file) */ ajFmtPrintAppS(&cmd, " --pbswitch %d ", pbswitch); ajFmtPrintAppS(&cmd, " --archpri %f ", archpri); if(binary) ajStrAppendC(&cmd, " --binary "); if(fast) ajFmtPrintAppS(&cmd, " --fast --gapmax %f ", gapmax); if(hand) ajStrAppendC(&cmd, " --hand "); ajFmtPrintAppS(&cmd, " --idlevel %f ", idlevel); if(noeff) ajStrAppendC(&cmd, " --noeff "); ajFmtPrintAppS(&cmd, " --swentry %f ", swentry); ajFmtPrintAppS(&cmd, " --swexit %f ", swexit); if(verbosity) ajStrAppendC(&cmd, " --verbose "); /* ACD option only allows one selection */ option = ajStrGetCharFirst(weighting); if(option == 'B') ajStrAppendC(&cmd, " --wblosum "); else if(option == 'G') ajStrAppendC(&cmd, " --wgsc "); else if(option == 'K') ajStrAppendC(&cmd, " --wme "); else if(option == 'W') ajStrAppendC(&cmd, " --wpb "); else if(option == 'V') ajStrAppendC(&cmd, " --wvoronoi "); else if(option == 'N') ajStrAppendC(&cmd, " --wnone "); if(o) ajFmtPrintAppS(&cmd, " -o %s ", ajFileGetNameC(o)); if(cfile) ajFmtPrintAppS(&cmd, " --cfile %s ", ajFileGetNameC(cfile)); /* -A (append) always set but file will be wiped by EMBOSS first unless append: "Y" is set for "hmmfile" in the ACD file. */ ajStrAppendC(&cmd, " -A -F "); ajFmtPrintAppS(&cmd, " %S %S", hmmfilename, ajSeqsetGetFilename(alignfile)); /* 4. Close ACD files */ ajSeqsetDel(&alignfile); ajFileClose(&prior); ajFileClose(&null); ajFileClose(&pam); ajFileClose(&hmmfile); ajFileClose(&o); ajFileClose(&cfile); /* 5. Call hmmbuild */ ajFmtPrint("\n%S\n", cmd); system(ajStrGetPtr(cmd)); /* 6. Exit cleanly */ ajStrDel(&nhmm); ajStrDel(&cmd); ajStrDel(&rnd1); ajStrDel(&rnd2); ajStrDel(&tmp); ajStrDel(&fmt); ajStrDel(&hmmfilename); ajStrDel(&strategy); ajStrDel(&weighting); embExit(); return 0; }
static AjBool assemoutWriteNextSam(AjPOutfile outfile, const AjPAssem assem) { AjPFile outf = ajOutfileGetFile(outfile); AjPAssemContig c = NULL; AjPAssemRead r = NULL; AjPAssemTag t = NULL; AjPAssemContig* contigs = NULL; AjIList j = NULL; AjPStr argstr = NULL; const AjPStr headertext = NULL; ajint n = 0; ajulong i = 0UL; AjBool ret = ajTrue; if(!outf || !assem) return ajFalse; ajDebug("assemoutWriteSam: # of contigs = %d\n", n); if(!assem->Hasdata) { ajFmtPrintF(outf, "@HD\tVN:1.3\tSO:%s\n", ajAssemGetSortorderC(assem)); /* Program record */ argstr = ajStrNewS(ajUtilGetCmdline()); ajStrExchangeKK(&argstr, '\n', ' '); ajFmtPrintF(outf, "@PG\tID:%S\tVN:%S\tCL:%S\n", ajUtilGetProgram(), ajNamValueVersion(), argstr); ajStrDel(&argstr); if(ajListGetLength(assem->ContigsOrder)) ajListToarray(assem->ContigsOrder, (void***)&contigs); else ajTableToarrayValues(assem->Contigs, (void***)&contigs); while (contigs[i]) /* contigs */ { c = contigs[i++]; if(!ajStrMatchC(c->Name, "*")) { ajFmtPrintF(outf, "@SQ\tSN:%S\tLN:%d", c->Name, c->Length); if(c->URI) ajFmtPrintF(outf, "\tUR:%S", c->URI); if(c->MD5) ajFmtPrintF(outf, "\tM5:%S", c->MD5); if(c->Species) ajFmtPrintF(outf, "\tSP:%S", c->Species); ajFmtPrintF(outf, "\n"); j = ajListIterNewread(c->Tags); while (!ajListIterDone(j)) { t = ajListIterGet(j); ajFmtPrintF(outf, "@CO\t%S %u %u %S\n", t->Name, t->x1, t->y1, t->Comment); } ajListIterDel(&j); } } headertext = assemSAMGetReadgroupHeaderlines(assem); if(headertext) ajFmtPrintF(outf,"%S", headertext); AJFREE(contigs); if(!assem->BamHeader) return ajTrue; } /* data */ j = ajListIterNewread(assem->Reads); if(ajListGetLength(assem->ContigsOrder)) i = ajListToarray(assem->ContigsOrder, (void***)&contigs); else i = ajTableToarrayValues(assem->Contigs, (void***)&contigs); while (!ajListIterDone(j)) /* reads */ { r = ajListIterGet(j); assemoutWriteSamAlignment(outf, r, contigs, (ajuint) i); } ajListIterDel(&j); AJFREE(contigs); return ret; }
/* @funcstatic seqwords_TermsRead ********************************************* ** ** Read the next Terms object from a file in embl-like format. The search ** terms are modified with a leading and trailing space. ** ** @param [r] inf [AjPFile] Input file stream ** @param [w] thys [AjPTerms*] Terms object ** ** @return [AjBool] True on succcess ** @@ *****************************************************************************/ static AjBool seqwords_TermsRead(AjPFile inf, AjPTerms *thys) { AjPStr line =NULL; /* Line of text. */ AjPStr temp =NULL; AjPList list_terms =NULL; /* List of keywords for a scop node*/ AjBool ok =ajFalse; AjPStr type = NULL; /* Memory management */ (*thys)=seqwords_TermsNew(); list_terms = ajListstrNew(); line = ajStrNew(); type = ajStrNew(); /* Read first line. */ ok = ajReadlineTrim(inf,&line); while(ok && !ajStrPrefixC(line,"//")) { if(ajStrPrefixC(line,"XX")) { ok = ajReadlineTrim(inf,&line); continue; } else if(ajStrPrefixC(line,"TY")) { ajFmtScanS(line, "%*s %S", &type); if(ajStrMatchC(type, "SCOP")) (*thys)->Type = ajSCOP; else if(ajStrMatchC(type, "CATH")) (*thys)->Type = ajCATH; } else if(ajStrPrefixC(line,"CL")) { ajStrAssignC(&(*thys)->Class,ajStrGetPtr(line)+3); ajStrRemoveWhiteExcess(&(*thys)->Class); } else if(ajStrPrefixC(line,"AR")) { ajStrAssignC(&(*thys)->Architecture,ajStrGetPtr(line)+3); ajStrRemoveWhiteExcess(&(*thys)->Architecture); } else if(ajStrPrefixC(line,"TP")) { ajStrAssignC(&(*thys)->Topology,ajStrGetPtr(line)+3); ajStrRemoveWhiteExcess(&(*thys)->Topology); } else if(ajStrPrefixC(line,"FO")) { ajStrAssignC(&(*thys)->Fold,ajStrGetPtr(line)+3); while(ajReadlineTrim(inf,&line)) { if(ajStrPrefixC(line,"XX")) break; ajStrAppendC(&(*thys)->Fold,ajStrGetPtr(line)+3); } ajStrRemoveWhiteExcess(&(*thys)->Fold); } else if(ajStrPrefixC(line,"SF")) { ajStrAssignC(&(*thys)->Superfamily,ajStrGetPtr(line)+3); while(ajReadlineTrim(inf,&line)) { if(ajStrPrefixC(line,"XX")) break; ajStrAppendC(&(*thys)->Superfamily,ajStrGetPtr(line)+3); } ajStrRemoveWhiteExcess(&(*thys)->Superfamily); } else if(ajStrPrefixC(line,"FA")) { ajStrAssignC(&(*thys)->Family,ajStrGetPtr(line)+3); while(ajReadlineTrim(inf,&line)) { if(ajStrPrefixC(line,"XX")) break; ajStrAppendC(&(*thys)->Family,ajStrGetPtr(line)+3); } ajStrRemoveWhiteExcess(&(*thys)->Family); } else if(ajStrPrefixC(line,"TE")) { /* Copy and clean up term. */ temp = ajStrNew(); ajStrAssignC(&temp,ajStrGetPtr(line)+3); ajStrRemoveWhiteExcess(&temp); /* Append a leading and trailing space to search term*/ ajStrAppendK(&temp, ' '); ajStrInsertC(&temp, 0, " "); /* Add the current term to the list. */ ajListstrPush(list_terms,temp); } ok = ajReadlineTrim(inf,&line); } if(!ok) { /* Clean up. */ ajListstrFree(&list_terms); ajStrDel(&line); /* Return. */ return ajFalse; } /* Convert the AjPList of terms to array of AjPSeq's. */ if(!((*thys)->N=ajListstrToarray((AjPList)list_terms,&(*thys)->Keywords))) ajWarn("Zero sized list of terms passed into seqwords_TermsRead"); /* Clean up. Free the list (not the nodes!). */ ajListstrFree(&list_terms); ajStrDel(&line); ajStrDel(&type); return ajTrue; }
void emboss_getoptions(char *pgm, int argc, char *argv[]) { AjPStr datatype = NULL; global = false; jumble = false; njumble = 1; lengths = false; outgrno = 1; outgropt = false; all = true; contchars = false; trout = true; usertree = false; printdata = false; progress = true; treeprint = true; mulsets = false; datasets = 1; embInitPV (pgm, argc, argv, "PHYLIPNEW",VERSION); phylofreq = ajAcdGetFrequencies("infile"); phylotrees = ajAcdGetTree("intreefile"); if (phylotrees) { numtrees = 0; while (phylotrees[numtrees]) numtrees++; usertree = true; lengths = ajAcdGetBoolean("lengths"); } datatype = ajAcdGetListSingle("datatype"); if(ajStrMatchC(datatype, "c")) contchars = true; outgrno = ajAcdGetInt("outgrno"); if(outgrno != 0) outgropt = true; else outgrno = 1; if(!usertree) { global = ajAcdGetBoolean("global"); njumble = ajAcdGetInt("njumble"); if(njumble >0) { inseed = ajAcdGetInt("seed"); jumble = true; emboss_initseed(inseed, &inseed0, seed); } else njumble = 1; } printdata = ajAcdGetBoolean("printdata"); progress = ajAcdGetBoolean("progress"); treeprint = ajAcdGetBoolean("treeprint"); trout = ajAcdGetToggle("trout"); embossoutfile = ajAcdGetOutfile("outfile"); embossouttree = ajAcdGetOutfile("outtreefile"); emboss_openfile(embossoutfile, &outfile, &outfilename); if(trout) emboss_openfile(embossouttree, &outtree, &outtreename); fprintf(outfile, "\nContinuous character Maximum Likelihood"); fprintf(outfile, " method version %s\n\n",VERSION); ajStrDel(&datatype); } /* emboss_getoptions */
void emboss_getoptions(char *pgm, int argc, char *argv[]) { AjPStr test = NULL; AjPStr outputformat = NULL; AjPStr typeofseq = NULL; AjPStr justweights = NULL; AjBool rewrite = false; long inseed, inseed0; data = genefreqs; seq = dna; bootstrap = false; jackknife = false; permute = false; ild = false; lockhart = false; blocksize = 1; regular = true; fracsample = 1.0; all = true; reps = 100; weights = false; mixture = false; ancvar = false; categories = false; justwts = false; printdata = false; dotdiff = true; progress = true; interleaved = true; xml = false; nexus = false; factors = false; enzymes = false; embInitPV(pgm, argc, argv, "PHYLIPNEW",VERSION); phylofreqs = ajAcdGetFrequencies("infile"); test = ajAcdGetListSingle("test"); if(ajStrMatchC(test, "b")) { bootstrap = true; regular = ajAcdGetToggle("regular"); if(regular) fracsample = 1.0; else { fracsample = ajAcdGetFloat("fracsample"); fracsample = fracsample/100.0; } blocksize = ajAcdGetInt("blocksize"); } else if(ajStrMatchC(test, "j")) { jackknife = true; regular = ajAcdGetToggle("regular"); if(regular) fracsample = 0.5; else { fracsample = ajAcdGetFloat("fracsample"); fracsample = fracsample/100.0; } } else if(ajStrMatchC(test, "c")) permute = true; else if(ajStrMatchC(test, "o")) ild = true; else if(ajStrMatchC(test, "s")) lockhart = true; else if(ajStrMatchC(test, "r")) rewrite = true; if(rewrite) { if (data == seqs) { outputformat = ajAcdGetListSingle("rewriteformat"); if(ajStrMatchC(outputformat, "n")) nexus = true; else if(ajStrMatchC(outputformat, "x")) xml = true; if( (nexus) || (xml) ) { typeofseq = ajAcdGetListSingle("seqtype"); if(ajStrMatchC(typeofseq, "d")) seq = dna; else if(ajStrMatchC(typeofseq, "r")) seq = rna; else if(ajStrMatchC(typeofseq, "p")) seq = protein; } } } else{ reps = ajAcdGetInt("reps"); inseed = ajAcdGetInt("seed"); emboss_initseed(inseed, &inseed0, seed); if(jackknife || bootstrap || permute) { phyloweights = ajAcdGetProperties("weights"); if(phyloweights) weights = true; } if(!permute) { justweights = ajAcdGetListSingle("justweights"); if(ajStrMatchC(justweights, "j")) justwts = true; } } printdata = ajAcdGetBoolean("printdata"); if(printdata) dotdiff = ajAcdGetBoolean("dotdiff"); progress = ajAcdGetBoolean("progress"); embossoutfile = ajAcdGetOutfile("outfile"); emboss_openfile(embossoutfile, &outfile, &outfilename); printf("\n bootstrap: %s",(bootstrap ? "true" : "false")); printf("\njackknife: %s",(jackknife ? "true" : "false")); printf("\n permute: %s",(permute ? "true" : "false")); printf("\n lockhart: %s",(lockhart ? "true" : "false")); printf("\n ild: %s",(ild ? "true" : "false")); printf("\n justwts: %s \n",(justwts ? "true" : "false")); } /* emboss_getoptions */
int main(int argc, char **argv) { /* ** All pointers set to NULL for safety. ** Variables names and initialisation values aligned for clarity. */ AjBool boo = ajFalse; ajint n1 = 0; ajint n2 = 0; ajlong l1 = 0; /* long int */ float f1 = 0.0; double d1 = 0.0; /* there is no long double */ size_t size = 100; /* Reserved memory size. Could be any value you know in advance. */ embInit("demostringnew", argc, argv); demostringnew_msg("/* Starting string values */"); /* Functions with the prefix ajStr are for manipulating EMBOSS strings. Functions with the prefix ajChar are for manipulating C-type (char*) string See filesection and datasection sections in ajstr.c */ /* ** String constructor functions ** See "@section constructors" in ajstr.c */ /* Construct a new string with no starting value or reserved size. There is no equivlent function for C-type (char*) strings */ str0 = ajStrNew (); /* Construct a new string with a reserved size but no starting value */ txt1 = ajCharNewRes(size); str1 = ajStrNewRes (size); /* Construct a new C-type (char*) string with a starting value ... */ txt2 = ajCharNewC ("Starting value"); /* ... copied from a C-type (char*) string */ str2 = ajStrNewC (txt2); /* ... copied from a C-type (char*) string */ txt3 = ajCharNewS (str2); /* ... copied from a string */ str3 = ajStrNewS (str2); /* ... copied from a string */ /* Construct a new string with a reserved size and starting value ... */ txt4 = ajCharNewResC("Starting value, reserved size", size); /* ... copied from a C-type (char*) string)*/ str4 = ajStrNewResC (txt4, size); /* ... copied from a C-type (char*) string */ /* or str4 = ajStrNewResLenC(txt4, size, strlen(txt4)); to specify string length */ txt5 = ajCharNewResS(str4, size); /* ... copied from a string */ str5 = ajStrNewResS (str4, size); /* ... copied from a string */ demostringnew_msg("/* After string constructor functions */"); /* ** String destructor functions ** See "@section destructors" in ajstr.c) */ /* Destruct a string */ ajCharDel(&txt1); ajCharDel(&txt2); ajCharDel(&txt3); ajCharDel(&txt4); ajCharDel(&txt5); ajStrDel (&str0); ajStrDel (&str1); ajStrDel (&str3); ajStrDel (&str5); /* str2 & str4 still in memory */ demostringnew_msg("/* After string destructor functions */"); /* ** String (de)referencing functions ** See "@section destructors" in ajstr.c) */ str0 = ajStrNewRef(str2); /* or ajStrAssignRef(&str0, str2); */ demostringnew_msg("/* After string reference */"); ajStrDelStatic(&str0); demostringnew_msg("/* After string dereference */"); /* ** String assignment functions ** See "@section assignment" in ajstr.c) */ /* Still only str2 & str4 in memory */ /* Assign a string value using ... */ ajStrAssignC(&str1, "Assigned value"); /* ... a C-type (char*) string */ /* or ajStrAssignLenC(&str1, "Assigned value", strlen("Assigned value")); to specify string length. */ ajStrAssignS(&str3, str1); /* ... a string */ ajStrAssignK(&str5, 'A'); /* ... a character */ demostringnew_msg("/* After string assignment 1 */"); ajStrAssignSubC(&str1, "Assigned value", 0, 11); ajStrAssignSubS(&str3, str1, 0, 9); demostringnew_msg("/* After string assignment 2 */"); /* The assignment functions allocate memory if necessary so str1, str3 and str5 will be created for you. It's bad practice to use this mechanism however because it's not obvious the string has been allocated (and needs freeing). Much cleaner to call the construct (ajStrNew) explicitly. */ /* Assign a string with a reserved size and value using ... */ ajStrAssignResC(&str1, size, "Assigned value, reserved size"); /* ... a C-type (char*) string */ ajStrAssignResS(&str3, size, str1); /* ... a string */ demostringnew_msg("/* After string assignment 3 */"); /* Assign a string value only if the string is empty using ... */ str0 = ajStrNew(); ajStrAssignEmptyC(&str0, "New value if string was empty"); /* ... a C-type (char*) string */ ajStrAssignEmptyS(&str1, str0); /* ... a string */ demostringnew_msg("/* After string assignment 4 */"); /* Now str0-5 in memory. The above code is for illustrative purposes: it's much cleaner to put all the constructors / destructors at the top / bottom of the code where possible. */ /* Assign all strings intuitive values */ txt0 = ajCharNewResC("TEXT 0", 100); txt1 = ajCharNewResC("TEXT 1", 100); txt2 = ajCharNewResC("Text 2", 100); txt3 = ajCharNewResC("Text 3", 100); txt4 = ajCharNewResC("Text 4", 100); txt5 = ajCharNewResC("Text 5", 100); ajStrAssignC(&str0, "STRING 0"); ajStrAssignC(&str1, "STRING 1"); ajStrAssignC(&str2, "String 2"); ajStrAssignC(&str3, "String 3"); ajStrAssignC(&str4, "String 4 WITHSOMETEXTINABLOCK"); ajStrAssignC(&str5, "String 5 WITHSOMETEXTINABLOCK"); demostringnew_msg("/* After string assignment 5 */"); /* ** String formatting functions ** See "@section formatting" in ajstr.c */ ajCharFmtLower(txt0); ajCharFmtLower(txt1); ajStrFmtLower(&str0); ajStrFmtLowerSub(&str1, 0, 2); ajCharFmtUpper(txt2); ajCharFmtUpper(txt3); ajStrFmtUpper(&str2); ajStrFmtUpperSub(&str3, 0, 2); demostringnew_msg("/* After string formatting 1 */"); ajStrFmtTitle(&str0); ajStrFmtQuote(&str1); ajStrFmtBlock(&str4, 3); demostringnew_msg("/* After string formatting 2 */"); /* See also ajStrFmtWrap, ajStrFmtWrapLeft ... these need checking. */ /* ** String conversion functions ** See "@section datatype to string conversion" in ajstr.c */ n1 = n2 = l1 = 1; f1 = d1 = 0.5; ajStrFromBool( &str0, boo); ajStrFromInt(&str1, n1); ajStrFromLong(&str2, l1); ajStrFromFloat(&str3, f1, 5); ajStrFromDouble(&str4, d1, 5); ajStrFromDoubleExp(&str5, d1, 5); demostringnew_msg("/* After datatype to string conversion */"); /* ** String conversion functions ** See "@section string to datatype conversion" in ajstr.c */ ajStrToBool(str0, &boo); ajStrToInt(str1, &n1); ajStrToLong(str2, &l1); ajStrToDouble(str4, &d1); ajUser("/* After string to datatype conversion */\n" "boo (from str0): %B\nn1 (from str1): %d\nl1 (from str2): %d", boo, n1, l1); ajFmtPrint("f1 (from str3): %f\nd1 (from str4): %f\n", f1, d1); /* Check ajUser ... doesn't support %f */ /* See also ajStrToHex */ /* Assign all strings new values */ strcpy(txt0, "Text String"); strcpy(txt1, "TEXT STRING"); strcpy(txt2, "Text*"); strcpy(txt3, "Text"); strcpy(txt4, "Text String 4"); strcpy(txt5, "Text String 5"); ajStrAssignC(&str0, "String"); ajStrAssignC(&str1, "STRING"); ajStrAssignC(&str2, "String*"); ajStrAssignC(&str3, "*String"); ajStrAssignC(&str4, "String 4"); ajStrAssignC(&str5, "String 5"); demostringnew_msg("/* After resetting strings */"); /* ** String comparison functions ** See "@section comparison" in ajstr.c */ ajUserDumpC("/* String comparison functions */"); boo = ajCharMatchC(txt0, txt1); ajUser("ajCharMatchC(txt0 txt1); == %B", boo); boo = ajCharMatchCaseC(txt0, txt1); ajUser("ajCharMatchCaseC(txt0 txt1); == %B", boo); boo = ajCharMatchC(txt0, txt2); ajUser("ajCharMatchC(txt0,txt2); == %B", boo); boo = ajCharMatchWildC(txt0, txt2); ajUser("ajCharMatchWildC(txt0,txt2); == %B", boo); boo = ajCharMatchWildS(txt0, str2); ajUser("ajCharMatchWildS(txt0,str2); == %B", boo); /* See also ajCharMatchWildNextC, ajCharMatchWildWordC ... these need checking & documentation updated. */ boo = ajCharPrefixC(txt0, txt3); ajUser("ajCharPrefixC(txt0, txt3); == %B", boo); boo = ajCharPrefixS(txt0, str0); ajUser("ajCharPrefixS(txt0, str0); == %B", boo); boo = ajCharPrefixCaseC(txt5, txt1); ajUser("ajCharPrefixCaseC(txt5, txt1); == %B", boo); boo = ajCharPrefixCaseC(txt1, txt5); ajUser("ajCharPrefixCaseC(txt1, txt5); == %B", boo); boo = ajCharPrefixCaseS(txt0, str0); ajUser("ajCharPrefixCaseS(txt0, str0); == %B", boo); boo = ajCharSuffixC(txt0, txt3); ajUser("ajCharSuffixC(txt0, txt3); === %B", boo); boo = ajCharSuffixS(txt0, str0); ajUser("ajCharSuffixS(txt0, str0); == %B", boo); /* See also ajCharSuffixCaseC, ajCharSuffixCaseC, ajCharSuffixCaseS, ajCharSuffixCaseS ... these need checking. */ boo = ajStrMatchC (str0, txt0); ajUser("ajStrMatchC (str0, txt0); == %B", boo); boo = ajStrMatchS(str0, str1); ajUser("ajStrMatchS(str0, str1); == %B", boo); boo = ajStrMatchCaseC(str0, txt0); ajUser("ajStrMatchCaseC(str0, txt0); == %B", boo); boo = ajStrMatchCaseS(str0, str0); ajUser("ajStrMatchCaseS(str0, str0); == %B", boo); /* ajUser("== %B", boo); boo = ajStrMatchWildC(str2, const char* text); ajStrMatchWildS (const AjPStr thys, const AjPStr wild); ajStrMatchWildWordC (const AjPStr str, const char* text); ajStrMatchWildWordS (const AjPStr str, const AjPStr text); ajStrPrefixC(const AjPStr str, const char* txt2); ajStrPrefixS(const AjPStr str, const AjPStr str2); ajStrPrefixCaseC (const AjPStr str, const char* pref); ajStrPrefixCaseS (const AjPStr str, const AjPStr pref); ajStrSuffixC (const AjPStr thys, const char* suff); ajStrSuffixS (const AjPStr thys, const AjPStr suff); */ /**************************************************************************/ /* String substitution functions (See "@section substitution" in ajstr.c) */ /**************************************************************************/ /* AjBool ajStrExchangeCC(AjPStr* Pstr, const char* txt, const char* txtnew); AjBool ajStrExchangeCS(AjPStr* Pstr, const char* txt, const AjPStr strnew); AjBool ajStrExchangeKK(AjPStr* Pstr, char chr, char chrnew); AjBool ajStrExchangeSC(AjPStr* Pstr, const AjPStr str, const char* txtnew); AjBool ajStrExchangeSS(AjPStr* Pstr, const AjPStr str, const AjPStr strnew); AjBool ajStrExchangeSetCC(AjPStr* Pstr, const char* oldc, const char* newc); AjBool ajStrExchangeSetSS(AjPStr* Pstr, const AjPStr str, const AjPStr strnew); AjBool ajStrRandom(AjPStr *s); AjBool ajStrReverse(AjPStr* Pstr); */ 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) { AjPList idlist; AjPList* fieldList = NULL; AjBool systemsort; AjBool cleanup; ajint blastv = 0; char dbtype = '\0'; ajuint maxindex; ajuint maxidlen = 0; ajuint maxlen; AjPStr version = NULL; AjPStr seqtype = NULL; AjPFile elistfile = NULL; AjPFile* alistfile = NULL; AjPStr dbname = NULL; AjPStr release = NULL; AjPStr datestr = NULL; AjPStr sortopt = NULL; void **entryIds = NULL; AjBool usesrc = AJTRUE; AjPStr directory; AjPStr indexdir; AjPStr filename; AjPStr exclude; AjPStr curfilename = NULL; AjPStr idformat = NULL; EmbPEntry entry; PBlastDb db = NULL; ajuint idCount = 0; ajuint idDone; AjPList listTestFiles = NULL; void ** testFiles = NULL; ajuint nfiles; ajuint ifile; ajuint jfile; ajuint filesize; short recsize; ajuint maxfilelen = 20; char date[4] = { 0,0,0,0 }; AjPStr tmpfname = NULL; AjPStr* fields = NULL; AjPFile entFile = NULL; AjPStr* divfiles = NULL; ajint* maxFieldLen = NULL; ajuint ifield = 0; ajuint nfields = 0; AjPFile logfile = NULL; ajuint* countField = NULL; ajuint* fieldTot = NULL; ajuint idCountFile = 0; ajuint i = 0; embInit("dbiblast", argc, argv); idformat = ajStrNewC("NCBI"); fields = ajAcdGetList("fields"); directory = ajAcdGetDirectoryName("directory"); indexdir = ajAcdGetOutdirName("indexoutdir"); filename = ajAcdGetString("filenames"); exclude = ajAcdGetString("exclude"); dbname = ajAcdGetString("dbname"); release = ajAcdGetString("release"); datestr = ajAcdGetString("date"); systemsort = ajAcdGetBoolean("systemsort"); cleanup = ajAcdGetBoolean("cleanup"); sortopt = ajAcdGetString("sortoptions"); maxindex = ajAcdGetInt("maxindex"); version = ajAcdGetListSingle("blastversion"); seqtype = ajAcdGetListSingle("seqtype"); usesrc = ajAcdGetBoolean("sourcefile"); logfile = ajAcdGetOutfile("outfile"); while(fields[nfields]) /* array ends with a NULL */ nfields++; if(nfields) { AJCNEW(maxFieldLen, nfields); AJCNEW0(countField, nfields); AJCNEW0(fieldTot, nfields); for(ifield=0; ifield < nfields; ifield++) maxFieldLen[ifield] = (ajint) maxindex * -1; if(systemsort) AJCNEW(alistfile, nfields); else { AJCNEW(fieldList, nfields); for(ifield=0; ifield < nfields; ifield++) fieldList[ifield] = ajListNew(); } } if(ajStrMatchC(datestr, "00/00/00")) ajFmtPrintS(&datestr, "%D", ajTimeRefTodayFmt("dbindex")); ajStrRemoveWhite(&dbname); /* used for temp filenames */ embDbiDateSet(datestr, date); idlist = ajListNew(); if(ajUtilGetBigendian()) readReverse = ajFalse; else readReverse = ajTrue; ajStrToInt(version, &blastv); dbtype = ajStrGetCharFirst(seqtype); ajDebug("reading '%S/%S'\n", directory, filename); ajDebug("writing '%S/'\n", indexdir); listTestFiles = embDbiFileListExc(directory, filename, exclude); ajListSort(listTestFiles, ajStrVcmp); nfiles = ajListToarray(listTestFiles, &testFiles); if(!nfiles) ajDie("No input files in '%S' matched filename '%S'", directory, filename); embDbiLogHeader(logfile, dbname, release, datestr, indexdir, maxindex); embDbiLogFields(logfile, fields, nfields); embDbiLogSource(logfile, directory, filename, exclude, (AjPStr*) testFiles, nfiles); embDbiLogCmdline(logfile); AJCNEW0(divfiles, nfiles); /* ** process each input file, one at a time */ jfile = 0; for(ifile=0; ifile < nfiles; ifile++) { curfilename = (AjPStr) testFiles[ifile]; if(!dbiblast_blastopenlib(curfilename, usesrc, blastv, dbtype, &db)) continue; /* could be the wrong file type with "*.*" */ ajDebug("processing filename '%S' ...\n", curfilename); ajDebug("processing file '%S' ...\n", db->TFile->Name); ajStrAssignS(&divfiles[jfile], db->TFile->Name); ajFilenameTrimPath(&divfiles[jfile]); if(ajStrGetLen(divfiles[jfile]) >= maxfilelen) maxfilelen = ajStrGetLen(divfiles[jfile]) + 1; if(systemsort) /* elistfile for entries, alist for fields */ elistfile = embDbiSortOpen(alistfile, jfile, dbname, fields, nfields); idCountFile = 0; for(i=0;i<nfields;i++) countField[i] = 0; while((entry=dbiblast_nextblastentry(db, jfile, idformat, systemsort, fields, maxFieldLen, &maxidlen, countField, elistfile, alistfile))) { idCountFile++; if(!systemsort) /* save the entry data in lists */ { embDbiMemEntry(idlist, fieldList, nfields, entry, jfile); } } idCount += idCountFile; if(systemsort) { embDbiSortClose(&elistfile, alistfile, nfields); /* lost the entry, so can't free it :-) */ } embDbiLogFile(logfile, curfilename, idCountFile, fields, countField, nfields); dbiblast_dbfree(&db); jfile++; } nfiles = jfile; /* ** write the division.lkp file */ embDbiWriteDivision(indexdir, dbname, release, date, maxfilelen, nfiles, divfiles, NULL); /* ** Write the entryname.idx index */ ajStrAssignC(&tmpfname, "entrynam.idx"); entFile = ajFileNewOutNamePathS(tmpfname, indexdir); recsize = maxidlen+10; filesize = 300 + (idCount*(ajint)recsize); embDbiHeader(entFile, filesize, idCount, recsize, dbname, release, date); if(systemsort) idDone = embDbiSortWriteEntry(entFile, maxidlen, dbname, nfiles, cleanup, sortopt); else /* save entries in entryIds array */ { idDone = embDbiMemWriteEntry(entFile, maxidlen, idlist, &entryIds); if(idDone != idCount) ajFatal("Duplicates not allowed for in-memory processing"); } embDbiHeaderSize(entFile, 300+(idDone*(ajint)recsize), idDone); ajFileClose(&entFile); /* ** Write the fields index files */ for(ifield=0; ifield < nfields; ifield++) { if(maxindex) maxlen = maxindex; else { if(maxFieldLen[ifield] >= 0) maxlen = maxFieldLen[ifield]; else maxlen = - maxFieldLen[ifield]; } if(systemsort) fieldTot[ifield] = embDbiSortWriteFields(dbname, release, date, indexdir, fields[ifield], maxlen, nfiles, idCount, cleanup, sortopt); else fieldTot[ifield] = embDbiMemWriteFields(dbname, release, date, indexdir, fields[ifield], maxlen, fieldList[ifield], entryIds); } embDbiLogFinal(logfile,maxindex, maxFieldLen, fields, fieldTot, nfields, nfiles, idDone, idCount); if(systemsort) embDbiRmEntryFile(dbname, cleanup); ajListMap(idlist, embDbiEntryDelMap, NULL); ajListFree(&idlist); AJFREE(entryIds); ajStrDelarray(&fields); for(i=0;i<nfields;i++) { if(systemsort) { ajFileClose(&alistfile[i]); } else { ajListMap(fieldList[i], embDbiFieldDelMap, NULL); ajListFree(&fieldList[i]); } } AJFREE(alistfile); AJFREE(fieldList); ajStrDel(&version); ajStrDel(&seqtype); ajFileClose(&elistfile); for(i=0;i<nfiles;i++) { ajStrDel(&divfiles[i]); } AJFREE(countField); AJFREE(fieldTot); ajStrDel(&dbname); ajStrDel(&release); ajStrDel(&datestr); ajStrDel(&sortopt); ajStrDel(&directory); ajStrDel(&indexdir); ajStrDel(&filename); ajStrDel(&exclude); ajStrDel(&idformat); ajStrDel(&tmpfname); AJFREE(maxFieldLen); ajFileClose(&logfile); ajListstrFreeData(&listTestFiles); ajStrDel(&t); ajStrDel(&id); ajStrDel(&acc); ajStrDel(&hline); ajStrDel(&tmpdes); ajStrDel(&tmpfd); ajStrDel(&tmpgi); ajStrDel(&tmpdb); ajStrDel(&tmpac); ajStrDel(&tmpsv); ajRegFree(&wrdexp); embDbiEntryDel(&dbiblastEntry); if(fdl) { for(i=0; i < nfields; i++) ajListFree(&fdl[i]); AJFREE(fdl); } for(i=0;i<nfiles;i++) { ajStrDel(&divfiles[i]); } AJFREE(divfiles); AJFREE(testFiles); embExit(); return 0; }