static char* messGetFilename(const char *path)
{
static char *path_copy = NULL;
const char *path_delim = SUBDIR_DELIMITER_STR;
char *result = NULL;
char *tmp;
if(path != NULL)
{
if(strcmp((path + strlen(path) - 1), path_delim) != 0)
{ /* Last char = "/" ?? */
if(path_copy != NULL)
AJFREE(path_copy);
path_copy = ajSysFuncStrdup(path);
tmp = ajSysFuncStrtok(path_copy, path_delim);
while(tmp != NULL)
{
result = tmp; /* Keep results of previous strtok */
tmp = ajSysFuncStrtok(NULL, path_delim);
}
}
}
return(result);
}
static void remap_read_equiv(AjPFile *equfile, AjPTable *table,
AjBool commercial)
{
AjPStr line;
AjPStr key;
AjPStr value;
const char *p;
line = ajStrNew();
while(ajReadlineTrim(*equfile,&line))
{
p = ajStrGetPtr(line);
if(!*p || *p=='#' || *p=='!')
continue;
p = ajSysFuncStrtok(p," \t\n");
key = ajStrNewC(p);
p = ajSysFuncStrtok(NULL," \t\n");
value = ajStrNewC(p);
if(!commercial)
ajStrTrimEndC(&value,"*");
ajTablePut(*table,(void *)key, (void *)value);
}
ajFileClose(equfile);
ajStrDel(&line);
return;
}
static void restover_read_equiv(AjPFile equfile, AjPTable table)
{
AjPStr line;
AjPStr key;
AjPStr value;
const char *p;
line = ajStrNew();
while(ajReadlineTrim(equfile,&line))
{
p=ajStrGetPtr(line);
if(!*p || *p=='#' || *p=='!')
continue;
p=ajSysFuncStrtok(p," \t\n");
key=ajStrNewC(p);
p=ajSysFuncStrtok(NULL," \t\n");
value=ajStrNewC(p);
ajTablePut(table,(void *)key, (void *)value);
}
ajStrDel(&line);
return;
}
void embIepPkRead(double *pK)
{
AjPFile inf = NULL;
AjPStr line;
const char *p;
double amino = 8.6;
double carboxyl = 3.6;
char ch;
ajint i;
inf = ajDatafileNewInNameC(PKFILE);
if(!inf)
ajFatal("%s file not found",PKFILE);
for(i=0;i<EMBIEPSIZE;++i)
pK[i]=0.0;
line = ajStrNew();
while(ajReadline(inf,&line))
{
p = ajStrGetPtr(line);
if(*p=='#' || *p=='!' || *p=='\n' || *p=='\r')
continue;
if(ajStrPrefixCaseC(line,"Amino"))
{
p = ajSysFuncStrtok(p," \t\n\r");
p = ajSysFuncStrtok(NULL," \t\n\r");
sscanf(p,"%lf",&amino);
continue;
}
if(ajStrPrefixCaseC(line,"Carboxyl"))
{
p = ajSysFuncStrtok(p," \t\n\r");
p = ajSysFuncStrtok(NULL," \t\n\r");
sscanf(p,"%lf",&carboxyl);
continue;
}
p = ajSysFuncStrtok(p," \t\n\r");
ch = ajSysCastItoc(toupper((ajint)*p));
p = ajSysFuncStrtok(NULL," \t\n\r");
sscanf(p,"%lf",&pK[ajBasecodeToInt(ch)]);
}
pK[EMBIEPAMINO] = amino;
pK[EMBIEPCARBOXYL] = carboxyl;
ajStrDel(&line);
ajFileClose(&inf);
return;
}
int main(int argc, char **argv)
{
AjPFile inf = NULL;
AjPFile inf2 = NULL;
AjPFeattable tab = NULL;
AjPReport report = NULL;
AjPSeq sequence = NULL;
AjPStr redatanew = NULL;
AjPStr str = NULL;
AjPStr regexp = NULL;
AjPStr temp = NULL;
AjPStr text = NULL;
AjPStr docdata = NULL;
AjPStr data = NULL;
AjPStr accession = NULL;
AjPStr name = NULL;
EmbPPatMatch match = NULL;
AjPStr savereg = NULL;
AjPStr fthit = NULL;
AjBool full;
AjBool prune;
ajint i;
ajint number;
ajint start;
ajint end;
ajint length;
ajint zstart;
ajint zend;
const char *p;
ajint seqlength;
AjPStr tmpstr = NULL;
AjPStr tailstr = NULL;
AjPFeature gf;
embInit("patmatmotifs", argc, argv);
ajStrAssignC(&fthit, "SO:0001067");
savereg = ajStrNew();
str = ajStrNew();
regexp = ajStrNew();
temp = ajStrNew();
data = ajStrNew();
accession = ajStrNew();
text = ajStrNew();
name = ajStrNew();
sequence = ajAcdGetSeq("sequence");
report = ajAcdGetReport("outfile");
full = ajAcdGetBoolean("full");
prune = ajAcdGetBoolean("prune");
ajSeqFmtUpper(sequence); /* prosite regexs are all upper case */
tab = ajFeattableNewSeq(sequence);
ajStrAssignC(&tailstr, "");
seqlength = ajStrGetLen(str);
str = ajSeqGetSeqCopyS(sequence);
redatanew = ajStrNewC("PROSITE/prosite.lines");
docdata = ajStrNewC("PROSITE/");
inf = ajDatafileNewInNameS(redatanew);
if(!inf)
ajFatal("Either EMBOSS_DATA undefined or PROSEXTRACT needs running");
ajFmtPrintAppS(&tmpstr, "Full: %B\n", full);
ajFmtPrintAppS(&tmpstr, "Prune: %B\n", prune);
ajFmtPrintAppS(&tmpstr, "Data_file: %F\n", inf);
ajReportSetHeaderS(report, tmpstr);
while(ajReadlineTrim(inf, ®exp))
{
p=ajStrGetPtr(regexp);
if(*p && *p!=' ' && *p!='^')
{
p=ajSysFuncStrtok(p," ");
ajStrAssignC(&name,p);
if(prune)
if(ajStrMatchCaseC(name,"myristyl") ||
ajStrMatchCaseC(name,"asn_glycosylation") ||
ajStrMatchCaseC(name,"camp_phospho_site") ||
ajStrMatchCaseC(name,"pkc_phospho_site") ||
ajStrMatchCaseC(name,"ck2_phospho_site") ||
ajStrMatchCaseC(name,"tyr_phospho_site"))
{
for(i=0;i<4;++i)
ajReadlineTrim(inf, ®exp);
continue;
}
p=ajSysFuncStrtok(NULL," ");
ajStrAssignC(&accession,p);
}
if(ajStrPrefixC(regexp, "^"))
{
p = ajStrGetPtr(regexp);
ajStrAssignC(&temp,p+1);
ajStrAssignC(&savereg,p+1);
match = embPatMatchFind(temp, str, ajFalse, ajFalse);
number = embPatMatchGetNumber(match);
for(i=0; i<number; i++)
{
seqlength = ajStrGetLen(str);
start = 1+embPatMatchGetStart(match, i);
end = 1+embPatMatchGetEnd(match, i);
length = embPatMatchGetLen(match, i);
gf = ajFeatNew(tab, NULL, fthit, start, end,
(float) length, ' ', 0);
ajFmtPrintS(&tmpstr, "*motif %S", name);
ajFeatTagAddSS(gf, NULL, tmpstr);
if(start-5<0)
zstart = 0;
else
zstart = start-5;
if(end+5> seqlength)
zend = end;
else
zend = end+5;
ajStrAssignSubS(&temp, str, zstart, zend);
}
if(full && number)
{
ajStrAssignC(&redatanew,ajStrGetPtr(docdata));
ajStrAppendC(&redatanew,ajStrGetPtr(accession));
inf2 = ajDatafileNewInNameS(redatanew);
if(!inf2)
continue;
/*
** Insert Prosite documentation from files made by
** prosextract.c
*/
ajFmtPrintAppS(&tailstr, "Motif: %S\n", name);
ajFmtPrintAppS(&tailstr, "Count: %d\n\n", number);
while(ajReadlineTrim(inf2, &text))
ajFmtPrintAppS(&tailstr, "%S\n", text);
ajFmtPrintAppS(&tailstr, "\n***************\n\n");
ajFileClose(&inf2);
}
embPatMatchDel(&match);
}
}
ajReportSetTailS(report,tailstr);
ajReportWrite(report, tab, sequence);
ajReportDel(&report);
ajFeattableDel(&tab);
ajStrDel(&temp);
ajStrDel(®exp);
ajStrDel(&savereg);
ajStrDel(&str);
ajStrDel(&data);
ajStrDel(&docdata);
ajStrDel(&text);
ajStrDel(&redatanew);
ajStrDel(&accession);
ajSeqDel(&sequence);
ajStrDel(&tailstr);
ajStrDel(&fthit);
ajStrDel(&name);
ajStrDel(&tmpstr);
ajFeattableDel(&tab);
ajFileClose(&inf);
embExit();
return 0;
}
EmbPMatPrints embMatProtReadInt(AjPFile fp)
{
EmbPMatPrints ret;
AjPStr line;
ajint i;
ajuint j;
ajuint m;
const char *p;
line = ajStrNewC("#");
p = ajStrGetPtr(line);
while(!*p || *p=='#' || *p=='!' || *p=='\n')
{
if(!ajReadlineTrim(fp,&line))
{
ajStrDel(&line);
return NULL;
}
p = ajStrGetPtr(line);
}
ajDebug("embMatProtReadint starting\n");
ajDebug ("Line: %S\n", line);
AJNEW0 (ret);
ret->cod = ajStrNew();
ajStrAssignS(&ret->cod,line);
ajReadlineTrim(fp,&line);
ret->acc = ajStrNew();
ajStrAssignS(&ret->acc,line);
ajReadlineTrim(fp,&line);
ajStrToUint(line,&ret->n);
ajReadlineTrim(fp,&line);
ret->tit = ajStrNew();
ajStrAssignS(&ret->tit,line);
ajDebug ("Lineb: %S\n", line);
AJCNEW(ret->len, ret->n);
AJCNEW(ret->max, ret->n);
AJCNEW(ret->thresh, ret->n);
AJCNEW(ret->matrix, ret->n);
for(m=0;m<ret->n;++m)
{
ajReadlineTrim(fp,&line);
ajStrToUint(line,&ret->len[m]);
ajReadlineTrim(fp,&line);
ajStrToUint(line,&ret->thresh[m]);
ajReadlineTrim(fp,&line);
ajStrToUint(line,&ret->max[m]);
ajDebug ("m: %d/%d len:%d thresh:%d max:%d\n",
m, ret->n, ret->len[m], ret->thresh[m], ret->max[m]);
for(i=0;i<26;++i)
{
AJCNEW0(ret->matrix[m][i], ret->len[m]);
ajReadlineTrim(fp,&line);
ajDebug ("Linec [%d][%d]: %S\n", m, i, line);
p = ajStrGetPtr(line);
for(j=0;j<ret->len[m];++j)
{
if(!j)
p = ajSysFuncStrtok(p," ");
else
p = ajSysFuncStrtok(NULL," ");
sscanf(p,"%u",&ret->matrix[m][i][j]);
}
}
}
ajReadlineTrim(fp,&line);
ajDebug ("Linec: %S\n", line);
ajStrDel(&line);
return ret;
}
int main(int argc, char **argv)
{
AjPFile infdat = NULL;
AjPFile infdoc = NULL;
AjPFile outf = NULL;
AjPFile outs = NULL;
AjBool haspattern;
const char *p;
AjPStr line = NULL;
AjPStr text = NULL;
AjPStr dirname = NULL;
AjPStr filename = NULL;
AjPStr id = NULL;
AjPStr ac = NULL;
AjPStr de = NULL;
AjPStr pa = NULL;
AjPStr ps = NULL;
AjPStr fn = NULL;
AjPStr re = NULL;
AjPStr fname = NULL;
AjBool flag;
AjBool isopen;
AjBool goback;
ajlong storepos = 0L;
embInit("prosextract", argc, argv);
dirname = ajAcdGetDirectoryName("prositedir");
line = ajStrNew();
text = ajStrNew();
id = ajStrNew();
ac = ajStrNew();
de = ajStrNew();
pa = ajStrNew();
ps = ajStrNew();
fn=ajStrNew();
ajStrAssignS(&fn,dirname);
ajStrAppendC(&fn,"prosite.dat");
if(!(infdat=ajFileNewInNameS(fn)))
ajFatal("Cannot open file %S",fn);
ajStrDel(&fn);
fn=ajStrNewC("PROSITE/prosite.lines");
outf = ajDatafileNewOutNameS(fn);
ajStrDel(&fn);
haspattern = ajFalse;
while(ajReadlineTrim(infdat, &line) )
{
if(ajStrPrefixC(line, "ID"))
{
if(ajStrSuffixC(line,"PATTERN."))
{
haspattern = ajTrue;
/*save id*/
p = ajStrGetPtr(line);
p = ajSysFuncStrtok(p," \t;");
p = ajSysFuncStrtok(NULL," \t;");
ajStrAssignC(&id,p);
ajFmtPrintF(outf, "%S ", id);
continue;
}
else
{
haspattern = ajFalse;
continue;
}
}
if(!haspattern)
continue;
if(ajStrPrefixC(line, "AC") )
{
p = ajStrGetPtr(line);
p = ajSysFuncStrtok(p, " \t;");
p = ajSysFuncStrtok(NULL, " \t;");
ajStrAssignC(&ac,p);
ajFmtPrintF(outf, "%S\n ", ac);
continue;
}
if(ajStrPrefixC(line, "DE") )
{
p = ajStrGetPtr(line);
p = ajSysFuncStrtok(p, " \t.");
p = ajSysFuncStrtok(NULL, " \t.");
ajStrAssignC(&de,p);
ajFmtPrintF(outf, "%S\n ", de);
continue;
}
if(ajStrPrefixC(line, "PA"))
{
ajStrAssignC(&pa,"");
while(ajStrPrefixC(line,"PA"))
{
p = ajStrGetPtr(line);
p = ajSysFuncStrtok(p, " \t.");
p = ajSysFuncStrtok(NULL, " \t.");
ajStrAppendC(&pa,p);
ajReadlineTrim(infdat, &line);
}
ajFmtPrintF(outf, "%S\n", pa);
re = embPatPrositeToRegExp(pa);
ajFmtPrintF(outf, "^%S\n\n", re);
ajStrDel(&re);
continue;
}
}
/* Finished processing prosite.dat so look at prosite.doc */
fn = ajStrNew();
ajStrAssignS(&fn,dirname);
ajStrAppendC(&fn,"prosite.doc");
if(!(infdoc=ajFileNewInNameS(fn)))
ajFatal("Cannot open file %S",fn);
ajStrDel(&fn);
fname = ajStrNewC("PROSITE/");
flag = ajFalse;
isopen = ajFalse;
goback = ajFalse;
while(ajReadlineTrim(infdoc, &text))
{
if(ajStrPrefixC(text, "{PS") && isopen && !goback)
goback = ajTrue;
if(ajStrPrefixC(text, "{PS") && !isopen)
{
storepos = ajFileResetPos(infdoc);
/* save out the documentation text to acc numbered outfiles . */
p = ajStrGetPtr(text)+1;
p = ajSysFuncStrtok(p, ";");
ajStrAssignS(&filename, fname);
ajStrAppendC(&filename, p);
outs = ajDatafileNewOutNameS(filename);
flag = ajTrue;
isopen = ajTrue;
continue;
}
if(ajStrPrefixC(text, "{BEGIN}") && flag)
{
while(ajReadlineTrim(infdoc, &text))
{
if(ajStrPrefixC(text,"{END}"))
break;
ajFmtPrintF(outs, "%S\n", text);
}
ajFileClose(&outs);
isopen = ajFalse;
if(goback)
{
goback = ajFalse;
ajFileSeek(infdoc,storepos,0);
}
}
}
ajStrDel(&line);
ajStrDel(&text);
ajStrDel(&dirname);
ajStrDel(&filename);
ajStrDel(&id);
ajStrDel(&ac);
ajStrDel(&de);
ajStrDel(&pa);
ajStrDel(&re);
ajStrDel(&ps);
ajStrDel(&fname);
ajFileClose(&infdat);
ajFileClose(&infdoc);
ajFileClose(&outf);
embExit();
return 0;
}
int main(int argc, char **argv)
{
AjPSeqall seqall;
AjPSeq seq = NULL;
AjPFile inf = NULL;
AjPStr strand = NULL;
AjPStr substr = NULL;
AjPStr name = NULL;
AjPStr mname = NULL;
AjPStr tname = NULL;
AjPStr pname = NULL;
AjPStr line = NULL;
AjPStr cons = NULL;
AjPStr m = NULL;
AjPStr n = NULL;
AjPAlign align= NULL; /* JISON, replaces AjPOutfile outf */
ajint type;
ajint begin;
ajint end;
ajulong len;
ajint i;
ajint j;
float **fmatrix=NULL;
ajint mlen;
float maxfs;
ajint thresh;
float gapopen;
float gapextend;
float opencoeff;
float extendcoeff;
const char *p;
ajulong maxarr = 1000;
ajulong alen;
float *path;
ajint *compass;
size_t stlen;
embInit("prophet", argc, argv);
seqall = ajAcdGetSeqall("sequence");
inf = ajAcdGetInfile("infile");
opencoeff = ajAcdGetFloat("gapopen");
extendcoeff = ajAcdGetFloat("gapextend");
align = ajAcdGetAlign("outfile"); /*JISON replacing outfile */
opencoeff = ajRoundFloat(opencoeff, 8);
extendcoeff = ajRoundFloat(extendcoeff, 8);
substr = ajStrNew();
name = ajStrNew();
mname = ajStrNew();
tname = ajStrNew();
line = ajStrNew();
m = ajStrNewC("");
n = ajStrNewC("");
type = prophet_getType(inf,&tname);
if(!type)
ajFatal("Unrecognised profile/matrix file format");
prophet_read_profile(inf,&pname,&mname,&mlen,&gapopen,&gapextend,&thresh,
&maxfs, &cons);
ajAlignSetMatrixName(align, mname);
AJCNEW(fmatrix, mlen);
for(i=0;i<mlen;++i)
{
AJCNEW(fmatrix[i], AZ);
if(!ajReadlineTrim(inf,&line))
ajFatal("Missing matrix line");
p = ajStrGetPtr(line);
p = ajSysFuncStrtok(p," \t");
for(j=0;j<AZ;++j)
{
sscanf(p,"%f",&fmatrix[i][j]);
p = ajSysFuncStrtok(NULL," \t");
}
}
AJCNEW(path, maxarr);
AJCNEW(compass, maxarr);
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);
len = ajStrGetLen(substr);
if(len > (ULONG_MAX/(ajulong)(mlen+1)))
ajFatal("Sequences too big. Try 'supermatcher'");
alen = len*mlen;
if(alen>maxarr)
{
stlen = (size_t) alen;
AJCRESIZE(path,stlen);
AJCRESIZE(compass,stlen);
maxarr=alen;
}
ajStrAssignC(&m,"");
ajStrAssignC(&n,"");
/* JISON used to be
prophet_scan_profile(substr,pname,name,mlen,fmatrix,
outf,cons,opencoeff,
extendcoeff,path,compass,&m,&n,len); */
/* JISON new call and reset align */
prophet_scan_profile(substr,name,pname,mlen,fmatrix,
align,cons,opencoeff,
extendcoeff,path,compass,&m,&n,(ajint)len);
ajAlignReset(align);
ajStrDel(&strand);
}
for(i=0;i<mlen;++i)
AJFREE (fmatrix[i]);
AJFREE (fmatrix);
AJFREE(path);
AJFREE(compass);
ajStrDel(&line);
ajStrDel(&cons);
ajStrDel(&name);
ajStrDel(&pname);
ajStrDel(&mname);
ajStrDel(&tname);
ajStrDel(&substr);
ajStrDel(&m);
ajStrDel(&n);
ajSeqDel(&seq);
ajFileClose(&inf);
ajAlignClose(align);
ajAlignDel(&align);
ajSeqallDel(&seqall);
embExit();
return 0;
}
static void prophet_read_profile(AjPFile inf, AjPStr *name, AjPStr *mname,
ajint *mlen, float *gapopen,
float *gapextend, ajint *thresh,
float *maxs, AjPStr *cons)
{
const char *p;
AjPStr line = NULL;
line = ajStrNew();
if(!ajReadlineTrim(inf,&line))
ajFatal("Premature EOF in profile file");
p = ajStrGetPtr(line);
if(strncmp(p,"Name",4))
ajFatal("Incorrect profile/matrix file format");
p = ajSysFuncStrtok(p," \t");
p = ajSysFuncStrtok(NULL," \t");
ajStrAssignC(name,p);
if(!ajReadlineTrim(inf,&line))
ajFatal("Premature EOF in profile file");
p = ajStrGetPtr(line);
if(strncmp(p,"Matrix",6))
ajFatal("Incorrect profile/matrix file format");
p = ajSysFuncStrtok(p," \t");
p = ajSysFuncStrtok(NULL," \t");
ajStrAssignC(mname,p);
if(!ajReadlineTrim(inf,&line))
ajFatal("Premature EOF in profile file");
p = ajStrGetPtr(line);
if(strncmp(p,"Length",6))
ajFatal("Incorrect profile/matrix file format");
sscanf(p,"%*s%d",mlen);
if(!ajReadlineTrim(inf,&line))
ajFatal("Premature EOF in profile file");
p = ajStrGetPtr(line);
if(strncmp(p,"Max_score",9))
ajFatal("Incorrect profile/matrix file format");
sscanf(p,"%*s%f",maxs);
if(!ajReadlineTrim(inf,&line))
ajFatal("Premature EOF in profile file");
p = ajStrGetPtr(line);
if(strncmp(p,"Threshold",9))
ajFatal("Incorrect profile/matrix file format");
sscanf(p,"%*s%d",thresh);
if(!ajReadlineTrim(inf,&line))
ajFatal("Premature EOF in profile file");
p = ajStrGetPtr(line);
if(strncmp(p,"Gap_open",8))
ajFatal("Incorrect profile/matrix file format");
sscanf(p,"%*s%f",gapopen);
if(!ajReadlineTrim(inf,&line))
ajFatal("Premature EOF in profile file");
p = ajStrGetPtr(line);
if(strncmp(p,"Gap_extend",10))
ajFatal("Incorrect profile/matrix file format");
sscanf(p,"%*s%f",gapextend);
if(!ajReadlineTrim(inf,&line))
ajFatal("Premature EOF in profile file");
p = ajStrGetPtr(line);
if(strncmp(p,"Consensus",9))
ajFatal("Incorrect profile/matrix file format");
p = ajSysFuncStrtok(p," \t\n");
p = ajSysFuncStrtok(NULL," \t\n");
ajStrAssignC(cons,p);
ajStrDel(&line);
return;
}
