AjPPatternSeq ajPatternSeqNewList (AjPPatlistSeq plist,
const AjPStr name, const AjPStr pat,
ajuint mismatch)
{
AjPPatternSeq pthis;
if (!ajStrGetLen(pat))
return NULL;
AJNEW0(pthis);
if(ajStrGetLen(name))
ajStrAssignS (&pthis->Name,name);
else
ajFmtPrintS(&pthis->Name, "pattern%d",
1+ajListGetLength(plist->Patlist));
ajStrAssignS(&pthis->Pattern,pat);
pthis->Protein = plist->Protein;
pthis->Mismatch = mismatch;
ajPatlistAddSeq(plist,pthis);
return pthis;
}
AjPPatternRegex ajPatternRegexNewList(AjPPatlistRegex plist,
const AjPStr name,
const AjPStr pat)
{
AjPPatternRegex pthis;
if (!ajStrGetLen(pat))
return NULL;
AJNEW0(pthis);
if(ajStrGetLen(name))
ajStrAssignS (&pthis->Name,name);
else
ajFmtPrintS(&pthis->Name, "regex%d",
1+ajListGetLength(plist->Patlist));
ajStrAssignS (&pthis->Pattern,pat);
pthis->Type = plist->Type;
pthis->Compiled = ajRegComp(pthis->Pattern);
ajPatlistAddRegex (plist,pthis);
return pthis;
}
size_t ajWritebinStr(AjPFile file, const AjPStr str, size_t len)
{
size_t ret;
ajuint ilen;
ajuint i;
ajuint j;
ajuint k;
ilen = 1+ajStrGetLen(str);
if(ilen >= len)
return fwrite(ajStrGetPtr(str), len, 1, file->fp);
ret = fwrite(ajStrGetPtr(str), ilen, 1, file->fp);
j = len - ilen;
k = 20;
for(i=0;i<j;i+=20)
{
if((j-i) < 20)
k = j-i;
fwrite("\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0", k, 1, file->fp);
}
return ret;
}
AjBool ajTimeSetS(AjPTime thys, const AjPStr timestr)
{
ajint year = 0;
ajint mon = 0;
ajint mday = 0;
ajint hour = 0;
ajint min = 0;
ajint sec = 0;
if(!thys)
return ajFalse;
if(!ajStrGetLen(timestr))
return ajFalse;
if(!ajFmtScanS(timestr, "%4d-%2d-%2d %2d:%2d:%2d",
&year, &mon, &mday, &hour, &min, &sec))
return ajFalse;
if(year > 1899)
year = year-1900;
thys->time.tm_year = year ;
thys->time.tm_mon = mon-1;
thys->time.tm_mday = mday ;
thys->time.tm_hour = hour;
thys->time.tm_min = min;
thys->time.tm_sec = sec;
thys->time.tm_isdst = -1;
mktime(&thys->time);
return ajTrue;
}
AjBool ajRegExec(AjPRegexp prog, const AjPStr str)
{
int startoffset = 0;
int options = 0;
int status = 0;
status = pcre_exec(prog->pcre, prog->extra, ajStrGetPtr(str),
ajStrGetLen(str), startoffset, options, prog->ovector,
3*prog->ovecsize);
if(status >= 0)
{
prog->orig = ajStrGetPtr(str);
if(status == 0)
ajWarn("ajRegExec too many substrings");
return ajTrue;
}
if(status < -1) /* -1 is a simple fail to match */
{ /* others are recursion limits etc. */
ajDebug("ajRegExec returned unexpected status '%d'\n", status);
prog->orig = ajStrGetPtr(str); /* needed for the trace */
ajRegTrace(prog);
}
prog->orig = NULL;
return ajFalse;
}
static void infoalign_OutputStr(AjPFile outfile, const AjPStr str, AjBool html,
AjBool after, ajuint minlength)
{
AjPStr marginfmt;
marginfmt = ajStrNewRes(10);
/* ajFmtPrintF doesn't seem to deal with formats like "%-*S" correctly */
ajFmtPrintS(&marginfmt, "%%-%dS", minlength);
if(html)
ajFmtPrintF(outfile, "<td>");
if(html || !after || minlength == NOLIMIT)
ajFmtPrintF(outfile, "%S", str);
else
/*
** Format:
** If this is the last item, don't put spaces or TABs after it.
** Try to fit the name in 'minlength' spaces, else just add a
** TAB after it
*/
ajFmtPrintF(outfile, ajStrGetPtr(marginfmt), str);
if(html)
ajFmtPrintF(outfile, "</td>\n");
else
if(after && ajStrGetLen(str) >= minlength)
ajFmtPrintF(outfile, "\t");
ajStrDel(&marginfmt);
return;
}
AjBool embPropGetProperties(const EmbPPropAmino prop, AjPStr* Pstr)
{
ajStrAssignC(Pstr, "");
if(prop->tiny)
ajStrAppendC(Pstr, "tiny,");
if(prop->sm_all)
ajStrAppendC(Pstr, "small,");
if(prop->aliphatic)
ajStrAppendC(Pstr, "aliphatic,");
if(prop->aromatic)
ajStrAppendC(Pstr, "aromatic,");
if(prop->polar)
ajStrAppendC(Pstr, "polar,");
if(prop->nonpolar)
ajStrAppendC(Pstr, "nonpolar,");
ajStrTrimEndC(Pstr, ",");
if(!ajStrGetLen(*Pstr))
return ajFalse;
return ajTrue;
}
AjBool ajAssemoutformatFind(const AjPStr format, ajint* iformat)
{
AjPStr tmpformat = NULL;
ajuint i = 0;
/* ajDebug("ajAssemoutformatFind '%S'\n", format); */
if(!ajStrGetLen(format))
return ajFalse;
ajStrAssignS(&tmpformat, format);
ajStrFmtLower(&tmpformat);
for(i=0; assemoutFormatDef[i].Name; i++)
{
/* ajDebug("test %d '%s' \n", i, assemoutFormatDef[i].Name); */
if(ajStrMatchCaseC(tmpformat, assemoutFormatDef[i].Name))
{
*iformat = i;
ajStrDel(&tmpformat);
/* ajDebug("found '%s' at %d\n", assemoutFormatDef[i].Name, i); */
return ajTrue;
}
}
ajErr("Unknown output format '%S'", format);
ajStrDel(&tmpformat);
*iformat = 0;
return ajFalse;
}
static ajint prima_primalign(const AjPStr a, const AjPStr b)
{
ajint plen;
ajint qlen;
ajint limit;
ajint i;
ajint n = 0;
ajint mm = 0;
ajint j;
const char *p;
const char *q;
ajint alen;
ajint blen;
alen = ajStrGetLen(a);
blen = ajStrGetLen(b);
if(alen > blen)
{
plen = alen;
qlen = blen;
p = ajStrGetPtr(a);
q = ajStrGetPtr(b);
}
else
{
plen = blen;
qlen = alen;
p = ajStrGetPtr(b);
q = ajStrGetPtr(a);
}
limit = plen-qlen+1;
for(i=0; i<limit; ++i)
{
for(j=0; j<qlen; ++j)
if(p[j]==q[j])
++n;
mm = AJMAX(mm, n);
++p;
}
return (ajint)(((float)mm/(float)qlen)*100.0);
}
static void silent_fmt_hits(AjPList hits, AjPFeattable feat,
AjBool silent, AjBool rev)
{
PSilent res;
AjPFeature sf = NULL;
AjPStr tmpFeatStr = NULL;
ajListSort(hits,silent_basecompare);
while(ajListPop(hits,(void **)&res))
{
if (rev)
sf = ajFeatNewIIRev(feat,
res->match, res->match+ajStrGetLen(res->site)-1);
else
sf = ajFeatNewII(feat,
res->match, res->match+ajStrGetLen(res->site)-1);
if (silent)
{
ajFmtPrintS(&tmpFeatStr, "*silent Yes");
ajFeatTagAdd (sf, NULL, tmpFeatStr);
}
ajFmtPrintS(&tmpFeatStr, "*enzyme %S", res->code);
ajFeatTagAdd (sf, NULL, tmpFeatStr);
ajFmtPrintS(&tmpFeatStr, "*rspattern %S", res->site);
ajFeatTagAdd (sf, NULL, tmpFeatStr);
ajFmtPrintS(&tmpFeatStr, "*baseposn %d", res->base);
ajFeatTagAdd (sf, NULL, tmpFeatStr);
ajFmtPrintS(&tmpFeatStr, "*aa %S.%S", res->seqaa, res->reaa);
ajFeatTagAdd (sf, NULL, tmpFeatStr);
ajFmtPrintS(&tmpFeatStr, "*mutation %c->%c", res->obase,res->nbase);
ajFeatTagAdd (sf, NULL, tmpFeatStr);
ajStrDel(&res->code);
ajStrDel(&res->site);
ajStrDel(&res->seqaa);
ajStrDel(&res->reaa);
AJFREE(res);
}
ajStrDel(&tmpFeatStr);
return;
}
static void silent_fmt_sequence(const char* title,
const AjPStr seq, AjPStr* tailstr, ajint start,
AjBool num)
{
const char *p;
ajint m;
ajint i;
ajint tlen;
ajFmtPrintAppS(tailstr,"%s:\n",title);
if(num)
{
p = ajStrGetPtr(seq);
ajFmtPrintAppS(tailstr,"%-7d",start);
tlen = ajStrGetLen(seq);
for(i=0; i<tlen ; i++)
{
ajFmtPrintAppS(tailstr,"%c",p[i]);
m=i+1;
if(m%10==0)
ajFmtPrintAppS(tailstr," ");
if(m%60==0 && m<tlen)
ajFmtPrintAppS(tailstr,"\n%-7d",(start+m+1));
}
}
else
{
p = ajStrGetPtr(seq);
tlen = ajStrGetLen(seq);
for(i=0; i<tlen ; i++)
{
ajFmtPrintAppS(tailstr,"%c",p[i]);
m=i+1;
if(m%10==0)
ajFmtPrintAppS(tailstr," ");
if(m%60==0 && m<tlen)
ajFmtPrintAppS(tailstr,"\n");
}
}
ajFmtPrintAppS(tailstr,"\n\n");
return;
}
static AjBool extractfeat_MatchPatternTags(const AjPFeature feat,
const AjPStr tpattern,
const AjPStr vpattern)
{
AjIList titer; /* iterator for feat */
AjPStr tagnam = NULL; /* tag structure */
AjPStr tagval = NULL; /* tag structure */
AjBool val = ajFalse; /* returned value */
AjBool tval; /* tags result */
AjBool vval; /* value result */
/*
** if there are no tags to match, but the patterns are
** both '*', then allow this as a match
*/
if(!ajStrCmpC(tpattern, "*") &&
!ajStrCmpC(vpattern, "*"))
return ajTrue;
/* iterate through the tags and test for match to patterns */
titer = ajFeatTagIter(feat);
while(ajFeatTagval(titer, &tagnam, &tagval))
{
tval = embMiscMatchPatternDelimC(tagnam, tpattern, ",;|");
/*
** If tag has no value then
** If vpattern is '*' the value pattern is a match
** Else check vpattern
*/
if(!ajStrGetLen(tagval))
{
if(!ajStrCmpC(vpattern, "*"))
vval = ajTrue;
else
vval = ajFalse;
}
else
vval = embMiscMatchPatternDelimC(tagval, vpattern, ",;|");
if(tval && vval)
{
val = ajTrue;
break;
}
}
ajListIterDel(&titer);
ajStrDel(&tagnam);
ajStrDel(&tagval);
return val;
}
const AjPStr ajXmlGetQryS(const AjPXml xml)
{
ajDebug("ajXmlGetQryS '%S'\n", xml->Qry);
if(ajStrGetLen(xml->Qry))
return xml->Qry;
xmlMakeQry(xml, &xmlTempQry);
return xmlTempQry;
}
const AjPStr ajResourceGetQryS(const AjPResource resource)
{
ajDebug("ajResourceGetQryS '%S'\n", resource->Qry);
if(ajStrGetLen(resource->Qry))
return resource->Qry;
resourceMakeQry(resource, &resourceTempQry);
return resourceTempQry;
}
const AjPStr ajRefseqGetQryS(const AjPRefseq refseq)
{
ajDebug("ajRefseqGetQryS '%S'\n", refseq->Qry);
if(ajStrGetLen(refseq->Qry))
return refseq->Qry;
refseqMakeQry(refseq, &refseqTempQry);
return refseqTempQry;
}
static AjBool assemoutWriteList(AjPFile outf, const AjPAssem assem)
{
if(!outf) return ajFalse;
if(!assem) return ajFalse;
if(ajStrGetLen(assem->Db))
ajFmtPrintF(outf, "%S:%S\n", assem->Db, assem->Id);
else
ajFmtPrintF(outf, "%S\n", assem->Id);
return ajTrue;
}
int main(int argc, char **argv)
{
/* Variable Declarations */
AjPFile outf;
AjPStr code = NULL;
char code1;
ajuint i;
ajuint iend;
/* ACD File Processing */
embInit("infobase", argc, argv);
code = ajAcdGetString("code");
outf = ajAcdGetOutfile("outfile");
/* Application logic */
ajStrFmtUpper(&code);
iend = ajStrGetLen(code);
ajFmtPrintF(outf, "%4s %-10s %-10s %s\n",
"Code", "Ambiguity", "Complement", "Mnemonic");
for(i=0;i<iend;i++)
{
code1=ajStrGetCharPos(code,i);
if(ajBaseExistsChar(code1))
{
ajFmtPrintF(outf, "%-4c %-10S %-10c %S\n",
code1, ajBaseGetCodes(code1),
ajBaseAlphacharComp(code1),
ajBaseGetMnemonic(code1));
}
else
{
ajFmtPrintF(outf, "%-4c %-10s %-10c %s\n",
code1, ".",
'.',
"invalid");
}
}
/* Memory management and exit */
ajStrDel(&code);
ajFileClose(&outf);
embExit();
return 0;
}
static void eprimer3_write_primer(AjPFile outfile, const char *tag,
const AjPStr pos,
const AjPStr tm, const AjPStr gc,
const AjPStr seq,
AjBool rev, ajint begin)
{
ajint startint;
ajint lenint;
float tmfloat;
float gcfloat;
AjPStr start = NULL;
AjPStr lenstr = NULL;
ajlong comma;
if(ajStrGetLen(pos))
{
ajStrToFloat(tm, &tmfloat);
ajStrToFloat(gc, &gcfloat);
comma = ajStrFindC(pos, ",");
ajStrAssignS(&start, pos);
ajStrCutRange(&start, comma, ajStrGetLen(start)-1);
ajStrToInt(start, &startint);
startint += begin;
ajStrAssignS(&lenstr, pos);
ajStrCutRange(&lenstr, 0, comma);
ajStrToInt(lenstr, &lenint);
if(rev)
startint = startint - lenint + 1;
ajFmtPrintF(outfile, " %s %6d %4d %2.2f %2.2f %S\n\n",
tag, startint, lenint, tmfloat, gcfloat, seq);
}
ajStrDel(&start);
ajStrDel(&lenstr);
return;
}
static AjBool resourceoutWriteBasic(AjPFile outf, const AjPResource resource)
{
if(!outf)
return ajFalse;
ajFmtPrintF(outf, "%-8s%S\n", "ID", resource->Id);
ajFmtPrintF(outf, "%-8s%S\n", "Name", resource->Name);
if(ajStrGetLen(resource->Url))
ajFmtPrintF(outf, "%-8s%S\n", "URL", resource->Url);
ajFmtPrintF(outf, "\n");
return ajTrue;
}
static AjBool resourceoutWriteList(AjPFile outf, const AjPResource resource)
{
if(!outf)
return ajFalse;
if(!resource)
return ajFalse;
if(ajStrGetLen(resource->Db))
ajFmtPrintF(outf, "%S:%S\n", resource->Db, resource->Id);
else
ajFmtPrintF(outf, "%S\n", resource->Id);
return ajTrue;
}
int main(int argc, char **argv)
{
/* Variable Declarations */
AjPSeqset seqset = NULL;
AjPAlign align = NULL;
AjPStr name = NULL;
AjPStr comment = NULL;
AjBool append = ajFalse;
AjPStr header = NULL;
/* ACD File Processing */
embInit("aligncopy", argc, argv);
seqset = ajAcdGetSeqset("sequences");
align = ajAcdGetAlign("outfile");
name = ajAcdGetString("name");
comment = ajAcdGetString("comment");
append = ajAcdGetBoolean("append");
/* Application logic */
ajAlignDefine(align, seqset);
if(ajStrGetLen(name))
ajFmtPrintS(&header, "Alignment: %S\n\n", name);
ajStrAppendS(&header, comment);
if(append)
ajAlignSetHeaderApp(align, header);
else
ajAlignSetHeader(align, header);
ajAlignWrite(align);
ajAlignClose(align);
/* Memory management and exit */
ajSeqsetDel(&seqset);
ajAlignDel(&align);
ajStrDel(&name);
ajStrDel(&comment);
ajStrDel(&header);
embExit();
return 0;
}
static ajuint patternRegexFormat(const AjPStr fmt)
{
ajuint i = 0;
if(!ajStrGetLen(fmt))
return 0;
while (patRegInformat[i].Name) {
if(ajStrMatchCaseC(fmt, patRegInformat[i].Name))
return i;
i++;
}
ajErr("Unrecognized regular expression file format '%S'",fmt);
return 0;
}
static void eprimer3_send_string(FILE * stream, const char * tag,
const AjPStr value)
{
AjPStr str;
str = ajStrNew();
if(ajStrGetLen(value))
{
ajFmtPrintS(&str, "%s=%S\n", tag, value);
eprimer3_write(str, stream);
}
ajStrDel(&str);
return;
}
static AjBool assemoutWriteNextList(AjPOutfile outfile, const AjPAssem assem)
{
AjPFile outf = ajOutfileGetFile(outfile);
if(!outf) return ajFalse;
if(!assem) return ajFalse;
if(!assem->Hasdata)
return ajTrue;
if(ajStrGetLen(assem->Db))
ajFmtPrintF(outf, "%S:%S\n", assem->Db, assem->Id);
else
ajFmtPrintF(outf, "%S\n", assem->Id);
return ajTrue;
}
static AjBool remap_Ambiguous(const AjPStr str)
{
ajuint ipos;
char chr;
for (ipos=0; ipos<ajStrGetLen(str); ipos++)
{
chr = ajStrGetCharPos(str, ipos);
if (tolower((int)chr) != 'a' &&
tolower((int)chr) != 'c' &&
tolower((int)chr) != 'g' &&
tolower((int)chr) != 't'
)
return ajTrue;
}
return ajFalse;
}
static AjBool extractfeat_MatchPatternDescribe(const AjPFeature feat,
const AjPStr describe,
AjPStr *strout)
{
AjIList titer; /* iterator for feat */
AjPStr tagnam = NULL; /* tag structure */
AjPStr tagval = NULL; /* tag structure */
AjBool val = ajFalse; /* returned value */
/* iterate through the tags and test for match to patterns */
titer = ajFeatTagIter(feat);
while(ajFeatTagval(titer, &tagnam, &tagval))
{
if(embMiscMatchPatternDelimC(tagnam, describe, ",;|"))
{
/* There's a match, so write to strout in a pretty format */
if(!val)
ajStrAssignC(strout, "(");
else
ajStrAppendC(strout, ", ");
val = ajTrue;
ajStrAppendS(strout, tagnam);
if(ajStrGetLen(tagval))
{
ajStrAppendC(strout, "=\"");
ajStrAppendS(strout, tagval);
ajStrAppendC(strout, "\"");
}
}
}
ajListIterDel(&titer);
if(val)
ajStrAppendC(strout, ") ");
ajStrDel(&tagnam);
ajStrDel(&tagval);
return val;
}
static ajuint patternSeqFormat(const AjPStr fmt)
{
ajuint i = 0;
if(!ajStrGetLen(fmt))
return 0;
while (patSeqInformat[i].Name)
{
if(ajStrMatchCaseC(fmt, patSeqInformat[i].Name))
return i;
i++;
}
ajErr("Unrecognized pattern file format '%S'",fmt);
return 0;
}
AjBool ensGvdatabaseadaptorFailedvariationsconstraint(
EnsPGvdatabaseadaptor gvdba,
const AjPStr tablename,
AjPStr *Pconstraint)
{
char *txttablename = NULL;
if (!gvdba)
return ajFalse;
if (!Pconstraint)
return ajFalse;
if (!*Pconstraint)
*Pconstraint = ajStrNew();
if (gvdba->Failedvariations)
{
if ((tablename != NULL) && (ajStrGetLen(tablename)))
{
ensDatabaseadaptorEscapeC(
ensGvdatabaseadaptorGetDatabaseadaptor(gvdba),
&txttablename,
tablename);
ajStrAssignC(Pconstraint, txttablename);
ajCharDel(&txttablename);
}
else
ajStrAssignC(Pconstraint, "failed_variation");
ajStrAppendC(Pconstraint, ".variation_id IS NULL");
}
else
ajStrAssignC(Pconstraint, "1");
return ajTrue;
}
static void resourceMakeQry(const AjPResource thys, AjPStr* qry)
{
ajDebug("resourceMakeQry (Id <%S> Formatstr <%S> Db <%S> "
"Filename <%S>)\n",
thys->Id, thys->Formatstr, thys->Db,
thys->Filename);
/* ajResourceTrace(thys); */
if(ajStrGetLen(thys->Db))
ajFmtPrintS(qry, "%S-id:%S", thys->Db, thys->Id);
else
{
ajFmtPrintS(qry, "%S::%S:%S", thys->Formatstr,
thys->Filename,thys->Id);
}
ajDebug(" result: <%S>\n",
*qry);
return;
}
static void dbiblast_dbname(AjPStr* dbname,
const AjPStr oname, const char *suff)
{
AjPStr suffix = NULL;
ajFmtPrintS(&suffix, ".%s", suff);
ajStrAssignS(dbname, oname);
if(ajStrGetCharFirst(oname)=='@')
ajStrCutStart(dbname, 1);
if(!ajStrSuffixS(*dbname, suffix))
{
ajStrDel(&suffix);
return;
}
ajStrCutEnd(dbname, ajStrGetLen(suffix));
ajStrDel(&suffix);
return;
}
