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 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; }
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 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; }
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; }
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; }
Int2 BlastFormattingInfoNew(EAlignView align_view, const SBlastOptions* search_options, const char* program_name, const char* db_name, const char* outfile_name, BlastFormattingInfo* *info_ptr) { BlastFormattingInfo* info; if (!outfile_name || !info_ptr || !search_options || align_view >= eAlignViewMax) return -1; info = *info_ptr = (BlastFormattingInfo*) calloc(1, sizeof(BlastFormattingInfo)); s_BlastFormattingOptionsNew(search_options->program, align_view, &info->format_options); info->search_options = search_options; info->program_name = strdup(program_name); if (db_name) info->db_name = strdup(db_name); if (align_view != eAlignViewXml && align_view < eAlignViewAsnText) { FILE* outfp; if ((outfp = FileOpen(outfile_name, "w")) == NULL) { ErrPostEx(SEV_WARNING, 0, 0, "Unable to open output file %s:", outfile_name); return -1; } info->outfp = outfp; } else { char write_mode[3]; /* AsnIoOpen requires a non-const argument, so use a local variable. */ char* filename_copy = strdup(outfile_name); if (align_view == eAlignViewXml) strcpy(write_mode, "wx"); else if (align_view == eAlignViewAsnText) strcpy(write_mode, "w"); else strcpy(write_mode, "wb"); if ((info->aip = AsnIoOpen(filename_copy, write_mode)) == NULL) { ErrPostEx(SEV_WARNING, 0, 0, "Unable to open output file %s:", filename_copy); return -1; } sfree(filename_copy); } info->is_seqalign_null = TRUE; /* will be updated in BLAST_FormatResults */ info->head_on_every_query = FALSE; /* One header for a file is the default. */ return 0; }
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 int mfmt_open_output( void *handle, char *file_name ) { /* Open the file using the AsnIoOpen routine */ asn_hand->ioptr = AsnIoOpen( file_name, (asn_hand->mode == binary) ? "wb" : "w" ); if( asn_hand->ioptr == NULL ) { asn_hand->have_error = ErrFetch( &asn_hand->error ); } else { asn_hand->have_error = FALSE; asn_hand->open_state = open_output; asn_hand->count = 0; } return( asn_hand->ioptr != 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_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_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; }
static void ProcessSingleRecord ( CharPtr filename, CSpeedFlagPtr cfp ) { AsnIoPtr aip; BioseqPtr bsp; ValNodePtr bsplist = NULL; BioseqSetPtr bssp; Pointer dataptr = NULL; Uint2 datatype, entityID = 0; FileCache fc; FILE *fp; Int1 iotype; Char line [512]; Int4 maxio = 1; SeqEntryPtr sep; time_t starttime, stoptime, worsttime; CharPtr str; Int4 x; if (cfp == NULL) return; if (StringHasNoText (filename)) return; if (StringChr (cfp->io, 'r') != NULL) { maxio = cfp->maxcount; } starttime = GetSecs (); for (x = 0; x < maxio; x++) { if (entityID != 0) { ObjMgrFreeByEntityID (entityID); entityID = 0; dataptr = NULL; } if (cfp->type == 1) { fp = FileOpen (filename, "r"); if (fp == NULL) { Message (MSG_POSTERR, "Failed to open '%s'", filename); return; } dataptr = ReadAsnFastaOrFlatFile (fp, &datatype, NULL, FALSE, FALSE, FALSE, FALSE); FileClose (fp); entityID = ObjMgrRegister (datatype, dataptr); } else if (cfp->type >= 2 && cfp->type <= 5) { aip = AsnIoOpen (filename, cfp->binary? "rb" : "r"); if (aip == NULL) { Message (MSG_POSTERR, "AsnIoOpen failed for input file '%s'", filename); return; } switch (cfp->type) { case 2 : dataptr = (Pointer) SeqEntryAsnRead (aip, NULL); datatype = OBJ_SEQENTRY; break; case 3 : dataptr = (Pointer) BioseqAsnRead (aip, NULL); datatype = OBJ_BIOSEQ; break; case 4 : dataptr = (Pointer) BioseqSetAsnRead (aip, NULL); datatype = OBJ_BIOSEQSET; break; case 5 : dataptr = (Pointer) SeqSubmitAsnRead (aip, NULL); datatype = OBJ_SEQSUB; break; default : break; } AsnIoClose (aip); entityID = ObjMgrRegister (datatype, dataptr); } else if (cfp->type == 6) { fp = FileOpen (filename, "r"); if (fp == NULL) { Message (MSG_POSTERR, "Failed to open '%s'", filename); return; } dataptr = ReadAsnFastaOrFlatFile (fp, &datatype, NULL, FALSE, FALSE, FALSE, FALSE); FileClose (fp); entityID = ObjMgrRegister (datatype, dataptr); } else if (cfp->type == 7) { fp = FileOpen (filename, "r"); if (fp == NULL) { Message (MSG_POSTERR, "Failed to open '%s'", filename); return; } FileCacheSetup (&fc, fp); str = FileCacheReadLine (&fc, line, sizeof (line), NULL); while (str != NULL) { str = FileCacheReadLine (&fc, line, sizeof (line), NULL); } FileClose (fp); return; } else { Message (MSG_POSTERR, "Input format type '%d' unrecognized", (int) cfp->type); return; } } if (entityID < 1 || dataptr == NULL) { Message (MSG_POSTERR, "Data read failed for input file '%s'", filename); return; } if (datatype == OBJ_SEQSUB || datatype == OBJ_SEQENTRY || datatype == OBJ_BIOSEQ || datatype == OBJ_BIOSEQSET) { stoptime = GetSecs (); worsttime = stoptime - starttime; if (cfp->logfp != NULL) { fprintf (cfp->logfp, "ASN reading time %ld seconds\n", (long) worsttime); fflush (cfp->logfp); } sep = GetTopSeqEntryForEntityID (entityID); if (sep == NULL) { sep = SeqEntryNew (); if (sep != NULL) { if (datatype == OBJ_BIOSEQ) { bsp = (BioseqPtr) dataptr; sep->choice = 1; sep->data.ptrvalue = bsp; SeqMgrSeqEntry (SM_BIOSEQ, (Pointer) bsp, sep); } else if (datatype == OBJ_BIOSEQSET) { bssp = (BioseqSetPtr) dataptr; sep->choice = 2; sep->data.ptrvalue = bssp; SeqMgrSeqEntry (SM_BIOSEQSET, (Pointer) bssp, sep); } else { sep = SeqEntryFree (sep); } } sep = GetTopSeqEntryForEntityID (entityID); } if (sep != NULL) { if (cfp->lock) { starttime = GetSecs (); bsplist = LockFarComponents (sep); stoptime = GetSecs (); worsttime = stoptime - starttime; if (cfp->logfp != NULL) { fprintf (cfp->logfp, "Far component locking time %ld seconds\n", (long) worsttime); fflush (cfp->logfp); } } if (StringChr (cfp->io, 'w') != NULL) { starttime = GetSecs (); iotype = ASNIO_TEXT_OUT; if (StringChr (cfp->io, 'b') != NULL) { iotype = ASNIO_BIN_OUT; } for (x = 0; x < cfp->maxcount; x++) { aip = AsnIoNew (iotype, cfp->ofp, NULL, NULL, NULL); if (aip != NULL) { SeqEntryAsnWrite (sep, aip, NULL); AsnIoFree (aip, FALSE); } } stoptime = GetSecs (); worsttime = stoptime - starttime; if (cfp->logfp != NULL) { fprintf (cfp->logfp, "ASN writing time %ld seconds\n", (long) worsttime); fflush (cfp->logfp); } } starttime = GetSecs (); for (x = 0; x < cfp->maxcount; x++) { DoProcess (sep, entityID, cfp); } stoptime = GetSecs (); worsttime = stoptime - starttime; if (cfp->logfp != NULL) { fprintf (cfp->logfp, "Internal processing time %ld seconds\n", (long) worsttime); fflush (cfp->logfp); } ObjMgrFreeByEntityID (entityID); bsplist = UnlockFarComponents (bsplist); } } else { Message (MSG_POSTERR, "Datatype %d not recognized", (int) datatype); } }
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; }
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; }
/***************************************************************************** * * 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; }
Int2 LIBCALLBACK VSMDescriptorAsnSave (Pointer data) { OMProcControlPtr ompcp; Char filename[255]; SelStructPtr ssp, sel; SeqDescrPtr sdp; BioseqPtr bsp; SeqEntryPtr sep; SeqMgrDescContext dcontext; #ifdef WIN_MAC FILE * fp; #endif ValNodePtr vnp; SaveSetSdpData sd; ValNodePtr obj_list = NULL; ompcp = (OMProcControlPtr)data; if (ompcp == NULL) return OM_MSG_RET_ERROR; sd.already_have_molinfo = FALSE; ssp = ObjMgrGetSelected(); if (ssp == NULL) { Message (MSG_ERROR, "You must select a sequence or set from which descriptors should be saved"); return OM_MSG_RET_DONE; } else { for (sel = ssp; sel != NULL; sel = sel->next) { GatherItem (sel->entityID, sel->itemID, sel->itemtype, (Pointer) &obj_list, AddToSaveList); } } /* 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 sd.aip = AsnIoOpen(filename, "w"); for (vnp = obj_list; vnp != NULL; vnp = vnp->next) { switch (vnp->choice) { case OBJ_SEQDESC: sdp = (SeqDescrPtr) vnp->data.ptrvalue; SeqDescAsnWrite (sdp, sd.aip, NULL); AsnPrintNewLine (sd.aip); AsnIoFlush (sd.aip); break; case OBJ_BIOSEQ: bsp = (BioseqPtr) vnp->data.ptrvalue; for (sdp = SeqMgrGetNextDescriptor (bsp, NULL, 0, &dcontext); sdp != NULL; sdp = SeqMgrGetNextDescriptor (bsp, sdp, 0, &dcontext)) { if (sdp->choice != Seq_descr_source && sdp->choice != Seq_descr_pub && sdp->choice != Seq_descr_molinfo && sdp->choice != Seq_descr_comment) continue; SeqDescAsnWrite (sdp, sd.aip, NULL); AsnPrintNewLine (sd.aip); AsnIoFlush (sd.aip); } break; case OBJ_BIOSEQSET: sep = SeqMgrGetSeqEntryForData (vnp->data.ptrvalue); VisitDescriptorsInSep (sep, &sd, SaveSetDescriptors); break; } } AsnIoClose(sd.aip); ArrowCursor(); } return OM_MSG_RET_DONE; }
Int2 Main (void) { AsnIoPtr aip; AsnTypePtr atp; FILE *dfp = NULL; Boolean do_nuc = FALSE; Boolean do_prot = FALSE; XtraPtr extra; FILE *fp; GBSeq gbsq; GBSet gbst; Boolean get_var; Char line [256]; Boolean only_new; CharPtr str; Char xmlbuf [128]; XtraBlock xtra; 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; } if (! objgbseqAsnLoad ()) { Message (MSG_POSTERR, "objgbseqAsnLoad failed"); return 1; } if (! GetArgs ("gbseqget", sizeof (myargs) / sizeof (Args), myargs)) { return 0; } fp = FileOpen (myargs [i_argInputFile].strvalue, "r"); if (fp == NULL) { return 1; } if (! StringHasNoText (myargs [d_argDateFile].strvalue)) { dfp = FileOpen (myargs [d_argDateFile].strvalue, "r"); if (dfp == NULL) { return 1; } } if (GetAppParam ("NCBI", "SETTINGS", "XMLPREFIX", NULL, xmlbuf, sizeof (xmlbuf))) { AsnSetXMLmodulePrefix (StringSave (xmlbuf)); } MemSet ((Pointer) &xtra, 0, sizeof (XtraBlock)); MemSet ((Pointer) &gbsq, 0, sizeof (GBSeq)); xtra.gbseq = &gbsq; aip = AsnIoOpen (myargs [o_argOutputFile].strvalue, "wx"); if (aip == NULL) { Message (MSG_POSTERR, "AsnIoOpen failed"); FileClose (fp); return 1; } only_new = (Boolean) myargs [n_argNewRecords].intvalue; get_var = (Boolean) myargs [v_argVariations].intvalue; str = myargs [m_argMolecule].strvalue; if (StringICmp (str, "n") == 0) { do_nuc = TRUE; } else if (StringICmp (str, "p") == 0) { do_prot = TRUE; } else if (StringICmp (str, "b") == 0) { do_nuc = TRUE; do_prot = TRUE; } else { do_nuc = TRUE; } PubSeqFetchEnable (); xtra.aip = aip; atp = AsnLinkType (NULL, AsnFind ("GBSet")); xtra.atp = AsnLinkType (NULL, AsnFind ("GBSet.E")); if (atp == NULL || xtra.atp == NULL) { Message (MSG_POSTERR, "AsnLinkType or AsnFind failed"); return 1; } extra = &xtra; MemSet ((Pointer) &gbst, 0, sizeof (GBSet)); AsnOpenStruct (aip, atp, (Pointer) &gbst); if (dfp != NULL) { DoQuery (fp, dfp, extra, get_var, do_nuc, do_prot); } else { str = ReadALine (line, sizeof (line), fp); while (str != NULL) { if (! StringHasNoText (str)) { ProcessAccession (str, extra, only_new, get_var, do_nuc, do_prot); } str = ReadALine (line, sizeof (line), fp); } } AsnCloseStruct (aip, atp, NULL); AsnPrintNewLine (aip); AsnIoClose (aip); FileClose (dfp); FileClose (fp); PubSeqFetchDisable (); 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 LIBCALLBACK VSMGenericBinAsnOpen ( Pointer data ) { Char filename[255]; AsnIoPtr aip; Pointer ptr; Uint2 entityID; Int2 ct, i, retval = OM_MSG_RET_OK; ObjMgrPtr omp; ObjMgrTypePtr omtp = NULL; OMProcControlPtr ompcp; WindoW w; GrouP g; ButtoN b; VSMReadBinStr vrb; VSeqMgrPtr vsmp; ompcp = (OMProcControlPtr)data; vsmp = VSeqMgrGet(); omp = vsmp->omp; filename[0] = '\0'; if (GetInputFileName(filename, (size_t)254, NULL, NULL)) { vrb.do_it = FALSE; vrb.window_done = FALSE; vrb.the_type = 0; w = ModalWindow (-50, -33, -10, -10, NULL); SetWindowExtra(w, &vrb, NULL); g = HiddenGroup(w, 0, 2, NULL); StaticPrompt(g, "Select ASN.1 type:", 0,0,systemFont,'l'); vrb.p = PopupList(g, TRUE, NULL); i = 0; ct = 0; omtp = NULL; while ((omtp = ObjMgrTypeFindNext(omp, omtp)) != NULL) { if (omtp->asnname != NULL) { i++; PopupItem(vrb.p, omtp->asnname); if (! StringCmp(vsmp->lastASNtype, omtp->asnname)) ct = i; } } if (! i) { ErrPostEx(SEV_ERROR,0,0, "No ASN.1 types are registered"); Remove(w); return OM_MSG_RET_ERROR; } if (! ct) ct = 1; SetValue(vrb.p, ct); g = HiddenGroup(w, 2, 0, NULL); DefaultButton(g, "Accept", AsnBinAcceptProc); b = PushButton(g, "Cancel", AsnBinCancelProc); Show(w); Nlm_WaitForCondition (! vrb.window_done); ProcessAnEvent(); if (! vrb.do_it) return retval; i = 0; omtp = NULL; while ((omtp = ObjMgrTypeFindNext(omp, omtp)) != NULL) { i++; if (i == vrb.the_type) break; } if (omtp == NULL) { ErrPostEx(SEV_ERROR,0,0,"Couldn't find vrb.the_type"); return OM_MSG_RET_ERROR; } StringMove(vsmp->lastASNtype, omtp->asnname); WatchCursor(); aip = AsnIoOpen(filename, "rb"); ptr = (*(omtp->asnread))(aip, NULL); AsnIoClose(aip); if (ptr == NULL) { ErrPostEx(SEV_ERROR,0,0,"Couldn't read [%s], type [%s]", filename, omtp->asnname); retval = OM_MSG_RET_ERROR; } else { entityID = ObjMgrRegister(omtp->datatype, ptr); ompcp->output_data = ptr; ompcp->output_entityID = entityID; PromoteToSeqEntry (entityID, omtp->datatype, ptr); retval = OM_MSG_RET_DONE; } ArrowCursor(); } else retval = OM_MSG_RET_OK; return retval; }
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 (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(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); }
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; }
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; }
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; }
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; }
BiostrucPtr LIBCALL MMDBBiostrucGet (DocUid uid, Int4 mdlLvl, Int4 maxModels) { AsnIoPtr aip = NULL; BiostrucPtr pbs = NULL; int index; Int4 acc; #ifdef MMDB_PUBSTRUCT extern WWWInfoPtr info; if(!file_db) { Int4 state = 0; char *dbserver = (database[0]?database:NULL); acc = uid; if(WWWFindName(info, "ps_acc") >=0) aip = PubStruct_readasn(dbserver, acc); else { index = WWWFindName(info, "ps_state"); if (index >= 0) { char * item; item = WWWGetValueByIndex(info,index); if (!StrToInt4(item,&state)) ErrPostEx(SEV_ERROR,0,0, "cant convert Pubstruct_state<%s> into integer",item); } if (state == 0 ) aip = PubStruct_viewasn(dbserver, uid); else { acc = PubStruct_lookup(dbserver,uid, state); /* fprintf(stderr,"%s:%d: acc=%d <<- %s(mmdb=%d,state=%d)\n", __FILE__,__LINE__,acc,dbserver,uid,state); */ if (acc>0) aip = PubStruct_readasn(dbserver, acc); } } } else #endif { Char path[PATH_MAX]; sprintf(path, "%s%ld.val", database, (long) uid); #ifdef MMDB_UNIXCOMPRESSED { FILE *pipe; Char compath[PATH_MAX]; sprintf(compath,"%s -c %s.gz ", gunzip, path); pipe=popen(compath,"rb"); if (pipe == 0) { ErrPostEx(SEV_FATAL,0,0, "MMDBBiostrucGet failed: Can't find gunzip in path.\n"); return NULL; } aip = AsnIoNew(ASNIO_BIN_IN, pipe , NULL, NULL, NULL); } #else if (FileLength(path) == 0) return NULL; aip = AsnIoOpen(path, "rb"); #endif } if (!aip) return NULL; pbs = BiostrucAsnGet(aip, NULL, mdlLvl, maxModels); #ifdef MMDB_PUBSTRUCT if(!file_db) PubStruct_closeasn (aip,1); else #endif AsnIoClose (aip); return pbs; }