static Int2 s_ServiceDisconnect(NI_HandPtr mhp)
{
s_EndServices(mhp->disp);
SOCK_Close((SOCK)mhp->extra_proc_info);
AsnIoClose(mhp->raip);
AsnIoClose(mhp->waip);
MemFree(mhp->hostname);
MemFree(mhp);
return 0;
}
static Int4 ProcessStream (InputStreamPtr isp, OutputStreamPtr osp, AsnStreamPtr asp, Int4Ptr gap_sizes)
{
AsnTypePtr atp, atp_srch;
AsnIoPtr asn_in, asn_out;
Int4 rval = 0;
SeqEntryPtr sep;
Uint2 entityID;
DataVal av;
if (isp == NULL || osp == NULL || asp == NULL || gap_sizes == NULL) return 1;
asn_in = AsnIoFromInputStream (isp);
asn_out = AsnIoFromOutputStream (osp);
if (isp->is_seqentry) {
atp = asp->atp_se;
atp_srch = asp->atp_se;
}
else {
atp = asp->atp_bss;
atp_srch = asp->atp_bss_se;
}
while ((atp = AsnReadId(asn_in, asp->amp, atp)) != NULL && rval == 0) {
if (atp != atp_srch) {
AsnReadVal(asn_in, atp, &av);
AsnWrite(asn_out, atp, &av);
AsnKillValue(atp, &av);
continue;
}
if ((sep = SeqEntryAsnRead(asn_in, atp)) == NULL) {
Message (MSG_POSTERR, "SeqEntryAsnRead failure");
rval = 1;
} else {
entityID = ObjMgrRegister (OBJ_SEQENTRY, sep);
ProcessSeqEntry (sep, gap_sizes);
if (! SeqEntryAsnWrite(sep, asn_out, atp)) {
Message (MSG_POSTERR, "SeqEntryAsnWrite failure");
rval = 1;
}
AsnIoFlush(asn_out);
ObjMgrFreeByEntityID (entityID);
}
} /* Endwhile, AsnReadId */
AsnIoClose(asn_in);
if (asn_out != osp->aip) {
AsnIoClose(asn_out);
}
return rval;
}
Int2 Main(void)
{
AsnIoPtr aip;
SeqEntryPtr sep;
BytePtr buf;
Uint2 size = 32000, count;
AsnIoMemPtr aimp;
/* check command line arguments */
if ( ! GetArgs("testmem",NUMARG, myargs))
return 1;
/* load the sequence alphabets */
/* (and sequence parse trees) */
if (! SeqEntryLoad())
ErrShow();
/* open the ASN.1 input file in the right mode */
if ((aip = AsnIoOpen (myargs[0].strvalue, myargs[1].intvalue?"rb":"r"))
== NULL)
ErrShow();
sep = SeqEntryAsnRead(aip, NULL); /* read the entry */
AsnIoClose(aip);
SeqEntryPack(sep); /* pack it */
buf = MemNew(size); /* allocate a buffer */
aimp = AsnIoMemOpen("wb", buf, size); /* open to write asn1 to it */
SeqEntryAsnWrite(sep, aimp->aip, NULL); /* write it */
AsnIoFlush(aimp->aip); /* flush it */
count = aimp->count; /* record how many bytes in it */
AsnIoMemClose(aimp); /* close it */
SeqEntryFree(sep); /* release the object */
aimp = AsnIoMemOpen("rb", buf, count); /* open to read from buffer */
sep = SeqEntryAsnRead(aimp->aip, NULL); /* read it */
AsnIoMemClose(aimp); /* close it */
MemFree(buf); /* free the buffer */
/* open the output file */
aip = AsnIoOpen (myargs[2].strvalue, "w");
SeqEntryAsnWrite(sep, aip, NULL); /* print it */
AsnIoClose(aip);
SeqEntryFree(sep);
return(0);
}
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
int mfmt_close_output( void *handle )
{
/* Irregardless of how we started it - close it */
if( asn_hand->count > 0 )
AsnEndStruct( asn_hand->ioptr, PUB_SET_medline);
switch( asn_hand->open_state ) {
case init_output:
AsnIoFlush( asn_hand->ioptr );
/* This trick is to fool AsnIoClose() */
asn_hand->ioptr->fp = fopen( "/dev/null", "w" );
/* Drop through */
case open_output:
AsnIoClose( asn_hand->ioptr );
case not_open:
default:
; /* Do nothing - it is not open */
}
/* Reinitialize the record */
asn_hand->file = NULL;
asn_hand->have_error = FALSE;
asn_hand->ioptr = NULL;
asn_hand->open_state = not_open;
/* We always assume success */
return( True );
}
static void SeqEntryToFeat (SeqEntryPtr sep, FILE *fp)
{
AsnExpOptPtr aeop;
AsnIoPtr aip;
ExpStructPtr esp;
if (sep != NULL && fp != NULL) {
esp = MemNew (sizeof (ExpStruct));
if (esp != NULL) {
aip = AsnIoNullOpen ();
if (aip != NULL) {
esp->fp = fp;
esp->aip = AsnIoNew (ASNIO_TEXT_OUT, fp, NULL, NULL, NULL);
esp->is_na = is_na;
esp->feat = 3; /* look for CdRegion SeqFeat */
aeop = AsnExpOptNew (aip, "Seq-feat", (Pointer) esp, GetSeqFeat);
if (aeop != NULL) {
SeqEntryAsnWrite (sep, aip, NULL);
fflush (fp);
AsnExpOptFree (aip, aeop);
}
AsnIoClose (aip);
}
MemFree (esp);
}
}
}
static Int2 LIBCALLBACK VSMGenericAsnSave (OMProcControlPtr ompcp, CharPtr mode )
{
Char filename[255];
SelStructPtr ssp, sel;
#ifdef WIN_MAC
FILE * fp;
#endif
ValNodePtr entity_list = NULL, vnp;
SelectedSaveData ssd;
ssp = ObjMgrGetSelected();
if (ssp == NULL)
{
return OM_MSG_RET_ERROR;
}
for (sel = ssp; sel != NULL; sel = sel->next)
{
for (vnp = entity_list;
vnp != NULL && vnp->data.intvalue != sel->entityID;
vnp = vnp->next)
{}
if (vnp == NULL)
{
ValNodeAddInt (&entity_list, 0, sel->entityID);
}
}
ssd.omp = ObjMgrGet();
/* get file name to use */
filename[0] = '\0';
if (GetOutputFileName(filename, (size_t)254, NULL))
{
WatchCursor();
#ifdef WIN_MAC
fp = FileOpen (filename, "r");
if (fp != NULL) {
FileClose (fp);
} else {
FileCreate (filename, "TEXT", "ttxt");
}
#endif
ssd.aip = AsnIoOpen(filename, mode);
ssd.ssp = ssp;
for (vnp = entity_list; vnp != NULL; vnp = vnp->next)
{
SaveSeqLocEntity (vnp->data.intvalue, &ssd);
GatherObjectsInEntity (vnp->data.intvalue, 0, NULL, SaveOneSelectedItem, (Pointer) &ssd, NULL);
}
ValNodeFree (entity_list);
AsnIoClose(ssd.aip);
ArrowCursor();
}
return OM_MSG_RET_DONE;
}
/*****************************************************************************
*
* PrintStackBuild(data, func, sflp)
*
*****************************************************************************/
NLM_EXTERN PrintStackPtr PrintStackBuild (Pointer data, AsnWriteFunc func, PrintFormatListPtr pflp)
{
PrintStackPtr psp;
AsnIoPtr aip;
Boolean retval;
PrintStackListPtr pslp;
PrintStackListItemPtr pstip;
if ((data == NULL) || (func == NULL) || (pflp == NULL))
return NULL;
aip = AsnIoNullOpen();
pslp = MemNew(sizeof(PrintStackList));
pstip = MemNew((size_t)(sizeof(PrintStackListItem) * 10));
pslp->pstip = pstip;
pslp->size = 10;
pslp->used = 1;
psp = MemNew(sizeof(PrintStack)); /* put the PrintStack on aip */
psp->pflp = pflp;
pstip->psp = psp;
AsnExpOptNew(aip, NULL, (Pointer)pslp, PrintStackAddItem);
retval = (*func)(data, aip, NULL);
AsnIoClose(aip);
MemFree(pslp->pstip);
MemFree(pslp);
PrintStackGetSize(psp); /* set agregate sizes including branches */
if (! retval)
{
Message(MSG_ERROR, "PrintStackBuild: writefunc failed");
}
return psp;
}
void BGenBankClose(BGenBankPtr bgbp)
{
AsnCloseStruct(bgbp->aip, bgbp->atp_bioseq_set_seq_set,NULL);
AsnCloseStruct(bgbp->aip, bgbp->atp_bioseq_set,NULL);
AsnIoClose(bgbp->aip);
MemFree(bgbp);
return;
}
NLM_EXTERN AsnIoConnPtr QUERY_AsnIoConnClose (
AsnIoConnPtr aicp
)
{
if (aicp == NULL) return NULL;
AsnIoClose (aicp->aip);
aicp->conn = NULL;
return (AsnIoConnPtr) MemFree (aicp);
}
BiostrucAnnotSetPtr LIBCALL VASTBsAnnotSetGet (Int4 uid)
{
AsnIoPtr aip = NULL;
AsnTypePtr atp = NULL;
Char path[PATH_MAX];
Char compath[PATH_MAX];
Char tempfile[PATH_MAX];
Char pcId[20];
Int2 iFileExists = 0;
BiostrucAnnotSetPtr pbsa = NULL;
int iAvail = 1;
FILE *pipe;
sprintf(pcId, "%ld", (long) uid);
path[0] = '\0';
StringCpy(path, database);
StringCat(path, pcId);
StringCat(path, ".bas");
#ifdef MMDB_UNIXCOMPRESSED
compath[0] = '\0';
sprintf(compath, "%s -d -c %s.gz ", gunzip, path);
pipe = popen(compath, "rb");
if (pipe == NULL) {
ErrPostEx(SEV_FATAL,0,0, "VASTBsAnnotSetGet failed: Can't find gunzip in path.\n");
return NULL;
}
aip = AsnIoNew(ASNIO_BIN_IN, pipe, NULL, NULL, NULL);
#else
iFileExists = FileLength(path);
if (iFileExists == 0)
{
return NULL;
}
aip = AsnIoOpen(path, "rb");
#endif
if (aip)
{
pbsa = BiostrucAnnotSetAsnRead(aip, NULL);
AsnIoClose (aip);
}
#ifdef MMDB_UNIXCOMPRESSED
pclose(pipe);
#endif
if (!pbsa) return NULL;
return pbsa;
}
static Boolean SaveSetsInOneSelectedSet (GatherObjectPtr gop)
{
SetSavePtr ssp;
SelStructPtr sel;
BioseqSetPtr bssp;
CharPtr filename, file_fmt = "%s_%d.sqn";
SeqEntryPtr sep;
AsnIoPtr aip;
#ifdef WIN_MAC
FILE *fp;
#endif
if (gop == NULL || gop->dataptr == NULL || gop->itemtype != OBJ_BIOSEQSET) return TRUE;
ssp = (SetSavePtr) gop->userdata;
if (ssp == NULL || StringHasNoText (ssp->file_base)) return TRUE;
sel = ssp->sel;
while (sel != NULL
&& (sel->entityID != gop->entityID
|| sel->itemtype != gop->itemtype
|| sel->itemID != gop->itemID))
{
sel = sel->next;
}
if (sel == NULL) return TRUE;
bssp = gop->dataptr;
filename = (CharPtr) MemNew (sizeof (Char) + (StringLen (ssp->file_base) + StringLen (file_fmt) + 15));
for (sep = bssp->seq_set; sep != NULL; sep = sep->next) {
sprintf (filename, file_fmt, ssp->file_base, ssp->file_num);
ssp->file_num++;
#ifdef WIN_MAC
fp = FileOpen (filename, "r");
if (fp != NULL) {
FileClose (fp);
} else {
FileCreate (filename, "TEXT", "ttxt");
}
#endif
aip = AsnIoOpen(filename, "w");
SeqEntryAsnWrite (sep, aip, NULL);
AsnIoClose (aip);
}
filename = MemFree (filename);
return TRUE;
}
static void WriteOneSubmission (
CharPtr path,
SeqSubmitPtr ssp
)
{
AsnIoPtr aip;
aip = AsnIoOpen (path, "w");
if (aip == NULL) return;
SeqSubmitAsnWrite (ssp, aip, NULL);
AsnIoFlush (aip);
AsnIoClose (aip);
}
static void WriteOneFile (
OutputStreamPtr osp,
SeqEntryPtr sep
)
{
AsnIoPtr aip;
aip = AsnIoFromOutputStream (osp);
if (aip != NULL) {
SeqEntryAsnWrite (sep, aip, NULL);
AsnIoFlush (aip);
}
if (aip != osp->aip) {
AsnIoClose (aip);
}
}
BlastFormattingInfo* BlastFormattingInfoFree(BlastFormattingInfo* info)
{
if (info->outfp)
FileClose(info->outfp);
/* Free the XML or ASN.1 i/o structure. Note that info->aip is set for
XML too, but it should not be freed twice. */
if (info->xmlp) {
Boolean ungapped =
!info->search_options->score_options->gapped_calculation;
MBXmlClose(info->xmlp, NULL, ungapped);
} else if (info->aip) {
AsnIoClose(info->aip);
}
sfree(info->program_name);
sfree(info->db_name);
sfree(info->format_options);
/* The remaining fields are not owned by the structure. */
sfree(info);
return NULL;
}
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);
}
Int2 Main (void)
{
AsnIoPtr aip;
Boolean convertgis;
Boolean extractmrnas;
CharPtr infile, outfile;
SeqEntryPtr sep;
/* standard setup */
ErrSetFatalLevel (SEV_MAX);
ErrClearOptFlags (EO_SHOW_USERSTR);
UseLocalAsnloadDataAndErrMsg ();
ErrPathReset ();
/* finish resolving internal connections in ASN.1 parse tables */
if (! AllObjLoad ()) {
Message (MSG_FATAL, "AllObjLoad failed");
return 1;
}
if (! SubmitAsnLoad ()) {
Message (MSG_FATAL, "SubmitAsnLoad failed");
return 1;
}
if (! FeatDefSetLoad ()) {
Message (MSG_FATAL, "FeatDefSetLoad failed");
return 1;
}
if (! SeqCodeSetLoad ()) {
Message (MSG_FATAL, "SeqCodeSetLoad failed");
return 1;
}
if (! GeneticCodeTableLoad ()) {
Message (MSG_FATAL, "GeneticCodeTableLoad failed");
return 1;
}
/* process command line arguments */
if (! GetArgs ("gi2accn", sizeof (myargs) / sizeof (Args), myargs)) {
return 0;
}
infile = (CharPtr) myargs [i_argInputFile].strvalue;
outfile = (CharPtr) myargs [o_argOutputFile].strvalue;
convertgis = (Boolean) myargs [c_argConvertGIs].intvalue;
extractmrnas = (Boolean) myargs [x_argExtractMrnas].intvalue;
aip = AsnIoOpen (infile, "r");
if (aip == NULL) {
Message (MSG_FATAL, "AsnIoOpen input file failed");
return 1;
}
sep = SeqEntryAsnRead (aip, NULL);
AsnIoClose (aip);
if (sep == NULL) {
Message (MSG_FATAL, "SeqEntryAsnRead failed");
return 1;
}
PubSeqFetchEnable ();
LookupFarSeqIDs (sep, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE);
/* Extract mRNA hits from BLAST against nr */
if (extractmrnas) {
VisitAnnotsInSep (sep, NULL, FindBlastNR);
DeleteMarkedObjects (0, OBJ_SEQENTRY, (Pointer) sep);
}
/* convert gi numbers to accession.version */
if (convertgis) {
VisitAlignmentsInSep (sep, NULL, UpdateAligns);
}
PubSeqFetchDisable ();
BasicSeqEntryCleanup (sep);
aip = AsnIoOpen (outfile, "w");
if (aip == NULL) {
Message (MSG_FATAL, "AsnIoOpen output file failed");
return 1;
}
SeqEntryAsnWrite (sep, aip, NULL);
AsnIoClose (aip);
return 0;
}
/*****************************************************************************
*
* Main program loop to read, process, write SeqEntrys
*
*****************************************************************************/
Int2 Main(void)
{
AsnIoPtr aipout=NULL, aipin;
AsnTypePtr atp, atp_inst;
AsnModulePtr amp;
DataVal dv;
CharPtr ftype;
BioseqPtr bsp;
/* check command line arguments */
if ( ! GetArgs("asn2xml 1.0",NUMARG, myargs))
return 1;
/* load the sequence alphabets */
/* (and sequence parse trees) */
if (! SeqEntryLoad())
ErrShow();
if (! SubmitAsnLoad())
ErrShow();
if (! SeqCodeSetLoad())
ErrShow();
/* get pointer to all loaded ASN.1 modules */
amp = AsnAllModPtr();
if (amp == NULL)
{
ErrShow();
return 1;
}
if (myargs[1].intvalue)
atp = AsnFind("Seq-entry");
else if (myargs[2].intvalue)
atp = AsnFind("Seq-submit");
else
atp = AsnFind("Bioseq-set"); /* get the initial type pointers */
if (atp == NULL)
{
ErrShow();
return 1;
}
atp_inst = AsnFind("Bioseq.inst");
if (atp_inst == NULL)
{
ErrShow();
return 1;
}
/* open the ASN.1 input file in the right mode */
if ((aipin = AsnIoOpen (myargs[0].strvalue, myargs[3].intvalue?"rb":"r"))
== NULL)
{
ErrPostEx(SEV_ERROR,0,0, "Can't open %s", myargs[0].strvalue);
ErrShow();
return 1;
}
/* open the ASN.1 output file in the right mode */
if (myargs[4].strvalue != NULL) /* output desired? */
{
ftype = "wx";
if ((aipout = AsnIoOpen (myargs[4].strvalue, ftype)) == NULL)
{
ErrPostEx(SEV_ERROR,0,0, "Can't open %s", myargs[4].strvalue);
ErrShow();
return 1;
}
}
/* log errors instead of die */
if (myargs[5].strvalue != NULL)
{
if (! ErrSetLog (myargs[5].strvalue))
{
ErrShow();
return 1;
}
else
ErrSetOpts (ERR_CONTINUE, ERR_LOG_ON);
}
while ((atp = AsnReadId(aipin, amp, atp)) != NULL)
{
if (atp == atp_inst) /* need object loader convert */
{
bsp = BioseqNew(); /* need newly initialized bsp */
BioseqInstAsnRead(bsp, aipin, atp);
BioseqInstAsnWrite(bsp, aipout, atp);
bsp = BioseqFree(bsp);
}
else
{
AsnReadVal(aipin, atp, &dv); /* read it */
AsnWrite(aipout, atp, &dv); /* write it */
AsnKillValue(atp, &dv); /* free it */
}
}
AsnIoClose(aipin);
AsnIoClose(aipout);
return(0);
}
Int2 Main (void)
{
AsnIoPtr aop = NULL;
AsnModulePtr amp;
AsnTypePtr atp_bss, atp_ss, atp_se;
BioseqSet bss;
FILE *fp;
ValNodePtr head, vnp;
Char path [PATH_MAX];
CharPtr progname, str, subfile;
ErrSetFatalLevel (SEV_MAX);
ErrClearOptFlags (EO_SHOW_USERSTR);
UseLocalAsnloadDataAndErrMsg ();
ErrPathReset ();
if (! AllObjLoad ()) {
Message (MSG_FATAL, "AllObjLoad failed");
return 1;
}
if (! SubmitAsnLoad ()) {
Message (MSG_FATAL, "SubmitAsnLoad failed");
return 1;
}
if (! SeqCodeSetLoad ()) {
Message (MSG_FATAL, "SeqCodeSetLoad failed");
return 1;
}
if (! GeneticCodeTableLoad ()) {
Message (MSG_FATAL, "GeneticCodeTableLoad failed");
return 1;
}
MemSet ((Pointer) &bss, 0, sizeof (BioseqSet));
amp = AsnAllModPtr ();
if (amp == NULL) {
Message (MSG_FATAL, "Unable to load AsnAllModPtr");
return 1;
}
atp_bss = AsnFind ("Bioseq-set");
if (atp_bss == NULL) {
Message (MSG_FATAL, "Unable to find ASN.1 type Bioseq-set");
return 1;
}
atp_ss = AsnFind ("Bioseq-set.seq-set");
if (atp_ss == NULL) {
Message (MSG_FATAL, "Unable to find ASN.1 type Bioseq-set.seq-set");
return 1;
}
atp_se = AsnFind ("Bioseq-set.seq-set.E");
if (atp_se == NULL) {
Message (MSG_FATAL, "Unable to find ASN.1 type Bioseq-set.seq-set.E");
return 1;
}
ProgramPath (path, sizeof (path));
progname = StringRChr (path, DIRDELIMCHR);
if (progname != NULL) {
progname++;
} else {
progname = "idcleanscan";
}
if (! GetArgs (progname, sizeof (myargs) / sizeof (Args), myargs)) {
return 0;
}
fp = FileOpen (myargs [o_argOutputFile].strvalue, "a");
if (fp == NULL) {
Message (MSG_FATAL, "FileOpen failed");
return 1;
}
if (StringHasNoText (myargs [p_argInputPath].strvalue)) {
str = myargs [i_argInputFile].strvalue;
if (! StringHasNoText (str)) {
DoReleaseFile (str, myargs [b_argBinaryFile].intvalue, myargs [c_argCompressed].intvalue, fp, aop, NULL);
}
} else {
head = DirCatalog (myargs [p_argInputPath].strvalue);
if (! StringHasNoText (myargs [s_argSubset].strvalue)) {
aop = AsnIoOpen (myargs [s_argSubset].strvalue, /* "wb" */ "w");
AsnOpenStruct (aop, atp_bss, (Pointer) &bss);
AsnOpenStruct (aop, atp_ss, (Pointer) bss.seq_set);
/*
av.intvalue = BioseqseqSet_class_genbank;
AsnWrite (aop, atp_cls, &av);
*/
}
for (vnp = head; vnp != NULL; vnp = vnp->next) {
if (vnp->choice == 0) {
str = (CharPtr) vnp->data.ptrvalue;
if (! StringHasNoText (str)) {
subfile = myargs [x_argFileSelect].strvalue;
if (StringHasNoText (subfile) || StringStr (str, subfile) != NULL) {
#ifdef OS_UNIX
/* printf ("%s\n", str); */
#endif
DoReleaseFile (str, myargs [b_argBinaryFile].intvalue, myargs [c_argCompressed].intvalue, fp, aop, atp_se);
}
}
}
}
if (aop != NULL) {
AsnCloseStruct (aop, atp_ss, (Pointer) bss.seq_set);
AsnCloseStruct (aop, atp_bss, (Pointer) &bss);
AsnIoClose (aop);
}
ValNodeFreeData (head);
}
FileClose (fp);
return 0;
}
Int2 Main(void)
{
AsnIoPtr aip;
FILE * aa = NULL, * na = NULL, * ql = NULL;
SeqEntryPtr sep;
SeqSubmitPtr ssp;
AsnTypePtr atp, atp2;
AsnModulePtr amp;
Uint1 group_segs = 0;
Boolean limit_to_genbank,
make_dna,
make_protein,
make_quality,
far_quality,
do_it;
/* check command line arguments */
if ( ! GetArgs("asn2fast",NUMARG, myargs))
return 1;
/* load the sequence alphabets */
/* (and sequence parse trees) */
if (! SeqEntryLoad())
{
ErrShow();
return 1;
}
/* get pointer to all loaded ASN.1 modules */
amp = AsnAllModPtr();
if (amp == NULL)
{
ErrShow();
return 1;
}
if (myargs[11].intvalue) {
if (! SubmitAsnLoad())
Message(MSG_FATAL, "Unable to load parse trees.");
atp2 = AsnFind("Seq-submit");
if (atp2 == NULL)
Message(MSG_FATAL, "Unable to find Seq-submit");
atp = AsnFind("Seq-submit");
if (atp == NULL)
Message(MSG_FATAL, "Unable to find Seq-submit");
} else {
atp = AsnFind("Bioseq-set"); /* get the initial type pointers */
if (atp == NULL)
{
ErrShow();
return 1;
}
atp2 = AsnFind("Bioseq-set.seq-set.E");
if (atp2 == NULL)
{
ErrShow();
return 1;
}
}
make_protein = (Boolean)(myargs[7].intvalue);
make_dna = (Boolean)(myargs[8].intvalue);
make_quality = (Boolean)(myargs[12].intvalue);
far_quality = (Boolean)(myargs[14].intvalue);
/* open the ASN.1 input file in the right mode */
if ((aip = AsnIoOpen (myargs[0].strvalue, myargs[2].intvalue?"rb":"r"))
== NULL)
{
ErrShow();
return 1;
}
/* open the output file */
if ((myargs[3].strvalue != NULL) && (make_protein))
{
if ( (aa = FileOpen (myargs[3].strvalue, "w")) == NULL)
{
ErrShow();
return 1;
}
}
if ((myargs[4].strvalue != NULL) && (make_dna))
{
if ( (na = FileOpen (myargs[4].strvalue, "w")) == NULL)
{
ErrShow();
return 1;
}
}
if ((myargs[13].strvalue != NULL) && (make_quality))
{
if ( (ql = FileOpen (myargs[13].strvalue, "w")) == NULL)
{
ErrShow();
return 1;
}
}
/* log errors instead of die */
if (myargs[5].strvalue != NULL)
{
if (! ErrSetLog (myargs[5].strvalue))
ErrShow();
else
ErrSetOpts (ERR_CONTINUE, ERR_LOG_ON);
}
if (myargs[6].intvalue) /* combine segmented seqs */
{
group_segs = 1;
if (myargs[10].intvalue)
group_segs = 3; /* and instantiate virtuals */
}
limit_to_genbank = (Boolean)(myargs[9].intvalue);
if (myargs [15].intvalue) {
ID1BioseqFetchEnable ("asn2fast", FALSE);
}
if (myargs [16].intvalue) {
LocalSeqFetchInit (FALSE);
}
if ( myargs[1].intvalue) /* read one Seq-entry */
{
sep = SeqEntryAsnRead(aip, NULL);
do_it = TRUE;
if (limit_to_genbank)
do_it = CheckIsGenBank(sep);
if (do_it)
{
if (make_protein)
SeqEntrysToFasta(sep, aa, FALSE, group_segs);
if (make_dna)
SeqEntrysToFasta(sep, na, TRUE, group_segs);
if (make_quality) {
if (far_quality) {
SeqEntryExplore (sep, (Pointer) ql, PrintFarQualScores);
} else {
SeqEntryExplore (sep, (Pointer) ql, PrintQualScores);
}
}
}
SeqEntryFree(sep);
}
else if ( myargs[11].intvalue) /* read Seq-submit's */
{
while ((atp = AsnReadId(aip, amp, atp)) != NULL)
{
if (atp == atp2) /* top level Seq-entry */
{
ssp = SeqSubmitAsnRead(aip, atp);
if (ssp->datatype == 1)
{
sep = (SeqEntryPtr) ssp->data;
do_it = TRUE;
if (limit_to_genbank)
do_it = CheckIsGenBank(sep);
if (do_it)
{
if (make_protein)
SeqEntrysToFasta(sep, aa, FALSE, group_segs);
if (make_dna)
SeqEntrysToFasta(sep, na, TRUE, group_segs);
if (make_quality) {
if (far_quality) {
SeqEntryExplore (sep, (Pointer) ql, PrintFarQualScores);
} else {
SeqEntryExplore (sep, (Pointer) ql, PrintQualScores);
}
}
}
}
SeqSubmitFree(ssp);
}
else
{
AsnReadVal(aip, atp, NULL);
}
}
}
else /* read Seq-entry's from a Bioseq-set */
{
while ((atp = AsnReadId(aip, amp, atp)) != NULL)
{
if (atp == atp2) /* top level Seq-entry */
{
sep = SeqEntryAsnRead(aip, atp);
do_it = TRUE;
if (limit_to_genbank)
do_it = CheckIsGenBank(sep);
if (do_it)
{
if (make_protein)
SeqEntrysToFasta(sep, aa, FALSE, group_segs);
if (make_dna)
SeqEntrysToFasta(sep, na, TRUE, group_segs);
if (make_quality) {
if (far_quality) {
SeqEntryExplore (sep, (Pointer) ql, PrintFarQualScores);
} else {
SeqEntryExplore (sep, (Pointer) ql, PrintQualScores);
}
}
}
SeqEntryFree(sep);
}
else
{
AsnReadVal(aip, atp, NULL);
}
}
}
AsnIoClose(aip);
if (make_protein)
FileClose(aa);
if (make_dna)
FileClose(na);
if (make_quality)
FileClose (ql);
if (myargs [16].intvalue) {
LocalSeqFetchDisable ();
}
if (myargs [15].intvalue) {
ID1BioseqFetchDisable ();
}
return(0);
}
Int2 Main (void)
{
Int2 m_argModuleIn=0, f_arg_moduleOut=1,
X_argDTDModuleOut=2, T_argTreeDumpOut=3,
v_argPrintFileIn = 4, p_argPrintFileOut = 5,
x_argXMLDataOut=6, d_argBinaryFileIn = 7
, t_argAsnTypeName = 8, e_argBinaryFileOut = 9
, o_argHeadFile = 10, l_argLoadFile = 11
, b_argBufferSize = 12, w_argTokenMax = 13
/*--- args below here are capitilized and for code generation, only--*/
/*-- Except for the 'M' arg, which will also affect normal use ---*/
, G_argGenerateCode = 14, M_argMoreModuleFiles = 15
, B_argCodeFileName = 16, D_argCodeGenDebugLevel = 17
, S_argDebugFileName = 18, I_argExtraIncludeName = 19
, Z_argBitTwiddle = 20, K_argLoadName = 21
, J_objMgrEntry = 22, L_objMgrLabel = 23, P_argXMLmodulePrefix = 24
, V_argChoiceStruct = 25;
AsnIoPtr aip = NULL,
aipout = NULL,
xaipout = NULL,
aipencode = NULL;
FILE * fp;
AsnModulePtr amp = NULL,
currentmod = NULL,
nextmod, thisamp;
AsnTypePtr atp;
Boolean print_each_module = FALSE;
AsnCodeInfoPtr acip = (AsnCodeInfoPtr)MemNew(sizeof(AsnCodeInfo));
CharPtr filename = NULL, p, last_comma, objmgrentry = NULL;
int len;
/* never abort on error, but show it */
ErrSetFatalLevel(SEV_MAX);
ErrSetMessageLevel(SEV_MIN);
asnargs[P_argXMLmodulePrefix].defaultvalue = (const char *)AsnGetXMLmodulePrefix();
if (! GetArgs("AsnTool 4", NUMARGS, asnargs))
return 1;
ErrClear();
AsnSetXMLmodulePrefix((CharPtr)(asnargs[P_argXMLmodulePrefix].strvalue));
/*
if (! GetArgs("AsnTool 4", NUMARGS, asnargs))
return 1;
ErrClear();
*/
if (! AsnIoSetBufsize(NULL, (Int2)asnargs[b_argBufferSize].intvalue))
return 1;
if ((aip = AsnIoOpen(asnargs[m_argModuleIn].strvalue, "r")) == NULL)
{
ErrShow();
return 1;
}
acip -> loadname = asnargs[m_argModuleIn].strvalue;
if (asnargs[K_argLoadName].strvalue != NULL) {
acip -> loadname = asnargs[K_argLoadName].strvalue; /* overrides m_argModuleIn, if set */
}
if (asnargs[e_argBinaryFileOut].strvalue != NULL) /* output a binary value file */
if ((aipencode = AsnIoOpen(asnargs[e_argBinaryFileOut].strvalue, "wb")) == NULL)
{
ErrShow();
return 1;
}
/** parse the module(s) ***/
if (asnargs[f_arg_moduleOut].strvalue != NULL)
{
if ((aipout = AsnIoOpen(asnargs[f_arg_moduleOut].strvalue, "w")) == NULL)
{
ErrShow();
return 1;
}
}
thisamp = NULL;
while ((nextmod = AsnLexTReadModule(aip)) != NULL )
{
if (thisamp == NULL)
thisamp = nextmod;
if (amp == NULL)
amp = nextmod;
else
currentmod->next = nextmod;
currentmod = nextmod;
}
acip -> last_amp = currentmod; /* last module of main file */
AsnStoreTree(acip->loadname, thisamp); /* store and link tree */
/*--- read additional module files that will be used for everything
but code generation.
---*/
if (asnargs[M_argMoreModuleFiles].strvalue != NULL)
for (p = asnargs[M_argMoreModuleFiles].strvalue; *p; p = last_comma + 1) {
/*--- extract next filename for reading ASN.1 definitions ---*/
for (last_comma = p; *last_comma; last_comma++) {
if (*last_comma == ',')
break;
}
len = last_comma - p;
filename = (char *)MemFree (filename);
filename = (char *)MemNew (len + 1);
StringNCpy (filename, p, len);
filename[len] = '\0';
#ifdef WIN_DUMB
printf ("Loading %s \n", filename);
#endif
if ((aip = AsnIoOpen(filename, "r")) == NULL)
{
ErrShow();
return 1;
}
/*--- read the modules in this current file ---*/
thisamp = NULL;
while ((nextmod = AsnLexTReadModule(aip)) != NULL )
{
if (thisamp == NULL)
thisamp = nextmod;
if (amp == NULL)
amp = nextmod;
else
currentmod->next = nextmod;
currentmod = nextmod;
}
AsnStoreTree(filename, thisamp); /* store and link tree */
if (!*last_comma)
break;
aip = AsnIoClose(aip);
}
aip = AsnIoClose(aip);
if (amp == NULL)
{
ErrPostEx(SEV_FATAL,0,0, "Unable to continue due to bad ASN.1 module");
ErrShow();
return 1;
}
if (asnargs[f_arg_moduleOut].strvalue != NULL)
{
if ((aipout = AsnIoOpen(asnargs[f_arg_moduleOut].strvalue, "w")) == NULL)
{
ErrShow();
return 1;
}
currentmod = amp;
do
{
AsnPrintModule(currentmod, aipout);
if (currentmod == acip->last_amp) /* last main module */
currentmod = NULL;
else
currentmod = currentmod->next;
} while (currentmod != NULL);
aipout = AsnIoClose(aipout);
}
if (asnargs[X_argDTDModuleOut].strvalue != NULL)
{
Char tbuf[250];
CharPtr ptr;
if (! StringCmp(asnargs[X_argDTDModuleOut].strvalue, "m"))
{
print_each_module = TRUE;
}
else
{
if ((aipout = AsnIoOpen(asnargs[X_argDTDModuleOut].strvalue, "wx")) == NULL)
{
ErrShow();
return 1;
}
}
currentmod = amp;
do
{
if (print_each_module)
{
StringMove(tbuf, currentmod->modulename);
for (ptr = tbuf; *ptr != '\0'; ptr++)
{
if (*ptr == '-')
*ptr = '_';
}
StringMove(ptr, ".dtd");
AsnPrintModuleXMLInc(currentmod, tbuf);
StringMove(ptr, ".mod");
aipout = AsnIoOpen(tbuf, "wx");
}
AsnPrintModuleXML(currentmod, aipout);
if (print_each_module)
aipout = AsnIoClose(aipout);
if (currentmod == acip->last_amp) /* last main module */
currentmod = NULL;
else
currentmod = currentmod->next;
} while (currentmod != NULL);
if (! print_each_module)
aipout = AsnIoClose(aipout);
}
if (asnargs[T_argTreeDumpOut].strvalue != NULL)
{
if ((fp = FileOpen(asnargs[T_argTreeDumpOut].strvalue, "w")) == NULL)
{
ErrShow();
return 1;
}
currentmod = amp;
do
{
AsnPrintTreeModule(currentmod, fp);
if (currentmod == acip->last_amp) /* last main module */
currentmod = NULL;
else
currentmod = currentmod->next;
} while (currentmod != NULL);
FileClose(fp);
}
acip -> amp = amp;
/* print a value file */
if (asnargs[p_argPrintFileOut].strvalue != NULL)
{
if ((aipout = AsnIoOpen(asnargs[p_argPrintFileOut].strvalue, "w")) == NULL)
{
ErrShow();
return 1;
}
}
/* print an XML file */
if (asnargs[x_argXMLDataOut].strvalue != NULL)
{
if ((xaipout = AsnIoOpen(asnargs[x_argXMLDataOut].strvalue, "wx")) == NULL)
{
ErrShow();
return 1;
}
}
if (asnargs[v_argPrintFileIn].strvalue != NULL) /* read a printvalue file */
{
if ((aip = AsnIoOpen(asnargs[v_argPrintFileIn].strvalue, "r")) == NULL)
{
ErrShow();
return 1;
}
AsnTxtReadValFile(amp, aip, aipout, aipencode, xaipout);
ErrShow();
}
aip = AsnIoClose(aip);
if (asnargs[d_argBinaryFileIn].strvalue != NULL) /* read a ber file */
{
if ((asnargs[t_argAsnTypeName].strvalue == NULL) || (! TO_UPPER(*asnargs[t_argAsnTypeName].strvalue)))
{
ErrPostEx(SEV_FATAL,0,0, "Must use -t Type to define contents of decode file");
ErrShow();
return 1;
}
atp = AsnTypeFind(amp, asnargs[t_argAsnTypeName].strvalue);
if (atp == NULL)
{
#ifdef WIN_MSWIN
ErrPostEx(SEV_FATAL,0,0, "Couldn't find Type %Fs", asnargs[t_argAsnTypeName].strvalue);
#else
ErrPostEx(SEV_FATAL,0,0, "Couldn't find Type %s", asnargs[t_argAsnTypeName].strvalue);
#endif
ErrShow();
return 1;
}
if ((aip = AsnIoOpen(asnargs[d_argBinaryFileIn].strvalue, "rb")) == NULL)
{
ErrShow();
return 1;
}
AsnBinReadValFile(atp, aip, aipout, aipencode, xaipout);
ErrShow();
}
AsnIoClose(xaipout);
AsnIoClose(aipout);
AsnIoClose(aip);
AsnIoClose(aipencode);
if (asnargs[o_argHeadFile].strvalue != NULL) /* produce header file */
AsnOutput(asnargs[o_argHeadFile].strvalue, amp, FALSE, (Int2)asnargs[w_argTokenMax].intvalue);
if (asnargs[l_argLoadFile].strvalue != NULL) /* produce loader file */
AsnOutput(asnargs[l_argLoadFile].strvalue, amp, TRUE, (Int2)asnargs[w_argTokenMax].intvalue);
if (asnargs[G_argGenerateCode ].intvalue != 0)
{
acip -> filename = asnargs[B_argCodeFileName].strvalue;
acip -> do_bit_twiddle = asnargs[Z_argBitTwiddle].intvalue;
acip -> force_choice_struct = asnargs[V_argChoiceStruct].intvalue;
acip -> include_filename = asnargs[I_argExtraIncludeName].strvalue;
acip -> maxDefineLength = asnargs[w_argTokenMax].intvalue;
acip -> debug_level = asnargs[D_argCodeGenDebugLevel ].intvalue;
acip -> object_manager_entry = asnargs[J_objMgrEntry].strvalue;
acip -> object_label = asnargs[L_objMgrLabel].strvalue;
if (asnargs[S_argDebugFileName].strvalue != NULL) {
(acip -> bug_fp) = FileOpen (asnargs[S_argDebugFileName].strvalue, "w");
} else {
(acip -> bug_fp) = FileOpen ("stderr", "w");
}
AsnCode(acip);
}
MemFree(acip);
MemFree(filename);
return 0;
}
Int2 Main_new(void)
{
BioseqPtr query_bsp=NULL, subject_bsp=NULL;
BioseqPtr bsp1=NULL, bsp2=NULL;
BioseqPtr fake_bsp=NULL, fake_subject_bsp=NULL;
BlastFormattingInfo* format_info = NULL;
BLAST_SummaryOptions* options=NULL;
Blast_SummaryReturn* extra_returns = Blast_SummaryReturnNew();
Boolean believe_query= FALSE;
Boolean seq1_is_na, seq2_is_na; /* seq1/2 is DNA if TRUE. */
Boolean seqannot_output; /* SeqAlign will be output. */
Boolean entrez_lookup; /* QUery/subject fetched from Entrez. */
Boolean mask_at_hash=FALSE; /* masking only on lookup table if TRUE. */
DbtagPtr dbtagptr;
EBlastProgramType program_number;
Int2 status; /* return value */
EAlignView align_view = eAlignViewPairwise; /* Used for formatting */
SeqAlignPtr seqalign=NULL;
SeqEntryPtr sep=NULL, sep1=NULL;
SeqLocPtr slp1, slp2; /* Used for actual search. */
SeqLocPtr filter_loc=NULL; /* Location of regions filtered (returned by engine) */
SeqLocPtr lcase_mask=NULL; /* For lower-case masking info from query FASTA. */
SeqLoc* repeat_mask = NULL; /* Repeat mask locations */
Uint1 strand_option = 0; /* FIXME */
SBlastOptions* search_options = NULL; /* Needed for formatting. */
SBlastSeqalignArray* seqalign_arr = NULL;
GeneticCodeSingletonInit();
strand_option = (Uint1) myargs[ARG_STRAND].intvalue;
entrez_lookup = (Boolean) myargs[ARG_ACCN].intvalue;
seqannot_output = (myargs[ARG_ASNOUT].strvalue != NULL);
believe_query = (seqannot_output || entrez_lookup);
/* Non-zero value for -m option means tabular output. */
if (myargs[ARG_FORMAT].intvalue != 0)
align_view = eAlignViewTabularWithComments;
BlastProgram2Number(myargs[ARG_PROGRAM].strvalue, &program_number);
seq1_is_na = (program_number == eBlastTypeBlastn ||
program_number == eBlastTypeBlastx ||
program_number == eBlastTypeRpsTblastn ||
program_number == eBlastTypeTblastx);
seq2_is_na = (program_number == eBlastTypeBlastn ||
program_number == eBlastTypeTblastn ||
program_number == eBlastTypeTblastx);
if (BL2SEQ_GetSequences(seq1_is_na, seq2_is_na, &query_bsp, &subject_bsp,
&sep, &sep1, &lcase_mask, believe_query)
== FALSE)
{
ErrPostEx(SEV_FATAL, 1, 0, "blast: Unable to get sequences");
return (1);
}
if (!entrez_lookup) {
if (!believe_query)
fake_bsp = BlastMakeFakeBioseq(query_bsp, NULL);
fake_subject_bsp = BioseqNew();
fake_subject_bsp->descr = subject_bsp->descr;
fake_subject_bsp->repr = subject_bsp->repr;
fake_subject_bsp->mol = subject_bsp->mol;
fake_subject_bsp->length = subject_bsp->length;
fake_subject_bsp->seq_data = subject_bsp->seq_data;
fake_subject_bsp->seq_data_type = subject_bsp->seq_data_type;
dbtagptr = DbtagNew();
dbtagptr->db = StringSave("BL_ORD_ID");
dbtagptr->tag = ObjectIdNew();
if (BioseqGetTitle(subject_bsp) != NULL)
dbtagptr->tag->str = StringSave(BioseqGetTitle(subject_bsp));
else
dbtagptr->tag->str = StringSave("No definition line found");
ValNodeAddPointer(&fake_subject_bsp->id, SEQID_GENERAL, dbtagptr);
bsp1 = (believe_query ? query_bsp : fake_bsp);
bsp2 = fake_subject_bsp;
} else { /* Query and subject Bioseqs are already "fake". */
bsp1 = query_bsp;
bsp2 = subject_bsp;
}
if (BL2SEQ_MakeSeqLoc(bsp1, bsp2, &slp1, &slp2, strand_option) == FALSE)
return 1;
if (Bl2SEQ_SummaryOptionsSet(&options, program_number) == FALSE)
return 1;
/* Find repeat mask, if necessary */
if ((status = Blast_FindRepeatFilterSeqLoc(slp1, myargs[ARG_FILTER].strvalue,
&repeat_mask, &extra_returns->error)) != 0)
{
if (extra_returns && extra_returns->error)
{
ErrSev max_sev = SBlastMessageErrPost(extra_returns->error);
if (max_sev >= SEV_ERROR)
return status;
}
}
/* Combine repeat mask with lower case mask */
if (repeat_mask)
lcase_mask = ValNodeLink(&lcase_mask, repeat_mask);
status = BLAST_TwoSeqLocSets(options, slp1, slp2, lcase_mask, &seqalign_arr,
&filter_loc, &mask_at_hash,
&extra_returns);
/* Free the lower case mask in SeqLoc form. */
lcase_mask = Blast_ValNodeMaskListFree(lcase_mask);
/* Post warning or error messages, no matter what the search status
was. */
SBlastMessageErrPost(extra_returns->error);
if (status != 0)
{
ErrPostEx(SEV_FATAL, 1, 0, "BLAST_TwoSeqLocSets failed");
return status;
}
if (myargs[ARG_ASNOUT].strvalue && seqalign_arr) {
AsnIoPtr asnout =
AsnIoOpen(myargs[ARG_ASNOUT].strvalue, (char*)"w");
GenericSeqAlignSetAsnWrite(seqalign_arr->array[0], asnout);
asnout = AsnIoClose(asnout);
}
/* Pass NULL for the database name, since there is no database. */
BlastFormattingInfoNewBasic(align_view, options, slp1,
myargs[ARG_OUT].strvalue, &search_options,
&format_info);
/* Always show gis in the output, hence pass TRUE for respective
argument. */
BlastFormattingInfoSetUpOptions(format_info, 0, 1,
(Boolean) myargs[ARG_HTML].intvalue,
(Boolean) myargs[ARG_USEMEGABLAST].intvalue,
TRUE, believe_query);
/* If masking was at hash only, free the masking locations,
* to prevent them from being used for formatting.
*/
if (SBlastOptionsGetMaskAtHash(search_options))
filter_loc = Blast_ValNodeMaskListFree(filter_loc);
/* Format the results */
status =
BLAST_FormatResults(seqalign_arr, 1, slp1, filter_loc, format_info,
extra_returns);
status = Blast_PrintOutputFooter(format_info, extra_returns);
/* Free masking locations if they haven't been freed already. */
filter_loc = Blast_ValNodeMaskListFree(filter_loc);
format_info = BlastFormattingInfoFree(format_info);
extra_returns = Blast_SummaryReturnFree(extra_returns);
search_options = SBlastOptionsFree(search_options);
if (entrez_lookup) {
BioseqFree(query_bsp);
BioseqFree(subject_bsp);
} else {
SeqEntryFree(sep);
SeqEntryFree(sep1);
}
options = BLAST_SummaryOptionsFree(options);
seqalign_arr = SBlastSeqalignArrayFree(seqalign_arr);
slp1 = SeqLocSetFree(slp1);
slp2 = SeqLocSetFree(slp2);
fake_bsp = BlastDeleteFakeBioseq(fake_bsp);
GeneticCodeSingletonFini();
return 0;
}
Int2 Main_old (void)
{
AsnIoPtr aip;
BioseqPtr fake_bsp = NULL, fake_subject_bsp = NULL, query_bsp = NULL,
subject_bsp = NULL;
BioseqPtr bsp1, bsp2;
BLAST_KarlinBlkPtr ka_params=NULL, ka_params_gap=NULL;
BLAST_OptionsBlkPtr options=NULL;
Boolean seq1_is_na, seq2_is_na;
CharPtr params_buffer=NULL;
DbtagPtr dbtagptr;
Uint1 align_type;
Uint4 align_options;
SeqAlignPtr seqalign;
SeqAnnotPtr seqannot;
SeqEntryPtr sep = NULL, sep1 = NULL;
CharPtr program_name, blast_outputfile;
FILE *outfp;
ValNodePtr mask_loc, mask_loc_start, vnp, other_returns=NULL, error_returns=NULL;
BLAST_MatrixPtr matrix;
Int4Ptr PNTR txmatrix;
int (LIBCALLBACK *handle_results)PROTO((VoidPtr search)) = NULL;
Boolean entrez_lookup = FALSE;
Boolean html, seqannot_output, believe_query;
Uint1 tabular_output;
Boolean gapped_calculation;
entrez_lookup = (Boolean) myargs[ARG_ACCN].intvalue;
html = (Boolean) myargs[ARG_HTML].intvalue;
seqannot_output = (myargs[ARG_ASNOUT].strvalue != NULL);
blast_outputfile = myargs [ARG_OUT].strvalue;
program_name = StringSave(myargs[ARG_PROGRAM].strvalue);
if (StringCmp(program_name, "blastn") &&
StringCmp(program_name, "blastp") &&
StringCmp(program_name, "blastx") &&
StringCmp(program_name, "tblastn") &&
StringCmp(program_name, "tblastx")) {
ErrPostEx(SEV_FATAL, 1, 0, "Program name must be blastn, blastp, blastx, tblastn or tblastx\n");
return (1);
}
align_type = BlastGetTypes(program_name, &seq1_is_na, &seq2_is_na);
if ((outfp = FileOpen(blast_outputfile, "w")) == NULL)
{
ErrPostEx(SEV_FATAL, 1, 0, "blast: Unable to open output file %s\n", blast_outputfile);
return (1);
}
gapped_calculation = (Boolean) myargs[ARG_GAPPED].intvalue;
believe_query = (seqannot_output || entrez_lookup);
options = BLASTOptionNewEx(program_name, gapped_calculation,
(Boolean) myargs[ARG_USEMEGABLAST].intvalue);
if (BL2SEQ_GetSequences(seq1_is_na, seq2_is_na, &query_bsp, &subject_bsp,
&sep, &sep1, &(options->query_lcase_mask),
believe_query) == FALSE)
{
ErrPostEx(SEV_FATAL, 1, 0, "blast: Unable to get sequences");
return (1);
}
if (!entrez_lookup) {
if (!believe_query)
fake_bsp = BlastMakeFakeBioseq(query_bsp, NULL);
fake_subject_bsp = BioseqNew();
fake_subject_bsp->descr = subject_bsp->descr;
fake_subject_bsp->repr = subject_bsp->repr;
fake_subject_bsp->mol = subject_bsp->mol;
fake_subject_bsp->length = subject_bsp->length;
fake_subject_bsp->seq_data = subject_bsp->seq_data;
fake_subject_bsp->seq_data_type = subject_bsp->seq_data_type;
dbtagptr = DbtagNew();
dbtagptr->db = StringSave("BL_ORD_ID");
dbtagptr->tag = ObjectIdNew();
if (BioseqGetTitle(subject_bsp) != NULL)
dbtagptr->tag->str = StringSave(BioseqGetTitle(subject_bsp));
else
dbtagptr->tag->str = StringSave("No definition line found");
ValNodeAddPointer(&fake_subject_bsp->id, SEQID_GENERAL, dbtagptr);
bsp1 = (believe_query ? query_bsp : fake_bsp);
bsp2 = fake_subject_bsp;
} else {
bsp1 = query_bsp;
bsp2 = subject_bsp;
}
tabular_output = (Uint1) myargs[ARG_FORMAT].intvalue;
if (myargs[ARG_SEARCHSP].floatvalue)
options->searchsp_eff = (Nlm_FloatHi) myargs[ARG_SEARCHSP].floatvalue;
options->filter_string = StringSave(myargs[ARG_FILTER].strvalue);
options->expect_value = (Nlm_FloatHi) myargs [ARG_EVALUE].floatvalue;
if (StringICmp("blastn", program_name) == 0)
{
options->penalty = myargs[ARG_MISMATCH].intvalue;
options->reward = myargs[ARG_MATCH].intvalue;
}
options->db_length = (Int8) myargs[ARG_DBSIZE].floatvalue;
options->discontinuous = FALSE;
if (myargs[ARG_XDROP].intvalue != 0)
{
options->gap_x_dropoff = myargs[ARG_XDROP].intvalue;
}
if (myargs[ARG_WORDSIZE].intvalue != 0)
options->wordsize = (Int2) myargs[ARG_WORDSIZE].intvalue;
if (options->is_megablast_search) {
options->cutoff_s2 = options->wordsize*options->reward;
}
options->matrix = MemFree(options->matrix);
BLASTOptionSetGapParams(options, myargs[ARG_MATRIX].strvalue, 0, 0);
if (myargs[ARG_GAPOPEN].intvalue != -1)
options->gap_open = myargs[ARG_GAPOPEN].intvalue;
if (myargs[ARG_GAPEXT].intvalue != -1)
options->gap_extend = myargs[ARG_GAPEXT].intvalue;
options->strand_option = myargs[ARG_STRAND].intvalue;
/* Input longest intron length is in nucleotide scale; in the lower
level code it will be used in protein scale */
if (myargs[ARG_INTRON].intvalue > 0)
options->longest_intron = myargs[ARG_INTRON].intvalue;
if (!myargs[ARG_LOC1].strvalue && !myargs[ARG_LOC2].strvalue) {
seqalign = BlastTwoSequencesWithCallback(bsp1, bsp2, program_name,
options, &other_returns, &error_returns, handle_results);
} else {
SeqLocPtr slp1=NULL, slp2=NULL;
if (BL2SEQ_MakeSeqLoc(bsp1, bsp2, &slp1, &slp2, options->strand_option) == FALSE)
return 1;
seqalign = BlastTwoSequencesByLocWithCallback(slp1, slp2, program_name, options, &other_returns, &error_returns, handle_results, NULL);
SeqLocFree(slp1);
SeqLocFree(slp2);
}
if (error_returns) {
BlastErrorPrint(error_returns);
for (vnp = error_returns; vnp; vnp = vnp->next) {
BlastDestroyErrorMessage((BlastErrorMsgPtr)vnp->data.ptrvalue);
}
ValNodeFree(error_returns);
}
ka_params = NULL;
ka_params_gap = NULL;
params_buffer = NULL;
mask_loc = NULL;
matrix = NULL;
txmatrix = NULL;
for (vnp=other_returns; vnp; vnp = vnp->next) {
switch (vnp->choice) {
case TXKABLK_NOGAP:
ka_params = vnp->data.ptrvalue;
break;
case TXKABLK_GAP:
ka_params_gap = vnp->data.ptrvalue;
break;
case TXPARAMETERS:
params_buffer = vnp->data.ptrvalue;
break;
case TXMATRIX:
matrix = vnp->data.ptrvalue;
if (matrix && !tabular_output)
txmatrix = BlastMatrixToTxMatrix(matrix);
break;
case SEQLOC_MASKING_NOTSET:
case SEQLOC_MASKING_PLUS1:
case SEQLOC_MASKING_PLUS2:
case SEQLOC_MASKING_PLUS3:
case SEQLOC_MASKING_MINUS1:
case SEQLOC_MASKING_MINUS2:
case SEQLOC_MASKING_MINUS3:
ValNodeAddPointer(&mask_loc, vnp->choice, vnp->data.ptrvalue);
break;
default:
break;
}
}
if (!tabular_output || seqannot_output) {
align_options = 0;
align_options += TXALIGN_MATRIX_VAL;
align_options += TXALIGN_SHOW_QS;
align_options += TXALIGN_COMPRESS;
align_options += TXALIGN_END_NUM;
if (StringICmp("blastx", program_name) == 0) {
align_options += TXALIGN_BLASTX_SPECIAL;
}
if (html)
align_options += TXALIGN_HTML;
seqannot = SeqAnnotNew();
seqannot->type = 2;
AddAlignInfoToSeqAnnot(seqannot, align_type);
seqannot->data = seqalign;
aip = NULL;
if (seqannot_output)
aip = AsnIoOpen (myargs[ARG_ASNOUT].strvalue,"w");
if (aip && seqannot) {
SeqAnnotAsnWrite((SeqAnnotPtr) seqannot, aip, NULL);
AsnIoReset(aip);
aip = AsnIoClose(aip);
}
}
if (!tabular_output) {
AcknowledgeBlastQuery(query_bsp, 70, outfp, believe_query, html);
ShowTextAlignFromAnnot(seqannot, 60, outfp, NULL, NULL, align_options, txmatrix, mask_loc, FormatScoreFunc);
seqannot = SeqAnnotFree(seqannot);
if (txmatrix)
txmatrix = TxMatrixDestruct(txmatrix);
init_buff_ex(85);
if (ka_params) {
PrintKAParameters(ka_params->Lambda, ka_params->K, ka_params->H, 70, outfp, FALSE);
}
if (ka_params_gap) {
PrintKAParameters(ka_params_gap->Lambda, ka_params_gap->K, ka_params_gap->H, 70, outfp, TRUE);
}
PrintTildeSepLines(params_buffer, 70, outfp);
free_buff();
} else {
PrintTabularOutputHeader(NULL, query_bsp, NULL,
program_name, 0, believe_query, outfp);
BlastPrintTabulatedResults(seqalign, query_bsp, NULL,
1, program_name, !gapped_calculation,
believe_query, 0, 0, outfp, FALSE);
SeqAlignSetFree(seqalign);
}
matrix = BLAST_MatrixDestruct(matrix);
MemFree(ka_params);
MemFree(ka_params_gap);
MemFree(params_buffer);
mask_loc_start = mask_loc;
while (mask_loc) {
SeqLocSetFree(mask_loc->data.ptrvalue);
mask_loc = mask_loc->next;
}
ValNodeFree(mask_loc_start);
fake_bsp = BlastDeleteFakeBioseq(fake_bsp);
other_returns = ValNodeFree(other_returns);
options->query_lcase_mask = SeqLocSetFree(options->query_lcase_mask);
options = BLASTOptionDelete(options);
MemFree(program_name);
FileClose(outfp);
if (entrez_lookup) {
BioseqFree(query_bsp);
BioseqFree(subject_bsp);
} else {
SeqEntryFree(sep);
SeqEntryFree(sep1);
}
return 0;
}
Int2 Main()
{
AsnIoPtr aip;
BioseqPtr bsp;
Pointer dataptr;
Uint2 datatype;
Boolean found;
SPI_mRNAToHerdPtr h_head;
SPI_mRNAToHerdPtr h_prev;
SPI_mRNAToHerdPtr hptr;
FILE *ifp;
Boolean isGIlist;
Char line[60];
Boolean lowercase;
SeqLocPtr lcaseloc;
FILE *ofp;
FILE *ofp2;
SeqAlignPtr sap;
SeqAnnotPtr sanp;
SeqEntryPtr sep;
FILE *sfp;
SeqIdPtr sip;
SeqLocPtr slp;
SPI_bsinfoPtr spig;
SPI_bsinfoPtr spig_head;
SPI_bsinfoPtr spig_prev;
SPI_bsinfoPtr spim;
SPI_bsinfoPtr spim_head;
SPI_bsinfoPtr spim_prev;
SPI_OptionsPtr spot;
SPI_RegionInfoPtr srip = NULL;
SPI_RegionInfoPtr srip_head;
SPI_RegionInfoPtr srip_prev;
CharPtr str;
CharPtr txt;
ID1BioseqFetchEnable("spidey", FALSE);
LocalSeqFetchInit(FALSE);
/* standard setup */
ErrSetFatalLevel (SEV_MAX);
ErrClearOptFlags (EO_SHOW_USERSTR);
UseLocalAsnloadDataAndErrMsg ();
ErrPathReset ();
if (! AllObjLoad ())
{
Message (MSG_FATAL, "AllObjLoad failed");
return 1;
}
if (! SubmitAsnLoad ())
{
Message (MSG_FATAL, "SubmitAsnLoad failed");
return 1;
}
if (! FeatDefSetLoad ())
{
Message (MSG_FATAL, "FeatDefSetLoad failed");
return 1;
}
if (! SeqCodeSetLoad ())
{
Message (MSG_FATAL, "SeqCodeSetLoad failed");
return 1;
}
if (! GeneticCodeTableLoad ())
{
Message (MSG_FATAL, "GeneticCodeTableLoad failed");
return 1;
}
if (!GetArgs("SPIDEY", NUMARGS, myargs))
return 0;
/* set the error message level high to suppress warnings from BLAST */
isGIlist = (Boolean)myargs[MYARGGILIST].intvalue;
txt = myargs[MYARGGENFILE].strvalue;
ifp = FileOpen(txt, "r");
spig_head = NULL;
if (ifp == NULL)
{
bsp = SPI_GetBspFromGIOrAcc(txt);
if (bsp == NULL)
{
ErrPostEx(SEV_ERROR, 0, 0, "Can't open genomic input file\n");
return -1;
} else
{
spig_head = (SPI_bsinfoPtr)MemNew(sizeof(SPI_bsinfo));
spig_head->bsp = bsp;
}
}
if (spig_head == NULL)
{
spig_prev = NULL;
/* read in the genomic sequence(s) first and put them into bsinfo structures */
while ((dataptr = ReadAsnFastaOrFlatFile (ifp, &datatype, NULL, FALSE, FALSE, TRUE, FALSE)) != NULL)
{
if (datatype == OBJ_BIOSEQ)
{
spig = (SPI_bsinfoPtr)MemNew(sizeof(SPI_bsinfo));
spig->bsp = (BioseqPtr)dataptr;
if (spig_head == NULL)
spig_head = spig_prev = spig;
else
{
spig_prev->next = spig;
spig_prev = spig;
}
} else if (datatype == OBJ_SEQENTRY)
{
sep = (SeqEntryPtr)dataptr;
SeqEntryExplore(sep, &spig_head, SPI_FindAllNuc);
}
}
FileClose(ifp);
}
if (spig_head == NULL)
{
ErrPostEx(SEV_ERROR, 0, 0, "No valid bioseqs in genomic file\n");
return -1;
} else if (ISA_aa(spig_head->bsp->mol))
{
ErrPostEx(SEV_ERROR, 0, 0, "At least one of the genomic sequences appears to be a protein.\n");
return -1;
}
if (spig_head->next != NULL)
{
ErrPostEx(SEV_ERROR, 0, 0, "This version can only process one genomic sequence at a time. Only the first sequence in this file will be used.\n");
spig_head->next = NULL;
}
spim_head = spim_prev = NULL;
txt = myargs[MYARGMRNAFILE].strvalue;
ifp = FileOpen(txt, "r");
if (ifp == NULL)
{
bsp = SPI_GetBspFromGIOrAcc(txt);
if (bsp == NULL)
{
ErrPostEx(SEV_ERROR, 0, 0, "Can't open mRNA input file\n");
return -1;
} else
{
spim_head = (SPI_bsinfoPtr)MemNew(sizeof(SPI_bsinfo));
spim_head->bsp = bsp;
}
}
if (spim_head == NULL)
{
lowercase = (Boolean)myargs[MYARGMASKED].intvalue;
lcaseloc = NULL;
/* if the mRNA has lowercase masking, read it in carefully to record the masking */
if (lowercase == TRUE)
{
while ((sep = FastaToSeqEntryForDb(ifp, TRUE, NULL, TRUE, NULL, NULL, &lcaseloc)) != NULL)
{
SeqEntryExplore(sep, &spim_head, SPI_FindAllNuc);
if (lcaseloc != NULL) /* put masking info into the bsinfo structure */
{
spim = spim_head;
sip = SeqLocId(lcaseloc);
found = FALSE;
while (spim != NULL && !found)
{
if (SeqIdComp(sip, spim->bsp->id) == SIC_YES)
{
found = TRUE;
spim->lcaseloc = lcaseloc;
}
spim = spim->next;
}
lcaseloc = NULL;
}
}
} else if (isGIlist) /* mRNA file is a list of GIs, must fetch the bioseqs */
{
str = ReadALine(line, sizeof(line), ifp);
while (str != NULL)
{
bsp = SPI_GetBspFromGIOrAcc(str);
if (bsp != NULL)
{
spim = (SPI_bsinfoPtr)MemNew(sizeof(SPI_bsinfo));
spim->bsp = bsp;
if (spim_head == NULL)
spim_head = spim_prev = spim;
else
{
spim_prev->next = spim;
spim_prev = spim;
}
}
str = ReadALine(line, sizeof(line), ifp);
}
} else /* mRNAs are FASTA or ASN.1, read them all in */
{
while ((dataptr = ReadAsnFastaOrFlatFile (ifp, &datatype, NULL, FALSE, FALSE, TRUE, FALSE)) != NULL)
{
if (datatype == OBJ_BIOSEQ)
{
spim = (SPI_bsinfoPtr)MemNew(sizeof(SPI_bsinfo));
spim->bsp = (BioseqPtr)dataptr;
if (spim_head == NULL)
spim_head = spim_prev = spim;
else
{
spim_prev->next = spim;
spim_prev = spim;
}
} else if (datatype == OBJ_SEQENTRY)
{
sep = (SeqEntryPtr)dataptr;
SeqEntryExplore(sep, &spim_head, SPI_FindAllNuc);
}
}
}
FileClose(ifp);
}
if (spim_head == NULL)
{
ErrPostEx(SEV_ERROR, 0, 0, "No valid bioseqs in mRNA file\n");
return -1;
} else if (ISA_aa(spim_head->bsp->mol))
{
ErrPostEx(SEV_ERROR, 0, 0, "At least one of the mRNA sequences appears to be a protein\n");
return -1;
}
txt = myargs[MYARGTABLE].strvalue;
if (txt != NULL)
{
ifp = FileOpen(txt, "r");
if (ifp == NULL)
{
ErrPostEx(SEV_ERROR, 0, 0, "Unable to open table file\n");
return -1;
}
SPI_ReadFeatureTable(ifp, spim_head);
spim = spim_head;
while (spim != NULL)
{
if (spim->lcaseloc != NULL)
{
slp = (SeqLocPtr)ValNodeNew(NULL);
slp->choice = SEQLOC_MIX;
slp->data.ptrvalue = (Pointer)spim->lcaseloc;
spim->lcaseloc = slp;
}
spim = spim->next;
}
}
spim = spim_head;
spot = (SPI_OptionsPtr)MemNew(sizeof(SPI_Options));
spot->printaln = myargs[MYARGPRALIGN].intvalue;
txt = myargs[MYARGOUTFILE].strvalue;
ofp = FileOpen(txt, "w");
if (ofp == NULL && spot->printaln != 3)
{
ErrPostEx(SEV_ERROR, 0, 0, "Unable to open output file\n");
return -1;
}
if (spot->printaln >= 2)
{
txt = myargs[MYARGALNFILE].strvalue;
ofp2 = FileOpen(txt, "a");
if (ofp2 == NULL)
{
ErrPostEx(SEV_ERROR, 0, 0, "Unable to open output file 2\n");
return -1;
}
} else
ofp2 = NULL;
/** ErrSetMessageLevel(SEV_MAX); **/
spot->firstpasseval = myargs[MYARG1STEVAL].floatvalue;
spot->secpasseval = myargs[MYARG2NDEVAL].floatvalue;
spot->thirdpasseval = myargs[MYARG3RDEVAL].floatvalue;
spot->numreturns = myargs[MYARGNUMMOD].intvalue;
spot->idcutoff = myargs[MYARGIDCUT].intvalue;
spot->lencutoff = myargs[MYARGLENCUT].intvalue;
spot->interspecies = (Boolean)myargs[MYARGSPEC].intvalue;
spot->printasn = (Boolean)myargs[MYARGASN].intvalue;
spot->fetchcds = (Boolean)myargs[MYARGGETCDS].intvalue;
/*spot->ace = (Boolean)myargs[MYARGACEDB].intvalue;*/
spot->from = myargs[MYARGFROM].intvalue;
spot->to = myargs[MYARGTO].intvalue;
spot->makemult = (Boolean)myargs[MYARGMULT].intvalue;
/*KSK*/
spot->bigintron = (Boolean)myargs[MYARGXL].intvalue;
spot->bigintron_size = myargs[MYARGXL_SIZE].intvalue;
spot->repeat_db_file = myargs[MYARGREPDB].strvalue;
txt = myargs[MYARGORG].strvalue;
if (!StringICmp(txt, "d") || !StringICmp(txt, "D")){
spot->organism = SPI_FLY;
}
else if (!StringICmp(txt, "p") || !StringICmp(txt, "P")){
spot->organism = SPI_PLANT;
}
else if (!StringICmp(txt, "c") || !StringICmp(txt, "C")){
spot->organism = SPI_CELEGANS;
}
else if (!StringICmp(txt, "m") || !StringICmp(txt, "M")){
spot->organism = SPI_DICTY;
}
else {
spot->organism = SPI_VERTEBRATE;
}
sap = NULL;
if (spot->printasn)
spot->sap_head = &sap;
txt = myargs[MYARGSTRAND].strvalue;
if (txt != NULL)
{
if (StrChr(txt, 'p') || StrChr(txt, 'P'))
spot->strand = Seq_strand_plus;
else
spot->strand = Seq_strand_minus;
} else
spot->strand = Seq_strand_both;
/*txt = myargs[MYARGDRAFTFILE].strvalue;
if (txt != NULL)
spot->draftfile = StringSave(txt);*/
txt = myargs[MYARGDSPLICE].strvalue;
if (txt != NULL)
{
sfp = FileOpen(txt, "r");
SPI_GetSpliceInfo(spot, sfp, TRUE);
FileClose(sfp);
}
txt = myargs[MYARGASPLICE].strvalue;
if (txt != NULL)
{
sfp = FileOpen(txt, "r");
SPI_GetSpliceInfo(spot, sfp, FALSE);
FileClose(sfp);
}
h_head = h_prev = NULL;
srip_head = srip_prev = NULL;
while (spim != NULL)
{
spot->lcaseloc = spim->lcaseloc;
if (spot->draftfile == NULL)
srip = SPI_AlnSinglemRNAToGen(spig_head, spim, ofp, ofp2, spot);
else
{
hptr = SPI_AlnSinglemRNAToPieces(spig_head, spim, ofp, ofp2, spot);
if (h_head != NULL)
{
h_prev->next = hptr;
h_prev = hptr;
} else
h_head = h_prev = hptr;
}
if (srip != NULL)
{
if (srip_head != NULL)
{
srip_prev->next = srip;
srip_prev = srip;
} else
srip_head = srip_prev = srip;
}
spim = spim->next;
}
if (spot->makemult)
{
SPI_MakeMultipleAlignment(srip_head);
SPI_PrintMultipleAlignment(srip_head, FALSE, spig_head->bsp, ofp);
SPI_RegionListFree(srip_head);
} else
SPI_RegionListFree(srip_head);
/* create the ASN.1 output, if requested; need to use the continuous alignment */
/* that was generated */
if (spot->printasn && *(spot->sap_head) != NULL && spot->draftfile == NULL)
{
sanp = SeqAnnotForSeqAlign(*(spot->sap_head));
txt = myargs[MYARGASNFILE].strvalue;
aip = AsnIoOpen(txt, "w");
SeqAnnotAsnWrite(sanp, aip, NULL);
AsnIoClose(aip);
SeqAlignSetFree(*(spot->sap_head));
}
FileClose(ofp);
FileClose(ofp2);
SPI_OptionsFree(spot);
SPI_bsinfoFreeList(spim_head);
SPI_bsinfoFreeList(spig_head);
LocalSeqFetchDisable();
ID1BioseqFetchDisable();
return 0;
}
static Int2 Main_old (void)
{
AsnIoPtr aip, xml_aip = NULL;
BioseqPtr query_bsp, PNTR query_bsp_array;
BioSourcePtr source;
BLAST_MatrixPtr matrix;
BLAST_OptionsBlkPtr options;
BLAST_KarlinBlkPtr ka_params=NULL, ka_params_gap=NULL;
BlastPruneSapStructPtr prune;
Boolean db_is_na, query_is_na, show_gi, believe_query=FALSE;
Boolean html=FALSE;
CharPtr params_buffer=NULL;
Int4 number_of_descriptions, number_of_alignments;
SeqAlignPtr seqalign, PNTR seqalign_array;
SeqAnnotPtr seqannot;
SeqEntryPtr PNTR sepp;
TxDfDbInfoPtr dbinfo=NULL, dbinfo_head;
Uint1 align_type, align_view, out_type;
Uint4 align_options, print_options;
ValNodePtr mask_loc, mask_loc_start, next_mask_loc;
ValNodePtr vnp, other_returns, error_returns;
CharPtr blast_program, blast_database, blast_inputfile, blast_outputfile;
FILE *infp, *outfp, *mqfp=NULL;
Int4 index, num_bsps, total_length, total_processed = 0;
Int2 ctr = 1;
Char prefix[2];
SeqLocPtr last_mask, mask_slp;
Boolean done, hits_found;
Boolean lcase_masking;
MBXmlPtr mbxp = NULL;
Boolean traditional_formatting;
blast_program = "blastn";
blast_database = myargs [ARG_DB].strvalue;
blast_inputfile = myargs [ARG_QUERY].strvalue;
blast_outputfile = myargs [ARG_OUT].strvalue;
if (myargs[ARG_HTML].intvalue)
html = TRUE;
if ((infp = FileOpen(blast_inputfile, "r")) == NULL) {
ErrPostEx(SEV_FATAL, 1, 0, "mgblast: Unable to open input file %s\n", blast_inputfile);
return (1);
}
align_view = (Int1) myargs[ARG_FORMAT].intvalue;
/* Geo mod:
-- replaced myargs[ARG_OUTTYPE].intvalue with out_type from now on
*/
out_type=(Int1) myargs[ARG_OUTTYPE].intvalue;
if (out_type==MGBLAST_FLTHITS || out_type==MGBLAST_HITGAPS) {
align_view = 12 + (out_type-MGBLAST_FLTHITS );
out_type=MBLAST_ALIGNMENTS;
//Attention: 12 MUST be the -m mgblast tab option for MGBLAST_FLTHITS format
// and MGBLAST_HITGAPS = MGBLAST_FLTHITS+1
if (align_view>12) { // this is MGBLAST_HITGAPS output
gap_Info=TRUE;
if (dbgaps_buf==NULL)
dbgaps_buf=(CharPtr) Malloc(dbgaps_bufsize + 1);
if (qgaps_buf==NULL)
qgaps_buf=(CharPtr) Malloc(qgaps_bufsize + 1);
}
}
outfp = NULL;
traditional_formatting =
(out_type == MBLAST_ALIGNMENTS ||
out_type == MBLAST_DELAYED_TRACEBACK);
if ((!traditional_formatting ||
(align_view != 7 && align_view != 10 && align_view != 11)) &&
blast_outputfile != NULL) {
if ((outfp = FileOpen(blast_outputfile, "w")) == NULL) {
ErrPostEx(SEV_FATAL, 1, 0, "blast: Unable to open output file %s\n", blast_outputfile);
return (1);
}
}
//align_type = BlastGetTypes(blast_program, &query_is_na, &db_is_na);
align_type = BlastGetTypes(blast_program, &query_is_na, &db_is_na);
/*
if (!traditional_formatting)
believe_query = TRUE;
else
believe_query = (Boolean) myargs[ARG_BELIEVEQUERY].intvalue;
*/
//Geo mod:
believe_query=FALSE;
//If ASN.1 output is requested and believe_query is not set to TRUE,
// exit with an error.
if (!believe_query && (myargs[ARG_ASNOUT].strvalue ||
align_view == 10 || align_view == 11)) {
ErrPostEx(SEV_FATAL, 1, 0,
"-J option must be TRUE to produce ASN.1 output; before "
"changing -J to TRUE please also ensure that all query "
"sequence identifiers are unique");
return -1;
}
options = BLASTOptionNewEx(blast_program, TRUE, TRUE);
if (options == NULL)
return 3;
options->do_sum_stats = FALSE;
options->is_neighboring = FALSE;
options->expect_value = (Nlm_FloatHi) myargs [ARG_EVALUE].floatvalue;
number_of_descriptions = myargs[ARG_DESCRIPTIONS].intvalue;
number_of_alignments = myargs[ARG_ALIGNMENTS].intvalue;
options->hitlist_size = MAX(number_of_descriptions, number_of_alignments);
if (myargs[ARG_XDROP].intvalue != 0)
options->gap_x_dropoff = myargs[ARG_XDROP].intvalue;
if (myargs[ARG_XDROP_UNGAPPED].intvalue != 0)
options->dropoff_2nd_pass = myargs[ARG_XDROP_UNGAPPED].intvalue;
if (myargs[ARG_XDROP_FINAL].intvalue != 0)
options->gap_x_dropoff_final = myargs[ARG_XDROP_FINAL].intvalue;
if (StringICmp(myargs[ARG_FILTER].strvalue, "T") == 0)
options->filter_string = StringSave("D");
else
options->filter_string = StringSave(myargs[ARG_FILTER].strvalue);
show_gi = (Boolean) myargs[ARG_SHOWGIS].intvalue;
options->penalty = myargs[ARG_MISMATCH].intvalue;
options->reward = myargs[ARG_MATCH].intvalue;
if (myargs[ARG_GAPOPEN].intvalue >= 0)
options->gap_open = myargs[ARG_GAPOPEN].intvalue;
if (myargs[ARG_GAPEXT].intvalue >= 0)
options->gap_extend = myargs[ARG_GAPEXT].intvalue;
if (options->gap_open == 0 && options->reward % 2 == 0 &&
options->gap_extend == options->reward / 2 - options->penalty)
/* This is the default value */
options->gap_extend = 0;
options->genetic_code = 1;
options->db_genetic_code = 1; /* Default; it's not needed here anyway */
options->number_of_cpus = myargs[ARG_THREADS].intvalue;
if (myargs[ARG_WORDSIZE].intvalue != 0)
options->wordsize = myargs[ARG_WORDSIZE].intvalue;
if (myargs[ARG_MINSCORE].intvalue == 0)
options->cutoff_s2 = options->wordsize*options->reward;
else
options->cutoff_s2 = myargs[ARG_MINSCORE].intvalue;
options->db_length = (Int8) myargs[ARG_DBSIZE].floatvalue;
options->searchsp_eff = (Nlm_FloatHi) myargs[ARG_SEARCHSP].floatvalue;
options->perform_culling = FALSE;
/* Kludge */
options->block_width = myargs[ARG_MAXPOS].intvalue;
options->strand_option = myargs[ARG_STRAND].intvalue;
options->window_size = myargs[ARG_WINDOW].intvalue;
#ifdef DO_NOT_SUPPRESS_BLAST_OP
options->mb_template_length = myargs[ARG_TEMPL_LEN].intvalue;
if (myargs[ARG_TEMPL_LEN].intvalue != 0)
options->mb_one_base_step = (Boolean) myargs[ARG_EVERYBASE].intvalue;
options->mb_disc_type = myargs[ARG_TEMPL_TYPE].intvalue;
#endif
lcase_masking = (Boolean) myargs[ARG_LCASE].intvalue;
/* Allow dynamic programming gapped extension only with affine
gap scores */
if (options->gap_open != 0 || options->gap_extend != 0)
options->mb_use_dyn_prog = (Boolean) myargs[ARG_DYNAMIC].intvalue;
print_options = 0;
align_options = 0;
align_options += TXALIGN_COMPRESS;
align_options += TXALIGN_END_NUM;
if (show_gi) {
align_options += TXALIGN_SHOW_GI;
print_options += TXALIGN_SHOW_GI;
}
if (align_view) {
align_options += TXALIGN_MASTER;
if (align_view == 1 || align_view == 3)
align_options += TXALIGN_MISMATCH;
if (align_view == 3 || align_view == 4 || align_view == 6)
align_options += TXALIGN_FLAT_INS;
if (align_view == 5 || align_view == 6)
align_options += TXALIGN_BLUNT_END;
} else {
align_options += TXALIGN_MATRIX_VAL;
align_options += TXALIGN_SHOW_QS;
}
if (html) {
align_options += TXALIGN_HTML;
print_options += TXALIGN_HTML;
}
if (myargs[ARG_GILIST].strvalue)
options->gifile = StringSave(myargs[ARG_GILIST].strvalue);
if (out_type == MBLAST_ENDPOINTS)
options->no_traceback = 1;
else if (out_type == MBLAST_DELAYED_TRACEBACK)
options->no_traceback = 2;
else
options->no_traceback = 0;
options->megablast_full_deflines = (Boolean) myargs[ARG_FULLID].intvalue;
options->perc_identity = (FloatLo) myargs[ARG_PERC_IDENT].floatvalue;
options->hsp_num_max = myargs[ARG_MAXHSP].intvalue;
if (!believe_query)
options->megablast_full_deflines = TRUE;
/*if (options->megablast_full_deflines)
believe_query = FALSE;*/
query_bsp_array = (BioseqPtr PNTR) MemNew((MAX_NUM_QUERIES+1)*sizeof(BioseqPtr));
sepp = (SeqEntryPtr PNTR) MemNew(MAX_NUM_QUERIES*sizeof(SeqEntryPtr));
StrCpy(prefix, "");
global_fp = outfp;
options->output = outfp;
if (traditional_formatting) {
if (align_view < 7) {
if (html) {
fprintf(outfp, "<HTML>\n<TITLE>MEGABLAST Search Results</TITLE>\n");
fprintf(outfp, "<BODY BGCOLOR=\"#FFFFFF\" LINK=\"#0000FF\" "
"VLINK=\"#660099\" ALINK=\"#660099\">\n");
fprintf(outfp, "<PRE>\n");
}
init_buff_ex(90);
BlastPrintVersionInfo("mgblast", html, outfp);
fprintf(outfp, "\n");
MegaBlastPrintReference(html, 90, outfp);
fprintf(outfp, "\n");
if(!PrintDbInformation(blast_database, !db_is_na, 70, outfp, html))
return 1;
free_buff();
#ifdef OS_UNIX
fprintf(global_fp, "%s", "Searching");
#endif
}
}
aip = NULL;
if (myargs[ARG_ASNOUT].strvalue != NULL) {
if ((aip = AsnIoOpen (myargs[ARG_ASNOUT].strvalue,"w")) == NULL) {
ErrPostEx(SEV_FATAL, 1, 0, "blast: Unable to open output file %s\n", myargs[ARG_ASNOUT].strvalue);
return 1;
}
}
else if (align_view == 10 || align_view == 11)
{
const char* mode = (align_view == 10) ? "w" : "wb";
if ((aip = AsnIoOpen (blast_outputfile, (char*) mode)) == NULL) {
ErrPostEx(SEV_FATAL, 1, 0, "blast: Unable to open output file %s\n", blast_outputfile);
return 1;
}
}
if (align_view == 7) {
xml_aip = AsnIoOpen(blast_outputfile, "wx");
}
if (myargs[ARG_QUERYLOC].strvalue) {
Int4 start, end;
Megablast_GetLoc(myargs[ARG_QUERYLOC].strvalue, &start, &end);
options->required_start = start - 1;
options->required_end = end -1;
}
done = FALSE;
while (!done) {
num_bsps = 0;
total_length = 0;
done = TRUE;
SeqMgrHoldIndexing(TRUE);
mask_slp = last_mask = NULL;
while ((sepp[num_bsps]=FastaToSeqEntryForDb(infp, query_is_na, NULL,
believe_query, prefix, &ctr,
&mask_slp)) != NULL) {
if (!lcase_masking) /* Lower case ignored */
mask_slp = SeqLocFree(mask_slp);
if (mask_slp) {
if (!last_mask)
options->query_lcase_mask = last_mask = mask_slp;
else {
last_mask->next = mask_slp;
last_mask = last_mask->next;
}
mask_slp = NULL;
}
query_bsp = NULL;
SeqEntryExplore(sepp[num_bsps], &query_bsp, FindNuc);
//debug:
/*
char query_buffer[255];
SeqIdWrite(query_bsp->id, query_buffer, PRINTID_FASTA_LONG, BUFFER_LENGTH);
fprintf(stderr, "===> query_buf=%s\n", query_buffer);
*/
if (query_bsp == NULL) {
ErrPostEx(SEV_FATAL, 1, 0, "Unable to obtain bioseq\n");
return 2;
}
source = BioSourceNew();
source->org = OrgRefNew();
source->org->orgname = OrgNameNew();
source->org->orgname->gcode = options->genetic_code;
ValNodeAddPointer(&(query_bsp->descr), Seq_descr_source, source);
query_bsp_array[num_bsps++] = query_bsp;
total_length += query_bsp->length;
if (total_length > myargs[ARG_MAXQUERY].intvalue ||
num_bsps >= MAX_NUM_QUERIES) {
done = FALSE;
break;
}
}
if (num_bsps == 0)
break;
SeqMgrHoldIndexing(FALSE);
other_returns = NULL;
error_returns = NULL;
if (out_type==MBLAST_ENDPOINTS)
seqalign_array = BioseqMegaBlastEngine(query_bsp_array, blast_program,
blast_database, options,
&other_returns, &error_returns,
dummy_callback, NULL, NULL, 0,
MegaBlastPrintEndpoints);
else if (out_type==MBLAST_SEGMENTS)
seqalign_array = BioseqMegaBlastEngine(query_bsp_array, blast_program,
blast_database, options,
&other_returns, &error_returns,
dummy_callback, NULL, NULL, 0,
MegaBlastPrintSegments);
else if (out_type==MBLAST_ALIGN_INFO) {
/* -- Geo mod: do not print header
PrintTabularOutputHeader(blast_database,
(num_bsps==1) ? query_bsp_array[0] : NULL,
NULL, "megablast", 0, believe_query,
global_fp);*/
seqalign_array = BioseqMegaBlastEngine(query_bsp_array, blast_program,
blast_database, options,
&other_returns, &error_returns,
dummy_callback, NULL, NULL, 0,
MegaBlastPrintAlignInfo);
} else if (out_type==MBLAST_ALIGNMENTS) {
seqalign_array = BioseqMegaBlastEngine(query_bsp_array, blast_program,
blast_database, options, &other_returns,
&error_returns, align_view < 7 ? tick_callback : NULL,
NULL, NULL, 0, NULL);
}
#ifdef OS_UNIX
fflush(global_fp);
#endif
if (error_returns) {
BlastErrorPrint(error_returns);
for (vnp = error_returns; vnp; vnp = vnp->next) {
BlastDestroyErrorMessage((BlastErrorMsgPtr)vnp->data.ptrvalue);
}
ValNodeFree(error_returns);
}
if (traditional_formatting) {
dbinfo = NULL;
ka_params = NULL;
ka_params_gap = NULL;
params_buffer = NULL;
mask_loc = NULL;
matrix = NULL;
for (vnp=other_returns; vnp; vnp = vnp->next) {
switch (vnp->choice) {
case TXDBINFO:
dbinfo = vnp->data.ptrvalue;
break;
case TXKABLK_NOGAP:
ka_params = vnp->data.ptrvalue;
break;
case TXKABLK_GAP:
ka_params_gap = vnp->data.ptrvalue;
break;
case TXPARAMETERS:
params_buffer = vnp->data.ptrvalue;
break;
case TXMATRIX:
matrix = vnp->data.ptrvalue;
break;
case SEQLOC_MASKING_NOTSET:
case SEQLOC_MASKING_PLUS1:
case SEQLOC_MASKING_PLUS2:
case SEQLOC_MASKING_PLUS3:
case SEQLOC_MASKING_MINUS1:
case SEQLOC_MASKING_MINUS2:
case SEQLOC_MASKING_MINUS3:
ValNodeAddPointer(&mask_loc, vnp->choice, vnp->data.ptrvalue);
break;
default:
break;
}
}
#ifdef OS_UNIX
if(align_view < 7) {
fprintf(global_fp, "%s\n", " done");
}
#endif
if (myargs[ARG_MASKEDQUERY].strvalue) {
if ((mqfp = FileOpen(myargs[ARG_MASKEDQUERY].strvalue, "w")) == NULL)
ErrPostEx(SEV_WARNING, 1, 0, "Unable to open file %s for masked query\n",
myargs[ARG_MASKEDQUERY].strvalue);
}
hits_found = FALSE;
mask_loc_start = next_mask_loc = mask_loc;
mask_loc = NULL;
if (align_view == 7) {
mbxp = PSIXmlInit(xml_aip, "megablast", blast_database,
options, query_bsp_array[0], 0);
}
if (seqalign_array) { //results returned back for processing
ReadDBBioseqFetchEnable ("megablast", blast_database, db_is_na, TRUE);
for (index=0; index<num_bsps; index++) {
seqalign = seqalign_array[index];
if (next_mask_loc &&
SeqIdComp(SeqLocId((SeqLocPtr)next_mask_loc->data.ptrvalue),
query_bsp_array[index]->id) == SIC_YES) {
mask_loc = (SeqLocPtr)
MemDup(next_mask_loc, sizeof(SeqLoc));
next_mask_loc = next_mask_loc->next;
mask_loc->next = NULL;
}
if (mqfp) {
/* convert mask locations from all sources into
a single seqloc */
mask_slp = NULL;
if (mask_loc)
mask_slp = blastMergeFilterLocs(mask_slp,
(SeqLocPtr)mask_loc->data.ptrvalue,
FALSE, 0, 0);
PrintMaskedSequence(query_bsp_array[index], mask_slp,
mqfp, 50, lcase_masking);
SeqLocSetFree(mask_slp);
}
if (seqalign==NULL) {
mask_loc = MemFree(mask_loc);
continue;
}
hits_found = TRUE;
if (align_view < 7) {
init_buff_ex(70);
AcknowledgeBlastQuery(query_bsp_array[index], 70, outfp,
believe_query, html);
free_buff();
}
if (align_view == 8 || align_view == 9) {
if (align_view == 9)
PrintTabularOutputHeader(blast_database,
query_bsp_array[index], NULL, blast_program, 0,
believe_query, global_fp);
/* debug:
char qbuf[512];
strcpy(qbuf, BioseqGetTitle(query_bsp_array[index]));
fprintf(stderr, "---> Here: query title=%s\n", qbuf);
*/
BlastPrintTabulatedResults(seqalign,
query_bsp_array[index], NULL, number_of_alignments,
blast_program, !options->gapped_calculation,
believe_query, 0, 0,
global_fp, (align_view == 9));
ObjMgrFreeCache(0);
SeqAlignSetFree(seqalign);
mask_loc = MemFree(mask_loc);
continue;
}
//Geo mod:
else if (align_view>=12) {
MGBlastPrintTab(seqalign,
query_bsp_array[index], number_of_alignments,
!options->gapped_calculation,
global_fp);
ObjMgrFreeCache(0);
SeqAlignSetFree(seqalign);
mask_loc = MemFree(mask_loc);
continue;
}
else if(align_view == 7) {
IterationPtr iterp;
iterp = BXMLBuildOneQueryIteration(seqalign,
NULL, FALSE,
!options->gapped_calculation, index,
NULL, query_bsp_array[index], mask_loc);
IterationAsnWrite(iterp, mbxp->aip, mbxp->atp);
AsnIoFlush(mbxp->aip);
IterationFree(iterp);
SeqAlignSetFree(seqalign);
mask_loc = MemFree(mask_loc);
continue;
}
seqannot = SeqAnnotNew();
seqannot->type = 2;
AddAlignInfoToSeqAnnot(seqannot, align_type);
seqannot->data = seqalign;
if (aip) {
SeqAnnotAsnWrite((SeqAnnotPtr) seqannot, aip, NULL);
AsnIoReset(aip);
}
if (outfp) { /* Uncacheing causes problems with ordinal nos. vs. gi's. */
prune = BlastPruneHitsFromSeqAlign(seqalign, number_of_descriptions, NULL);
ObjMgrSetHold();
init_buff_ex(85);
PrintDefLinesFromSeqAlign(prune->sap, 80,
outfp, print_options, FIRST_PASS, NULL);
free_buff();
prune = BlastPruneHitsFromSeqAlign(seqalign, number_of_alignments, prune);
seqannot->data = prune->sap;
if (align_view != 0)
ShowTextAlignFromAnnot(seqannot, 60, outfp, NULL,
NULL, align_options, NULL,
mask_loc, NULL);
else
ShowTextAlignFromAnnot(seqannot, 60, outfp, NULL, NULL, align_options, NULL, mask_loc, FormatScoreFunc);
seqannot->data = seqalign;
prune = BlastPruneSapStructDestruct(prune);
ObjMgrClearHold();
ObjMgrFreeCache(0);
}
seqannot = SeqAnnotFree(seqannot);
mask_loc = MemFree(mask_loc);
} /* End loop on seqaligns for different queries */
ReadDBBioseqFetchDisable();
}
if (mbxp != NULL) {
MBXmlClose(mbxp, other_returns, !options->gapped_calculation);
}
if (mqfp)
FileClose(mqfp);
if (!hits_found && align_view < 7)
fprintf(outfp, "\n\n ***** No hits found ******\n\n");
matrix = BLAST_MatrixDestruct(matrix);
if(html)
fprintf(outfp, "<PRE>\n");
init_buff_ex(85);
dbinfo_head = dbinfo;
if(align_view < 7) {
while (dbinfo) {
PrintDbReport(dbinfo, 70, outfp);
dbinfo = dbinfo->next;
}
}
dbinfo_head = TxDfDbInfoDestruct(dbinfo_head);
if (ka_params) {
if(align_view < 7)
PrintKAParameters(ka_params->Lambda, ka_params->K, ka_params->H, 70, outfp, FALSE);
MemFree(ka_params);
}
if (ka_params_gap) {
if(align_view < 7)
PrintKAParameters(ka_params_gap->Lambda, ka_params_gap->K, ka_params_gap->H, 70, outfp, TRUE);
MemFree(ka_params_gap);
}
if(align_view < 7)
PrintTildeSepLines(params_buffer, 70, outfp);
MemFree(params_buffer);
free_buff();
mask_loc = mask_loc_start;
while (mask_loc) {
SeqLocSetFree(mask_loc->data.ptrvalue);
mask_loc = mask_loc->next;
}
ValNodeFree(mask_loc_start);
} else { //not traditional formatting
/* Just destruct all other_returns parts */
for (vnp=other_returns; vnp; vnp = vnp->next) {
switch (vnp->choice) {
case TXDBINFO:
TxDfDbInfoDestruct(vnp->data.ptrvalue);
break;
case TXKABLK_NOGAP:
case TXKABLK_GAP:
case TXPARAMETERS:
MemFree(vnp->data.ptrvalue);
break;
case TXMATRIX:
BLAST_MatrixDestruct(vnp->data.ptrvalue);
break;
case SEQLOC_MASKING_NOTSET:
case SEQLOC_MASKING_PLUS1:
case SEQLOC_MASKING_PLUS2:
case SEQLOC_MASKING_PLUS3:
case SEQLOC_MASKING_MINUS1:
case SEQLOC_MASKING_MINUS2:
case SEQLOC_MASKING_MINUS3:
mask_loc = vnp->data.ptrvalue;
SeqLocSetFree(mask_loc);
default:
break;
}
}
}
other_returns = ValNodeFree(other_returns);
MemFree(seqalign_array);
options->query_lcase_mask =
SeqLocSetFree(options->query_lcase_mask);
/* Freeing SeqEntries can be very expensive, do this only if
this is not the last iteration of search */
if (!done) {
for (index=0; index<num_bsps; index++) {
sepp[index] = SeqEntryFree(sepp[index]);
query_bsp_array[index] = NULL;
}
}
total_processed += num_bsps;
} /* End of loop on complete searches */
aip = AsnIoClose(aip);
/*if (align_view == 7)
xml_aip = AsnIoClose(xml_aip);*/
if (align_view < 7 && html)
fprintf(outfp, "</PRE>\n</BODY>\n</HTML>\n");
if (align_view < 7 && myargs[ARG_LOGINFO].intvalue)
fprintf(outfp, "Mega BLAST run finished, processed %d queries\n",
total_processed);
MemFree(query_bsp_array);
MemFree(sepp);
MemFree(qgaps_buf);
MemFree(dbgaps_buf);
options = BLASTOptionDelete(options);
FileClose(infp);
FileClose(outfp);
return 0;
}
Int2 Main()
{
PMSD pmsdRoot = NULL;
static char valfilein[PATH_MAX];
Int2 iDotLen = 0;
AsnIoPtr aip=NULL;
NcbiMimeAsn1Ptr nmap=NULL;
BiostrucPtr bsp=NULL;
BiostrucSeqPtr bssp=NULL;
PDNMS pdnmsModelstruc = NULL;
ErrSev esMsg,esLog,esFatal;
PDNML pdnmlModel;
PMLD pmldThis;
Boolean isMime = FALSE;
Int4 iModels = 0, iNCBImodel = 0, iPDBmodel = 0, iAscii = 0;
/* Initialize MMDB-API */
ErrSetLogfile("error_strSummary.log", ELOG_APPEND|ELOG_BANNER);
ErrSetOptFlags(EO_SHOW_SEVERITY|EO_SHOW_CODES|EO_LOG_FILELINE|EO_SHOW_USERSTR|EO_SHOW_ERRTEXT|EO_BEEP|EO_WAIT_KEY|EO_LOGTO_USRFILE);
if (!GetArgs("strSummary reports on what is inside .val or .cn3 or .prt file to stdout.\nCaution - will not work on Biounits downloaded from NCBI, use Asymmetric Units\n",3,Rargs))
return 1;
/* we use exact filenames and extensions to avoid confusion */
StringCpy(valfilein, Rargs[0].strvalue);
if (FileLength(valfilein) == 0)
{
ErrPostEx(SEV_FATAL,13,1,"Unable to find input file %s",Rargs[0].strvalue);
return 13;
}
if (!OpenMMDBAPI(0,NULL)) {
ErrPostEx(SEV_FATAL,12,1,"Unable to open MMDBAPI, check for missing bstdt.val dictionary file.");
return 12;
}
/* load an ASN.1 file *.val or *.c3d or *.prt write out Biostruc only */
aip=AsnIoOpen(valfilein,"rb");
if (aip==NULL) {
ErrPostEx(SEV_FATAL,11,1,"Unable open ASN.1 stream in file %s",valfilein);
return 11;
}
/* first try biostruc load */
/* printf("try biostruc\n"); */
esMsg=ErrGetMessageLevel();
esLog=ErrGetLogLevel();
esFatal=ErrGetFatalLevel();
ErrSetMessageLevel(SEV_MAX);
ErrSetLogLevel(SEV_MAX);
ErrSetFatalLevel(SEV_MAX);
bsp=BiostrucAsnRead(aip,NULL);
AsnIoClose(aip);
ErrSetMessageLevel(esMsg);
ErrSetLogLevel(esLog);
ErrSetFatalLevel(esFatal);
if (bsp == NULL) { /* try ascii */
aip = AsnIoOpen(valfilein,"r");
if (aip==NULL) {
ErrPostEx(SEV_FATAL,10,1,"Unable open binary or ascii ASN.1 from file %s",valfilein);
return 10;
}
esMsg=ErrGetMessageLevel();
esLog=ErrGetLogLevel();
esFatal=ErrGetFatalLevel();
ErrSetMessageLevel(SEV_MAX);
ErrSetLogLevel(SEV_MAX);
ErrSetFatalLevel(SEV_MAX);
bsp=BiostrucAsnRead(aip,NULL);
AsnIoClose(aip);
ErrSetMessageLevel(esMsg);
ErrSetLogLevel(esLog);
ErrSetFatalLevel(esFatal);
if (bsp) iAscii = 1;
}
if (bsp==NULL) {
/* printf("try mime binary\n"); */
/* then try NCBIMime load */
aip=NULL;
aip=AsnIoOpen(valfilein,"rb");
ErrSetMessageLevel(SEV_MAX);
ErrSetLogLevel(SEV_MAX);
ErrSetFatalLevel(SEV_MAX);
nmap=NcbiMimeAsn1AsnRead(aip,NULL);
ErrSetMessageLevel(esMsg);
ErrSetLogLevel(esLog);
ErrSetFatalLevel(esFatal);
AsnIoClose(aip);
if (nmap == NULL) {
/* printf("try mime ascii\n"); */
aip=AsnIoOpen(valfilein,"r");
ErrSetMessageLevel(SEV_MAX);
ErrSetLogLevel(SEV_MAX);
ErrSetFatalLevel(SEV_MAX);
nmap=NcbiMimeAsn1AsnRead(aip,NULL);
ErrSetMessageLevel(esMsg);
ErrSetLogLevel(esLog);
ErrSetFatalLevel(esFatal);
AsnIoClose(aip);
if (nmap) iAscii = 1;
}
if (nmap!=NULL) {
/* got an NCBI mime */
if (nmap->choice!=NcbiMimeAsn1_strucseq && nmap->choice!=NcbiMimeAsn1_strucseqs) {
/* wrong MIME type */
nmap=NcbiMimeAsn1Free(nmap);
ErrPostEx(SEV_ERROR,9,1,"MIME-type wrapper is not a strucseq or strucseqs - no Biostruc to report in: %s",valfilein);
return 9;
}
isMime = TRUE;
/* unwrap the mime and leave the bsp for PDB conversion */
bssp=(BiostrucSeqPtr)(nmap->data.ptrvalue);
bsp=bssp->structure;
bssp->structure = NULL;
/* may want to report on contents of wrapper ... */
nmap=NcbiMimeAsn1Free(nmap); /* discard the wrapper */
nmap = NULL;
bssp = NULL;
}
}
if (bsp == NULL) {
ErrPostEx(SEV_ERROR,8,1,"No Biostruc in files to report in: %s",valfilein);
return 8;
}
pdnmsModelstruc=MakeAModelstruc(bsp);
if (pdnmsModelstruc==NULL) {
ErrPostEx(SEV_ERROR,7,1,"Unable to convert Biostruc to Modelstruc");
return 7;
}
pmsdRoot=(PMSD)(pdnmsModelstruc->data.ptrvalue);
if (pmsdRoot==NULL) {
ErrPostEx(SEV_ERROR,6,1,"Internal error.");
return 6;
}
/* OK, Ready to Start Reporting */
printf("Filename: %s\n", valfilein);
if (Rargs[1].intvalue == FALSE) {
if (iAscii) printf("ASCII Asn.1 (.prt) ");
else printf("Binary Asn.1 (.val) ");
if (isMime) printf("Entry Point: NCBIMime\n");
else printf("Entry Point: Biostruc\n");
if (pmsdRoot->pcPDBName != NULL) printf("PDB code: %s\n",pmsdRoot->pcPDBName);
printf("MMDB Id: %d\n", (int) pmsdRoot->iMMDBid);
printf("Name: %s\n",GetStrucStrings(pdnmsModelstruc, LONG_NAME));
printf("PDB Class: %s\n",GetStrucStrings(pdnmsModelstruc, PDB_CLASS));
printf("PDB Source: %s\n",GetStrucStrings(pdnmsModelstruc, PDB_SOURCE));
pdnmlModel=pmsdRoot->pdnmlModels;
while (pdnmlModel) {
iModels++;
pmldThis=(PMLD)(pdnmlModel->data.ptrvalue);
if (pmldThis->iType==Model_type_ncbi_all_atom) {
iNCBImodel = pdnmlModel->choice;
}
if (pmldThis->iType==Model_type_pdb_model) {
iPDBmodel = pdnmlModel->choice;
}
pdnmlModel=pdnmlModel->next;
}
printf("Number of Models: %d\n",iModels);
if(iNCBImodel) printf("NCBI All Atom Model: %d\n",iNCBImodel);
if (iPDBmodel) printf("PDB All Atom Model: %d\n",iPDBmodel);
if (pmsdRoot->pDictLocal) printf("Has Local Chemical Graph Dictionary\n");
printf("Number of Molecules: %d\n", (int) pmsdRoot->iMolCount); /* number of molecules */
printf("Number of Objects: %d\n",(int) pmsdRoot->iObjCount); /* number of objects */
printf("Number of Density Sets: %d\n",(int) pmsdRoot->iDensCount); /* number of densities */
printf("Number of Inter-Molecule Bonds: %d\n", (int) pmsdRoot->iIMBCount);
if (Rargs[2].intvalue == TRUE) {
printf("\n\nRAMACHANDRAN Angles for all Proteins:\n");
if (iNCBImodel) {
printf("NCBI All Atom Coordinate Model Number %d\n\nChain, AA, Num, Phi, Psi\n",iNCBImodel);
WriteStdoutRamaOneModel(pmsdRoot, iNCBImodel );
}
else if (iPDBmodel) {
printf("PDB All Atom Coordinate Model Number %d:\n\nChain, AA, Num, Phi, Psi\n",iPDBmodel);
WriteStdoutRamaOneModel(pmsdRoot, iPDBmodel );
}
}
}
printf("\n\n");
/* Output FASTA for each chain and dump het list - oldie but goodie code ! */
WriteFASTASeqHet(pdnmsModelstruc, stdout);
/* Shut Down MMDB-API */
/* All Modelstrucs remaining are freed in CloseMMDB-API() */
CloseMMDBAPI();
return 0;
}
Int2 Main(void)
{
Char app [64];
CharPtr directory;
CharPtr ptr;
Char sfx [32];
OutputStreamData osd;
InputStreamData isd;
AsnStreamData asd;
Int4 gap_sizes[2];
Int4 rval = 0;
Int4 u_eq = 0, u_gteq = -1, k_eq = 0, k_gteq = -1;
/* standard setup */
ErrSetFatalLevel (SEV_MAX);
ErrClearOptFlags (EO_SHOW_USERSTR);
UseLocalAsnloadDataAndErrMsg ();
ErrPathReset ();
/* finish resolving internal connections in ASN.1 parse tables */
if (! AllObjLoad ()) {
Message (MSG_FATAL, "AllObjLoad failed");
return 1;
}
if (! SubmitAsnLoad ()) {
Message (MSG_FATAL, "SubmitAsnLoad failed");
return 1;
}
if (! FeatDefSetLoad ()) {
Message (MSG_FATAL, "FeatDefSetLoad failed");
return 1;
}
if (! SeqCodeSetLoad ()) {
Message (MSG_FATAL, "SeqCodeSetLoad failed");
return 1;
}
if (! GeneticCodeTableLoad ()) {
Message (MSG_FATAL, "GeneticCodeTableLoad failed");
return 1;
}
SetUpAsnStreamData (&asd);
/* initialize OuputStreamData */
MemSet (&osd, 0, sizeof (osd));
/* initialize InputStreamData */
MemSet (&isd, 0, sizeof (isd));
/* initialize gap_sizes */
gap_sizes[0] = 0;
gap_sizes[1] = 0;
/* process command line arguments */
sprintf (app, "raw2delt %s", RAW2DELT_APPLICATION);
if (! GetArgs (app, sizeof (myargs) / sizeof (Args), myargs)) {
return 0;
}
u_eq = (Int4) myargs [u_argEqUnknownGap].intvalue;
u_gteq = (Int4) myargs [U_argGTEqUnknownGap].intvalue;
k_eq = (Int4) myargs [k_argEqUnknownGap].intvalue;
k_gteq = (Int4) myargs [K_argGtEqUnknownGap].intvalue;
if (u_eq < 1 && u_gteq < 1 && k_eq < 1 && k_gteq < 1) {
Message (MSG_FATAL, "Must specify values for at least one of -u, -U, -k, -K");
return 1;
} else if (u_eq > -1 && u_gteq > -1) {
Message (MSG_FATAL, "May only specify value for -u or -U, not both");
return 1;
} else if (k_eq > -1 && k_gteq > -1) {
Message (MSG_FATAL, "May only specify value for -k or -K, not both");
return 1;
}
if (u_eq > 0) {
gap_sizes[0] = u_eq;
} else if (u_gteq > 0) {
gap_sizes[0] = 0 - u_gteq;
}
if (k_eq > 0) {
gap_sizes[1] = k_eq;
} else if (k_gteq > 0) {
gap_sizes[1] = 0 - k_gteq;
}
if (gap_sizes[0] == gap_sizes[1]) {
Message (MSG_FATAL, "Cannot specify the same size for known and unknown length gaps");
return 1;
}
directory = (CharPtr) myargs [p_argInputPath].strvalue;
osd.results_dir = (CharPtr) myargs [r_argOutputPath].strvalue;
if (StringHasNoText (osd.results_dir)) {
osd.results_dir = NULL;
}
osd.suffix = (CharPtr) myargs [x_argSuffix].strvalue;
osd.outsuffix = (CharPtr) myargs [s_argOutSuffix].strvalue;
osd.base = (CharPtr) myargs [i_argInputFile].strvalue;
osd.outfile = (CharPtr) myargs [o_argOutputFile].strvalue;
if (StringHasNoText (osd.outfile)) {
osd.outfile = NULL;
}
osd.is_binary = (Boolean) myargs [d_argOutputBinary].intvalue;
if (osd.base == "stdin") {
osd.base = NULL;
}
/* if we don't have an output directory or an output file, and the user hasn't provided an
* output suffix, add a default.
*/
if (osd.results_dir == NULL && osd.outfile == NULL && StringHasNoText (osd.outsuffix)) {
osd.outsuffix = ".delta";
}
isd.is_binary = (Boolean) myargs [b_argInputBinary].intvalue;
isd.is_seqentry = (Boolean) myargs [e_argInputSeqEntry].intvalue;
isd.directory = directory;
isd.base = osd.base;
isd.suffix = osd.suffix;
if (StringDoesHaveText (osd.outfile)) {
osd.aip = AsnIoOpen (osd.outfile, "w");
if (osd.aip == NULL) {
Message (MSG_FATAL, "Unable to open output file");
return 1;
}
} else {
if (StringHasNoText (osd.results_dir)) {
osd.results_dir = directory;
}
/* if we're putting the results in a separate directory, strip the directory name from the output base */
if (!StringHasNoText (osd.results_dir) && !StringHasNoText (osd.base)) {
#ifdef OS_MSWIN
ptr = StringRChr (osd.base, '\\');
#else
ptr = StringRChr (osd.base, '/');
#endif;
if (ptr != NULL) {
osd.base = ptr + 1;
}
}
}
if (StringHasNoText(directory) && StringHasNoText(osd.base)) {
rval = ProcessStream (&isd, &osd, &asd, gap_sizes);
} else if (StringDoesHaveText (osd.base)) {
ptr = StringRChr (osd.base, '.');
sfx[0] = '\0';
if (ptr != NULL) {
StringNCpy_0 (sfx, ptr, sizeof (sfx));
*ptr = '\0';
}
osd.suffix = sfx;
isd.suffix = sfx;
if (isd.is_binary) {
rval = ProcessStream (&isd, &osd, &asd, gap_sizes);
} else {
rval = ProcessOneRecord (directory, &osd, gap_sizes);
}
} else {
rval = FileRecurse (directory, &isd, &osd, &asd, gap_sizes);
}
if (osd.aip != NULL) {
AsnIoFlush (osd.aip);
AsnIoClose (osd.aip);
}
return rval;
}
char *readASNSeq(const short whichEntry, const char *filename,
const long skiplines,
const short format, /* note: this is kASNseqentry or kASNseqset */
long *seqlen, short *nseq,
short *error, char **seqid )
{
AsnIoPtr aip = NULL;
SeqEntryPtr the_set;
AsnTypePtr atp, atp2;
AsnModulePtr amp;
Boolean inIsBinary= FALSE; /* damn, why can't asn routines test this? */
char *seq, stemp[200];
int i, count;
*seqlen= 0;
*nseq= 0;
*error= 0;
seq= NULL;
/*fprintf(stderr,"readASNseq: SeqEntryLoad\n");*/
/* asn dictionary setups */
if (! SeqEntryLoad()) goto errxit; /* sequence alphabets (and sequence parse trees) */
amp = AsnAllModPtr(); /* get pointer to all loaded ASN.1 modules */
if (amp == NULL) goto errxit;
atp = AsnFind("Bioseq-set"); /* get the initial type pointers */
if (atp == NULL) goto errxit;
atp2 = AsnFind("Bioseq-set.seq-set.E");
if (atp2 == NULL) goto errxit;
/* open the ASN.1 input file in the right mode */
/*fprintf(stderr,"readASNseq: AsnIoOpen(%s)\n", filename);*/
if ((aip = AsnIoOpen(filename, inIsBinary?"rb":"r")) == NULL) goto errxit;
for (i=0; i<skiplines; i++) fgets( stemp, 255, aip->fp); /* this may mess up asn routines... */
if (! ErrSetLog ("stderr")) goto errxit;
else ErrSetOpts(ERR_CONTINUE, ERR_LOG_ON); /*?? log errors instead of die */
seq= NULL;
if (format == kASNseqentry) { /* read one Seq-entry */
/*fprintf(stderr,"readASNseq: SeqEntryAsnRead\n");*/
the_set = SeqEntryAsnRead(aip, NULL);
SeqEntryToRaw(the_set, false, whichEntry, nseq, &seq, seqid, seqlen);
SeqEntryFree(the_set);
goto goodexit;
}
else { /* read Seq-entry's from a Bioseq-set */
count = 0;
/*fprintf(stderr,"readASNseq: AsnReadId\n");*/
while ((atp = AsnReadId(aip, amp, atp)) != NULL) {
if (atp == atp2) { /* top level Seq-entry */
the_set = SeqEntryAsnRead(aip, atp);
SeqEntryToRaw(the_set, false, whichEntry, nseq, &seq, seqid, seqlen);
SeqEntryFree(the_set);
if (*nseq >= whichEntry) goto goodexit;
}
else
AsnReadVal(aip, atp, NULL);
count++;
}
}
goodexit:
AsnIoClose(aip);
*error= 0;
return seq;
errxit:
AsnIoClose(aip);
*error= eASNerr;
if (seq) free(seq);
return NULL;
}
void BEPrintIds(BEDataPtr pBdata, Uint4 *ids, int count)
{
Int4 i;
SeqEntryPtr sep, sep_all;
Boolean retvalue = TRUE;
SeqIdPtr sip = NULL;
BioseqPtr bsp;
BGenBankPtr bgbp;
AsnIoPtr aip;
Boolean is_na = FALSE;
if(pBdata->format == F_GILIST) {
for(i = 0; i < count; i++)
fprintf(stdout, "%d\n", (int) ids[i]);
return;
}
if(pBdata->database == 0)
is_na = TRUE;
if(pBdata->format == F_ASN1_GENB)
bgbp = BGenBankInit();
for(i = 0; i < count; i++) {
sep_all = BESeqEntryGet(ids[i]);
if(sep_all == NULL) {
ErrPostEx(SEV_ERROR, 88, 67, "Retrieving of blob for the "
"gi=%d failed", (int)ids[i]);
continue;
}
if(!pBdata->allset) {
ObjMgrRegister(OBJ_SEQENTRY, sep_all);
sip = ValNodeNew(NULL);
sip->choice = SEQID_GI;
sip->data.intvalue = ids[i];
if((bsp = BioseqFind(sip)) == NULL) {
ErrPostEx(SEV_ERROR, 88, 67,
"Error finding bioseq for gi=%d\n", (int)ids[i]);
continue;
}
sep = SeqEntryNew();
sep->choice = 1; /* Bioseq */
sep->data.ptrvalue = bsp;
} else {
sep = sep_all;
}
switch(pBdata->format) {
case F_FASTA: /* 1 */
if(!SeqEntryToFasta(sep, stdout, is_na)) {
if(!SeqEntryToFasta(sep, stdout, !is_na)) {
ErrPostEx(SEV_ERROR, 88, 67, "Printing of FASTA format "
"(gi=%d) failed\r\n", (int)ids[i]);
}
}
break;
case F_ASN1: /* 2 */
aip = AsnIoNew(ASNIO_TEXT_OUT, stdout, NULL, NULL, NULL);
SeqEntryAsnWrite(sep, aip, NULL);
AsnIoClose(aip);
break;
case F_GILIST: /* 3 */
for(i = 0; i < count; i++)
fprintf(stdout, "%d\n", (int) ids[i]);
break;
case F_DLIST: /* 4 */
if (IS_Bioseq(sep))
retvalue = SeqEntrysToDefline(sep, stdout, is_na, 3);
else
retvalue = SeqEntrysToDefline(sep, stdout, is_na, 0);
if(retvalue == FALSE) {
if (IS_Bioseq(sep))
retvalue = SeqEntrysToDefline(sep, stdout, !is_na, 3);
else
retvalue = SeqEntrysToDefline(sep, stdout, !is_na, 0);
}
break;
case F_ASN1_GENB: /* 5 */
retvalue = SeqEntryAsnWrite(sep, bgbp->aip, bgbp->atp);
break;
default:
case F_GEN: /* 0 */
if(!SeqEntryToFlatEx(sep_all, stdout,
is_na ? GENBANK_FMT : GENPEPT_FMT,
RELEASE_MODE, sip, FF_REGULAR)) {
if(!SeqEntryToFlatEx(sep_all, stdout,
is_na ? GENPEPT_FMT : GENBANK_FMT,
RELEASE_MODE, sip, FF_REGULAR)) {
}
}
break;
}
SeqEntryFree(sep_all);
ValNodeFree(sip);
}
if(pBdata->format == F_ASN1_GENB)
BGenBankClose(bgbp);
return;
}
static void GetThisBioseq (XOSPtr xosp)
{
GatherScopePtr gsp;
CharPtr asnseqentfile;
Int4 gi;
AsnIoPtr aiop;
Boolean flagHaveNet;
SeqEntryPtr sep;
gsp = xosp->gsp;
aiop = NULL;
asnseqentfile = xosp->filename;
gi = xosp->gi;
xosp->sep = SeqEntryFree (xosp->sep);
if (gi > 0)
{
if (!EntrezInit ("twopv", FALSE, &flagHaveNet))
{
ErrPostEx (SEV_ERROR, TOP_ERROR, 102,
"Entrez init failed");
ErrShow ();
return;
}
}
if (gi > 0)
{
sep = EntrezSeqEntryGet (gi, SEQENTRY_READ_BIOSEQ);
}
else if (asnseqentfile != NULL)
{
if ((aiop = AsnIoOpen (asnseqentfile, "r")) == NULL)
{
Message (MSG_ERROR, "Failed to open: %s", asnseqentfile);
}
sep = SeqEntryAsnRead (aiop, NULL);
}
else
{
sep = NULL;
}
if (sep == NULL)
{
ErrPostEx (SEV_ERROR, TOP_ERROR, 104,
"No SeqEntry");
ErrShow ();
}
else
{
xosp->sep = sep;
xosp->bsp = NULL;
xosp->gi = gi;
GatherSeqEntry (sep, (Pointer) xosp, GetBioseq, (Pointer) gsp);
}
if (gi > 0)
EntrezFini ();
else
AsnIoClose (aiop);
if (xosp->bsp != NULL)
{
if (!ISA_na (xosp->bsp->mol))
{
xosp->sep = SeqEntryFree (xosp->sep);
xosp->bsp = NULL;
xosp->filename = (CharPtr) MemFree (xosp->filename);
xosp->gi = 0;
ErrPostEx (SEV_ERROR, TOP_ERROR, 101, "Not nucleic acid Bioseq");
ErrShow ();
}
}
else
{
xosp->sep = SeqEntryFree (xosp->sep);
xosp->filename = (CharPtr) MemFree (xosp->filename);
xosp->gi = 0;
ErrPostEx (SEV_ERROR, TOP_ERROR, 101, "No Bioseq");
ErrShow ();
}
return;
}