/*****************************************************************************
*
* opens a file and reads SeqEntrys
* calls ProcessSeqEntry to do the actual work on it
*
*****************************************************************************/
static void ProcessFile (FileListPtr flp, CharPtr root, CharPtr outputfile)
{
CASN_Handle casnh;
FILE *fp;
Char path [PATH_MAX];
SeqEntryPtr sep;
CASN_Type type;
Char buf[40];
Int4 ctr = 0;
if (flp != NULL) {
fp = FileOpen (outputfile, "a");
if (fp != NULL) {
if (pmon != NULL)
{
sprintf(path, "Opening [%s]", flp->fname);
MonitorStrValue(pmon, path);
}
StringCpy (path, root);
FileBuildPath (path, flp->fdir, NULL);
FileBuildPath (path, NULL, flp->fname);
if ((casnh = CASN_Open (path)) != NULL) {
if (! is_na) {
type = CASN_Type_aa;
} else {
type = CASN_Type_nt;
}
if (CASN_DocType (casnh) == type) {
while ((sep = CASN_NextSeqEntry (casnh)) != NULL) {
if (pmon != NULL)
{
ctr++;
sprintf(buf, "Processing %s Entry %ld", flp->fname,(long)ctr);
MonitorStrValue(pmon, buf);
}
ProcessSeqEntry (sep, fp);
SeqEntryFree (sep);
}
}
CASN_Close (casnh);
}
else
Message(MSG_ERROR, "Can't open [%s]", path);
FileClose (fp);
} else {
Message (MSG_FATAL, "Unable to reopen output file [%s]", outputfile);
}
}
}
static Pointer ReadOneFile (
CharPtr directory,
CharPtr base,
CharPtr suffix,
Uint2Ptr datatype
)
{
Pointer dataptr;
Char file [FILENAME_MAX], path [PATH_MAX];
FILE* fp;
*datatype = 0;
StringNCpy_0 (path, directory, sizeof (path));
sprintf (file, "%s.%s", base, suffix);
FileBuildPath (path, NULL, file);
fp = FileOpen (path, "r");
if (fp == NULL) return NULL;
/* ReadAsnFastaOrFlatFile can read ASN.1, FASTA, and feature table formats */
dataptr = ReadAsnFastaOrFlatFile (fp, datatype, NULL, FALSE, FALSE, TRUE, FALSE);
FileClose (fp);
return dataptr;
}
static void FlatfileOneFile (
CharPtr directory,
CharPtr base,
CharPtr suffix,
SeqEntryPtr sep
)
{
Char file [FILENAME_MAX], path [PATH_MAX];
FILE *fp;
ErrSev oldErrSev;
StringNCpy_0 (path, directory, sizeof (path));
sprintf (file, "%s.%s", base, suffix);
FileBuildPath (path, NULL, file);
fp = FileOpen (path, "w");
if (fp == NULL) return;
oldErrSev = ErrSetMessageLevel (SEV_MAX);
SeqEntryToFlat (sep, fp, GENBANK_FMT, SEQUIN_MODE);
ErrSetMessageLevel (oldErrSev);
FileClose (fp);
}
static void ValidateOneFile (
CharPtr directory,
CharPtr base,
CharPtr suffix,
SeqEntryPtr sep
)
{
Char file [FILENAME_MAX], path [PATH_MAX];
ErrSev oldErrSev;
ValidStructPtr vsp;
StringNCpy_0 (path, directory, sizeof (path));
sprintf (file, "%s.%s", base, suffix);
FileBuildPath (path, NULL, file);
ErrSetOptFlags (EO_LOGTO_USRFILE);
ErrSetLogfile (path, ELOG_APPEND | ELOG_NOCREATE);
vsp = ValidStructNew ();
if (vsp != NULL) {
vsp->useSeqMgrIndexes = TRUE;
vsp->suppressContext = TRUE;
oldErrSev = ErrSetMessageLevel (SEV_NONE);
ValidateSeqEntry (sep, vsp);
ValidStructFree (vsp);
ErrSetMessageLevel (oldErrSev);
}
ErrSetLogfile (NULL, ELOG_APPEND | ELOG_NOCREATE);
ErrClearOptFlags (EO_LOGTO_USRFILE);
}
static AsnIoPtr AsnIoFromInputStream (
InputStreamPtr isp
)
{
AsnIoPtr aip;
Char file [FILENAME_MAX], path [PATH_MAX];
CharPtr read_flag;
if (isp == NULL) return NULL;
if (isp->is_binary) {
read_flag = "rb";
} else {
read_flag = "r";
}
if (isp->base == NULL) {
aip = AsnIoOpen ("stdin", read_flag);
} else {
StringNCpy_0 (path, isp->directory, sizeof (path));
sprintf (file, "%s%s", isp->base, isp->suffix);
FileBuildPath (path, NULL, file);
aip = AsnIoOpen (path, read_flag);
}
return aip;
}
static AsnIoPtr AsnIoFromOutputStream (OutputStreamPtr osp)
{
AsnIoPtr aip;
Char file [FILENAME_MAX], path [PATH_MAX];
CharPtr write_flag;
if (osp == NULL) return NULL;
if (osp->aip == NULL) {
write_flag = osp->is_binary ? "wb" : "w";
if (StringDoesHaveText (osp->outfile)) {
StringNCpy_0 (path, osp->outfile, sizeof (path));
} else {
if (osp->base == NULL) {
aip = AsnIoOpen ("stdout", write_flag);
} else {
if (osp->outsuffix == NULL) {
osp->outsuffix = "";
}
StringNCpy_0 (path, osp->results_dir, sizeof (path));
sprintf (file, "%s%s%s", osp->base, osp->suffix, osp->outsuffix);
FileBuildPath (path, NULL, file);
aip = AsnIoOpen (path, write_flag);
if (aip == NULL) {
Message (MSG_POSTERR, "Unable to write to %s.", path);
}
}
}
} else {
aip = osp->aip;
}
return aip;
}
static SeqSubmitPtr ReadOneSubmission (
CharPtr directory,
CharPtr base,
CharPtr suffix
)
{
AsnIoPtr aip;
Char file [FILENAME_MAX], path [PATH_MAX];
SeqSubmitPtr ssp;
if (base == NULL) {
base = "";
}
if (suffix == NULL) {
suffix = "";
}
StringNCpy_0 (path, directory, sizeof (path));
sprintf (file, "%s%s", base, suffix);
FileBuildPath (path, NULL, file);
aip = AsnIoOpen (path, "r");
if (aip == NULL) return NULL;
ssp = SeqSubmitAsnRead (aip, NULL);
AsnIoClose (aip);
return ssp;
}
static FILE* OpenOneFile (
CharPtr directory,
CharPtr base,
CharPtr suffix
)
{
Char file [FILENAME_MAX], path [PATH_MAX];
if (base == NULL) {
base = "";
}
if (suffix == NULL) {
suffix = "";
}
StringNCpy_0 (path, directory, sizeof (path));
sprintf (file, "%s%s", base, suffix);
FileBuildPath (path, NULL, file);
return FileOpen (path, "r");
}
static void WriteOneFile (
CharPtr directory,
CharPtr base,
CharPtr suffix,
SeqEntryPtr sep
)
{
AsnIoPtr aip;
Char file [FILENAME_MAX], path [PATH_MAX];
StringNCpy_0 (path, directory, sizeof (path));
sprintf (file, "%s.%s", base, suffix);
FileBuildPath (path, NULL, file);
aip = AsnIoOpen (path, "w");
if (aip == NULL) return;
SeqEntryAsnWrite (sep, aip, NULL);
AsnIoFlush (aip);
AsnIoClose (aip);
}
/* return -1 on failure, 0 on success */
static Int4 FileRecurse (
CharPtr directory,
InputStreamPtr isp,
OutputStreamPtr osp,
AsnStreamPtr asp,
Int4Ptr gap_sizes
)
{
Char path [PATH_MAX];
CharPtr ptr;
CharPtr str;
ValNodePtr head, vnp;
CharPtr orig_dir, orig_base;
Int4 rval = 0;
/* get list of all files in source directory */
head = DirCatalog (directory);
for (vnp = head; vnp != NULL; vnp = vnp->next) {
if (vnp->choice == 0) {
str = (CharPtr) vnp->data.ptrvalue;
if (StringDoesHaveText (str)) {
/* does filename have desired substring? */
ptr = StringStr (str, osp->suffix);
if (ptr != NULL) {
/* make sure detected suffix is really at end of filename */
if (StringCmp (ptr, osp->suffix) == 0) {
*ptr = '\0';
/* process file that has desired suffix (usually .fsa) */
osp->base = str;
orig_dir = isp->directory;
isp->directory = directory;
orig_base = isp->base;
isp->base = str;
if (isp->is_binary) {
rval |= ProcessStream (isp, osp, asp, gap_sizes);
} else {
rval |= ProcessOneRecord (directory, osp, gap_sizes);
}
isp->directory = orig_dir;
isp->base = orig_base;
osp->base = NULL;
}
}
}
} else if (vnp->choice == 1) {
/* recurse into subdirectory */
StringNCpy_0 (path, directory, sizeof (path));
str = (CharPtr) vnp->data.ptrvalue;
FileBuildPath (path, str, NULL);
rval |= FileRecurse (path, isp, osp, asp, gap_sizes);
}
}
/* clean up file list */
ValNodeFreeData (head);
return rval;
}
PCSAN LIBCALL LoadCSAN(CharPtr pcFile)
{
FILE *f;
Char fullpath [PATH_MAX];
CharPtr ptr;
PCSAN pcsanHead = NULL;
PCSAN pcsanTemp = NULL;
Char pcBuf[250];
CharPtr ppcParse[125];
CharPtr pcTemp = NULL;
CharPtr pcTest = NULL;
CharPtr pcSeqPart = NULL;
ValNodePtr pvn = NULL;
long int val = 0;
Int4 i = 0;
Int4 iString = 0;
Int4 iLen =0;
Int4 iWC =0;
Int4 iWL = 0;
Int4 iGi = 0;
if (!pcFile) return(NULL);
ProgramPath (fullpath, sizeof (fullpath) - 1);
ptr = StringRChr (fullpath, DIRDELIMCHR);
if (ptr != NULL) {
*ptr = '\0';
}
/* printf("FULLPATH[%s]\n",IsNullStr(fullpath)); */
FileBuildPath (fullpath, NULL, pcFile);
/* printf("FULLPATH[%s]\n",IsNullStr(fullpath)); */
if ((f = FileOpen (fullpath, "r")) == NULL)
{
if (FindPath ("NCBI", "NCBI", "DATA", fullpath, sizeof (fullpath) - 1))
{
FileBuildPath (fullpath, NULL, pcFile);
f = FileOpen (fullpath, "r");
if (f == NULL)
{
ErrPost(CTX_NCBIOBJ, 1, "Couldn't open [%s] in LoadCSA", IsNullStr(fullpath));
return (NULL);
}
}
else
{
ErrPost(CTX_NCBIOBJ, 1, "FindPath failed in LoadNeighbors");
return (NULL);
}
}
do /* get each line, tokenize into ppcParse */
{
pcBuf[0] = '\0';
pcTest = fgets(pcBuf, (size_t)250, f);
/* printf("[%s]\n",IsNullStr(pcTest)); */
if (pcTest)
{
iLen = StringLen(pcTest);
/* Break into words delimited by whitespace or "|" */
/* gi|123456| */
/* printf("LineLength %d\n",(int) iLen); */
for (i=0; i < 125; i++) ppcParse[i] = NULL;
pcTemp = pcTest;
ppcParse[0] = pcTest;
iWC = 1;
while ((*pcTemp != '\0') && (iWC < 125))
{
if ((*pcTemp == '|') || (*pcTemp == ' ') || (*pcTemp == '\t') || (*pcTemp == '\n'))
{
*pcTemp = '\0'; /* terminate current word */
do {
pcTemp++; /* skip whitespace to next word */
} while ((*pcTemp == '|') || (*pcTemp == ' ') || (*pcTemp == '\t') || (*pcTemp == '\n'));
ppcParse[iWC] = pcTemp; /* start next word */
iWC++;
}
else
pcTemp++;
}
/* DEBUG TEST */
/* for (i=0; i<125; i++)
if (ppcParse[i] != NULL)
{
printf("%ld/%ld [%s]\n",i,iWC, IsNullStr(ppcParse[i]));
} */
/* If ppcParse[0] is "gi" then this is a VALID sequence line and the last
word parsed is the sequence */
if (ppcParse[0][0] != '\0')
{
iWL = StringLen(ppcParse[0]);
if (iWL == 2)
if (((ppcParse[0][0] == 'g') ||
(ppcParse[0][0] == 'G')) &&
((ppcParse[0][1] == 'i') ||
(ppcParse[0][1] == 'I')))
{
/* next word should be GI */
iGi = 0;
if (StrToInt4 (ppcParse[1], &iGi))
{
/* printf("GI is (%ld)\n",iGi); */
if (iGi == 0) goto parserr;
/* find the 2nd last string = sequence */
/* last string is stripped off line terminator, by the way... */
iString=2; /* start after GI */
while (ppcParse[iString+1] != NULL)
{ /* iString is the LAST sting - line terminator */
iString++;
}
pcsanTemp = pcsanHead;
while (pcsanTemp)
{ /* look for existing pcsan */
if (iGi == pcsanTemp->iGi)
{
break;
}
pcsanTemp = pcsanTemp->next;
}
if (!pcsanTemp) /* otherwise add a new one */
{
pcsanTemp = NewCSAN();
pcsanTemp->next = pcsanHead;
pcsanHead = pcsanTemp; /* put at head of list */
pcsanTemp->iGi = iGi;
}
/* Initialize fields */
pcSeqPart = NULL;
pcSeqPart = StringSave(ppcParse[iString-1]);
/* printf("SEQ [%ld]= [%s]\n",(long) iString-1, IsNullStr(pcSeqPart)); */
ValNodeAddStr(&pcsanTemp->pvnSeqAlnPart, 0, pcSeqPart);
} /* if GI */
} /* if line starts with GI */
} /* if line starts with a word */
} /* if pcTest */
} while (pcTest);
printf("REPORT\n");
pcsanTemp = pcsanHead;
while (pcsanTemp)
{
printf("GI = [%ld]\n", (long) pcsanTemp->iGi);
pvn = pcsanTemp->pvnSeqAlnPart;
while (pvn)
{
printf(">%s<\n",(char *) IsNullStr(pvn->data.ptrvalue));
pvn = pvn->next;
}
pcsanTemp = pcsanTemp->next;
}
FileClose(f);
return pcsanHead;
parserr:
FileClose(f);
ErrPostEx(SEV_FATAL,0,0, "Error in input format \n");
FreeCSAN(pcsanHead);
return NULL;
}
/*****************************************************************************
*
* AsnTreeLoad(file, &avn, &at, &)
*
*****************************************************************************/
NLM_EXTERN Boolean LIBCALL AsnTreeLoad (char *file, AsnValxNodePtr *avnptr, AsnTypePtr *atptr, AsnModulePtr *ampptr)
{
AsnValxNodePtr avn = NULL, avncurr;
AsnTypePtr at = NULL, atcurr;
AsnModulePtr amp = NULL, ampcurr;
ValNodePtr anp, ampanp;
int numval, numtype, nummod, i;
FILE * fp;
int isa, next;
long intvalue;
double realvalue;
char name[PATH_MAX], fname[60];
CharPtr ptr;
int bools[5], tagclass, tagnumber, defaultvalue, type, branch;
/* check to see if we already have it (could happen) */
anp = names;
ampanp = amps;
while (anp != NULL)
{
if (! StringCmp((CharPtr)anp->data.ptrvalue, file))
{ /* have it */
if (* ampptr == NULL) /* fill dynamic load */
{
* ampptr = (AsnModulePtr) ampanp->data.ptrvalue;
* atptr = (* ampptr)->types;
/* don't really need avnptr filled in */
}
return TRUE;
}
ampanp = ampanp->next;
anp = anp->next;
}
if (! ProgMon("Load ASN.1 Trees"))
return FALSE;
if (* ampptr != NULL) /* static load, add to list */
{
AsnStoreTree(file, (* ampptr));
return TRUE; /* already loaded */
}
if (! FindPath("ncbi", "ncbi", "asnload", name, sizeof (name)))
{
AsnIoErrorMsg(NULL, 85);
return FALSE;
}
FileBuildPath (name, NULL, file);/* add file to path */
fp = FileOpen(name, "r");
if (fp == NULL)
{
AsnIoErrorMsg(NULL, 83, (CharPtr) name);
return FALSE;
}
fscanf(fp, "%d %d %d", &numval, &numtype, &nummod);
if (numval)
avn = (AsnValxNodePtr) MemNew(numval * sizeof(AsnValxNode));
at = (AsnTypePtr) MemNew(numtype * sizeof(AsnType));
amp = (AsnModulePtr) MemNew(nummod * sizeof(AsnModule));
*avnptr = avn;
*atptr = at;
*ampptr = amp;
avncurr = avn;
for (i = 0; i < numval; i++)
{
fscanf(fp, "%d %s %ld %lf %d", &isa, name, &intvalue, &realvalue, &next);
avncurr->valueisa = isa;
if (*name != '-')
avncurr->name = StringSave(name);
avncurr->intvalue = (Int4)intvalue;
avncurr->realvalue = (FloatHi)realvalue;
avncurr->next = (AsnValxNodePtr) PointerDecode((Int2)next, avn, at);
avncurr++;
}
atcurr = at;
for (i = 0; i < numtype; i++)
{
fscanf(fp, "%d %s %d %d %d %d %d %d %d %d %d %d %d",
&isa, name, &tagclass, &tagnumber, bools, bools+1, bools+2,
bools+3, bools+4, &defaultvalue, &type, &branch, &next);
atcurr->isa = isa;
if (*name != '-')
{
atcurr->name = StringSave(name);
ptr = atcurr->name;
while (*ptr != '\0')
{
if (*ptr == '!')
*ptr = ' ';
ptr++;
}
}
atcurr->tagclass = (Uint1)tagclass;
atcurr->tagnumber = tagnumber;
atcurr->implicit = (Boolean)bools[0];
atcurr->optional = (Boolean)bools[1];
atcurr->hasdefault = (Boolean)bools[2];
atcurr->exported = (Boolean)bools[3];
atcurr->imported = (Boolean)bools[4];
atcurr->defaultvalue = (AsnValxNodePtr)PointerDecode((Int2)defaultvalue, avn, at);
atcurr->type = (AsnTypePtr)PointerDecode((Int2)type, avn, at);
atcurr->branch = PointerDecode((Int2)branch, avn, at);
atcurr->next = (AsnTypePtr)PointerDecode((Int2)next, avn,at);
atcurr++;
}
ampcurr = amp;
for (i = 0; i < nummod; i++)
{
fscanf(fp, "%s %s %d %d", name, fname, &type, &next);
if (*name != '-')
ampcurr->modulename = StringSave(name);
if (*fname != '-')
ampcurr->filename = StringSave(fname);
ampcurr->types = (AsnTypePtr)PointerDecode((Int2)type, avn, at);
if (next != -32000)
ampcurr->next = &[next];
ampcurr++;
}
FileClose(fp);
/* store it in list */
AsnStoreTree(file, (* ampptr));
return TRUE;
}
static FloatHiPtr NTComposition (SeqPortPtr spp, Int4 length,
Int4 window, Uint1 filtertype)
{
Int4 i, n, iring;
Boolean flagMatch;
FloatHi NTcount;
FloatHiPtr ringptr;
Char res[FILTS], chres;
FloatHi scr[FILTS];
Boolean flagFilter;
FloatHiPtr fhead, fptr;
Char buf[PATH_MAX], filename[32];
if (length < window)
return NULL;
if (!FindPath ("ncbi", "ncbi", "data", buf, sizeof (buf)))
return NULL;
fptr = (FloatHiPtr) MemNew ((sizeof (FloatHi)) * length);
fhead = fptr;
for (i = 0; i < length; i++)
*fptr++ = 0.0;
fptr = fhead;
switch (filtertype)
{
case NA_FILTER_GC:
StringCpy (filename, "KSgc.flt");
FileBuildPath (buf, NULL, "KSgc.flt");
break;
case NA_FILTER_AT:
StringCpy (filename, "KSat.flt");
FileBuildPath (buf, NULL, "KSat.flt");
break;
case NA_FILTER_PUR:
StringCpy (filename, "KSpur.flt");
FileBuildPath (buf, NULL, "KSpur.flt");
break;
case NA_FILTER_PYR:
StringCpy (filename, "KSpyr.flt");
FileBuildPath (buf, NULL, "KSpyr.flt");
break;
default:
MemFree (fptr);
return NULL;
}
flagFilter = ReadFilter (res, scr, buf, filename);
if (!flagFilter)
{
MemFree (fptr);
return NULL;
}
/* set up ring buffer */
ringptr = (FloatHiPtr) MemNew (sizeof (FloatHi) * window);
iring = 0;
NTcount = 0;
for (i = 0; i < window; i++)
{
chres = SeqPortGetResidue (spp);
flagMatch = 0;
n = 0;
while (res[n] != '\0')
{
if (chres == res[n])
{
flagMatch = 1;
break;
}
n++;
}
switch (flagMatch)
{
case 1:
NTcount += scr[n];
ringptr[iring] = scr[n];
break;
default:
ringptr[iring] = 0;
break;
}
iring++;
if (iring == window)
iring = 0;
}
for (i = 0; i < window/2; i++)
fptr++;
*fptr = NTcount/window*100;
fptr++;
/* calculate average */
for (i = window; i < length; i++)
{
NTcount = NTcount - ringptr[iring];
chres = SeqPortGetResidue (spp);
flagMatch = FALSE;
n = 0;
while (res[n] != '\0')
{
if (chres == res[n])
{
flagMatch = TRUE;
break;
}
n++;
}
switch (flagMatch)
{
case 1:
NTcount += scr[n];
ringptr[iring] = scr[n];
break;
default:
ringptr[iring] = 0;
break;
}
iring++;
if (iring == window)
iring = 0;
*fptr = NTcount/window*100;
fptr++;
}
MemFree (ringptr);
return fhead;
}
/*****************************************************************************
*
* PrintTemplateSetPtr PrintTemplateSetLoad()
* loads PrintTemplates
* If path== NULL, looks for "prt.prt" in the "data" directory
*
*****************************************************************************/
static Boolean PrintTemplateSetLoadInt ( CharPtr path, Boolean verbose )
{
AsnIoPtr aip;
FILE *f;
Boolean retval;
Char filename [80];
Char fullpath [PATH_MAX];
CharPtr ptr;
ErrSev lastLevel;
aip = NULL;
if (path != NULL && *path != '\0' && StringRChr (path, DIRDELIMCHR) != NULL) {
StringNCpy (fullpath, path, sizeof (fullpath) - 1);
if ((aip = AsnIoOpen (fullpath, "r")) == NULL) {
if (verbose) {
ErrPost(CTX_NCBIOBJ, 1, "Couldn't open [%s]", fullpath);
}
return FALSE;
}
} else {
if (path != NULL && *path != '\0') {
StringNCpy (filename, path, sizeof (filename) - 1);
} else {
StringCpy (filename, "prt.prt");
}
ProgramPath (fullpath, sizeof (fullpath) - 1);
ptr = StringRChr (fullpath, DIRDELIMCHR);
if (ptr != NULL) {
*ptr = '\0';
}
FileBuildPath (fullpath, NULL, filename);
/* silence SEV_INFO errors from FileOpen() */
if ((lastLevel = ErrGetMessageLevel()) < SEV_WARNING)
ErrSetMessageLevel (SEV_WARNING);
if ((f = FileOpen (fullpath, "r")) == NULL) {
ErrSetMessageLevel (lastLevel);
if (FindPath ("NCBI", "NCBI", "DATA", fullpath, sizeof (fullpath) - 1)) {
FileBuildPath (fullpath, NULL, filename);
if ((aip = AsnIoOpen (fullpath, "r")) == NULL) {
if (verbose) {
ErrPost(CTX_NCBIOBJ, 1, "Couldn't open [%s]", fullpath);
}
return FALSE;
}
} else {
if (verbose) {
ErrPost(CTX_NCBIOBJ, 1, "FindPath failed in PrintTemplateSetLoad - ncbi configuration file missing or incorrect");
}
return FALSE;
}
} else {
ErrSetMessageLevel (lastLevel);
FileClose (f);
if ((aip = AsnIoOpen(fullpath, "r")) == NULL) {
if (verbose) {
ErrPost(CTX_NCBIOBJ, 1, "Couldn't open [%s]", fullpath);
}
return FALSE;
}
}
}
retval = PrintTemplateSetAsnRead(aip);
AsnIoClose(aip);
return retval;
}
