Ejemplo n.º 1
0
static void CommentFieldsToDialog (DialoG d, Pointer data)
{
  TagListPtr tlp;
  ValNodePtr fields, vnp;
  CharPtr    str;

  tlp = (TagListPtr) GetObjectExtra (d);
  if (tlp == NULL) {
    return;
  }

  fields = (ValNodePtr) data;

  tlp->vnp = ValNodeFreeData (tlp->vnp);
  SendMessageToDialog (tlp->dialog, VIB_MSG_RESET);
  for (vnp = fields; vnp != NULL; vnp = vnp->next) {
    str = TagStringFromFieldRule (vnp->data.ptrvalue);
    if (str != NULL) {
      ValNodeAddPointer (&(tlp->vnp), 0, str);
    }
  }

  SendMessageToDialog (tlp->dialog, VIB_MSG_REDRAW);
  tlp->max = MAX ((Int2) 0, (Int2) (ValNodeLen (tlp->vnp) - tlp->rows));
  CorrectBarMax (tlp->bar, tlp->max);
  CorrectBarPage (tlp->bar, tlp->rows - 1, tlp->rows - 1);
  if (tlp->max > 0) {
    SafeShow (tlp->bar);
  } else {
    SafeHide (tlp->bar);
  }
}
Ejemplo n.º 2
0
void FreeCSAN(PCSAN pcsanThis)
{
  if (pcsanThis->next) FreeCSAN(pcsanThis->next);
  if (pcsanThis->pcSeqName) MemFree(pcsanThis->pcSeqName);
  if (pcsanThis->pvnSeqAlnPart) ValNodeFreeData(pcsanThis->pvnSeqAlnPart);
  if (pcsanThis->pcSeqAln) MemFree(pcsanThis->pcSeqAln);
  return;
}
Ejemplo n.º 3
0
static ValNodePtr FetchItemFieldValuesFree (ValNodePtr field_values)
{
  ValNodePtr vnp;

  for (vnp = field_values; vnp != NULL; vnp = vnp->next) {
    vnp->data.ptrvalue = ValNodeFreeData (vnp->data.ptrvalue);
  }
  field_values = ValNodeFree (field_values);
  return field_values;
}
Ejemplo n.º 4
0
static void DoReleaseFile (CharPtr inputFile, Boolean binary, Boolean compressed, FILE *fp, AsnIoPtr aop, AsnTypePtr atp_se)

{
  ScanData      sd;
  StringSetPtr  ssp;
  ValNodePtr    vnp;

  fprintf (fp, "\n***** %s *****\n\n", inputFile);

  sd.fp = fp;
  sd.aop = aop;
  sd.atp_se = atp_se;
  StringCpy (sd.buf, "?");
  sd.bulk = FALSE;
  sd.cgList = NULL;
  sd.lcList = NULL;
  sd.impCdsCount = 0;
  sd.recordCount = 0;

  ScanBioseqSetRelease (inputFile, binary, compressed, (Pointer) &sd, DoRecord);

  for (vnp = sd.cgList; vnp != NULL; vnp = vnp->next) {
    ssp = (StringSetPtr) vnp->data.ptrvalue;
    if (ssp == NULL) continue;
    fprintf (sd.fp, "CG - %s (%ld) - %s\n", ssp->firstID, (long) ssp->count, ssp->text);
  }

  for (vnp = sd.lcList; vnp != NULL; vnp = vnp->next) {
    ssp = (StringSetPtr) vnp->data.ptrvalue;
    if (ssp == NULL) continue;
    fprintf (sd.fp, "LC - %s (%ld) - %s\n", ssp->firstID, (long) ssp->count, ssp->text);
  }

  if (sd.impCdsCount != 0) {
    fprintf (sd.fp, "IC - (%ld)\n", (long) sd.impCdsCount);
  }

  sd.cgList = ValNodeFreeData (sd.cgList);
  sd.lcList = ValNodeFreeData (sd.lcList);

  fprintf (fp, "\n\n!!!!! %s - %ld records !!!!!\n\n", inputFile, (long) sd.recordCount);
}
Ejemplo n.º 5
0
/******************************************************************
*
*	free_cvp_list(cvp_list)
*	free a list of CodonVectorPtr
*
******************************************************************/
NLM_EXTERN ValNodePtr free_cvp_list(ValNodePtr cvp_list)
{
	ValNodePtr next;
	CodonVectorPtr cvp;
	Int2 i;

	while(cvp_list)
	{
		next = cvp_list->next;
		cvp_list->next = NULL;
		cvp = cvp_list->data.ptrvalue;
		for(i=0; i<3; ++i)
			MemFree(cvp->buf[i]);
		SeqIdFree(cvp->sip);
		ValNodeFreeData(cvp_list);
		cvp_list = next;
	}

	return NULL;
}
Ejemplo n.º 6
0
Int2 Main (void)

{
  AsnIoPtr      aop = NULL;
  AsnModulePtr  amp;
  AsnTypePtr    atp_bss, atp_ss, atp_se;
  BioseqSet     bss;
  FILE          *fp;
  ValNodePtr    head, vnp;
  Char          path [PATH_MAX];
  CharPtr       progname, str, subfile;

  ErrSetFatalLevel (SEV_MAX);
  ErrClearOptFlags (EO_SHOW_USERSTR);
  UseLocalAsnloadDataAndErrMsg ();
  ErrPathReset ();

  if (! AllObjLoad ()) {
    Message (MSG_FATAL, "AllObjLoad failed");
    return 1;
  }
  if (! SubmitAsnLoad ()) {
    Message (MSG_FATAL, "SubmitAsnLoad failed");
    return 1;
  }
  if (! SeqCodeSetLoad ()) {
    Message (MSG_FATAL, "SeqCodeSetLoad failed");
    return 1;
  }
  if (! GeneticCodeTableLoad ()) {
    Message (MSG_FATAL, "GeneticCodeTableLoad failed");
    return 1;
  }

  MemSet ((Pointer) &bss, 0, sizeof (BioseqSet));

  amp = AsnAllModPtr ();
  if (amp == NULL) {
    Message (MSG_FATAL, "Unable to load AsnAllModPtr");
    return 1;
  }

  atp_bss = AsnFind ("Bioseq-set");
  if (atp_bss == NULL) {
    Message (MSG_FATAL, "Unable to find ASN.1 type Bioseq-set");
    return 1;
  }

  atp_ss = AsnFind ("Bioseq-set.seq-set");
  if (atp_ss == NULL) {
    Message (MSG_FATAL, "Unable to find ASN.1 type Bioseq-set.seq-set");
    return 1;
  }


  atp_se = AsnFind ("Bioseq-set.seq-set.E");
  if (atp_se == NULL) {
    Message (MSG_FATAL, "Unable to find ASN.1 type Bioseq-set.seq-set.E");
    return 1;
  }

  ProgramPath (path, sizeof (path));
  progname = StringRChr (path, DIRDELIMCHR);
  if (progname != NULL) {
    progname++;
  } else {
    progname = "idcleanscan";
  }

  if (! GetArgs (progname, sizeof (myargs) / sizeof (Args), myargs)) {
    return 0;
  }

  fp = FileOpen (myargs [o_argOutputFile].strvalue, "a");
  if (fp == NULL) {
    Message (MSG_FATAL, "FileOpen failed");
    return 1;
  }

  if (StringHasNoText (myargs [p_argInputPath].strvalue)) {

    str = myargs [i_argInputFile].strvalue;
    if (! StringHasNoText (str)) {
      DoReleaseFile (str, myargs [b_argBinaryFile].intvalue, myargs [c_argCompressed].intvalue, fp, aop, NULL);
    }

  } else {

    head = DirCatalog (myargs [p_argInputPath].strvalue);

    if (! StringHasNoText (myargs [s_argSubset].strvalue)) {
      aop = AsnIoOpen (myargs [s_argSubset].strvalue, /* "wb" */ "w");
      AsnOpenStruct (aop, atp_bss, (Pointer) &bss);
      AsnOpenStruct (aop, atp_ss, (Pointer) bss.seq_set);
      /*
      av.intvalue = BioseqseqSet_class_genbank;
      AsnWrite (aop, atp_cls, &av);
      */
    }

    for (vnp = head; vnp != NULL; vnp = vnp->next) {
      if (vnp->choice == 0) {
        str = (CharPtr) vnp->data.ptrvalue;
        if (! StringHasNoText (str)) {
          subfile = myargs [x_argFileSelect].strvalue;
          if (StringHasNoText (subfile) || StringStr (str, subfile) != NULL) {
#ifdef OS_UNIX
            /* printf ("%s\n", str); */
#endif
            DoReleaseFile (str, myargs [b_argBinaryFile].intvalue, myargs [c_argCompressed].intvalue, fp, aop, atp_se);
          }
        }
      }
    }

    if (aop != NULL) {
      AsnCloseStruct (aop, atp_ss, (Pointer) bss.seq_set);
      AsnCloseStruct (aop, atp_bss, (Pointer) &bss);
      AsnIoClose (aop);
    }

    ValNodeFreeData (head);
  }

  FileClose (fp);

  return 0;
}
Ejemplo n.º 7
0
static void DoGraphs (BioseqPtr bsp, Pointer userdata)

{
  Byte          bases [400];
  ByteStorePtr  bs;
  Int2          ctr, i, j, val;
  Int4          curroffset = 0, gphlen = 0, seqlen = 0, slplen,
                bslen, min = INT4_MAX, max = INT4_MIN,
                NsWithScore, ACGTsWithoutScore;
  DeltaSeqPtr   dsp;
  Uint2         entityID, olditemid = 0, olditemtype = 0,
                numdsp = 0, numsgp = 0;
  GphItemPtr    gip;
  ValNodePtr    head, vnp;
  Boolean       noErrors = TRUE;
  Uint1         residue;
  ScanDataPtr   sdp;
  SeqGraphPtr   sgp;
  SeqIntPtr     sintp;
  SeqLocPtr     slocp;
  SeqLitPtr     slp;
  SeqPortPtr    spp;
  Char          str [128];

  if (bsp == NULL) return;
  if (! ISA_na (bsp->mol)) return;
  if (SeqMgrGetParentOfPart (bsp, NULL) != NULL) return;

  sdp = (ScanDataPtr) userdata;

  entityID = ObjMgrGetEntityIDForPointer (bsp);
  head = GetSeqGraphsOnBioseq (entityID, bsp);
  if (head == NULL) return;

  for (vnp = head; vnp != NULL; vnp = vnp->next) {
    gip = (GphItemPtr) vnp->data.ptrvalue;
    if (gip == NULL) continue;
    sgp = gip->sgp;
    min = MIN ((Int4) min, (Int4) sgp->min.intvalue);
    max = MAX ((Int4) max, (Int4) sgp->max.intvalue);

    if (sgp->min.intvalue < 0 || sgp->min.intvalue > 100) {
      sprintf (str, "Graph min (%ld) out of range", (long) sgp->min.intvalue);
      PrintGraphMessage (bsp, sdp, str, NULL);
      noErrors = FALSE;
    }

    if (sgp->max.intvalue < 0 || sgp->max.intvalue > 100) {
      sprintf (str, "Graph max (%ld) out of range", (long) sgp->max.intvalue);
      PrintGraphMessage (bsp, sdp, str, NULL);
      noErrors = FALSE;
    }

    gphlen += sgp->numval;
    bs = (ByteStorePtr) sgp->values;
    if (bs != NULL) {
      bslen = BSLen (bs);
      if (sgp->numval != bslen) {
        sprintf (str, "SeqGraph (%ld) and ByteStore (%ld) length mismatch", (long) sgp->numval, (long) bslen);
        PrintGraphMessage (bsp, sdp, str, NULL);
        noErrors = FALSE;
      }
    }
  }

  if (bsp->repr == Seq_repr_raw) {
    seqlen = bsp->length;
  } else if (bsp->repr == Seq_repr_delta) {
    for (dsp = (DeltaSeqPtr) (bsp->seq_ext); dsp != NULL; dsp = dsp->next) {
      switch (dsp->choice) {
        case 1 :
          slocp = (SeqLocPtr) dsp->data.ptrvalue;
          if (slocp == NULL) break;
          if (slocp->choice != SEQLOC_NULL) {
            seqlen += SeqLocLen (slocp);
          }
          break;
        case 2 :
          slp = (SeqLitPtr) dsp->data.ptrvalue;
          if (slp == NULL || slp->seq_data == NULL) break;
          seqlen += slp->length;
          break;
        default :
          break;
      }
    }
  }

  if (seqlen != gphlen) {
    sprintf (str, "SeqGraph (%ld) and Bioseq (%ld) length mismatch", (long) gphlen, (long) seqlen);
    PrintGraphMessage (bsp, sdp, str, NULL);
    noErrors = FALSE;
  }

  if (bsp->repr == Seq_repr_delta) {
    for (dsp = (DeltaSeqPtr) (bsp->seq_ext), vnp = head;
         dsp != NULL && vnp != NULL; dsp = dsp->next) {
      gip = (GphItemPtr) vnp->data.ptrvalue;
      if (gip == NULL) continue;
      sgp = gip->sgp;
      if (sgp == NULL) continue;
      switch (dsp->choice) {
        case 1 :
          slocp = (SeqLocPtr) dsp->data.ptrvalue;
          if (slocp != NULL && slocp->choice != SEQLOC_NULL) {
            slplen = SeqLocLen (slocp);
            curroffset += slplen;
            if (sgp->numval != slplen) {
              sprintf (str, "SeqGraph (%ld) and SeqLoc (%ld) length mismatch", (long) sgp->numval, (long) slplen);
              PrintGraphMessage (bsp, sdp, str, NULL);
              noErrors = FALSE;
            }
            numdsp++;
            if (vnp != NULL) {
              vnp = vnp->next;
              numsgp++;
            }
          }
          break;
        case 2 :
          slp = (SeqLitPtr) dsp->data.ptrvalue;
          if (slp != NULL && slp->seq_data != NULL) {
            if (sgp->numval != slp->length) {
              sprintf (str, "SeqGraph (%ld) and SeqLit (%ld) length mismatch", (long) sgp->numval, (long) slp->length);
              PrintGraphMessage (bsp, sdp, str, NULL);
              noErrors = FALSE;
            }
            slocp = sgp->loc;
            if (slocp != NULL && slocp->choice == SEQLOC_INT) {
              sintp = (SeqIntPtr) slocp->data.ptrvalue;
              if (sintp != NULL) {
                if (sintp->from != curroffset) {
                  sprintf (str, "SeqGraph (%ld) and SeqLit (%ld) start do not coincide", (long) sintp->from, (long) curroffset);
                  PrintGraphMessage (bsp, sdp, str, NULL);
                  noErrors = FALSE;
                }
                if (sintp->to != slp->length + curroffset - 1) {
                  sprintf (str, "SeqGraph (%ld) and SeqLit (%ld) stop do not coincide", (long) sintp->to, (long) (slp->length + curroffset - 1));
                  PrintGraphMessage (bsp, sdp, str, NULL);
                  noErrors = FALSE;
                }
              }
            }
            numdsp++;
            if (vnp != NULL) {
              vnp = vnp->next;
              numsgp++;
            }
          }
          if (slp != NULL) {
            curroffset += slp->length;
          }
          break;
        default :
          break;
      }
    }
    if (numdsp != numsgp) {
      sprintf (str, "Different number of SeqGraph (%d) and SeqLit (%d) components", (int) numsgp, (int) numdsp);
      PrintGraphMessage (bsp, sdp, str, NULL);
      noErrors = FALSE;
    }
  }

  for (vnp = head; vnp != NULL; vnp = vnp->next) {
    gip = (GphItemPtr) vnp->data.ptrvalue;
    if (gip == NULL) continue;
    sgp = gip->sgp;
    if (sgp == NULL) continue;
    spp = SeqPortNewByLoc (sgp->loc, Seq_code_iupacna);
    if (spp == NULL) continue;
    slplen = SeqLocLen (sgp->loc);
    if (bsp->repr == Seq_repr_delta || bsp->repr == Seq_repr_virtual) {
      SeqPortSet_do_virtual (spp, TRUE);
    }

    bs = (ByteStorePtr) sgp->values;
    BSSeek (bs, 0, SEEK_SET);
    j = 0;
    val = 0;

    ctr = SeqPortRead (spp, bases, sizeof (bases));
    i = 0;
    residue = (Uint1) bases [i];

    NsWithScore = 0;
    ACGTsWithoutScore = 0;

    while (residue != SEQPORT_EOF && j < sgp->numval) {
      if (IS_residue (residue)) {
        val = (Int2) BSGetByte (bs);
        j++;
        switch (residue) {
          case 'A' :
          case 'C' :
          case 'G' :
          case 'T' :
            if (val == 0) {
              ACGTsWithoutScore++;
            }
            break;
          case 'N' :
            if (val > 0) {
              NsWithScore++;
            }
            break;
          default :
            break;
        }
      }
      i++;
      if (i >= ctr) {
        i = 0;
        ctr = SeqPortRead (spp, bases, sizeof (bases));
        if (ctr < 0) {
          bases [0] = -ctr;
        } else if (ctr < 1) {
          bases [0] = SEQPORT_EOF;
        }
      }
      residue = (Uint1) bases [i];
    }

    if (ACGTsWithoutScore > 0) {
      sprintf (str, "%ld ACGT bases have zero score value", (long) ACGTsWithoutScore);
      PrintGraphMessage (bsp, sdp, str, NULL);
      noErrors = FALSE;
    }
    if (NsWithScore > 0) {
      sprintf (str, "%ld N bases have positive score value", (long) NsWithScore);
      PrintGraphMessage (bsp, sdp, str, NULL);
      noErrors = FALSE;
    }

    SeqPortFree (spp);
  }

  if (noErrors) {
    PrintGraphMessage (bsp, sdp, "Quality scores okay", NULL);
  }

  ValNodeFreeData (head);
}
Ejemplo n.º 8
0
Int2 Main (void)

{
  CharPtr     base, directory, organism, ptr;
  Boolean     altstart, findorf, flatfile, validate;
  ValNodePtr  head, vnp;

  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 (! FeatDefSetLoad ()) {
    Message (MSG_FATAL, "FeatDefSetLoad failed");
    return 1;
  }

  if (! GetArgs ("sgd2asn", sizeof (myargs) / sizeof (Args), myargs)) {
    return 0;
  }

  directory = (CharPtr) myargs [0].strvalue;
  base = (CharPtr) myargs [1].strvalue;
  organism = (CharPtr) myargs [2].strvalue;
  findorf = (Boolean) myargs [3].intvalue;
  altstart = (Boolean) myargs [4].intvalue;
  validate = (Boolean) myargs [5].intvalue;
  flatfile = (Boolean) myargs [6].intvalue;

  if (! StringHasNoText (base)) {
    ptr = StringStr (base, ".fsa");
    if (ptr != NULL) {
      *ptr = '\0';
      ProcessOneRecord (directory, base, organism, findorf, altstart, validate, flatfile);
    }
  } else {
    head = DirCatalog (directory);
    for (vnp = head; vnp != NULL; vnp = vnp->next) {
      if (vnp->choice == 0) {
        base = (CharPtr) vnp->data.ptrvalue;
        if (! StringHasNoText (base)) {
          ptr = StringStr (base, ".fsa");
          if (ptr != NULL) {
            *ptr = '\0';
            ProcessOneRecord (directory, base, organism, findorf, altstart, validate, flatfile);
          }
        }
      }
    }
    ValNodeFreeData (head);
  }

  return 0;
}
Ejemplo n.º 9
0
static void ProcessOneRecord (
  CharPtr directory,
  CharPtr base,
  CharPtr organism,
  Boolean findorf,
  Boolean altstart,
  Boolean validate,
  Boolean flatfile
)

{
  BioSourcePtr  biop = NULL;
  BioseqPtr     bsp;
  Uint2         datatype, entityID;
  Int2          genCode;
  MolInfoPtr    mip;
  SeqAnnotPtr   sap;
  SeqEntryPtr   sep;
  SeqFeatPtr    sfp;
  SqnTagPtr     stp;
  CharPtr       ttl;
  ValNodePtr    vnp;

  Message (MSG_POST, "Processing %s\n", base);

  bsp = (BioseqPtr) ReadOneFile (directory, base, "fsa", &datatype);
  if (bsp == NULL || datatype != OBJ_BIOSEQ) {
    ObjMgrFree (datatype, (Pointer) bsp);
    return;
  }

  if (bsp->mol == Seq_mol_na) {
    bsp->mol = Seq_mol_dna;
  }

  vnp = ValNodeExtract (&(bsp->descr), Seq_descr_title);
  if (vnp != NULL) {
    ttl = (CharPtr) vnp->data.ptrvalue;
    if (ttl != NULL) {
      stp = SqnTagParse (ttl);
      if (stp != NULL) {
        biop = OldParseTitleIntoBioSource (stp, bsp, organism);
      }
      SqnTagFree (stp);
    }
    ValNodeFreeData (vnp);
  }
  if (biop == NULL) {
    biop = OldParseTitleIntoBioSource (NULL, bsp, organism);
  }
  if (biop != NULL) {
    SeqDescrAddPointer (&(bsp->descr), Seq_descr_source, (Pointer) biop);
  }

  mip = MolInfoNew ();
  if (mip != NULL) {
    mip->biomol = MOLECULE_TYPE_GENOMIC;
    SeqDescrAddPointer (&(bsp->descr), Seq_descr_molinfo, (Pointer) mip);
  }

  entityID = ObjMgrRegister (datatype, (Pointer) bsp);

  sep = GetBestTopParentForData (entityID, bsp);
  genCode = SeqEntryToGeneticCode (sep, NULL, NULL, 0);

  if (findorf) {
    AnnotateBestOrf (bsp, genCode, altstart);
  }

  sap = (SeqAnnotPtr) ReadOneFile (directory, base, "tbl", &datatype);
  if (sap != NULL && datatype == OBJ_SEQANNOT && sap->type == 1) {
    sap->next = bsp->annot;
    bsp->annot = sap;
  } else {
    ObjMgrFree (datatype, (Pointer) sap);
  }

  /* for parsed in features or best ORF, promote CDS products to protein bioseq */

  for (sap = bsp->annot; sap != NULL; sap = sap->next) {
    if (sap->type == 1) {
      SetEmptyGeneticCodes (sap, genCode);
      sfp = (SeqFeatPtr) sap->data;
      PromoteXrefs (sfp, bsp, entityID);
    }
  }

  sep = GetTopSeqEntryForEntityID (entityID);
  if (sep != NULL) {
    SeriousSeqEntryCleanup (sep, NULL, NULL);
    WriteOneFile (directory, base, "sqn", sep);
    if (validate || flatfile) {
      SeqMgrIndexFeatures (entityID, 0);
    }
    if (validate) {
      Message (MSG_POST, "Validating %s\n", base);
      ValidateOneFile (directory, base, "val", sep);
    }
    if (flatfile) {
      Message (MSG_POST, "Flatfile %s\n", base);
      sep = FindNucSeqEntry (sep);
      FlatfileOneFile (directory, base, "gbf", sep);
    }
  }

  ObjMgrFreeByEntityID (entityID);
}
Ejemplo n.º 10
0
NLM_EXTERN Nlm_Int4 Nlm_DirExplore (
  Nlm_CharPtr directory,
  Nlm_CharPtr filter,
  Nlm_CharPtr suffix,
  Nlm_Boolean recurse,
  Nlm_DirExpProc proc,
  Nlm_VoidPtr userdata
)

{
  Nlm_Int4     count = 0;
  Nlm_Char     file [FILENAME_MAX], path [PATH_MAX];
  Nlm_CharPtr  ptr, str;
  ValNodePtr   head, vnp;

  if (proc == NULL) return 0;
  if (Nlm_StringHasNoText (directory) /* || Nlm_StringHasNoText (suffix) */ ) return 0;

  /* get list of all files in source directory */

  head = Nlm_DirCatalog (directory);

  for (vnp = head; vnp != NULL; vnp = vnp->next) {
    if (vnp->choice == 0) {
      str = (Nlm_CharPtr) vnp->data.ptrvalue;
      if (! Nlm_StringHasNoText (str)) {

        /* check filename for indicated suffix */

        ptr = Nlm_StringStr (str, suffix);
        if (ptr != NULL) {

          /* make sure detected suffix is really at end of filename */

          if (Nlm_StringCmp (ptr, suffix) == 0) {
            *ptr = '\0';
          } else {
            ptr = NULL;
          }
        }

        if (Nlm_StringHasNoText (suffix) || ptr != NULL) {

          Nlm_StringNCpy_0 (path, directory, sizeof (path));
          sprintf (file, "%s%s", str, suffix);
          Nlm_FileBuildPath (path, NULL, file);

          /* check full path/file name for desired filter */

          if (Nlm_StringHasNoText (filter) || Nlm_StringStr (path, filter) != NULL) {

            /* process file that satisfies optional filter and suffix constraints */

            proc (path, userdata);
            count++;
          }
        }
      }
    } else if (vnp->choice == 1 && recurse) {

      /* recurse into subdirectory */

      Nlm_StringNCpy_0 (path, directory, sizeof (path));
      str = (Nlm_CharPtr) vnp->data.ptrvalue;
      Nlm_FileBuildPath (path, str, NULL);

      count += Nlm_DirExplore (path, filter, suffix, recurse, proc, userdata);
    }
  }

  /* clean up file list */

  ValNodeFreeData (head);

  return count;
}
Ejemplo n.º 11
0
/* return -1 on failure, 0 on success */
static Int4 FileRecurse (
  CharPtr         directory,
  InputStreamPtr  isp,
  OutputStreamPtr osp,
  AsnStreamPtr    asp,
  Int4Ptr         gap_sizes
)

{
  Char        path [PATH_MAX];
  CharPtr     ptr;
  CharPtr     str;
  ValNodePtr  head, vnp;
  CharPtr     orig_dir, orig_base;
  Int4        rval = 0;

  /* get list of all files in source directory */

  head = DirCatalog (directory);

  for (vnp = head; vnp != NULL; vnp = vnp->next) {
    if (vnp->choice == 0) {
      str = (CharPtr) vnp->data.ptrvalue;
      if (StringDoesHaveText (str)) {

        /* does filename have desired substring? */

        ptr = StringStr (str, osp->suffix);

        if (ptr != NULL) {

          /* make sure detected suffix is really at end of filename */

          if (StringCmp (ptr, osp->suffix) == 0) {
            *ptr = '\0';

            /* process file that has desired suffix (usually .fsa) */
            osp->base = str;
            orig_dir = isp->directory;
            isp->directory = directory;
            orig_base = isp->base;
            isp->base = str;
            if (isp->is_binary) {
              rval |= ProcessStream (isp, osp, asp, gap_sizes);
            } else {
              rval |= ProcessOneRecord (directory, osp, gap_sizes);
            }
            isp->directory = orig_dir;
            isp->base = orig_base;
            osp->base = NULL;
          }
        }
      }
    } else if (vnp->choice == 1) {

      /* recurse into subdirectory */

      StringNCpy_0 (path, directory, sizeof (path));
      str = (CharPtr) vnp->data.ptrvalue;
      FileBuildPath (path, str, NULL);
      rval |= FileRecurse (path, isp, osp, asp, gap_sizes);
    }
  }

  /* clean up file list */

  ValNodeFreeData (head);
  return rval;
}
Ejemplo n.º 12
0
Int2 Main (void)

{
  CharPtr       base, directory, outfile, suffix, ptr;
  BioseqSetPtr  bssp;
  ValNodePtr    head, vnp;
  SeqEntryPtr   sep;
  SeqSubmitPtr  ssp;

  /* 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 ("subfuse", sizeof (myargs) / sizeof (Args), myargs)) {
    return 0;
  }

  directory = (CharPtr) myargs [p_argInputPath].strvalue;
  outfile = (CharPtr) myargs [o_argOutputFile].strvalue;
  suffix = (CharPtr) myargs [x_argSuffix].strvalue;

  bssp = BioseqSetNew ();
  if (bssp == NULL) return 0;
  bssp->_class = BioseqseqSet_class_genbank;

  sep = SeqEntryNew ();
  if (sep == NULL) return 0;
  sep->choice = 2;
  sep->data.ptrvalue = (Pointer) bssp;

  ssp = SeqSubmitNew ();
  if (ssp == NULL) return 0;
  ssp->datatype = 1;
  ssp->data = (Pointer) sep;

  /* get list of all files in source directory */

  head = DirCatalog (directory);

  for (vnp = head; vnp != NULL; vnp = vnp->next) {
    if (vnp->choice == 0) {
      base = (CharPtr) vnp->data.ptrvalue;
      if (! StringHasNoText (base)) {
        ptr = StringStr (base, suffix);
        if (ptr != NULL) {
          *ptr = '\0';
          Message (MSG_POST, "Processing %s\n", base);
          ProcessOneRecord (ssp, bssp, directory, base, suffix);
        }
      }
    }
  }

  /* clean up file list */

  ValNodeFreeData (head);

  /* write output file */

  WriteOneSubmission (outfile, ssp);

  return 0;
}
Ejemplo n.º 13
0
Int2 Main (void)
{
    Int2        argcount;
    Boolean     flagHaveNet;

    Int4        gi;
    SeqEntryPtr sep;
    ComPatPtr   cpp, cpph = NULL;
    SeqAlignPtr sap, sapn;
    StdSegPtr   ssp;
    SeqLocPtr   slp, slpn;
    Int4        start, stop;

    FILE        *fiop;
    Char        fastafile[256], namesfile[256];
    CharPtr     title;
    CharPtr     taxon;

    FloatHi     mw;
    ValNodePtr  namelist = NULL;

    static CharPtr pattern_file = "ncbipros.dat";
    static CharPtr protease_file = "ncbiendo.dat";
    static CharPtr names_file = "ncbipnam.dat";

    static GatherScope  gs;
    GatherScopePtr      gsp;
    static Gather_PBS   gpbs;
    Gather_PBSPtr       gpbsp;

#ifndef NO_TAX_NET
    Int4   i;
    static Char taxdata[8];
    static Gather_TaxId gti;
    Gather_TaxIdPtr     gtip;
#endif

#ifndef NO_TAX_NET
    Int2   ia=4, ib=5, ic=6, id=7, ie=8, ig=9, ih=10, ii=11;
#else
    Int2         ib=4, ic=5, id=6, ie=7, ig=8, ih=9,  ii=10;
#endif

    argcount = sizeof (myargs) / sizeof (Args);
    if (!GetArgs ("ProSiteSearch", argcount, myargs))
        return 1;

    if (myargs[0].intvalue == 0 && myargs[1].strvalue == NULL)
    {
        ErrPostEx (SEV_ERROR, TOP_ERROR, 100,
                   "No gi or FastA file given :: for help :   srchaa -");
        ErrShow ();
        exit (1);
    }

    gsp = &gs;

#ifndef NO_TAX_NET
    gtip = &gti;
#endif
    gpbsp = &gpbs;

    MemSet ((Pointer) gsp, 0, sizeof (GatherScope));
    MemSet ((Pointer) gsp->ignore, (int) (TRUE),
            (size_t) (OBJ_MAX * sizeof (Boolean)));

    gsp->ignore[OBJ_SEQDESC] = TRUE;
    gsp->ignore[OBJ_BIOSEQ] = FALSE;

    gpbsp->bsp = NULL;

    gi = myargs[0].intvalue;
    if (myargs[1].strvalue != NULL)
        StrCpy (fastafile, myargs[1].strvalue);
    else
        fastafile[0] = '\0';

    if (gi > 0)
    {
        if (!EntrezInit ("srchaa", FALSE, &flagHaveNet))
        {
            ErrPostEx (SEV_ERROR, TOP_ERROR, 102,
                       "Entrez init failed");
            ErrShow ();
            exit (1);
        }
    }

#ifndef NO_TAX_NET
    if (myargs[ia].intvalue)
    {
        if (!TaxArchInit ())
        {
            ErrPostEx (SEV_ERROR, TOP_ERROR, 103,
                       "Taxonomy init failed");
            ErrShow ();
            exit (1);
        }
    }
#endif

    fiop = NULL;
    if (gi > 0)
    {
        sep = EntrezSeqEntryGet (gi, SEQENTRY_READ_BIOSEQ);
    }
    else
    {
        if ((fiop = FileOpen (fastafile, "r")) == NULL)
        {
            ErrPostEx (SEV_ERROR, TOP_ERROR, 103,
                       "Failed to open FastA file: %s", fastafile);
            ErrShow ();
            exit (1);
        }
        sep = FastaToSeqEntry (fiop, FALSE);
    }

    if (sep == NULL)
    {
        ErrPostEx (SEV_ERROR, TOP_ERROR, 104,
                   "No seqentry found");
        ErrShow ();
        exit (1);
    }

    while (sep != NULL)
    {
        gsp->ignore[OBJ_SEQDESC] = TRUE;
        gsp->ignore[OBJ_BIOSEQ] = FALSE;
        gpbsp->bsp = NULL;
        gpbsp->gi = gi;
        GatherSeqEntry (sep, (Pointer) gpbsp, GetBioseq, (Pointer) gsp);

        taxon = NULL;
#ifndef NO_TAX_NET
        if (myargs[ia].intvalue)
        {
            for (i = 0; i < 8; i++)
                taxdata[i] = '-';
            taxon = taxdata;

            gsp->ignore[OBJ_SEQDESC] = FALSE;
            gsp->ignore[OBJ_BIOSEQ] = TRUE;

            gtip->taxid = 0;
            GatherSeqEntry (sep, (Pointer) gtip, GetTaxId, (Pointer) gsp);

            if (gtip->taxid != 0)
                WhatOrg (gtip->taxid, taxon);
            else
                taxon = NULL;
        }
#endif

        if (gpbsp->bsp != NULL)
        {
            if (ISA_aa (gpbsp->bsp->mol))
            {
                if (cpph == NULL)
                {
                    namesfile[0] = '\0';
                    if (myargs[id].intvalue)
                        StrCpy (namesfile, names_file);
                    if (myargs[ie].strvalue != NULL)
                        StrCpy (namesfile, myargs[ie].strvalue);

                    if (myargs[ig].strvalue != NULL)
                    {
                        if ((cpph = CompilePattern (myargs[ig].strvalue, 1)) != NULL)
                            StrCpy (cpph->name, "User Pattern");
                    }
                    else
                    {
                        namelist = ReadPatternNames (namesfile);
                        if (myargs[ib].intvalue)
                            cpph = ReadPrositePattern (protease_file,
                                                       (Boolean) myargs[2].intvalue,
                                                       myargs[3].intvalue,
                                                       taxon, NULL);
                        else
                            cpph = ReadPrositePattern (pattern_file,
                                                       (Boolean) myargs[2].intvalue,
                                                       myargs[3].intvalue,
                                                       taxon, namelist);
                    }
                }

                if (!(Boolean) myargs[ih].intvalue)
                {
                    title = FastaTitle (gpbsp->bsp, ">", NULL);
                    printf ("%s\n", title);
                    MemFree (title);
                }
                cpp = cpph;
                while (cpp != NULL)
                {
                    sap = PatternMatchBioseq (gpbsp->bsp, cpp,
                                              (Int4)myargs[ii].intvalue);
                    if (myargs[ib].intvalue)
                    {
                        printf (">%s\n", cpp->name);
                        if (sap != NULL)
                            printf ("   Start     Stop       M.W.\n");
                    }
                    if (myargs[ib].intvalue)
                    {
                        EmbedMolecularWeightInfo (sap, gpbsp->bsp);
                        if (myargs[ic].intvalue)
                            URK_SeqAlignSortByMolWt (&sap);
                        while (sap != NULL)
                        {
                            ssp = (StdSegPtr) sap->segs;
                            slp = ssp->loc;
                            start = SeqLocStart (slp);
                            stop = SeqLocStop (slp);
                            mw = ssp->scores->value.realvalue;
                            printf ("%8ld %8ld    %9.2f\n",
                                    (long) start+1, (long) stop+1, mw);
                            sapn = sap->next;
                            SeqAlignFree (sap);
                            sap = sapn;
                        }
                    }
                    else
                    {
                        slp = MatchSa2Sl (&sap);
                        if (myargs[ih].intvalue && slp != NULL)
                        {
                            title = FastaTitle (gpbsp->bsp, ">", NULL);
                            printf ("%s\n", title);
                            MemFree (title);
                        }
                        while (slp != NULL)
                        {
                            start = SeqLocStart (slp);
                            stop = SeqLocStop (slp);
                            printf ("%8ld %8ld    %s\n",
                                    (long) start+1, (long) stop+1, cpp->name);
                            slpn = slp->next;
                            SeqLocFree (slp);
                            slp = slpn;
                        }
                    }
                    cpp = cpp->nextpattern;
                }
            }
            else
            {
                ErrPostEx (SEV_ERROR, TOP_ERROR, 106,
                           "Not a protein bioseq");
                ErrShow ();
                exit (1);
            }
        }
        else
        {
            ErrPostEx (SEV_ERROR, TOP_ERROR, 105,
                       "No bioseq found");
            ErrShow ();
            exit (1);
        }
        SeqEntryFree (sep);
        sep = NULL;
        if (fiop != NULL)
            sep = FastaToSeqEntry (fiop, FALSE);
    }

    ComPatFree (cpph);
    ValNodeFreeData (namelist);
    FileClose (fiop);
    if (gi > 0)
        EntrezFini ();
#ifndef NO_TAX_NET
    if (myargs[ia].intvalue)
        TaxArchFini ();
#endif
    return 0;
}
Ejemplo n.º 14
0
/*******************************************************************************

  Function : DDV_GetRulerForEditor()
  
  Purpose : create the ruler for the editor. This new descriptor is created
      using the descriptor of the viewer.

  Return value : an allocated data block ready for use by the editor. Null if
  failure

*******************************************************************************/
NLM_EXTERN ValNodePtr DDV_GetRulerForEditor(ValNodePtr descr_head,Int4 from_disp,
		Int4 to_disp)
{
DDVRulerDescrPtr drdp,prev_drdp,new_drdp;
ValNodePtr  vnp2,vnp3,vnpDesc;
Int4     cumulDecr,drdp_size,beginCopy,endCopy,drdp_start_ali;
Boolean  bPop;

	cumulDecr=0;
	vnpDesc=NULL;
	prev_drdp=NULL;
	
	for(vnp2=descr_head;vnp2!=NULL;vnp2=vnp2->next){
		drdp=(DDVRulerDescrPtr)vnp2->data.ptrvalue;
		drdp_size=drdp->disp_stop-drdp->disp_start+1;

		/*not yet in the region of interest ?*/
		if (drdp->disp_stop<from_disp) {
			cumulDecr+=drdp_size;
			continue;
		}
		
		beginCopy=_max_(from_disp,drdp->disp_start);
		endCopy=_min_(drdp->disp_stop,to_disp);

		if (drdp->bUnAligned==FALSE)
			drdp_start_ali=drdp->align_start+(beginCopy-drdp->disp_start);
		else
			drdp_start_ali=(Int4)-1;
		/*in order to merge nodes of same type, i keep track of
		the previous populated drdp node. Same style==yes, then
		just extend to the right the previous node*/
		if (prev_drdp){
			if (prev_drdp->bUnAligned==drdp->bUnAligned){
				prev_drdp->disp_stop=endCopy;
				bPop=TRUE;
			}
			else{
				bPop=FALSE;
			}
		}
		else{
			bPop=FALSE;
		}
		if (!bPop){
			new_drdp=(DDVRulerDescrPtr)MemNew(sizeof(DDVRulerDescr));
			if (!new_drdp) goto erreur;
			
			new_drdp->disp_start=beginCopy;
			new_drdp->disp_stop=endCopy;
			new_drdp->align_start=drdp_start_ali;
			new_drdp->bUnAligned=drdp->bUnAligned;
			if (!vnpDesc){
				vnp3=ValNodeAddPointer(&vnpDesc,0,(Pointer)new_drdp);
			}
			else{
				vnp3=ValNodeAddPointer(&vnp3,0,(Pointer)new_drdp);
			}
			prev_drdp=new_drdp;
		}
		if (drdp->disp_stop>=to_disp) break;
		cumulDecr+=drdp_size;
	}

	return(vnpDesc);
erreur:
	if (vnpDesc)
		ValNodeFreeData(vnpDesc);
	return(NULL);
}