AjPResource ajResourceNewResource(const AjPResource res)
{
AjPResource ret;
AJNEW0(ret);
ret->Id = ajStrNewS(res->Id);
ret->Acc = ajStrNewS(res->Acc);
ret->Name = ajStrNewS(res->Name);
ret->Desc = ajStrNewS(res->Desc);
ret->Url = ajStrNewS(res->Url);
ret->Cat = ajListstrNewList(res->Cat);
ret->Idalt = ajListstrNewList(res->Idalt);
ret->Taxon = ajListNew();
ret->Edamdat = ajListNew();
ret->Edamfmt = ajListNew();
ret->Edamid = ajListNew();
ret->Edamtpc = ajListNew();
ajRestermlistClone(res->Taxon, ret->Taxon);
ajRestermlistClone(res->Edamdat, ret->Edamdat);
ajRestermlistClone(res->Edamfmt, ret->Edamfmt);
ajRestermlistClone(res->Edamid, ret->Edamid);
ajRestermlistClone(res->Edamtpc, ret->Edamtpc);
ret->Xref = ajListNew();
ajReslinklistClone(res->Xref, ret->Xref);
ret->Query = ajListNew();
ajResquerylistClone(res->Query, ret->Query);
ret->Example = ajListstrNewList(res->Example);
return ret;
}
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;
}
static void makeprotseq_parse_pepstats(AjPList* list,AjPFile data)
{
AjPStr line = ajStrNew();
AjPStr ch;
AjPStr chcopy = NULL;
const AjPStr tok;
double value = 0.0;
ajint count = 0;
ajint i = 0;
ajDebug("Parsing pepstats file.\n");
/* skip the lines before residues */
while(ajReadline(data,&line))
{
if(ajStrFindC(line,"Residue") == 0)
break;
}
/* parse residue part */
while(ajReadlineTrim(data,&line))
{
if(ajStrParseCountC(line," \t") == 0)
break;
ch = ajStrNew();
tok = ajStrParseWhite(line);
ajStrAppendS(&ch,tok);
ajStrFmtLower(&ch);
for(count = 1; count < 5; count++)
tok = ajStrParseWhite(NULL);
ajStrToDouble(tok,&value);
count = (ajint) (value * 100) +
((value - (int) value ) >= 0.5 ? 1 : 0);
for(i=0; i<count; i++)
{
chcopy = ajStrNewS(ch);
ajListstrPush(*list,chcopy);
}
ajStrDel(&ch);
}
ajStrDel(&line);
return;
}
int main(int argc, char **argv)
{
/* Variable declarations */
AjPOutfile outfile = NULL;
AjPTaxall taxall = NULL;
AjPTax tax = NULL;
AjPList taxlist = ajListNew();
AjPTax taxchild = NULL;
AjPTaxin taxchildin = NULL;
AjPStr taxchildqry = NULL;
AjPTable foundtable = NULL;
ajuint ifound = 0;
ajuint ichild = 0;
ajuint ikeep = 0;
/* ACD processing */
embInit("taxgetdown", argc, argv);
taxall = ajAcdGetTaxonall("taxons");
outfile = ajAcdGetOuttaxon("outfile");
taxchildin = ajTaxinNew();
taxchild = ajTaxNew();
foundtable = ajTablestrNew(600);
while(ajTaxallNext(taxall, &tax))
{
ifound++;
ajFmtPrintS(&taxchildqry, "%S-up:%S",
ajTaxGetDb(tax), ajTaxGetId(tax));
ajTaxinQryS(taxchildin, taxchildqry);
while(ajTaxinRead(taxchildin, taxchild))
{
ichild++;
if(!ajTableMatchS(foundtable, taxchild->Id))
{
ajTaxoutWrite(outfile, taxchild);
ajTablePut(foundtable, ajStrNewS(taxchild->Id),
(void *) 1);
ikeep++;
}
}
}
if(!ifound)
ajErr("No matching terms");
/* Memory clean-up and exit */
ajStrDel(&taxchildqry);
ajListFree(&taxlist);
ajTaxallDel(&taxall);
ajTaxDel(&tax);
ajTaxinDel(&taxchildin);
ajTaxDel(&taxchild);
ajOutfileClose(&outfile);
ajTablestrFreeKey(&foundtable);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("gseqinfo", argc, argv, "GEMBASSY", "1.0.1");
struct soap soap;
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr seqid = NULL;
AjPStr tmp = NULL;
AjPStr parse = NULL;
AjPStr numA = NULL;
AjPStr numT = NULL;
AjPStr numG = NULL;
AjPStr numC = NULL;
AjPStrTok handle = NULL;
ajint n;
char *in0;
char *result;
AjBool show = 0;
AjPFile outf = NULL;
seqall = ajAcdGetSeqall("sequence");
outf = ajAcdGetOutfile("outfile");
while(ajSeqallNext(seqall, &seq))
{
soap_init(&soap);
inseq = NULL;
ajStrAppendC(&inseq, ">");
ajStrAppendS(&inseq, ajSeqGetNameS(seq));
ajStrAppendC(&inseq, "\n");
ajStrAppendS(&inseq, ajSeqGetSeqS(seq));
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
in0 = ajCharNewS(inseq);
if(soap_call_ns1__seqinfo(
&soap,
NULL,
NULL,
in0,
&result
) == SOAP_OK)
{
tmp = ajStrNewC(result);
ajStrExchangeCC(&tmp, "<", "\n");
ajStrExchangeCC(&tmp, ">", "\n");
handle = ajStrTokenNewC(tmp, "\n");
while(ajStrTokenNextParse(handle, &parse))
{
if(ajStrIsInt(parse))
if(!numA)
numA = ajStrNewS(parse);
else if(!numT)
numT = ajStrNewS(parse);
else if(!numG)
numG = ajStrNewS(parse);
else if(!numC)
numC = ajStrNewS(parse);
}
if(show)
ajFmtPrint("Sequence: %S A: %S T: %S G: %S C: %S\n",
seqid, numA, numT, numG, numC);
else
ajFmtPrintF(outf, "Sequence: %S A: %S T: %S G: %S C: %S\n",
seqid, numA, numT, numG, numC);
}
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);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("ggcskew", argc, argv, "GEMBASSY", "1.0.3");
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjBool accid = ajFalse;
AjPStr restid = NULL;
AjPStr seqid = NULL;
AjPStr base = NULL;
AjPStr url = NULL;
AjPStr tmpname = NULL;
AjPSeqout tmpout = NULL;
ajint window = 0;
ajint slide = 0;
AjBool cumulative = 0;
AjBool at = 0;
AjBool purine = 0;
AjBool keto = 0;
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");
at = ajAcdGetBoolean("at");
purine = ajAcdGetBoolean("purine");
keto = ajAcdGetBoolean("keto");
plot = ajAcdGetToggle("plot");
outf = ajAcdGetOutfile("outfile");
mult = ajAcdGetGraphxy("graph");
base = ajStrNewC("rest.g-language.org");
gAssignUniqueName(&tmpname);
ajStrAppendC(&tmpname, ".fasta");
while(ajSeqallNext(seqall, &seq))
{
tmpout = ajSeqoutNew();
if(!ajSeqoutOpenFilename(tmpout, tmpname))
{
embExitBad();
}
ajSeqoutSetFormatS(tmpout,ajStrNewC("fasta"));
ajSeqoutWriteSeq(tmpout, seq);
ajSeqoutClose(tmpout);
ajSeqoutDel(&tmpout);
ajFmtPrintS(&url, "http://%S/upload/upl.pl", base);
gFilePostSS(url, tmpname, &restid);
ajStrDel(&url);
ajSysFileUnlinkS(tmpname);
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(ajStrGetLen(seqid) == 0)
{
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
}
if(ajStrGetLen(seqid) == 0)
{
ajWarn("No valid header information\n");
}
url = ajStrNew();
ajFmtPrintS(&url, "http://%S/%S/gcskew/window=%d/slide=%d/cumulative=%d/"
"at=%d/purine=%d/keto=%d/output=f/", base, restid, window,
slide, cumulative, at, purine, keto);
if(plot)
{
title = ajStrNew();
ajStrAppendC(&title, argv[0]);
ajStrAppendC(&title, " of ");
ajStrAppendS(&title, seqid);
gpp.title = ajStrNewS(title);
gpp.xlab = ajStrNewC("location");
gpp.ylab = ajStrNewC("GC skew");
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);
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&base);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPReport outf = NULL;
AjPFile inf = NULL;
ajint begin;
ajint end;
AjPList l = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPStr line = NULL;
AjPStr name = NULL;
AjPStr acc = NULL;
AjPStr bf = NULL;
AjPStr menu;
AjPStr pattern = NULL;
AjPStr opattern = NULL;
AjPStr pname = NULL;
AjPStr key = NULL;
AjPStr value = NULL;
AjPTable atable = NULL;
AjPTable btable = NULL;
ajint mismatch;
ajint minlength;
ajint sum;
ajint v;
char cp;
const char *p;
embInit("tfscan", argc, argv);
seqall = ajAcdGetSeqall("sequence");
outf = ajAcdGetReport("outfile");
mismatch = ajAcdGetInt("mismatch");
minlength = ajAcdGetInt("minlength");
menu = ajAcdGetListSingle("menu");
pname = ajStrNew();
cp=ajStrGetCharFirst(menu);
if(cp=='F')
ajStrAssignC(&pname,"tffungi");
else if(cp=='I')
ajStrAssignC(&pname,"tfinsect");
else if(cp=='O')
ajStrAssignC(&pname,"tfother");
else if(cp=='P')
ajStrAssignC(&pname,"tfplant");
else if(cp=='V')
ajStrAssignC(&pname,"tfvertebrate");
else if(cp=='C')
inf = ajAcdGetDatafile("custom");
if(cp!='C')
{
inf = ajDatafileNewInNameS(pname);
if(!inf)
ajFatal("Either EMBOSS_DATA undefined or TFEXTRACT needs running");
}
name = ajStrNew();
acc = ajStrNew();
bf = ajStrNewC("");
substr = ajStrNew();
line = ajStrNew();
pattern = ajStrNewC("AA");
opattern = ajStrNew();
while(ajSeqallNext(seqall, &seq))
{
begin=ajSeqallGetseqBegin(seqall);
end=ajSeqallGetseqEnd(seqall);
ajStrAssignC(&name,ajSeqGetNameC(seq));
strand=ajSeqGetSeqCopyS(seq);
ajStrAssignSubC(&substr,ajStrGetPtr(strand),begin-1,end-1);
ajStrFmtUpper(&substr);
l=ajListNew();
atable = ajTablestrNew(1000);
btable = ajTablestrNew(1000);
sum=0;
while(ajReadlineTrim(inf,&line))
{
p = ajStrGetPtr(line);
if(!*p || *p=='#' || *p=='\n' || *p=='!')
continue;
ajFmtScanS(line,"%S%S%S",&pname,&pattern,&acc);
p += ajStrGetLen(pname);
while(*p && *p==' ')
++p;
p += ajStrGetLen(pattern);
while(*p && *p==' ')
++p;
p += ajStrGetLen(acc);
while(*p && *p==' ')
++p;
ajStrAssignS(&opattern,pattern);
ajStrAssignC(&bf,p); /* rest of line */
v = embPatVariablePattern(pattern,substr,pname,l,0,
mismatch,begin);
if(v)
{
key = ajStrNewS(pname);
value = ajStrNewS(acc);
ajTablePut(atable,(void *)key,(void *)value);
key = ajStrNewS(pname);
value = ajStrNewS(bf);
ajTablePut(btable,(void *)key,(void *)value);
}
sum += v;
}
if(sum)
tfscan_print_hits(&l,sum,outf,atable,seq,minlength,
btable);
ajFileSeek(inf,0L,0);
ajListFree(&l);
ajTablestrFree(&atable);
ajTablestrFree(&btable);
ajStrDel(&strand);
}
ajStrDel(&line);
ajStrDel(&name);
ajStrDel(&acc);
ajStrDel(&pname);
ajStrDel(&opattern);
ajStrDel(&bf);
ajStrDel(&pattern);
ajStrDel(&substr);
ajSeqDel(&seq);
ajFileClose(&inf);
ajReportClose(outf);
ajReportDel(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&menu);
embExit();
return 0;
}
int main(int argc, char **argv)
{
/* Variable declarations */
AjPOutfile outfile = NULL;
AjBool obsolete = ajTrue;
AjPObo obo = NULL;
AjPObo oboanc = NULL;
AjPObo oboparent = NULL;
AjPOboall oboall = NULL;
AjPOboin oboin = NULL;
AjPStr oboqryup = NULL;
AjPStr oboqryanc = NULL;
AjPTable alltable = NULL;
AjPTable newtable = NULL;
AjPStr up = NULL;
AjPList uplist = NULL;
ajuint iterms = 0;
AjPStr topid = NULL;
AjPStr obodb = NULL;
AjBool saved = ajFalse;
/* ACD processing */
embInit("ontogetcommon", argc, argv);
oboall = ajAcdGetOboall("oboterms");
outfile = ajAcdGetOutobo("outfile");
obsolete = ajAcdGetBoolean("obsolete");
oboin = ajOboinNew();
oboparent = ajOboNew();
oboanc = ajOboNew();
uplist = ajListNew();
alltable = ajTablestrNew(600);
newtable = ajTablestrNew(600);
while(ajOboallNext(oboall, &obo))
{
saved = ajFalse;
if(!obsolete && ajOboIsObsolete(obo))
continue;
if(!iterms)
{
ajDebug("store id '%S'\n", ajOboGetId(obo));
ajStrAssignS(&obodb, ajOboGetDb(obo));
ajTablePut(alltable, ajStrNewS(ajOboGetId(obo)), NULL);
saved = ajTrue;
}
else
{
ajDebug("test id '%S'\n", ajOboGetId(obo));
if(ajTableMatchS(alltable, ajOboGetId(obo)))
{
ajDebug("keep id '%S'\n", ajOboGetId(obo));
ajTablePut(newtable, ajStrNewS(ajOboGetId(obo)), NULL);
saved = ajTrue;
}
}
if(saved)
ajStrAssignS(&topid, ajOboGetId(obo));
if(ajOboGetParents(obo, uplist)) /* that was the root */
{
while(ajListstrPop(uplist, &up))
{
ajDebug("up: '%S'\n", up);
ajFmtPrintS(&oboqryup, "%S-id:%S", ajOboGetDb(obo), up);
ajOboinQryS(oboin, oboqryup);
while(ajOboinRead(oboin, oboparent))
{
if(!obsolete && ajOboIsObsolete(oboparent))
continue;
if(!iterms)
{
ajDebug("store parent '%S'\n", ajOboGetId(oboparent));
ajTablePut(alltable, ajStrNewS(ajOboGetId(oboparent)),
NULL);
}
else
{
ajDebug("test parent '%S'\n", ajOboGetId(oboparent));
if(ajTableMatchS(alltable, ajOboGetId(oboparent)))
{
ajDebug("keep parent '%S'\n",
ajOboGetId(oboparent));
ajTablePut(newtable,
ajStrNewS(ajOboGetId(oboparent)),
NULL);
if(!saved)
{
ajStrAssignS(&topid, ajOboGetId(oboparent));
saved = ajTrue;
}
}
}
if(!ajOboGetParents(oboparent, uplist))
continue;
}
ajStrDel(&up);
}
}
if(iterms)
ajTableMergeAnd(alltable, newtable);
ajDebug("id: '%S' saved %u\n",
ajOboGetId(obo),
ajTableGetLength(alltable));
if(!ajTableGetLength(alltable))
ajDie("Query '%S' no matching ancestor found for obo term '%S:%S'",
ajOboallGetQryS(oboall), ajOboGetDb(obo), ajOboGetId(obo));
iterms++;
}
ajFmtPrintS(&oboqryanc, "%S-id:%S", obodb, topid);
ajOboinQryS(oboin, oboqryanc);
while(ajOboinRead(oboin, oboanc))
{
ajObooutWrite(outfile, oboanc);
}
/* Memory clean-up and exit */
ajOboallDel(&oboall);
ajOboinDel(&oboin);
ajOboDel(&oboanc);
ajOboDel(&oboparent);
ajListFree(&uplist);
ajTablestrFreeKey(&alltable);
ajTablestrFreeKey(&newtable);
ajStrDel(&oboqryup);
ajStrDel(&oboqryanc);
ajStrDel(&obodb);
ajStrDel(&topid);
ajOutfileClose(&outfile);
embExit();
return 0;
}
static void merger_Merge(AjPAlign align, AjPStr *ms,
const char *a, const char *b,
const AjPStr m, const AjPStr n, ajint start1,
ajint start2,
const char *namea, const char *nameb)
{
ajint apos;
ajint bpos;
ajint i;
AjPStr mm = NULL;
AjPStr nn = NULL;
char *p;
char *q;
ajint olen; /* length of walk alignment */
size_t tt;
/* lengths of the sequences after the aligned region */
ajint alen;
ajint blen;
AjPStr tmpstr = NULL;
mm = ajStrNewS(m);
nn = ajStrNewS(n);
p = ajStrGetuniquePtr(&mm);
q = ajStrGetuniquePtr(&nn);
olen = ajStrGetLen(mm);
/* output the left hand side */
if(start1 > start2)
{
for(i=0; i<start1; i++)
ajStrAppendK(ms, a[i]);
if(start2)
{
ajFmtPrintAppS(&tmpstr, "WARNING: *************************"
"********\n");
ajFmtPrintAppS(&tmpstr, "The region of alignment only starts at "
"position %d of sequence %s\n", start2+1, nameb);
ajFmtPrintAppS(&tmpstr, "Only the sequence of %s is being used "
"before this point\n\n", namea);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
}
}
else if(start2 > start1)
{
for(i=0; i<start2; i++)
ajStrAppendK(ms, b[i]);
if(start1)
{
ajFmtPrintAppS(&tmpstr, "WARNING: **************************"
"*******\n");
ajFmtPrintAppS(&tmpstr, "The region of alignment only starts at "
"position %d of sequence %s\n", start1+1, namea);
ajFmtPrintAppS(&tmpstr, "Only the sequence of %s is being used "
"before this point\n\n", nameb);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
}
}
else if(start1 && start2)
{
/* both the same length and > 1 before the aligned region */
ajFmtPrintAppS(&tmpstr,
"WARNING: *********************************\n");
ajFmtPrintAppS(&tmpstr, "There is an equal amount of unaligned "
"sequence (%d) at the start of the sequences.\n",
start1);
ajFmtPrintAppS(&tmpstr, "Sequence %s is being arbitrarily chosen "
"for the merged sequence\n\n", namea);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
for(i=0; i<start1; i++)
ajStrAppendK(ms, a[i]);
}
/* header */
ajFmtPrintS(&tmpstr, "Conflicts: %15.15s %15.15s\n", namea, nameb);
ajFmtPrintAppS(&tmpstr,
" position base position base Using\n");
ajAlignSetTailApp(align, tmpstr);
/* make the merged sequence
**
** point to the start of the alignment in the complete unaligned
** sequences
*/
apos = start1;
bpos = start2;
for(i=0; i<olen; i++)
{
if(p[i]=='.' || p[i]==' ' || p[i]=='-' ||
q[i]=='.' || q[i]==' ' || q[i]=='-')
{ /* gap! */
if(merger_bestquality(a, b, apos, bpos))
{
p[i] = toupper((ajint)p[i]);
if(p[i] != '.' && p[i] != ' ' && p[i] != '-')
ajStrAppendK(ms, p[i]);
ajFmtPrintS(&tmpstr,
" %8d '%c' %8d '%c' '%c'\n",
apos+1, p[i], bpos+1, q[i], p[i]);
ajAlignSetTailApp(align, tmpstr);
}
else
{
q[i] = toupper((ajint)q[i]);
if(q[i] != '.' && q[i] != ' ' && q[i] != '-')
ajStrAppendK(ms, q[i]);
ajFmtPrintS(&tmpstr,
" %8d '%c' %8d '%c' '%c'\n",
apos+1, p[i], bpos+1, q[i], q[i]);
ajAlignSetTailApp(align, tmpstr);
}
}
else if(p[i]=='n' || p[i]=='N')
{
q[i] = toupper((ajint)q[i]);
ajStrAppendK(ms, q[i]);
}
else if(q[i]=='n' || q[i]=='N')
{
p[i] = toupper((ajint)p[i]);
ajStrAppendK(ms, p[i]);
}
else if(p[i] != q[i])
{
/*
** get the sequence with the best quality and use the base
** from that one
*/
if(merger_bestquality(a, b, apos, bpos))
{
p[i] = toupper((ajint)p[i]);
ajStrAppendK(ms, p[i]);
ajFmtPrintS(&tmpstr,
" %8d '%c' %8d '%c' '%c'\n",
apos+1, p[i], bpos+1, q[i], p[i]);
ajAlignSetTailApp(align, tmpstr);
}
else
{
q[i] = toupper((ajint)q[i]);
ajStrAppendK(ms, q[i]);
ajFmtPrintS(&tmpstr,
" %8d '%c' %8d '%c' '%c'\n",
apos+1, p[i], bpos+1, q[i], q[i]);
ajAlignSetTailApp(align, tmpstr);
}
}
else
ajStrAppendK(ms, p[i]);
/* update the positions in the unaligned complete sequences */
if(p[i] != '.' && p[i] != ' ' && p[i] != '-') apos++;
if(q[i] != '.' && q[i] != ' ' && q[i] != '-') bpos++;
}
/* output the right hand side */
tt = strlen(&a[apos]);
alen = (ajint) tt;
tt = strlen(&b[bpos]);
blen = (ajint) tt;
if(alen > blen)
{
ajStrAppendC(ms, &a[apos]);
if(blen)
{
ajFmtPrintAppS(&tmpstr, "WARNING: ***************************"
"******\n");
ajFmtPrintAppS(&tmpstr, "The region of alignment ends at "
"position %d of sequence %s\n",
bpos+1, nameb);
ajFmtPrintAppS(&tmpstr, "Only the sequence of %s is being used "
"after this point\n\n", namea);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
}
}
if(blen > alen)
{
ajStrAppendC(ms, &b[bpos]);
if(alen)
{
ajFmtPrintAppS(&tmpstr, "WARNING: ***************************"
"******\n");
ajFmtPrintAppS(&tmpstr, "The region of alignment ends at "
"position %d of sequence %s\n",
apos+1, namea);
ajFmtPrintAppS(&tmpstr, "Only the sequence of %s is being used "
"after this point\n\n", nameb);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
}
}
else if(alen && blen)
{ /* both the same length and > 1 */
ajFmtPrintAppS(&tmpstr, "WARNING: ************************"
"*********\n");
ajFmtPrintAppS(&tmpstr, "There is an equal amount of unaligned "
"sequence (%d) at the end of the sequences.\n",
alen);
ajFmtPrintAppS(&tmpstr, "Sequence %s is being arbitrarily chosen "
"for the merged sequence\n\n", namea);
ajStrAppendC(ms, &a[apos]);
ajAlignSetTailApp(align, tmpstr);
ajStrDel(&tmpstr);
}
ajStrDel(&mm);
ajStrDel(&nn);
ajStrDel(&tmpstr);
return;
}
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)
{
AjPStr cl = NULL;
AjPStr stmp = NULL;
AjPStr squal = NULL;
/* AjBool bqual = ajFalse; */
AjPTable preftab = NULL;
embInitPV("emira", argc, argv, "MIRA",VERSION);
cl = ajStrNewS(ajAcdGetpathC("mira"));
stmp = ajStrNew();
preftab = emira_makepreftab();
if(ajAcdIsUserdefinedC("genome"))
{
squal = ajAcdGetListSingle("genome");
ajFmtPrintAppS(&cl," -genome%S",squal);
ajStrDel(&squal);
}
if(ajAcdIsUserdefinedC("mapping"))
{
squal = ajAcdGetListSingle("mapping");
ajFmtPrintAppS(&cl," -mapping%S",squal);
ajStrDel(&squal);
}
if(ajAcdIsUserdefinedC("clipping"))
{
squal = ajAcdGetListSingle("clipping");
ajFmtPrintAppS(&cl," -clipping%S",squal);
ajStrDel(&squal);
}
if(ajAcdIsUserdefinedC("setparam"))
{
squal = ajAcdGetListSingle("setparam");
if(!ajStrMatchC(squal,"unspecified"))
ajFmtPrintAppS(&cl," -%S",squal);
ajStrDel(&squal);
}
emira_dostrings(&cl, preftab);
emira_doinfiles(&cl, preftab);
emira_dodirectories(&cl, preftab);
emira_dobools(&cl, preftab);
emira_dointegers(&cl, preftab);
emira_dolistsingles(&cl, preftab);
ajDebug("Constructed command line: %S\n",cl);
#if 0
ajFmtPrint("%S\n",cl);
#endif
#if 1
system(ajStrGetPtr(cl));
#endif
ajStrDel(&stmp);
ajStrDel(&cl);
ajTablestrFree(&preftab);
embExit();
return 0;
}
static ajint silent_restr_read(AjPList *relist,const AjPStr enzymes)
{
EmbPPatRestrict rptr = NULL;
AjPFile fin = NULL;
AjPStr refilename = NULL;
register ajint RStotal = 0;
PRinfo rinfo = NULL;
AjBool isall = ajFalse;
ajint ne = 0;
ajint i;
AjPStr *ea = NULL;
refilename = ajStrNewC("REBASE/embossre.enz");
rptr = embPatRestrictNew();
*relist = ajListNew();
fin = ajDatafileNewInNameS(refilename);
if(!fin)
ajFatal("Aborting...restriction file '%S' not found", refilename);
/* Parse the user-selected enzyme list */
if(!enzymes)
isall = ajTrue;
else
{
ne = ajArrCommaList(enzymes,&ea);
for(i=0;i<ne;++i)
ajStrRemoveWhite(&ea[i]);
if(ajStrMatchCaseC(ea[0],"all"))
isall = ajTrue;
else
isall = ajFalse;
}
while(!ajFileIsEof(fin))
{
if(!embPatRestrictReadEntry(rptr,fin))
continue;
if(!isall)
{
for(i=0;i<ne;++i)
if(ajStrMatchCaseS(ea[i],rptr->cod))
break;
if(i==ne)
continue;
}
AJNEW(rinfo);
/* reading in RE info into rinfo from EmbPPatRestrict structure */
rinfo->code = ajStrNewS(rptr->cod);
rinfo->site = ajStrNewS(rptr->pat);
rinfo->revsite = ajStrNewS(rptr->pat);
ajSeqstrReverse(&rinfo->revsite);
rinfo->ncuts = rptr->ncuts;
rinfo->cut1 = rptr->cut1;
rinfo->cut2 = rptr->cut2;
rinfo->cut3 = rptr->cut3;
rinfo->cut4 = rptr->cut4;
ajListPush(*relist,(void *)rinfo);
RStotal++;
}
for(i=0;i<ne;++i)
ajStrDel(&ea[i]);
AJFREE(ea);
embPatRestrictDel(&rptr);
ajFileClose(&fin);
ajStrDel(&refilename);
return RStotal;
}
int main(int argc, char **argv)
{
const char *codons[]=
{
"TAG","TAA","TGA","GCG","GCA","GCT","GCC","TGT", /* 00-07 */
"TGC","GAT","GAC","GAA","GAG","TTT","TTC","GGT", /* 08-15 */
"GGG","GGA","GGC","CAT","CAC","ATA","ATT","ATC", /* 16-23 */
"AAA","AAG","CTA","TTA","TTG","CTT","CTC","CTG", /* 24-31 */
"ATG","AAT","AAC","CCG","CCA","CCT","CCC","CAA", /* 32-39 */
"CAG","CGT","CGA","CGC","AGG","AGA","CGG","TCG", /* 40-47 */
"TCA","AGT","TCT","TCC","AGC","ACG","ACT","ACA", /* 48-55 */
"ACC","GTA","GTT","GTC","GTG","TGG","TAT","TAC" /* 56-63 */
};
const char *aa=
"***AAAACCDDEEFFGGGGHHIIIKKLLLLLLMNNPPPPQQRRRRRRSSSSSSTTTTVVVVWYY";
AjPFile inf = NULL;
AjPFile outf = NULL;
char *entryname = NULL;
AjPStr fname = NULL;
AjPStr key = NULL;
AjPStr tmpkey = NULL;
AjBool allrecords = AJFALSE;
AjPTable table = NULL;
ajint i = 0;
ajint j = 0;
ajint k = 0;
ajint x = 0;
ajint savecount[3];
AjPStr *keyarray = NULL;
CutgPValues *valarray = NULL;
AjPCod codon = NULL;
ajint sum = 0;
char c;
AjPList flist = NULL;
AjPFile logf = NULL;
AjPStr entry = NULL;
AjPStr baseentry = NULL;
AjPStr wild = NULL;
AjPStr division = NULL;
AjPStr release = NULL;
AjPStr wildspecies = NULL;
CutgPValues value = NULL;
AjPStr docstr = NULL;
AjPStr species = NULL;
AjPStr filename = NULL;
ajint nstops;
embInit("cutgextract",argc,argv);
tmpkey = ajStrNew();
fname = ajStrNew();
table = ajTablestrNewLen(TABLE_ESTIMATE);
flist = ajAcdGetDirlist("directory");
wild = ajAcdGetString("wildspec");
release = ajAcdGetString("release");
logf = ajAcdGetOutfile("outfile");
wildspecies = ajAcdGetString("species");
filename = ajAcdGetString("filename");
allrecords = ajAcdGetBoolean("allrecords");
ajStrInsertC(&release, 0, "CUTG");
ajStrRemoveWhite(&release);
while(ajListPop(flist,(void **)&entry))
{
ajStrAssignS(&baseentry, entry);
ajFilenameTrimPath(&baseentry);
ajDebug("Testing file '%S'\n", entry);
if(!ajStrMatchWildS(baseentry,wild))
{
ajStrDel(&entry);
continue;
}
ajDebug("... matched wildcard '%S'\n", wild);
inf = ajFileNewInNameS(entry);
if(!inf)
ajFatal("cannot open file %S",entry);
ajFmtPrintS(&division, "%F", inf);
ajFilenameTrimAll(&division);
while((entryname = cutgextract_next(inf, wildspecies,
&species, &docstr)))
{
if(ajStrGetLen(filename))
ajStrAssignS(&tmpkey,filename);
else
ajStrAssignC(&tmpkey,entryname);
/* See if organism is already in the table */
value = ajTableFetch(table,tmpkey);
if(!value) /* Initialise */
{
key = ajStrNewS(tmpkey);
AJNEW0(value);
ajStrAssignS(&value->Species,species);
ajStrAssignS(&value->Division, division);
ajTablePut(table,(void *)key,(void *)value);
}
for(k=0;k<3;k++)
savecount[k] = value->Count[k];
nstops = cutgextract_readcodons(inf,allrecords, value->Count);
if(nstops < 1)
{
value->Skip++;
continue;
}
value->CdsCount++;
if(nstops>1)
{
value->CdsCount += (nstops - 1);
value->Warn++;
ajWarn("Found %d stop codons (%d %d %d) for CDS '%S'",
nstops,
value->Count[0] - savecount[0],
value->Count[1] - savecount[1],
value->Count[2] - savecount[2],
cutgextractSavepid);
}
}
ajStrDel(&entry);
ajFileClose(&inf);
}
ajTableToarrayKeysValues(table,(void***) &keyarray, (void***) &valarray);
i = 0;
while(keyarray[i])
{
key = keyarray[i];
value = (CutgPValues) valarray[i++];
codon = ajCodNew();
sum = 0;
for(j=0;j<CODONS;++j)
{
sum += value->Count[j];
x = ajCodIndexC(codons[j]);
codon->num[x] = value->Count[j];
c = aa[j];
if(c=='*')
codon->aa[x] = 27;
else
codon->aa[x] = c-'A';
}
ajCodCalcUsage(codon,sum);
ajStrAppendC(&key, ".cut");
if(allrecords)
{
if(value->Warn)
ajFmtPrintF(logf, "Writing %S CDS: %d Warnings: %d\n",
key, value->CdsCount, value->Warn);
else
ajFmtPrintF(logf, "Writing %S CDS: %d\n",
key, value->CdsCount);
}
else
{
if(value->Skip)
ajFmtPrintF(logf, "Writing %S CDS: %d Skipped: %d\n",
key, value->CdsCount, value->Skip);
else
ajFmtPrintF(logf, "Writing %S CDS: %d\n",
key, value->CdsCount);
}
ajFmtPrintS(&fname,"CODONS/%S",key);
outf = ajDatafileNewOutNameS(fname);
if(!outf)
ajFatal("Cannot open output file %S",fname);
ajCodSetNameS(codon, key);
ajCodSetSpeciesS(codon, value->Species);
ajCodSetDivisionS(codon, value->Division);
ajCodSetReleaseS(codon, release);
ajCodSetNumcds(codon, value->CdsCount);
ajCodSetNumcodons(codon, sum);
ajCodWrite(codon, outf);
ajFileClose(&outf);
ajStrDel(&key);
ajStrDel(&value->Division);
ajStrDel(&value->Doc);
ajStrDel(&value->Species);
AJFREE(value);
ajCodDel(&codon);
}
AJFREE(keyarray);
AJFREE(valarray);
ajTableFree(&table);
ajListFree(&flist);
ajStrDel(&wild);
ajStrDel(&release);
ajStrDel(&wildspecies);
ajStrDel(&filename);
ajFileClose(&logf);
ajStrDel(&cutgextractSavepid);
ajStrDel(&cutgextractLine);
ajStrDel(&cutgextractOrg);
ajStrDel(&fname);
ajStrDel(&tmpkey);
ajStrDel(&species);
ajStrDel(&docstr);
ajStrDel(&division);
ajStrDel(&baseentry);
embExit();
return 0;
}
int main(int argc, char **argv)
{
/* Variable declarations */
AjPOutfile outfile = NULL;
AjPStr* ranks = NULL;
AjBool hidden = ajFalse;
AjPTax tax = NULL;
AjPTax taxparent = NULL;
AjPTaxall taxall = NULL;
AjPTaxin taxinparent = NULL;
AjPStr taxqryup = NULL;
AjPTable foundtable = NULL;
const AjPStr taxrank = NULL;
ajuint up;
AjPList uplist = NULL;
ajuint i;
/* ACD processing */
embInit("taxgetrank", argc, argv);
taxall = ajAcdGetTaxonall("taxons");
ranks = ajAcdGetList("rank");
outfile = ajAcdGetOuttaxon("outfile");
hidden = ajAcdGetBoolean("hidden");
for(i=0; ranks[i]; i++)
{
ajStrExchangeKK(&ranks[i], '_', ' ');
}
taxinparent = ajTaxinNew();
taxparent = ajTaxNew();
uplist = ajListNew();
foundtable = ajTablestrNew(600);
while(ajTaxallNext(taxall, &tax))
{
up = ajTaxGetParent(tax);
while (up > 1)
{
ajFmtPrintS(&taxqryup, "%S-id:%u", ajTaxGetDb(tax), up);
ajTaxinQryS(taxinparent, taxqryup);
if(!ajTaxinRead(taxinparent, taxparent))
break;
if(hidden || !ajTaxIsHidden(taxparent))
{
taxrank = ajTaxGetRank(taxparent);
for(i=0; ranks[i]; i++)
{
if(ajStrMatchS(taxrank, ranks[i]))
{
if(!ajTableMatchS(foundtable, taxparent->Id))
{
ajTaxoutWrite(outfile, taxparent);
ajTablePut(foundtable,
ajStrNewS(taxparent->Id),
(void *) 1);
}
}
}
}
up = ajTaxGetParent(taxparent);
}
}
/* Memory clean-up and exit */
ajTaxallDel(&taxall);
ajTaxinDel(&taxinparent);
ajTaxDel(&tax);
ajTaxDel(&taxparent);
ajListFree(&uplist);
ajTablestrFreeKey(&foundtable);
ajStrDel(&taxqryup);
ajStrDelarray(&ranks);
ajOutfileClose(&outfile);
embExit();
return 0;
}
int main(int argc, char **argv)
{
/* Variable declarations */
AjPStr query;
AjPOutfile outfile = NULL;
AjPResource resource = NULL;
AjPResourcein resourcein = NULL;
AjPOboin oboin = NULL;
AjPObo obo = NULL;
AjPStr oboqry = NULL;
AjPStr resourceqry = NULL;
AjPStr qrystr = NULL;
AjPTable obotable = NULL;
AjPTable foundtable = NULL;
AjBool subclasses = ajFalse;
AjPStrTok handle = NULL;
AjPList obolist = NULL;
AjPObo obotest = NULL;
ajuint i;
ajuint imax = 3;
const char* fields[] = {"id", "acc", "nam", "des"};
/* ACD processing */
embInit("drfindid", argc, argv);
query = ajAcdGetString("query");
outfile = ajAcdGetOutresource("outfile");
/* sensitive = ajAcdGetBoolean("sensitive"); */
subclasses = ajAcdGetBoolean("subclasses");
resourcein = ajResourceinNew();
resource = ajResourceNew();
oboin = ajOboinNew();
obo = ajOboNew();
obolist = ajListNew();
obotable = ajTablestrNew(600);
foundtable = ajTablestrNew(600);
handle = ajStrTokenNewC(query, ",");
while(ajStrTokenNextParse(&handle, &qrystr))
{
for(i=0; i<imax; i++)
{
ajFmtPrintS(&oboqry, "edam-%s:%S", fields[i], qrystr);
ajOboinQryS(oboin, oboqry);
while(ajOboinRead(oboin, obo))
{
ajListPushAppend(obolist, ajOboNewObo(obo));
if(subclasses)
ajOboGetTree(obo, obolist);
ajDebug("%S '%S' %u\n",
qrystr, obo->Id, ajListGetLength(obolist));
while(ajListGetLength(obolist))
{
ajListPop(obolist, (void**) &obotest);
if(!ajTableMatchS(obotable, obotest->Id))
{
ajDebug("edam %s '%S' namespace '%S' name '%S'\n",
fields[i], obotest->Id, obotest->Namespace,
obotest->Name);
ajTablePut(obotable, ajStrNewS(obotest->Id),
(void *) 1);
ajFmtPrintS(&resourceqry, "drcat-eid:%S",
ajOboGetId(obotest));
ajResourceinQryS(resourcein, resourceqry);
while(ajResourceinRead(resourcein, resource))
{
if(!ajTableMatchS(foundtable, resource->Id))
{
ajDebug("drcat id '%S' category '%S'\n",
resource->Id, resource->Cat);
ajResourceoutWrite(outfile, resource);
ajTablePut(foundtable, ajStrNewS(resource->Id),
(void *) 1);
}
}
}
ajOboDel(&obotest);
}
}
}
}
/* Memory clean-up and exit */
ajOboDel(&obo);
ajOboinDel(&oboin);
ajResourceDel(&resource);
ajResourceinDel(&resourcein);
ajListFree(&obolist);
ajStrTokenDel(&handle);
ajStrDel(&qrystr);
ajStrDel(&query);
ajStrDel(&oboqry);
ajStrDel(&resourceqry);
ajTablestrFreeKey(&obotable);
ajTablestrFreeKey(&foundtable);
ajOutfileClose(&outfile);
embExit();
return 0;
}
static CachePNode cacheNodeNew(const EnsPCache cache, void* key, void* value)
{
ajuint *Puintkey = NULL;
CachePNode node = NULL;
if(!cache)
return NULL;
if(!key)
return NULL;
if(!value)
return NULL;
AJNEW0(node);
/* Add the size of the Ensembl Cache Node itself. */
node->Bytes += (ajuint) sizeof (CacheONode);
switch(cache->Type)
{
case ensECacheTypeNumeric:
/* Reference AJAX unsigned integer key data. */
AJNEW0(Puintkey);
*Puintkey = *((ajuint *) key);
node->Key = (void *) Puintkey;
/* Add the size of unsigned integer key data. */
node->Bytes += (ajuint) sizeof (ajuint);
break;
case ensECacheTypeAlphaNumeric:
/* Reference AJAX String key data. */
node->Key = (void *) ajStrNewS((AjPStr) key);
/* Add the size of AJAX String key data. */
node->Bytes += (ajuint) sizeof (AjOStr);
node->Bytes += ajStrGetRes((AjPStr) node->Key);
break;
default:
ajWarn("cacheNodeNew got unexpected Cache type %d.\n",
cache->Type);
}
/* Reference the value data. */
if(cache->Reference && value)
node->Value = (*cache->Reference)(value);
/* Calculate the size of the value data. */
if(cache->Size && node->Value)
node->Bytes += (*cache->Size)(node->Value);
node->Dirty = ajFalse;
return node;
}
int main(int argc, char **argv)
{
/* Variable declarations */
AjPOutfile outfile = NULL;
AjPOboall oboall = NULL;
AjBool subclasses = ajFalse;
AjBool obsolete = ajFalse;
AjPObo obo = NULL;
AjPObo obotest = NULL;
AjPList obolist = ajListNew();
AjPTable foundtable = NULL;
ajuint ifound = 0;
ajuint ikeep = 0;
/* ACD processing */
embInit("ontoget", argc, argv);
oboall = ajAcdGetOboall("oboterms");
outfile = ajAcdGetOutobo("outfile");
subclasses = ajAcdGetBoolean("subclasses");
obsolete = ajAcdGetBoolean("obsolete");
foundtable = ajTablestrNew(600);
while(ajOboallNext(oboall, &obo))
{
ajListPushAppend(obolist, ajOboNewObo(obo));
if(subclasses)
ajOboGetTree(obo, obolist);
while(ajListGetLength(obolist))
{
ajListPop(obolist, (void**) &obotest);
if(!obsolete && ajOboIsObsolete(obotest))
{
ajOboDel(&obotest);
continue;
}
ifound++;
if(!ajTableMatchS(foundtable, obotest->Id))
{
ajObooutWrite(outfile, obotest);
ajTablePut(foundtable, ajStrNewS(obotest->Id),
(void *) 1);
ikeep++;
}
ajOboDel(&obotest);
}
}
if(!ifound)
ajErr("No matching terms");
/* Memory clean-up and exit */
ajListFree(&obolist);
ajOboallDel(&oboall);
ajOboDel(&obo);
ajOutfileClose(&outfile);
ajTablestrFreeKey(&foundtable);
embExit();
return 0;
}
static PSilent silent_checktrans(const AjPStr seq,const EmbPMatMatch match,
const PRinfo rlp, ajint begin, ajint radj,
AjBool rev, ajint end)
{
PSilent ret;
const char *p = NULL;
const char *q = NULL;
const char *s = NULL;
char *t;
const char *u;
ajint matchpos;
ajint framep;
ajint count;
AjPTrn table = NULL;
AjPStr s1 = NULL;
AjPStr s2 = NULL;
char c;
char rc;
ajint min = INT_MAX; /* Reverse sense intentional! */
ajint max = -INT_MAX;
ajint fpos;
ajint rpos;
ajint x;
AjPStr tstr = NULL;
matchpos = match->start;
fpos = matchpos;
rpos=radj-fpos-match->len;
tstr = ajStrNewS(seq);
t = ajStrGetuniquePtr(&tstr);
p = t+fpos-(begin+1);
u = q = ajStrGetPtr(rlp->site);
/* Test here for whether cut site is within sequence substring */
if(rlp->ncuts==4)
{
min = AJMIN(rlp->cut1,rlp->cut2);
max = AJMAX(rlp->cut3,rlp->cut4);
}
else if(rlp->ncuts==2)
{
min = AJMIN(rlp->cut1,rlp->cut2);
max = AJMAX(rlp->cut1,rlp->cut2);
}
else
{
ajWarn("Possibly corrupt RE file");
ajStrDel(&tstr);
return NULL;
}
if(!rev) /* forward strand */
{
if(matchpos+min<0||matchpos+max>end+1)
{
/*Cut site not in sequence range*/
ajStrDel(&tstr);
return NULL;
}
}
else /* reverse strand */
{
if(radj-matchpos-1-min>end+1||radj-matchpos-1-max<begin)
{
/*Cut site not in sequence range*/
ajStrDel(&tstr);
return NULL;
}
}
count=0;
while(ajBaseAlphaToBin(*q++) & ajBaseAlphaToBin(*p++))
++count;
/* Changed base postion */
x = fpos+count-(begin+1);
/* Where the frame starts on the reverse strand */
framep = (end-begin+1)%3;
c = t[x];
rc = u[count];
if(!rev) /* forward strand */
s = t+x-x%3;
else /* reverse strand */
s = t+x-(x-framep)%3;
table = ajTrnNewI(0);
/* translates codon pointed to by s (original seq) */
s1 = ajStrNewK(ajTrnCodonC(table,s));
t[x] = rc;
/* translates codon pointed to by s (mutated base from RS pattern */
s2 = ajStrNewK(ajTrnCodonC(table,s));
t[x] = c; /* changes mutated base in seq back to original base */
AJNEW(ret);
ret->obase = c;
ret->nbase = rc;
ret->code = ajStrNewC(ajStrGetPtr(rlp->code));
ret->site = ajStrNewC(ajStrGetPtr(rlp->site));
ret->seqaa = ajStrNewC(ajStrGetPtr(s1));
ret->reaa = ajStrNewC(ajStrGetPtr(s2));
if(ajStrMatchS(s1,s2))
ret->issilent = ajTrue;
else
ret->issilent = ajFalse;
if(!rev)
{
ret->match = matchpos;
ret->base = matchpos+count;
}
else
{
ret->match = rpos;
ret->base = rpos+match->len-1-count;
}
ajStrDel(&tstr);
ajStrDel(&s1);
ajStrDel(&s2);
ajTrnDel(&table);
return ret;
}
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("gcgr", argc, argv, "GEMBASSY", "1.0.1");
struct soap soap;
struct ns1__cgrInputParams params;
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr seqid = NULL;
ajint width = 0;
AjPFile outf = NULL;
AjPStr filename = NULL;
AjPStr outfname = NULL;
AjPStr format = NULL;
ajint i;
char *in0;
char *result;
seqall = ajAcdGetSeqall("sequence");
width = ajAcdGetInt("width");
filename = ajAcdGetString("goutfile");
format = ajAcdGetString("format");
params.width = width;
i = 0;
while(ajSeqallNext(seqall, &seq))
{
soap_init(&soap);
inseq = NULL;
ajStrAppendC(&inseq, ">");
ajStrAppendS(&inseq, ajSeqGetAccS(seq));
ajStrAppendC(&inseq, "\n");
ajStrAppendS(&inseq, ajSeqGetSeqS(seq));
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
in0 = ajCharNewS(inseq);
if(soap_call_ns1__cgr(
&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, "png"))
{
if(!gHttpConvertC(result, &outf, ajStrNewC("png"), 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(&filename);
embExit();
}
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;
}
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;
}
int main(int argc, char **argv)
{
AjPSeqall seqall = NULL;
AjPFile dend_outfile = NULL;
AjPStr tmp_dendfilename = NULL;
AjPFile tmp_dendfile = NULL;
AjPStr tmp_aln_outfile = NULL;
AjPSeqset seqset = NULL;
AjPSeqout seqout = NULL;
AjPSeqin seqin = NULL;
AjBool only_dend;
AjBool are_prot = ajFalse;
AjBool do_slow;
AjBool use_dend;
AjPFile dend_file = NULL;
AjPStr dend_filename = NULL;
ajint ktup;
ajint gapw;
ajint topdiags;
ajint window;
AjBool nopercent;
AjPStr pw_matrix = NULL;
AjPStr pw_dna_matrix = NULL;
AjPFile pairwise_matrix = NULL;
float pw_gapc;
float pw_gapv;
AjPStr pwmstr = NULL;
char pwmc = '\0';
AjPStr pwdstr = NULL;
char pwdc = '\0';
AjPStr m1str = NULL;
AjPStr m2str = NULL;
char m1c = '\0';
char m2c = '\0';
AjPStr matrix = NULL;
AjPStr dna_matrix = NULL;
AjPFile ma_matrix = NULL;
float gapc;
float gapv;
AjBool endgaps;
AjBool norgap;
AjBool nohgap;
ajint gap_dist;
ajint maxdiv;
AjPStr hgapres = NULL;
AjPSeqout fil_file = NULL;
AjPSeq seq = NULL;
AjPStr cmd = NULL;
AjPStr tmp = NULL;
AjPStr tmpFilename;
AjPStr line = NULL;
ajint nb = 0;
/* get all the parameters */
embInit("emma", argc, argv);
pwmstr = ajStrNew();
pwdstr = ajStrNew();
m1str = ajStrNew();
m2str = ajStrNew();
seqall = ajAcdGetSeqall("sequence");
seqout = ajAcdGetSeqoutset("outseq");
dend_outfile = ajAcdGetOutfile("dendoutfile");
only_dend = ajAcdGetToggle("onlydend");
use_dend = ajAcdGetToggle("dendreuse");
dend_file = ajAcdGetInfile("dendfile");
if (dend_file)
ajStrAssignS(&dend_filename, ajFileGetPrintnameS(dend_file));
ajFileClose(&dend_file);
do_slow = ajAcdGetToggle("slowalign");
ktup = ajAcdGetInt("ktup");
gapw = ajAcdGetInt("gapw");
topdiags = ajAcdGetInt("topdiags");
window = ajAcdGetInt("window");
nopercent = ajAcdGetBoolean("nopercent");
pw_matrix = ajAcdGetListSingle("pwmatrix");
pwmc = ajStrGetCharFirst(pw_matrix);
if(pwmc=='b')
ajStrAssignC(&pwmstr,"blosum");
else if(pwmc=='p')
ajStrAssignC(&pwmstr,"pam");
else if(pwmc=='g')
ajStrAssignC(&pwmstr,"gonnet");
else if(pwmc=='i')
ajStrAssignC(&pwmstr,"id");
else if(pwmc=='o')
ajStrAssignC(&pwmstr,"own");
pw_dna_matrix = ajAcdGetListSingle("pwdnamatrix");
pwdc = ajStrGetCharFirst(pw_dna_matrix);
if(pwdc=='i')
ajStrAssignC(&pwdstr,"iub");
else if(pwdc=='c')
ajStrAssignC(&pwdstr,"clustalw");
else if(pwdc=='o')
ajStrAssignC(&pwdstr,"own");
pairwise_matrix = ajAcdGetInfile("pairwisedatafile");
pw_gapc = ajAcdGetFloat( "pwgapopen");
pw_gapv = ajAcdGetFloat( "pwgapextend");
matrix = ajAcdGetListSingle( "matrix");
m1c = ajStrGetCharFirst(matrix);
if(m1c=='b')
ajStrAssignC(&m1str,"blosum");
else if(m1c=='p')
ajStrAssignC(&m1str,"pam");
else if(m1c=='g')
ajStrAssignC(&m1str,"gonnet");
else if(m1c=='i')
ajStrAssignC(&m1str,"id");
else if(m1c=='o')
ajStrAssignC(&m1str,"own");
dna_matrix = ajAcdGetListSingle( "dnamatrix");
m2c = ajStrGetCharFirst(dna_matrix);
if(m2c=='i')
ajStrAssignC(&m2str,"iub");
else if(m2c=='c')
ajStrAssignC(&m2str,"clustalw");
else if(m2c=='o')
ajStrAssignC(&m2str,"own");
ma_matrix = ajAcdGetInfile("mamatrixfile");
gapc = ajAcdGetFloat("gapopen");
gapv = ajAcdGetFloat("gapextend");
endgaps = ajAcdGetBoolean("endgaps");
norgap = ajAcdGetBoolean("norgap");
nohgap = ajAcdGetBoolean("nohgap");
gap_dist = ajAcdGetInt("gapdist");
hgapres = ajAcdGetString("hgapres");
maxdiv = ajAcdGetInt("maxdiv");
tmp = ajStrNewC("fasta");
/*
** Start by writing sequences into a unique temporary file
** get file pointer to unique file
*/
fil_file = ajSeqoutNew();
tmpFilename = emma_getUniqueFileName();
if(!ajSeqoutOpenFilename( fil_file, tmpFilename))
embExitBad();
/* Set output format to fasta */
ajSeqoutSetFormatS( fil_file, tmp);
while(ajSeqallNext(seqall, &seq))
{
/*
** Check sequences are all of the same type
** Still to be done
** Write out sequences
*/
if (!nb)
are_prot = ajSeqIsProt(seq);
ajSeqoutWriteSeq(fil_file, seq);
++nb;
}
ajSeqoutClose(fil_file);
if(nb < 2)
ajFatal("Multiple alignments need at least two sequences");
/* Generate clustalw command line */
cmd = ajStrNewS(ajAcdGetpathC("clustalw"));
/* add tmp file containing sequences */
ajStrAppendC(&cmd, " -infile=");
ajStrAppendS(&cmd, tmpFilename);
/* add out file name */
tmp_aln_outfile = emma_getUniqueFileName();
ajStrAppendC(&cmd, " -outfile=");
ajStrAppendS(&cmd, tmp_aln_outfile);
/* calculating just the nj tree or doing full alignment */
if(only_dend)
ajStrAppendC(&cmd, " -tree");
else
if(!use_dend)
ajStrAppendC(&cmd, " -align");
/* Set sequence type from information from acd file */
if(are_prot)
ajStrAppendC(&cmd, " -type=protein");
else
ajStrAppendC(&cmd, " -type=dna");
/*
** set output to MSF format - will read in this file later and output
** user requested format
*/
ajStrAppendC(&cmd, " -output=");
ajStrAppendC(&cmd, "gcg");
/* If going to do pairwise alignment */
if(!use_dend)
{
/* add fast pairwise alignments*/
if(!do_slow)
{
ajStrAppendC(&cmd, " -quicktree");
ajStrAppendC(&cmd, " -ktuple=");
ajStrFromInt(&tmp, ktup);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -window=");
ajStrFromInt(&tmp, window);
ajStrAppendS(&cmd, tmp);
if(nopercent)
ajStrAppendC(&cmd, " -score=percent");
else
ajStrAppendC(&cmd, " -score=absolute");
ajStrAppendC(&cmd, " -topdiags=");
ajStrFromInt(&tmp, topdiags);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -pairgap=");
ajStrFromInt(&tmp, gapw);
ajStrAppendS(&cmd, tmp);
}
else
{
if(pairwise_matrix)
{
if(are_prot)
ajStrAppendC(&cmd, " -pwmatrix=");
else
ajStrAppendC(&cmd, " -pwdnamatrix=");
ajStrAppendS(&cmd, ajFileGetPrintnameS(pairwise_matrix));
}
else
{
if(are_prot)
{
ajStrAppendC(&cmd, " -pwmatrix=");
ajStrAppendS(&cmd, pwmstr);
}
else
{
ajStrAppendC(&cmd, " -pwdnamatrix=");
ajStrAppendS(&cmd, pwdstr);
}
}
ajStrAppendC(&cmd, " -pwgapopen=");
ajStrFromFloat(&tmp, pw_gapc, 3);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -pwgapext=");
ajStrFromFloat(&tmp, pw_gapv, 3);
ajStrAppendS(&cmd, tmp);
}
}
/* Multiple alignments */
/* using existing tree or generating new tree? */
if(use_dend)
{
ajStrAppendC(&cmd, " -usetree=");
ajStrAppendS(&cmd, dend_filename);
}
else
{
/* use tmp file to hold dend file, will read back in later */
tmp_dendfilename = emma_getUniqueFileName();
ajStrAppendC(&cmd, " -newtree=");
ajStrAppendS(&cmd, tmp_dendfilename);
}
if(ma_matrix)
{
if(are_prot)
ajStrAppendC(&cmd, " -matrix=");
else
ajStrAppendC(&cmd, " -pwmatrix=");
ajStrAppendS(&cmd, ajFileGetPrintnameS(ma_matrix));
}
else
{
if(are_prot)
{
ajStrAppendC(&cmd, " -matrix=");
ajStrAppendS(&cmd, m1str);
}
else
{
ajStrAppendC(&cmd, " -dnamatrix=");
ajStrAppendS(&cmd, m2str);
}
}
ajStrAppendC(&cmd, " -gapopen=");
ajStrFromFloat(&tmp, gapc, 3);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -gapext=");
ajStrFromFloat(&tmp, gapv, 3);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -gapdist=");
ajStrFromInt(&tmp, gap_dist);
ajStrAppendS(&cmd, tmp);
ajStrAppendC(&cmd, " -hgapresidues=");
ajStrAppendS(&cmd, hgapres);
if(!endgaps)
ajStrAppendC(&cmd, " -endgaps");
if(norgap)
ajStrAppendC(&cmd, " -nopgap");
if(nohgap)
ajStrAppendC(&cmd, " -nohgap");
ajStrAppendC(&cmd, " -maxdiv=");
ajStrFromInt(&tmp, maxdiv);
ajStrAppendS(&cmd, tmp);
/* run clustalw */
/* ajFmtError("..%s..\n\n", ajStrGetPtr( cmd)); */
ajDebug("Executing '%S'\n", cmd);
ajSysExecS(cmd);
/* produce alignment file only if one was produced */
if(!only_dend)
{
/* read in tmp alignment output file to output through EMBOSS output */
seqin = ajSeqinNew();
/*
** add the Usa format to the start of the filename to tell EMBOSS
** format of file
*/
ajStrInsertC(&tmp_aln_outfile, 0, "msf::");
ajSeqinUsa(&seqin, tmp_aln_outfile);
seqset = ajSeqsetNew();
if(ajSeqsetRead(seqset, seqin))
{
ajSeqoutWriteSet(seqout, seqset);
ajSeqoutClose(seqout);
ajSeqinDel(&seqin);
/* remove the Usa from the start of the string */
ajStrCutStart(&tmp_aln_outfile, 5);
}
else
ajFmtError("Problem writing out EMBOSS alignment file\n");
}
/* read in new tmp dend file (if produced) to output through EMBOSS */
if(tmp_dendfilename!=NULL)
{
tmp_dendfile = ajFileNewInNameS( tmp_dendfilename);
if(tmp_dendfile!=NULL){
while(ajReadlineTrim(tmp_dendfile, &line))
ajFmtPrintF(dend_outfile, "%s\n", ajStrGetPtr( line));
ajFileClose(&tmp_dendfile);
ajSysFileUnlinkS(tmp_dendfilename);
}
}
ajSysFileUnlinkS(tmpFilename);
if(!only_dend)
ajSysFileUnlinkS(tmp_aln_outfile);
ajStrDel(&pw_matrix);
ajStrDel(&matrix);
ajStrDel(&pw_dna_matrix);
ajStrDel(&dna_matrix);
ajStrDel(&tmp_dendfilename);
ajStrDel(&dend_filename);
ajStrDel(&tmp_aln_outfile);
ajStrDel(&pwmstr);
ajStrDel(&pwdstr);
ajStrDel(&m1str);
ajStrDel(&m2str);
ajStrDel(&hgapres);
ajStrDel(&cmd);
ajStrDel(&tmp);
ajStrDel(&tmpFilename);
ajStrDel(&line);
ajFileClose(&dend_outfile);
ajFileClose(&tmp_dendfile);
ajFileClose(&dend_file);
ajFileClose(&pairwise_matrix);
ajFileClose(&ma_matrix);
ajSeqallDel(&seqall);
ajSeqsetDel(&seqset);
ajSeqDel(&seq);
ajSeqoutDel(&seqout);
ajSeqoutDel(&fil_file);
ajSeqinDel(&seqin);
embExit();
return 0;
}
static AjBool assemoutWriteSamAlignment(AjPFile outf, const AjPAssemRead r,
AjPAssemContig const * contigs,
ajint ncontigs)
{
AjPAssemTag t = NULL;
AjIList l = NULL;
AjPStr qualstr = NULL;
AjPStr tmp = NULL;
ajint POS = 0;
AjPStr CIGAR = NULL;
const char* RNEXT = NULL;
AjPStr SEQ = NULL;
AjPStr QUAL = NULL;
AjPStr SEQunpadded = NULL;
AjPStr QUALunpadded = NULL;
AjPStr consensus = NULL;
AjBool rc= ajFalse;
AjBool ret = ajTrue;
const char* refseq = NULL;
const AjPAssemContig contig = NULL;
ajuint k = 0;
if(r->Reference>=ncontigs)
ajDie("assemoutWriteSamAlignment: reference sequence number"
" '%d' is larger than or equal to known number of reference"
" sequences '%d'. Problem while processing read '%S'.",
r->Reference,
ncontigs,
r->Name);
contig = (r->Reference==-1 ? NULL : contigs[r->Reference]);
ajStrAssignRef(&SEQ, r->Seq);
consensus = contig==NULL? NULL : contig->Consensus;
if (r->Rnext==-1)
RNEXT= "*";
else if(r->Rnext==r->Reference)
RNEXT = "=";
else
RNEXT = ajStrGetPtr(contigs[r->Rnext]->Name);
if (r->Flag & BAM_FREVERSE)
{
rc = ajTrue;
qualstr = ajStrNewS(r->SeqQ);
if(!r->Reversed)
{
ajStrReverse(&qualstr);
ajSeqstrReverse(&SEQ);
}
QUAL = qualstr;
POS = r->y1;
ajStrAssignSubS(&tmp, SEQ,
ajStrGetLen(r->Seq) - r->y2,
ajStrGetLen(r->Seq) - r->x2
);
}
else
{
rc= ajFalse;
POS = r->x1;
QUAL = r->SeqQ;
ajStrAssignSubS(&tmp, SEQ,
r->x2-1,
r->y2-1
);
}
if(r->Cigar==NULL && consensus)
{
refseq = ajStrGetPtr(consensus) + (rc ? r->y1-1 : r->x1-1);
CIGAR = assemoutMakeCigar(refseq, ajStrGetPtr(tmp));
SEQunpadded = ajStrNewRes(ajStrGetLen(SEQ));
QUALunpadded = ajStrNewRes(ajStrGetLen(SEQ));
for(k=0; k< ajStrGetLen(SEQ); k++)
{
if (ajStrGetCharPos(SEQ, k) == '*')
continue;
ajStrAppendK(&SEQunpadded, ajStrGetCharPos(SEQ, k));
ajStrAppendK(&QUALunpadded, ajStrGetCharPos(QUAL, k));
}
ajDebug("cigar: %S\n", CIGAR);
ajStrAssignS(&tmp, CIGAR);
if(rc)
{
if(r->y2 < (ajint)ajStrGetLen(SEQ))
ajFmtPrintS(&CIGAR, "%dS%S",
ajStrGetLen(SEQ) - r->y2, tmp);
if(r->x2 > 1)
ajFmtPrintAppS(&CIGAR, "%dS", r->x2 - 1);
}
else
{
if(r->x2 > 1)
ajFmtPrintS(&CIGAR, "%dS%S", r->x2 - 1, tmp);
if(r->y2 < (ajint)ajStrGetLen(SEQ))
ajFmtPrintAppS(&CIGAR, "%dS",
ajStrGetLen(SEQ) - r->y2);
}
ajStrDel(&tmp);
}
else if(r->Cigar==NULL)
{
ajErr("both CIGAR string and consensus sequence not available");
ret = ajFalse;
ajStrAssignK(&CIGAR, '*');
}
else if(!ajStrGetLen(r->Cigar))
ajStrAssignK(&CIGAR, '*');
else if(ajStrGetLen(r->Cigar))
{
if(!ajStrGetLen(SEQ))
ajStrAssignK(&SEQ, '*');
if(!ajStrGetLen(QUAL))
ajStrAssignK(&QUAL, '*');
}
ajStrDel(&tmp);
ajFmtPrintF(outf, "%S\t%d\t%s\t%d\t%d\t%S\t%s\t%Ld\t%d\t%S\t%S",
r->Name,
r->Flag,
(contig==NULL ? "*" : ajStrGetPtr(contig->Name)),
POS,
r->MapQ,
(CIGAR ? CIGAR : r->Cigar),
RNEXT,
r->Pnext,
r->Tlen,
(r->Cigar ? SEQ : SEQunpadded),
(r->Cigar ? QUAL : QUALunpadded));
l = ajListIterNewread(r->Tags);
while (!ajListIterDone(l))
{
t = ajListIterGet(l);
/* TODO: array type, 'B' */
/* In SAM, all single integer types are mapped to int32_t [SAM spec] */
ajFmtPrintF(outf, "\t%S:%c:",
t->Name,
(t->type == 'c' || t->type == 'C' ||
t->type == 's' || t->type == 'S'
|| t->type == 'I') ? 'i' : t->type
);
if(t->x1 || t->y1)
ajFmtPrintF(outf, " %u %u", t->x1, t->y1);
if(t->Comment && ajStrGetLen(t->Comment)>0)
ajFmtPrintF(outf, "%S", t->Comment);
}
ajListIterDel(&l);
ajFmtPrintF(outf, "\n");
if(qualstr)
ajStrDel(&qualstr);
ajStrDel(&SEQ);
ajStrDel(&CIGAR);
ajStrDel(&SEQunpadded);
ajStrDel(&QUALunpadded);
return ret;
}
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[])
{
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[])
{
embInitPV("gbaseinformationcontent", argc, argv, "GEMBASSY", "1.0.1");
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
AjPStr position = 0;
ajint PatLen = 0;
ajint upstream = 0;
ajint downstream = 0;
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");
position = ajAcdGetSelectSingle("position");
PatLen = ajAcdGetInt("patlen");
upstream = ajAcdGetInt("upstream");
downstream = ajAcdGetInt("downstream");
accid = ajAcdGetBoolean("accid");
plot = ajAcdGetToggle("plot");
outf = ajAcdGetOutfile("outfile");
mult = ajAcdGetGraphxy("graph");
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;
}
}
if(accid)
{
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(!ajStrGetLen(seqid))
{
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
}
if(!ajStrGetLen(seqid))
{
ajFmtError("No valid header information\n");
embExitBad();
}
ajStrAssignS(&restid, seqid);
}
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
url = ajStrNew();
ajFmtPrintS(&url, "http://%S/%S/base_information_content/position=%S/"
"PatLen=%d/upstream=%d/downstream=%d/output=f/tag=gene",
base, restid, position, PatLen, upstream, downstream);
if(plot)
{
title = ajStrNew();
ajStrAppendC(&title, argv[0]);
ajStrAppendC(&title, " of ");
ajStrAppendS(&title, seqid);
gpp.title = ajStrNewS(title);
gpp.xlab = ajStrNewC("position");
gpp.ylab = ajStrNewC("information content");
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);
}
}
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&seqid);
ajStrDel(&position);
embExit();
return 0;
}
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;
}
int main(int argc, char **argv)
{
AjPSeqset seqset = NULL;
AjPStr cl = NULL;
AjPSeqout seqout = NULL;
AjBool full = ajFalse;
AjPStr fn = NULL;
AjPStr stmp = NULL;
AjPStr outfname = NULL;
embInitPV("echlorop", argc, argv, "CBSTOOLS", VERSION);
seqset = ajAcdGetSeqset("sequence");
outfname= ajAcdGetOutfileName("outfile");
full = ajAcdGetBoolean("full");
cl = ajStrNewS(ajAcdGetpathC("chlorop"));
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(full)
ajStrAppendC(&cl," -F");
ajFmtPrintS(&stmp," %S",fn);
ajStrAppendS(&cl,stmp);
#if 0
ajFmtPrint("%S\n",cl);
#endif
#if 1
ajSysExecOutnameAppendS(cl, outfname);
#endif
ajSysFileUnlinkS(fn);
ajStrDel(&cl);
ajStrDel(&fn);
ajStrDel(&stmp);
ajSeqoutDel(&seqout);
ajSeqsetDel(&seqset);
ajStrDel(&outfname);
embExit();
return 0;
}
int main(int argc, char *argv[])
{
embInitPV("gviewcds", argc, argv, "GEMBASSY", "1.0.1");
AjPSeqall seqall;
AjPSeq seq;
AjPStr inseq = NULL;
ajint length = 0;
ajint gap = 0;
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;
AjPPStr names = NULL;
ajint i;
seqall = ajAcdGetSeqall("sequence");
length = ajAcdGetInt("length");
gap = ajAcdGetInt("gap");
accid = ajAcdGetBoolean("accid");
plot = ajAcdGetToggle("plot");
outf = ajAcdGetOutfile("outfile");
mult = ajAcdGetGraphxy("graph");
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;
}
}
if(accid)
{
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
if(!ajStrGetLen(seqid))
{
ajStrAssignS(&seqid, ajSeqGetNameS(seq));
}
if(!ajStrGetLen(seqid))
{
ajFmtError("No valid header information\n");
embExitBad();
}
ajStrAssignS(&restid, seqid);
}
ajStrAssignS(&seqid, ajSeqGetAccS(seq));
url = ajStrNew();
ajFmtPrintS(&url, "http://%S/%S/view_cds/length=%d/gap=%d/"
"output=f/tag=gene", base, restid, length, gap);
if(plot)
{
if((names = (AjPPStr)malloc(sizeof(AjPStr) * 5)) == NULL) {
ajDie("Error in memory allocation, exiting\n");
}
names[0] = NULL;
names[1] = ajStrNewC("A");
names[2] = ajStrNewC("T");
names[3] = ajStrNewC("G");
names[4] = ajStrNewC("C");
title = ajStrNew();
ajStrAppendC(&title, argv[0]);
ajStrAppendC(&title, " of ");
ajStrAppendS(&title, seqid);
gpp.title = ajStrNewS(title);
gpp.xlab = ajStrNewC("position");
gpp.ylab = ajStrNewC("percentage");
gpp.names = names;
if(!gFilebuffURLS(url, &buff))
{
ajDie("File downloading error from:\n%S\n", url);
}
if(!gPlotFilebuff(buff, mult, &gpp))
{
ajDie("Error in plotting\n");
}
i = 0;
while(names[i])
{
AJFREE(names[i]);
++i;
}
AJFREE(names);
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);
}
}
}
ajFileClose(&outf);
ajSeqallDel(&seqall);
ajSeqDel(&seq);
ajStrDel(&seqid);
embExit();
return 0;
}
