static void DoFastaTrans (
SeqFeatPtr sfp,
Pointer userdata
)
{
ByteStorePtr bs;
CSpeedFlagPtr cfp;
CharPtr seq, str;
if (sfp == NULL) return;
cfp = (CSpeedFlagPtr) userdata;
if (cfp == NULL) return;
if (sfp->data.choice != SEQFEAT_CDREGION) return;
bs = ProteinFromCdRegion (sfp, FALSE);
if (bs == NULL) return;
seq = (CharPtr) BSMerge (bs, NULL);
BSFree (bs);
if (seq == NULL) return;
if (cfp->ofp != NULL) {
str = SeqLocPrint (sfp->location);
if (str != NULL) {
fprintf (cfp->ofp, "> (%s)\n", str);
MemFree (str);
}
fprintf (cfp->ofp, "%s\n", seq);
}
MemFree (seq);
}
NLM_EXTERN Boolean LIBCALL AsnGenericBaseSeqOfFree (ValNodePtr ptr, int whichvalslot)
{
Boolean retval = TRUE;
ValNodePtr current, nextcur;
for (current = ptr; current; current = nextcur) {
nextcur = current->next;
switch (whichvalslot) {
case ASNCODE_BYTEVAL_SLOT:
BSFree ((ByteStorePtr)current->data.ptrvalue);
break;
case ASNCODE_PTRVAL_SLOT:
MemFree (current->data.ptrvalue);
current->data.ptrvalue = NULL;
break;
case ASNCODE_REALVAL_SLOT:
case ASNCODE_INTVAL_SLOT:
case ASNCODE_BIGINTVAL_SLOT:
case ASNCODE_BOOLVAL_SLOT:
/* No-op */
break;
}
}
ValNodeFree (ptr);
return retval;
}
static Pointer AsnLexReadStringEx (AsnIoPtr aip, AsnTypePtr atp, Uint1 fix_non_print)
{
Int2 token;
ByteStorePtr ssp;
CharPtr result=NULL;
Int4 bytes;
token = AsnLexWordEx (aip, fix_non_print); /* read the start */
if (token != START_STRING)
{
AsnIoErrorMsg(aip, 43, AsnErrGetTypeName(atp->name), aip->linenumber);
return NULL;
}
ssp = BSNew(0);
if (ssp == NULL) return result;
token = AsnLexWordEx (aip, fix_non_print); /* read the string(s) */
while (token == IN_STRING)
{
bytes = BSWrite(ssp, aip->word, (Int4)aip->wordlen);
if (bytes != (Int4)(aip->wordlen))
{
BSFree(ssp);
return result;
}
token = AsnLexWord(aip);
}
if (token == ERROR_TOKEN) return NULL;
if (token != END_STRING)
{
AsnIoErrorMsg(aip, 44, AsnErrGetTypeName(atp->name), aip->linenumber);
return NULL;
}
if (AsnFindBaseIsa(atp) == STRSTORE_TYPE) /* string store */
return ssp;
result = (CharPtr) BSMerge(ssp, NULL);
BSFree(ssp);
return result;
}
/*****************************************************************************
*
* void AsnKillValue(atp, dvp)
* eliminates stored values such as strings
*
*****************************************************************************/
NLM_EXTERN void LIBCALL AsnKillValue (AsnTypePtr atp, DataValPtr dvp)
{
Int2 isa;
isa = AsnFindBaseIsa(atp);
if (ISA_STRINGTYPE(isa))
MemFree(dvp->ptrvalue);
else if ((isa == OCTETS_TYPE) || (isa == STRSTORE_TYPE))
BSFree((ByteStorePtr) dvp->ptrvalue);
return;
}
/*****************************************************************************
*
* StdAuthListNamesPrint(dvp)
* prints just Auth-list.names to a string
*
*****************************************************************************/
NLM_EXTERN CharPtr StdAuthListNamesPrint(DataValPtr dvp)
{
AuthListPtr alp;
Boolean first = TRUE;
ValNodePtr vnp;
PersonIdPtr pip;
AuthorPtr ap;
ByteStorePtr bsp;
CharPtr str;
Char buf[60];
if (dvp == NULL) return NULL;
alp = (AuthListPtr)(dvp->ptrvalue);
if (alp == NULL) return NULL;
bsp = BSNew(80);
for (vnp = alp->names; vnp != NULL; vnp = vnp->next)
{
if (! first) /* separators for names after first one */
{
if (vnp->next != NULL)
BSPutByte(bsp, (Int2)',');
else
{
BSPutByte(bsp, (Int2)' ');
BSPutByte(bsp, (Int2)'&');
}
BSPutByte(bsp, (Int2)' ');
}
first = FALSE;
if (alp->choice == 3 || alp->choice == 2) /* ml or str */
{
BSWrite(bsp, vnp->data.ptrvalue, (Int4)(StringLen((CharPtr)(vnp->data.ptrvalue))));
}
else if (alp->choice == 1) /* std */
{
ap = (AuthorPtr) (vnp->data.ptrvalue);
if (ap != NULL)
{
pip = ap->name;
PersonIdPrint(pip, buf);
BSWrite(bsp, buf, (Int4)StringLen(buf));
}
else
BSPutByte(bsp, (Int2)'?');
}
}
str = BSMerge(bsp, NULL);
BSFree(bsp);
return str;
}
/*****************************************************************************
*
* ByteStorePtr AsnLexReadOctets(aip, atp)
* expects Octets type next
* assumes none of it has already been read
* does not advance to next token
* atp points to the definition of this OCTET STRING
*
*****************************************************************************/
NLM_EXTERN ByteStorePtr AsnLexReadOctets (AsnIoPtr aip, AsnTypePtr atp)
{
Int2 token, len;
ByteStorePtr ssp = NULL;
Byte tbuf[256]; /* was 101 - changed to handle occasional hand-edited ASN.1? */
Int4 bytes, left, added;
token = AsnLexWord(aip); /* read the start */
if (token != START_BITHEX)
{
AsnIoErrorMsg(aip, 45, AsnErrGetTypeName(atp->name), aip->linenumber);
return NULL;
}
ssp = BSNew(0);
if (ssp == NULL) return ssp;
token = AsnLexWord(aip); /* read the octet(s) */
left = 0;
while (token == IN_BITHEX)
{
len = (Int2)(aip->wordlen + left);
MemCopy((tbuf + left), aip->word, (len - left));
tbuf[len] = '\0';
added = AsnTypeStringToHex(tbuf, len, tbuf, &left);
if (added < 0)
{
AsnIoErrorMsg(aip, 46, AsnErrGetTypeName(atp->name), aip->linenumber);
return NULL;
}
if (added)
{
bytes = BSWrite(ssp, tbuf, added);
if (bytes != added)
{
ssp = BSFree(ssp);
return ssp;
}
}
if (left) /* left a char */
{
MemCopy(tbuf, ((aip->word)+(aip->wordlen - left)),left);
}
token = AsnLexWord(aip);
}
if (token != OCTETS)
{
AsnIoErrorMsg(aip, 47, AsnErrGetTypeName(atp->name), aip->linenumber);
return NULL;
}
return ssp;
}
void XMLParserDispose(XMLParser* parser)
{
if (parser == NULL) return;
{
QBNodePool* pool = QBNodePoolPtr(parser);
if (parser->node) {
BSRelease(parser->node);
parser->node = NULL;
}
if (parser->stack) {
BSRelease(parser->stack);
parser->stack = NULL;
}
if (parser->string) {
BSFree(parser->string);
parser->string = NULL;
}
BSFree(parser);
QBNodePoolRecycle(pool);
}
}
PostingPtr LIBCALL FreePost (PostingPtr pst)
{
if (pst != NULL) {
if (pst->uids != NULL) {
BSFree (pst->uids);
}
if (pst->buffer != NULL) {
MemFree (pst->buffer);
}
MemFree (pst);
}
return NULL;
}
/*****************************************************************************
*
* SimpleSeqFree(ssp)
*
*****************************************************************************/
NLM_EXTERN SimpleSeqPtr SimpleSeqFree (SimpleSeqPtr ssp)
{
Int2 i;
if (ssp == NULL)
return NULL;
for (i = 0; i < ssp->numid; i++)
MemFree(ssp->id[i]);
MemFree(ssp->title);
BSFree(ssp->seq);
return MemFree(ssp);
}
/*****************************************************************************
*
* StdFormatPrint(data, func, templatename, options)
*
*****************************************************************************/
NLM_EXTERN Boolean StdFormatPrint (Pointer data, AsnWriteFunc func, CharPtr templatename, StdPrintOptionsPtr options)
{
PrintStackPtr psp;
CharPtr ptr = NULL;
PrintFormatListPtr pflp;
if ((data == NULL) || (func == NULL) || (templatename == NULL) || (options == NULL))
return FALSE;
pflp = PrintFormatListGet(templatename);
if (pflp == NULL) return FALSE;
if (options->fp == NULL)
{
options->bstp = BSNew(80);
options->ptr = NULL;
}
psp = PrintStackBuild(data, func, pflp);
/***
printf("Before sort\n");
PrintStackDump(psp, stdout, 0);
***/
PrintStackSort(psp);
/***
printf("After sort\n");
PrintStackDump(psp, stdout, 0);
printf("\n\n");
***/
PrintStackPrint(psp, options);
PrintStackFree(psp);
if (options->fp == NULL)
{
if (BSLen(options->bstp))
options->ptr = BSMerge(options->bstp, NULL);
BSFree(options->bstp);
}
return TRUE;
}
static BSErr appendChar(XMLParser* parser,unsigned char a)
{
if (parser->string == NULL) {
parser->string = (unsigned char*)BSCalloc(QBNodePoolPtr(parser),1000,"appendChar");
parser->strptr = 0;
}
if (parser->string) {
if (BSSize(parser->string)-1 <= parser->strptr) {
unsigned char* mem = (unsigned char*)BSCalloc(QBNodePoolPtr(parser),BSSize(parser->string)+1000,"appendChar");
if (mem) {
strcpy((char*)mem,(char*)parser->string);
BSFree(parser->string);
parser->string = mem;
} else {
return BSERR_MEM;
}
}
parser->string[parser->strptr++] = a;
parser->string[parser->strptr] = 0;
}
return BSERR_OK;
}
static TrajErr TRADESBenchmark(void)
{
/* protein is 1CDZ, same as beta protein - mixed alpha/beta protein 96 AA */
static Char sequence[]="ELPDFFQGKHFFLYGEFPGDERRKLIRYVTAFNGELEDYMSDRVQFVITAQEWDPSFEEALMDNPSLAFVRPRWIYSCNEKQKLLPHQLYGVVPQA";
CharPtr pc;
FILE *f;
Char fnamseq[PATH_MAX];
Char fnam[PATH_MAX];
Char fnamtrj[PATH_MAX];
Char fnuturndb[PATH_MAX];
Int2 err,numAA,cnt;
Int4 randseed,dbsize;
pMakeTrjParamBlock mkdata;
pFoldTrajParamBlock foldtrajprm;
CPUTimePtr pTime1,pTime2,pTime3,pTime4;
BiostrucPtr bspBiostruc;
PDNMS pdnmsModelstruc;
PMSD pmsdHead;
PDNML pdnmlModel;
PMLD pmldThis;
BiostrucIdPtr pbi=NULL;
BiostrucDescrPtr pbd=NULL;
printf("%d is the CODEBASE version here.\n6502:UNIX x86_32, 6503003:UNIX x86_64, 6500:Win32, 6401:UNIX PPC_32\n\n", S4VERSION);
sprintf(fnuturndb,"UTURNDB"); /* to clean up errant U-Turn files CWVH 2010 */
if (!OPENMMDBAPI(0,NULL)) {
ErrPostEx(SEV_ERROR,2,1,"Unable to open MMDBAPI");
return ERR_FAIL;
}
printf("One moment, opening rotamer library...\n");
if (LoadRotLib()!=ERR_SUCCESS) {
ErrPostEx(SEV_ERROR,1,8,"Cannot open rotamer library (%s%s) - if the file is missing, please re-install the software",CFG_local_datafilepath,NEWSCWRL_FNAM);
return ERR_FAIL;
}
pc=DFPTmpNam(FALSE,FALSE);
if ((f=FileOpen(pc,"w"))==NULL) {
CLOSEMMDBAPI();
FreeRotLib();
ErrPostEx(SEV_ERROR,errno,1,"Failed to open %s file",pc);
return ERR_FAIL;
}
fprintf(f,"%s\n",sequence);
/* Make sure disk space was sufficient to write to file */
if (fflush(f)==EOF) {
FileClose(f);
CLOSEMMDBAPI();
FreeRotLib();
ErrPostEx(SEV_ERROR,errno,1,"Failed to write to %s file",pc);
return ERR_FAIL;
}
FileClose(f);
StringCpy(fnamseq,pc);
sprintf(fnam,"%s%s",CFG_local_datafilepath,BENCH_TRAJ);
sprintf(fnamtrj,"%s%s%s",CFG_local_datafilepath,BENCH_TRAJ,ASN_EXT);
mkdata = (pMakeTrjParamBlock)MemNew(sizeof(MakeTrjParamBlock));
mkdata->TrajMethod = 2; /* from sequence */
mkdata->valfnamin = NULL;
mkdata->pcChain = NULL;
mkdata->modelnum = 1;
mkdata->startres = 1;
mkdata->endres = 0;
mkdata->peakheight = 100;
mkdata->noise = 0;
mkdata->savechi = 0;
mkdata->sigma_x = 0.0;
mkdata->sigma_y = 0.0;
mkdata->temperature = 0;
mkdata->timestep = 0.0;
mkdata->seqfnamin = fnamseq;
mkdata->tgtype = 4;
mkdata->sstrufname = NULL;
mkdata->DoRPS = FALSE;
mkdata->uturn = FALSE;
mkdata->SStruinput = FALSE;
mkdata->trjfnamout = fnam;
mkdata->comprtype = USE_RLE;
mkdata->constrfnamin = NULL;
mkdata->units=UNITS_ARBITRARY;
mkdata->templat=NULL;
mkdata->zhangwindsize = 0;
mkdata->alignfile=NULL;
mkdata->ssmask=NULL;
mkdata->dumpcsv=0;
mkdata->benchmark=1;
mkdata->all_coil = (Boolean)(FALSE);
mkdata->all_beta = (Boolean)(FALSE);
/* ensure config file is set right, even if user may have fudged it */
if (SetConfigFileValues(WALK_PHIPSI,50.0/*errtol*/, 0.25/*abbb*/, 0.50/*absc*/, 0.0/*tunnelprob*/)!=ERR_SUCCESS) {
CLOSEMMDBAPI();
FreeRotLib();
mkdata=MemFree(mkdata);
FileRemove(pc);
#ifdef OS_UNIX
ErrPostEx(SEV_ERROR,0,0,"Unable to write config file .foldtrajrc, cannot continue");
#else
ErrPostEx(SEV_FATAL,0,0,"Unable to write config file foldtraj.ini, cannot continue");
#endif
return ERR_FAIL;
}
printf("Predicting secondary structure and generating trajectory distribution...\n");
pTime1=CPUTimeMeasure();
MakeTrj((VoidPtr)mkdata);
printf("MadeTrj complete, unpacking ASN.1 Trajectory Graph\n");
pTime2=CPUTimeMeasure();
mkdata=MemFree(mkdata);
FileRemove(fnamseq);
if (UnPackAsnTrajGraph(fnam,&numAA,sequence,NULL,&pbi,&pbd,NULL)==NULL) {
CLOSEMMDBAPI();
FreeRotLib();
FileRemove(fnamtrj);
ErrPostEx(SEV_ERROR,2,3,"Unable to read trajectory distribution %s, please create a new one",fnam);
return ERR_FAIL;
}
randseed=54374;
RandomSeed(randseed);
StringCpy(tmpskelfname,DFPTmpNam(FALSE,FALSE));
/* make the ASN.1 file for this protein's chemical graph */
BuildSkelASN(sequence,tmpskelfname);
InitBSPLog(randseed,sequence,totalstruc);
TGInit(tmpdbasename,DB_READ,&dbsize);
printf("Folding protein...\n");
pTime3=CPUTimeMeasure();
for (cnt=0;cnt<100;cnt++) {
bspBiostruc=NULL;
bspBiostruc=MIMEBiostrucAsnGet(tmpskelfname,"r",NULL);
if (bspBiostruc==NULL) {
CLOSEMMDBAPI();
FreeRotLib();
FileRemove(fnamtrj);
BSFree(bspTempLog);
FileRemove(tmpskelfname);
TGClose();
CleanUpDB(tmpdbasename);
CleanUpDB(fnuturndb);
ErrPostEx(SEV_ERROR,3,1,"Unable to fetch Biostruc");
return ERR_FAIL;
}
if (pbi!=NULL) {
if (bspBiostruc->id!=NULL)
AsnGenericChoiceSeqOfFree(bspBiostruc->id,(AsnOptFreeFunc)BiostrucIdFree);
bspBiostruc->id=pbi;
pbi=NULL;
}
if (pbd!=NULL) {
if (bspBiostruc->descr!=NULL)
AsnGenericChoiceSeqOfFree(bspBiostruc->descr,(AsnOptFreeFunc)BiostrucDescrFree);
bspBiostruc->descr=pbd;
pbd=NULL;
}
/* now the chemical graph is correctly in memory as a modelstruc, with
co-ordinates (and hence PALDs) assigned only to a-carbons */
pdnmsModelstruc=MakeAModelstruc(bspBiostruc);
if (pdnmsModelstruc==NULL) {
CLOSEMMDBAPI();
FreeRotLib();
FileRemove(fnamtrj);
BSFree(bspTempLog);
FileRemove(tmpskelfname);
TGClose();
CleanUpDB(tmpdbasename);
CleanUpDB(fnuturndb);
ErrPostEx(SEV_ERROR,4,1,"Unable to convert Biostruc to Modelstruc. Please ensure your protein only contains the 20 standard amino acids.");
return ERR_FAIL;
}
pmsdHead=(PMSD)(pdnmsModelstruc->data.ptrvalue);
/* remove ppAsnOrder for all models so it will be rebuilt
in WriteAsnAllModel */
pdnmlModel=pmsdHead->pdnmlModels;
while (pdnmlModel) {
pmldThis=(PMLD)(pdnmlModel->data.ptrvalue);
if (pmldThis->ppAsnOrder) {
PTRVectorFree(pmldThis->ppAsnOrder,0);
pmldThis->ppAsnOrder=NULL;
}
pdnmlModel=pdnmlModel->next;
}
if (dbsize!=((PMMD)((pmsdHead->pdnmmHead)->data.ptrvalue))->iResCount) {
CLOSEMMDBAPI();
FreeRotLib();
FreeAModelstruc(pdnmsModelstruc);
BSFree(bspTempLog);
FileRemove(fnamtrj);
FileRemove(tmpskelfname);
TGClose();
CleanUpDB(tmpdbasename);
CleanUpDB(fnuturndb);
ErrPostEx(SEV_ERROR,1,1,"protein length inconsistency error, expect: %d actual: %d, possibly due to corrupt trajectory file; aborting",((PMMD)((pmsdHead->pdnmmHead)->data.ptrvalue))->iResCount,dbsize);
return ERR_FAIL;
}
foldtrajprm=(pFoldTrajParamBlock)MemNew(sizeof(FoldTrajParamBlock));
foldtrajprm->pmsdRoot=pmsdHead;
foldtrajprm->Model=1;
foldtrajprm->err=0;
foldtrajprm->gen=0;
foldtrajprm->errorfile=NULL;
/* do the folding here */
TRADEProtein((VoidPtr)foldtrajprm,1);
err=foldtrajprm->err;
foldtrajprm=MemFree(foldtrajprm);
FreeAModelstruc(pdnmsModelstruc);
if (err!=ERR_SUCCESS && err!=ERR_INCOMPLETE) {
FileRemove(fnamtrj);
FileRemove(tmpskelfname);
BSFree(bspTempLog);
TGClose();
CleanUpDB(tmpdbasename);
CleanUpDB(fnuturndb);
CLOSEMMDBAPI();
FreeRotLib();
ErrPostEx(SEV_ERROR,1,1,"Benchtraj returned a folding error %d",err);
return ERR_FAIL;
}
}
pTime4=CPUTimeMeasure();
FileRemove(fnamtrj);
FileRemove(tmpskelfname);
BSFree(bspTempLog);
TGClose();
CleanUpDB(tmpdbasename);
CleanUpDB(fnuturndb);
CLOSEMMDBAPI();
FreeRotLib();
printf("Benchmark complete.\n\nSummary\n-------\n Usr time Sys time\n -------- --------\n");
printf("Maketrj %9.3f %9.3f\nFoldtraj %9.3f %9.3f\n\n",CPUTimeGetUser(pTime2)-CPUTimeGetUser(pTime1),CPUTimeGetSys(pTime2)-CPUTimeGetSys(pTime1),CPUTimeGetUser(pTime4)-CPUTimeGetUser(pTime3),CPUTimeGetSys(pTime4)-CPUTimeGetSys(pTime3));
printf("Benchtraj successful\n");
return ERR_SUCCESS;
}
NLM_EXTERN Int4 print_protein_for_cds(SeqFeatPtr sfp, CharPtr buf, SeqLocPtr loc, Boolean reverse_minus)
{
CdRegionPtr crp;
Int4 frame_offset, start_offset;
Uint1 f_strand;
Boolean reverse;
Int4 cd_len;
GatherRange gr;
Int2 p_pos, buf_len;
Int4 a_left, a_right;
Int4 aa, val;
SeqLocPtr slp;
SeqPortPtr spp;
ByteStorePtr p_data;
Int4 end_pos, start_pos = -1;
Uint1 residue;
Boolean seal_ends = FALSE;
Boolean reverse_order;
if(sfp == NULL || sfp->data.choice != 3)
return -1;
if(buf == NULL || loc == NULL)
return -1;
crp = sfp->data.value.ptrvalue;
if(crp == NULL)
return -1;
if(buf[0] == '\0')
seal_ends = TRUE;
spp = NULL;
p_data = NULL;
if(sfp->product !=NULL && !IS_BOGO_Product(sfp->ext))
{
spp = SeqPortNewByLoc(sfp->product, Seq_code_ncbieaa);
if(spp !=NULL)
{
SeqPortSeek(spp, 0, SEEK_SET);
end_pos = spp->totlen-1;
}
}
if(spp == NULL)
{
p_data = ProteinFromCdRegion(sfp, TRUE);
/* p_data = ProteinFromCdRegion(sfp, FALSE); */
if(p_data !=NULL)
{
BSSeek(p_data, 0, SEEK_SET);
end_pos = BSLen(p_data)-1;
}
}
if(spp == NULL && p_data == NULL)
return -1;
if(crp->frame == 0)
frame_offset = 0;
else
frame_offset = (Int4)crp->frame-1;
start_offset = frame_offset;
f_strand = SeqLocStrand(sfp->location);
reverse = ck_reverse(f_strand, SeqLocStrand(loc));
/*if reverse == TRUE, the translated protein is written backwards*/
if(reverse && reverse_minus)
reverse_order = TRUE;
else
reverse_order = FALSE;
slp = NULL;
cd_len = 0;
aa = 0;
buf_len = SeqLocLen(loc);
if(reverse_order)
{
p_pos = buf_len -1;
if(seal_ends)
{
buf[p_pos+1] = '\0';
seal_ends = FALSE;
}
}
else
p_pos = 0;
while((slp = SeqLocFindNext(sfp->location, slp))!=NULL)
{
if(SeqLocOffset(loc, slp, &gr, 0))
{
if(reverse_order)
{
if(gr.right < p_pos)
p_pos = (Int2)(gr.right);
}
else
{
if(p_pos < gr.left)
p_pos = (Int2)(gr.left);
}
SeqLocOffset(slp, loc, &gr, 0);
a_left = gr.left + cd_len;
a_right = gr.right + cd_len;
/* if(reverse_order)
{
temp = a_right;
a_right = -a_left;
a_left = -temp;
} */
for(; a_left<=a_right; ++a_left)
{
val = ABS(a_left) - start_offset;
aa = val/3;
if(aa < 0 || aa > end_pos)/*stop & partial codon*/
{
buf[p_pos] = '^';
}
else
{
if(val%3==1)/*label aa in the middle of 3-bp codon*/
{
if(start_pos == -1)
start_pos = aa;
if(spp !=NULL)
{
SeqPortSeek(spp, aa, SEEK_SET);
residue = SeqPortGetResidue(spp);
}
else
{
BSSeek(p_data, aa, SEEK_SET);
residue = (Uint1)BSGetByte(p_data);
}
if(IS_ALPHA(residue) || residue == '*' || residue == '-')
buf[p_pos] = residue;
else
buf[p_pos] = '?';
}
else
buf[p_pos] = ' ';
}
if(reverse_order)
-- p_pos;
else {
++p_pos;
if (p_pos > buf_len)
break;
}
}
}
cd_len += SeqLocLen(slp);
/*frame_offset = (cd_len - start_offset)%3;
if(frame_offset > 0)
--frame_offset;*/
}
if(spp != NULL)
SeqPortFree(spp);
if(p_data != NULL)
BSFree(p_data);
if(p_pos == 0) /*all the residues are introns*/
{
if(seal_ends)
{
end_pos = buf_len;
MemSet((Pointer)buf, '~', (size_t)(end_pos) * sizeof(Char));
buf[end_pos] = '\0';
}
}
else
{
if(seal_ends)
{
buf[p_pos] = '\0';
}
if(start_pos == -1)
start_pos = aa;
}
return start_pos;
}
