static void remap_RenamePreferred(const AjPList list, const AjPTable table,
AjPList newlist)
{
AjIList iter = NULL;
AjPStr key = NULL;
const AjPStr value = NULL;
AjPStr name = NULL;
iter = ajListIterNewread(list);
while((key = (AjPStr)ajListIterGet(iter)))
{
/*
** If a key-value entry found, write the new value to the new list
** else write the old key name to the new list
*/
value = ajTableFetchS(table, key);
name = ajStrNew();
if(value)
{
ajDebug("Rename: %S renamed to %S\n", key, value);
ajStrAssignS(&name, value);
}
else
{
ajDebug("Rename: %S not found\n", key);
ajStrAssignS(&name, key);
}
ajListstrPushAppend(newlist, name);
}
ajListIterDel(&iter);
return;
}
void ajTimeTrace(const AjPTime thys)
{
ajDebug("Time value trace '%D'\n", thys);
ajDebug("format: '%s'\n", thys->format);
return;
}
AjBool embPropTransversion(char base1, char base2)
{
AjBool bu1;
AjBool bu2;
AjBool by1;
AjBool by2;
bu1 = embPropPurine(base1);
bu2 = embPropPurine(base2);
by1 = embPropPyrimidine(base1);
by2 = embPropPyrimidine(base2);
ajDebug("base1 py = %b, pu = %b", bu1, by1);
ajDebug("base2 py = %b, pu = %b", bu2, by2);
/* not a purine or a pyrimidine - ambiguous - return ajFalse */
if(!bu1 && !by1)
return ajFalse;
if(!bu2 && !by2)
return ajFalse;
ajDebug("embPropTransversion result = %d", (bu1 != bu2));
return (bu1 != bu2);
}
void embPatlistSeqSearch (AjPFeattable ftable, const AjPSeq seq,
AjPPatlistSeq plist, AjBool reverse)
{
AjPPatternSeq patseq = NULL;
AjPPatComp compPat;
ajDebug ("embPatlistSearchListSeq: Searching '%S' for %d patterns\n",
ajSeqGetNameS(seq), ajPatlistSeqGetSize(plist));
while (ajPatlistSeqGetNext(plist,&patseq))
{
compPat = ajPatternSeqGetCompiled(patseq);
if (!compPat && !embPatternSeqCompile(patseq))
{
ajPatlistSeqRemoveCurrent(plist);
continue;
}
embPatternSeqSearch(ftable,seq,patseq,reverse);
ajDebug("end loop\n");
}
ajPatlistSeqRewind(plist);
return;
}
void embPatlistRegexSearch (AjPFeattable ftable, const AjPSeq seq,
AjPPatlistRegex plist, AjBool reverse)
{
AjPPatternRegex patreg = NULL;
AjPRegexp compPat;
AjPStr tmp = NULL;
ajStrAssignS(&tmp,ajSeqGetNameS(seq));
ajDebug ("embPatlistSearchSequence: Searching '%S' for patterns\n",tmp);
while (ajPatlistRegexGetNext(plist,&patreg))
{
compPat = ajPatternRegexGetCompiled(patreg);
if (!compPat)
{
ajPatlistRegexRemoveCurrent(plist);
continue;
}
embPatternRegexSearch(ftable,seq,patreg,reverse);
ajDebug("end loop\n");
}
/* ajDebug ("embPatlistSearchListRegex: Done search '%S'\n",tmp); */
ajPatlistRegexRewind(plist);
ajStrDel(&tmp);
return;
}
/* @func embPatternSeqCompile *************************************************
**
** Adds compiled pattern into AjPPattern.
**
** @param [w] pat [AjPPatternSeq] Pattern for compiling
** @return [AjBool] True, if compilation succeeded
** @@
******************************************************************************/
AjBool embPatternSeqCompile (AjPPatternSeq pat)
{
AjPPatComp embpat;
AjBool embType;
AjPStr pattern = NULL;
ajStrAssignS(&pattern,ajPatternSeqGetPattern(pat));
ajStrFmtUpper(&pattern);
ajDebug("embPatlistSeqCompile: name %S, pattern %S\n",
ajPatternSeqGetName(pat),pattern);
embpat = ajPatCompNew();
if (ajPatternSeqGetProtein(pat))
embType=ajTrue;
else
embType=ajFalse;
if (!embPatGetTypeII(embpat,pattern,
ajPatternSeqGetMismatch(pat),embType))
{
ajDebug("embPatlistSeqCompile: Illegal pattern %S: '%S'\n",
ajPatternSeqGetName(pat),ajPatternSeqGetPattern(pat));
ajPatCompDel(&embpat);
ajStrDel(&pattern);
return ajFalse;
}
embPatCompileII(embpat,ajPatternSeqGetMismatch(pat));
ajPatternSeqSetCompiled(pat,embpat);
ajStrDel(&pattern);
return ajTrue;
}
void ajRegExit(void)
{
if(regDfaWorkspace)
AJFREE(regDfaWorkspace);
ajDebug("Regexp usage (bytes): %Ld allocated, %Ld freed, %Ld in use "
"(sizes change)\n",
regAlloc, regFree, (regAlloc - regFree));
ajDebug("Regexp usage (number): %Ld allocated, %Ld freed %Ld in use\n",
regCount, regFreeCount, regTotal);
return;
}
AjBool embPropTransition(char base1, char base2)
{
AjBool bu1;
AjBool bu2;
AjBool by1;
AjBool by2;
bu1 = embPropPurine(base1);
bu2 = embPropPurine(base2);
by1 = embPropPyrimidine(base1);
by2 = embPropPyrimidine(base2);
ajDebug("base1 py = %b, pu = %b", bu1, by1);
ajDebug("base2 py = %b, pu = %b", bu2, by2);
/* not a purine or a pyrimidine - ambiguous - return ajFalse */
if(!bu1 && !by1)
return ajFalse;
if(!bu2 && !by2)
return ajFalse;
/* no change - return ajFalse */
if(tolower((int)base1) == tolower((int)base2))
return ajFalse;
/* U to T is not a transition */
if(tolower((int)base1) == 't' && tolower((int)base2) == 'u')
return ajFalse;
if(tolower((int)base1) == 'u' && tolower((int)base2) == 't')
return ajFalse;
/* C to Y, T to Y, A to R, G to R - ambiguous - not a transition */
if(bu1 && tolower((int)base2) == 'r')
return ajFalse;
if(bu2 && tolower((int)base1) == 'r')
return ajFalse;
if(by1 && tolower((int)base2) == 'y')
return ajFalse;
if(by2 && tolower((int)base1) == 'y')
return ajFalse;
ajDebug("embPropTransition result = %b", (bu1 == bu2));
return (bu1 == bu2);
}
void ajRegTrace(const AjPRegexp rexp)
{
ajint isub;
ajint ilen;
ajint ipos;
ajint istart;
ajint iend;
static AjPStr str = NULL;
ajDebug(" REGEXP trace\n");
if (!rexp->orig)
ajDebug("original string not saved - unable to trace string values\n");
for(isub=0; isub < rexp->ovecsize; isub++)
{
istart = 2*isub;
iend = istart+1;
if (!rexp->orig)
{
if(!isub)
ajDebug("original string from %d .. %d\n",
rexp->ovector[istart], rexp->ovector[iend]);
else
ajDebug("substring %2d from %d .. %d\n",
isub, rexp->ovector[istart], rexp->ovector[iend]);
continue;
}
if(rexp->ovector[iend] >= rexp->ovector[istart])
{
ilen = rexp->ovector[iend] - rexp->ovector[istart];
ajStrSetRes(&str, ilen+1);
memmove(str->Ptr, &rexp->orig[rexp->ovector[istart]], ilen);
str->Len = ilen;
str->Ptr[ilen] = '\0';
if(!isub)
{
ajDebug(" original string '%s'\n", rexp->orig);
ajDebug(" string match '%S'\n", str);
}
else
{
ipos = rexp->ovector[istart];
ajDebug(" substring %2d '%S' at %d\n", isub, str, ipos);
}
}
}
ajDebug("\n");
ajStrDel(&str);
return;
}
static void eprimer3_end_write(FILE *stream)
{
ajDebug("Closing output pipe stream\n");
fclose(stream);
return;
}
static void eprimer3_write(const AjPStr str, FILE *stream)
{
fputs(ajStrGetPtr(str), stream);
ajDebug("eprimer3_write '%S'\n", str);
return;
}
static const AjPStr eprimer3_tableget(const char *key1, ajint number,
const char *key2,
const AjPTable table)
{
AjPStr fullkey = NULL;
AjPStr keynum = NULL;
const AjPStr value = NULL;
ajStrAssignC(&fullkey, key1);
if(number > 0)
{
ajStrAppendC(&fullkey, "_");
ajStrFromInt(&keynum, number);
ajStrAppendS(&fullkey, keynum);
}
if(strcmp(key2, ""))
ajStrAppendC(&fullkey, "_");
ajStrAppendC(&fullkey, key2);
ajDebug("Constructed key=%S\n", fullkey);
value = ajTableFetchS(table, fullkey);
ajStrDel(&fullkey);
ajStrDel(&keynum);
return value;
}
AjBool ensKaryotypebandTrace(const EnsPKaryotypeband kb, ajuint level)
{
AjPStr indent = NULL;
if(!kb)
return ajFalse;
indent = ajStrNew();
ajStrAppendCountK(&indent, ' ', level * 2);
ajDebug("%SensKaryotypebandTrace %p\n"
"%S Adaptor %p\n"
"%S Identifier %u\n"
"%S Feature %p\n"
"%S Name '%S'\n"
"%S Stain '%S'\n",
indent, kb,
indent, kb->Adaptor,
indent, kb->Identifier,
indent, kb->Feature,
indent, kb->Name,
indent, kb->Stain);
ensFeatureTrace(kb->Feature, 1);
ajStrDel(&indent);
return ajTrue;
}
void ensGvsynonymDel(EnsPGvsynonym *Pgvs)
{
EnsPGvsynonym pthis = NULL;
if (!Pgvs)
return;
#if defined(AJ_DEBUG) && AJ_DEBUG >= 1
if (ajDebugTest("ensGvsynonymDel"))
{
ajDebug("ensGvsynonymDel\n"
" *Pgvs %p\n",
*Pgvs);
ensGvsynonymTrace(*Pgvs, 1);
}
#endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
if (!(pthis = *Pgvs) || --pthis->Use)
{
*Pgvs = NULL;
return;
}
ensGvsourceDel(&pthis->Gvsource);
ajStrDel(&pthis->Name);
ajStrDel(&pthis->Moleculetype);
ajMemFree((void **) Pgvs);
return;
}
AjBool ensGvdatabaseadaptorTrace(const EnsPGvdatabaseadaptor gvdba,
ajuint level)
{
AjPStr indent = NULL;
if (!gvdba)
return ajFalse;
indent = ajStrNew();
ajStrAppendCountK(&indent, ' ', level * 2);
ajDebug("%SensGvdatabaseadaptorTrace %p\n"
"%S Databaseadaptor %p\n"
"%S Failedvariations '%B'\n",
indent, gvdba,
indent, gvdba->Adaptor,
indent, gvdba->Failedvariations);
ensDatabaseadaptorTrace(gvdba->Adaptor, level + 1);
ajStrDel(&indent);
return ajTrue;
}
void ensGvdatabaseadaptorDel(EnsPGvdatabaseadaptor *Pgvdba)
{
EnsPGvdatabaseadaptor pthis = NULL;
if (!Pgvdba)
return;
#if defined(AJ_DEBUG) && AJ_DEBUG >= 1
if (ajDebugTest("ensGvdatabaseadaptorDel"))
{
ajDebug("ensGvdatabaseadaptorDel\n"
" *Pgvdba %p\n",
*Pgvdba);
ensGvdatabaseadaptorTrace(*Pgvdba, 1);
}
#endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
if (!(pthis = *Pgvdba))
return;
ajMemFree((void **) Pgvdba);
return;
}
AjBool ensIntronTrace(const EnsPIntron intron, ajuint level)
{
AjPStr indent = NULL;
if(!intron)
return ajFalse;
indent = ajStrNew();
ajStrAppendCountK(&indent, ' ', level * 2);
ajDebug("%SensIntronTrace %p\n"
"%S Feature %p\n"
"%S PreviousExon %p\n"
"%S NextExon %p\n"
"%S Use %u\n",
indent, intron,
indent, intron->Feature,
indent, intron->PreviousExon,
indent, intron->NextExon,
indent, intron->Use);
ensFeatureTrace(intron->Feature, level + 1);
ensExonTrace(intron->PreviousExon, level + 1);
ensExonTrace(intron->NextExon, level + 1);
ajStrDel(&indent);
return ajTrue;
}
AjBool ensProjectionsegmentTrace(const EnsPProjectionsegment ps, ajuint level)
{
AjPStr indent = NULL;
if(!ps)
return ajFalse;
indent = ajStrNew();
ajStrAppendCountK(&indent, ' ', level * 2);
ajDebug("%SensProjectionsegmentTrace %p\n"
"%S SrcStart %d\n"
"%S SrcEnd %d\n"
"%S TrgSlice %p\n"
"%S Use %u\n",
indent, ps,
indent, ps->SrcStart,
indent, ps->SrcEnd,
indent, ps->TrgSlice,
indent, ps->Use);
ensSliceTrace(ps->TrgSlice, level + 1);
ajStrDel(&indent);
return ajTrue;
}
static ajint dbiblast_loadtable(ajuint* table, ajint isize, PBlastDb db,
ajint top, ajint pos)
{
ajint i;
ajint j;
ajint imax;
imax = pos + isize;
if(imax > (db->Size+1))
imax = db->Size+1;
ajDebug("loadtable size %d top %d db->Size %d pos %d imax %d\n",
isize, top, db->Size, pos, imax);
dbiblast_memfseek(db->TFile, top + 4*(pos), 0);
j = 0;
for(i=pos; i<=imax; i++)
{
/* ajDebug("reading at %d\n", ajFileResetPos(db->TFile->File));*/
dbiblast_memreadUInt4(db->TFile,&table[j++]);
/* ajDebug("read i: %d j: %d value: %d\n", i, j-1, table[j-1]);*/
}
return imax - pos + 1;
}
void ensStorableDel(EnsPStorable *Pstorable)
{
EnsPStorable pthis = NULL;
if (!Pstorable)
return;
#if defined(AJ_DEBUG) && AJ_DEBUG >= 1
if (ajDebugTest("ensStorableDel"))
ajDebug("ensStorableDel\n"
" *Pstorable %p\n",
*Pstorable);
#endif /* defined(AJ_DEBUG) && AJ_DEBUG >= 1 */
if (!(pthis = *Pstorable) || --pthis->Use)
{
*Pstorable = NULL;
return;
}
ajMemFree((void **) Pstorable);
return;
}
static void splitter_ProcessChunk (AjPSeqout seqout, const AjPSeq seq,
ajuint start, ajuint end, const AjPStr name,
AjBool feature)
{
AjPStr str;
AjPFeattable new_feattable = NULL;
AjPSeq subseq;
ajDebug("splitter_ProcessChunk %d..%d '%S' %B\n",
start, end, name, feature);
str = ajStrNew();
subseq = ajSeqNew();
new_feattable = ajFeattableNew(name);
subseq->Fttable = new_feattable;
ajFeattableSetNuc(new_feattable);
ajStrAssignSubC(&str,ajSeqGetSeqC(seq),start,end);
ajSeqAssignSeqS(subseq,str);
if(feature)
splitter_AddSubSeqFeat(subseq->Fttable,start,end,seq);
ajSeqAssignNameS(subseq, name);
splitter_write(seqout,subseq,seq);
ajStrDel(&str);
ajSeqDel(&subseq);
return;
}
AjBool ajRegExecC(AjPRegexp prog, const char* str)
{
int startoffset = 0;
int options = 0;
int status = 0;
status = pcre_exec(prog->pcre, prog->extra, str, strlen(str),
startoffset, options, prog->ovector, 3*prog->ovecsize);
if(status >= 0)
{
prog->orig = str;
if(status == 0)
ajWarn("ajRegExecC too many substrings");
return ajTrue;
}
if(status < -1) /* -1 is a simple fail to match */
{ /* others are recursion limits etc. */
ajDebug("ajRegExecC returned unexpected status '%d'\n", status);
prog->orig = str; /* needed for the trace */
ajRegTrace(prog);
}
prog->orig = NULL;
return ajFalse;
}
void ajPatternRegexDebug (const AjPPatternRegex pat)
{
ajDebug ("patPatternRegexDebug:\n name: %S\n pattern: %S\n type: %d",
pat->Name, pat->Pattern, pat->Type);
return;
}
static AjBool merger_bestquality(const char * a, const char *b,
ajint apos, ajint bpos)
{
float qa;
float qb;
qa = merger_quality(a, apos, 5);
qb = merger_quality(b, bpos, 5);
if(qa == qb)
{
/* both have the same quality, use a larger window */
qa = merger_quality(a, apos, 10);
qb = merger_quality(b, bpos, 10);
}
if(qa == qb)
{
/* both have the same quality, use a larger window */
qa = merger_quality(a, apos, 20);
qb = merger_quality(b, bpos, 20);
}
ajDebug("merger_bestquality %d..%d = %.3f %.3f\n", apos, bpos, qa, qb);
if(qa >= qb)
/* both have the same quality, use the first sequence */
return ajTrue;
return ajFalse;
}
static void tranalign_AddGaps(AjPSeq newseq,
const AjPSeq nseq, const AjPSeq pseq,
ajlong npos)
{
AjPStr newstr = NULL;
ajuint ppos = 0;
newstr = ajStrNew();
for(; ppos<ajSeqGetLen(pseq); ppos++)
if(ajSeqGetSeqC(pseq)[ppos] == '-')
ajStrAppendC(&newstr, "---");
else
{
ajStrAppendSubS(&newstr, ajSeqGetSeqS(nseq), npos, npos+2);
npos+=3;
}
ajDebug("aligned seq=%S\n", newstr);
ajSeqAssignSeqS(newseq, newstr);
ajStrDel(&newstr);
return;
}
static void supermatcher_findendpoints(const EmbPWordMatch max,
const AjPSeq trgseq, const AjPSeq qryseq,
ajint *trgstart, ajint *qrystart,
ajint *trgend, ajint *qryend)
{
ajint amax;
ajint bmax;
ajint offset;
*trgstart = max->seq1start;
*qrystart = max->seq2start;
offset = *trgstart - *qrystart;
if(offset > 0)
{
*trgstart = offset;
*qrystart = 0;
}
else
{
*qrystart = 0-offset;
*trgstart = 0;
}
amax = ajSeqGetLen(trgseq)-1;
bmax = ajSeqGetLen(qryseq)-1;
*trgend = *trgstart;
*qryend = *qrystart;
ajDebug("++ end1 %d -> %d end2 %d -> %d\n", *trgend, amax, *qryend, bmax);
while(*trgend<amax && *qryend<bmax)
{
(*trgend)++;
(*qryend)++;
}
ajDebug("++ end1 %d end2 %d\n", *trgend, *qryend);
ajDebug("supermatcher_findendpoints: %d..%d [%d] %d..%d [%d]\n",
trgstart, *trgend, ajSeqGetLen(trgseq), qrystart, *qryend,
ajSeqGetLen(qryseq));
return;
}
void ajPatternSeqDebug (const AjPPatternSeq pat)
{
ajDebug ("patPatternSeqDebug:\n name: %S\n pattern: %S\n protein: %B,"
" mismatch: %d\n",
pat->Name, pat->Pattern, pat->Protein, pat->Mismatch);
return;
}
AjBool ajAssemoutWrite(AjPOutfile outf, const AjPAssem assem)
{
ajuint i = ajOutfileGetFormatindex(outf);
AjPFile outfile = ajOutfileGetFile(outf);
ajDebug("ajAssemoutWrite %d\n",i);
return (*assemoutFormatDef[i].Write)(outfile, assem);
}
axiom_node_t* ajSoapAxis2Call(axis2_svc_client_t *client,
const axutil_env_t *env,
axiom_node_t *payload)
{
axiom_node_t *ret_node = NULL;
axis2_char_t * om_str = NULL;
if (ajDebugOn())
{
om_str = axiom_node_to_string(payload, env);
if (om_str)
{
ajDebug("\nSending OM : %s\n", om_str);
AXIS2_FREE(env->allocator, om_str);
om_str = NULL;
}
}
/* Send request */
ret_node = axis2_svc_client_send_receive(client, env, payload);
if (ret_node)
{
if(ajDebugOn())
{
om_str = axiom_node_to_string(ret_node, env);
if (om_str)
ajDebug("\nReceived OM : %s\n", om_str);
AXIS2_FREE(env->allocator, om_str);
om_str = NULL;
}
}
else
{
ajDebug("seqAxis2wsCall: webservice call failed: %s\n",
AXIS2_ERROR_GET_MESSAGE(env->error));
ajErr("webservice call FAILED: %s\n",
AXIS2_ERROR_GET_MESSAGE(env->error));
}
return ret_node;
}
void ajPatlistAddRegex (AjPPatlistRegex thys, AjPPatternRegex pat)
{
ajDebug ("ajPatlistAddRegex list size %d '%S' '%S' '%d'\n",
ajListGetLength (thys->Patlist), pat->Name,
pat->Pattern, pat->Type);
ajListPushAppend(thys->Patlist, pat);
return;
}
