NCBI C Toolkit Cross Reference

   /*   sequin2.c
   * ===========================================================================
   *
   *                            PUBLIC DOMAIN NOTICE
   *            National Center for Biotechnology Information (NCBI)
   *
   *  This software/database is a "United States Government Work" under the
   *  terms of the United States Copyright Act.  It was written as part of
   *  the author's official duties as a United States Government employee and
  *  thus cannot be copyrighted.  This software/database is freely available
  *  to the public for use. The National Library of Medicine and the U.S.
  *  Government do not place any restriction on its use or reproduction.
  *  We would, however, appreciate having the NCBI and the author cited in
  *  any work or product based on this material
  *
  *  Although all reasonable efforts have been taken to ensure the accuracy
  *  and reliability of the software and data, the NLM and the U.S.
  *  Government do not and cannot warrant the performance or results that
  *  may be obtained by using this software or data. The NLM and the U.S.
  *  Government disclaim all warranties, express or implied, including
  *  warranties of performance, merchantability or fitness for any particular
  *  purpose.
  *
  * ===========================================================================
  *
  * File Name:  sequin2.c
  *
  * Author:  Jonathan Kans
  *
  * Version Creation Date:   1/22/95
  *
  * $Revision: 6.670 $
  *
  * File Description: 
  *
  * Modifications:  
  * --------------------------------------------------------------------------
  * Date     Name        Description of modification
  * -------  ----------  -----------------------------------------------------
  *
  *
  * ==========================================================================
  */
  
  #include "sequin.h"
  #include <document.h>
  #include <sequtil.h>
  #include <biosrc.h>
  #include <cdrgn.h>
  #include <seqsub.h>
  #include <tofasta.h>
  #include <gather.h>
  #include <subutil.h>
  #include <suggslp.h>
  #include <toasn3.h>
  #include <toporg.h>
  #include <salfiles.h>
  #include <salsap.h>
  #include <salign.h>
  #include <edutil.h>
  #include <vsm.h>
  //#include <accentr.h>
  //#include <accutils.h>
  #include <pmfapi.h>
  #include <explore.h>
  #include <aliparse.h>
  #include <algo/blast/api/twoseq_api.h>
  #ifdef WIN_MOTIF
  #include <netscape.h>
  #endif
  #include <actutils.h>
  #include <salpanel.h>
  #include <findrepl.h>
  #include <macrodlg.h>
  #include <macroapi.h>
  
  extern EnumFieldAssoc  biosource_genome_simple_alist [];
  extern EnumFieldAssoc  biosource_origin_alist [];
  
  static ENUM_ALIST(biomol_nucX_alist)
    {"Genomic DNA",            253},
    {"Genomic RNA",            254},
    {"Precursor RNA",            2},
    {"mRNA [cDNA]",              3},
    {"Ribosomal RNA",            4},
    {"Transfer RNA",             5},
    {"Small nuclear RNA",        6},
    {"Small cytoplasmic RNA",    7},
    {"Other-Genetic",            9},
    {"cRNA",                    11},
    {"Small nucleolar RNA",     12},
    {"Transcribed RNA",         13}, 
    {"Transfer-messenger RNA", MOLECULE_TYPE_TMRNA },
  END_ENUM_ALIST
  
  static ENUM_ALIST(biomol_nucGen_alist)
    {"Genomic DNA",            253},
    {"Genomic RNA",            254},
  END_ENUM_ALIST
 
 static ENUM_ALIST(topology_nuc_alist)
 {"Linear",          TOPOLOGY_LINEAR},
 {"Circular",        TOPOLOGY_CIRCULAR},
 END_ENUM_ALIST
 
 static ENUM_ALIST(molecule_alist)
 {"DNA",             Seq_mol_dna },
 {"RNA",             Seq_mol_rna },
 END_ENUM_ALIST
 
 #define PRINTED_INT_MAX_LEN 15
 
 #define CREATE_FASTA_REQUIRED 0
 #define CREATE_FASTA_WARNING  1
 
 /* This structure holds a list of IDs and titles for a set of sequences.
  * It can be used to represent the new list of sequences being imported,
  * the existing list of sequences being imported, suggested changes for
  * a list of sequences, etc.
  */
 typedef struct idandtitleedit 
 {
   CharPtr PNTR id_list;
   CharPtr PNTR title_list;
   BoolPtr      is_seg;
   Int4         num_sequences;
   Boolean      nuc_only;
 } IDAndTitleEditData, PNTR IDAndTitleEditPtr;
 
 /* These functions are for creating, copying, and freeing lists
  * of titles and IDs.
  */
 static IDAndTitleEditPtr IDAndTitleEditNew (void)
 {
   IDAndTitleEditPtr iatep;
   
   iatep = (IDAndTitleEditPtr) MemNew (sizeof (IDAndTitleEditData));
   if (iatep != NULL)
   {
     iatep->id_list = NULL;
     iatep->title_list = NULL;
     iatep->is_seg = NULL;
     iatep->num_sequences = 0;
     iatep->nuc_only = FALSE;
   }
   return iatep;
 }
 
 static void IDAndTitleEditInit (IDAndTitleEditPtr iatep, Int4 new_num_sequences)
 {
   Int4 seq_num;
   if (iatep == NULL)
   {
     return;
   }
   
   /* free old lists, if any */
   for (seq_num = 0; seq_num < iatep->num_sequences; seq_num++)
   {
     iatep->id_list [seq_num] = MemFree (iatep->id_list [seq_num]);
     iatep->title_list [seq_num] = MemFree (iatep->title_list [seq_num]);
   }
   iatep->id_list = MemFree (iatep->id_list);
   iatep->title_list = MemFree (iatep->title_list);
   iatep->is_seg = MemFree (iatep->is_seg);
   
   /* now create blanks for num_sequences entries */
   iatep->num_sequences = MAX (0, new_num_sequences);
   if (iatep->num_sequences > 0)
   {
     iatep->id_list = (CharPtr PNTR) MemNew (iatep->num_sequences * sizeof (CharPtr));
     iatep->title_list = (CharPtr PNTR) MemNew (iatep->num_sequences * sizeof (CharPtr));
     iatep->is_seg = (BoolPtr) MemNew (iatep->num_sequences * sizeof (Boolean));
     for (seq_num = 0; seq_num < iatep->num_sequences; seq_num++)
     {
       iatep->id_list [seq_num] = NULL;
       iatep->title_list  [seq_num] = NULL;
       iatep->is_seg [seq_num] = FALSE;
     }
   } 
 }
 
 static IDAndTitleEditPtr IDAndTitleEditCopy (IDAndTitleEditPtr iatep_orig)
 {
   IDAndTitleEditPtr iatep_copy;
   Int4              seq_num;
   
   if (iatep_orig == NULL)
   {
     return NULL;
   }
   
   iatep_copy = IDAndTitleEditNew ();
   if (iatep_copy == NULL)
   {
     return NULL;
   }
   
   IDAndTitleEditInit (iatep_copy, iatep_orig->num_sequences);
   for (seq_num = 0; seq_num < iatep_copy->num_sequences; seq_num++)
   {
     iatep_copy->id_list [seq_num] = StringSave (iatep_orig->id_list [seq_num]);
     iatep_copy->title_list [seq_num] = StringSave (iatep_orig->title_list [seq_num]);
     if (iatep_orig->is_seg != NULL)
     {
       iatep_copy->is_seg [seq_num] = iatep_orig->is_seg [seq_num];
     }
   }
   
   return iatep_copy;
 }
 
 static IDAndTitleEditPtr IDAndTitleEditFree (IDAndTitleEditPtr iatep)
 {
   Int4 i;
   
   if (iatep != NULL)
   {
     for (i = 0; i < iatep->num_sequences; i++)
     {
       iatep->id_list [i] = MemFree (iatep->id_list [i]);
       iatep->title_list [i] = MemFree (iatep->title_list [i]);
     }
     iatep->id_list = MemFree (iatep->id_list);
     iatep->title_list = MemFree (iatep->title_list);
     iatep->is_seg = MemFree (iatep->is_seg);
     iatep = MemFree (iatep);
   }
   return iatep;
 }
 
 /* These functions are for applying lists of titles and IDs
  * to a SeqEntry list.
  */
 static Int4 CountSequencesAndSegments (SeqEntryPtr list, Boolean nuc_only)
 {
   Int4         num_seqs = 0;
   BioseqSetPtr bssp;
   BioseqPtr    bsp;
   
   while (list != NULL)
   {
     if (list->data.ptrvalue != NULL)
     {
       if (IS_Bioseq (list))
       {
         bsp = (BioseqPtr) list->data.ptrvalue;
         if (!nuc_only || ISA_na (bsp->mol)) {
           num_seqs ++;
         }
       }
       else if (IS_Bioseq_set (list))
       {
         bssp = (BioseqSetPtr) list->data.ptrvalue;
         num_seqs += CountSequencesAndSegments (bssp->seq_set, nuc_only);
       }
     }
     list = list->next;
   }
   return num_seqs;
 }
 
 static BioseqPtr FindNthSequenceInSet (SeqEntryPtr seq_list, Int4 nth, BoolPtr is_seg, Boolean nuc_only)
 {
   Int4         pos = 0;
   BioseqPtr    bsp = NULL;
   BioseqSetPtr bssp;
   SeqEntryPtr  sep;
   
   while (seq_list != NULL && bsp == NULL)
   {
     if (seq_list->data.ptrvalue != NULL)
     {
       if (IS_Bioseq (seq_list) && seq_list->data.ptrvalue != NULL 
           && (!nuc_only || ISA_na(((BioseqPtr)seq_list->data.ptrvalue)->mol)))
       {
         if (nth == pos)
         {
           bsp = seq_list->data.ptrvalue;
         }
         else
         {
           pos ++;
         }
       }
       else if (IS_Bioseq_set (seq_list))
       {
         bssp = (BioseqSetPtr) seq_list->data.ptrvalue;
         if (bssp->_class == BioseqseqSet_class_parts && is_seg != NULL)
         {
           *is_seg = TRUE;
         }
         sep = bssp->seq_set;
         while (sep != NULL && bsp == NULL)
         {
           bsp = FindNthSequenceInSet (sep, nth - pos, is_seg, nuc_only);
           if (bsp == NULL)
           {
             if (IS_Bioseq_set (sep))
             {
               bssp = (BioseqSetPtr) sep->data.ptrvalue;
               pos += CountSequencesAndSegments (bssp->seq_set, nuc_only);
             }
             else if (IS_Bioseq (sep) && (!nuc_only || ISA_na (((BioseqPtr)(sep->data.ptrvalue))->mol)))
             {
               pos ++;
             }
           }
           sep = sep->next;
         }
         if (bsp == NULL && is_seg != NULL)
         {
           *is_seg = FALSE;
         }
       }      
     }
     seq_list = seq_list->next;
   }
   return bsp;
 }
 
 static IDAndTitleEditPtr SeqEntryListToIDAndTitleEditEx (SeqEntryPtr list, Boolean nuc_only)
 {
   IDAndTitleEditPtr iatep;
   Int4              num_sequences, i;
   BioseqPtr         bsp;
   SeqDescrPtr       sdp;
   SeqIdPtr          sip;
   
   num_sequences = CountSequencesAndSegments (list, nuc_only);
   if (num_sequences == 0)
   {
     return NULL;
   }
   
   iatep = IDAndTitleEditNew ();
   if (iatep == NULL)
   {
     return NULL;
   }
 
   iatep->nuc_only = nuc_only;
   IDAndTitleEditInit (iatep, num_sequences);
 
   for (i = 0; i < num_sequences; i++)
   {
     bsp = FindNthSequenceInSet (list, i, &(iatep->is_seg [i]), nuc_only);
     if (bsp != NULL)
     {
       sip = SeqIdFindBest (bsp->id, SEQID_GENBANK);
       if (sip != NULL)
       {
         if (sip->choice == SEQID_LOCAL) {
           iatep->id_list [i] = SeqIdWholeLabel (sip, PRINTID_REPORT);
         } else {
           iatep->id_list [i] = SeqIdWholeLabel (sip, PRINTID_FASTA_SHORT);
         }
       }
       sdp = bsp->descr;
       while (sdp != NULL && sdp->choice != Seq_descr_title)
       {
         sdp = sdp->next;
       }
       if (sdp != NULL && !StringHasNoText (sdp->data.ptrvalue))
       {
         iatep->title_list [i] = StringSave (sdp->data.ptrvalue);
       }
     }
   }
   return iatep;
 }
 static IDAndTitleEditPtr SeqEntryListToIDAndTitleEdit (SeqEntryPtr list)
 {
   return SeqEntryListToIDAndTitleEditEx (list, FALSE);
 }
 
 static void ReplaceIDAndTitleForBioseq (BioseqPtr bsp, SeqIdPtr new_sip, CharPtr title)
 {
   SeqDescrPtr sdp;
   SeqEntryPtr sep;
   
   if (bsp == NULL)
   {
     return;
   }
   
   /* replace ID */
   
   if (new_sip != NULL)
   {
     if (bsp->id != NULL)
     {
       new_sip->next = bsp->id->next;
       bsp->id->next = NULL;
       bsp->id = SeqIdFree (bsp->id);
     }
     bsp->id = new_sip;
     SeqMgrReplaceInBioseqIndex(bsp);
   }
   else
   {
     bsp->id = SeqIdFree (bsp->id);
   }
     
   /* replace title */
   if (title == NULL)
   {
     title = StringSave ("");
   }
   sdp = bsp->descr;
   while (sdp != NULL && sdp->choice != Seq_descr_title)
   {
     sdp = sdp->next;
   }
   if (sdp == NULL)
   {
     sep = SeqMgrGetSeqEntryForData (bsp);
     sdp = CreateNewDescriptor (sep, Seq_descr_title);
     sdp->data.ptrvalue = title;
   }
   else
   {
     sdp->data.ptrvalue = MemFree (sdp->data.ptrvalue);
     sdp->data.ptrvalue = title;
   }  
 }
 
 static void ResetSegSetIDLists (SeqEntryPtr list)
 {
   BioseqSetPtr bssp, parts;
   BioseqPtr    seg_bsp;
   SeqEntryPtr  sep;
   SeqLocPtr    loc, next_loc, last_loc;
   
   if (list == NULL)
   {
     return;
   }
   
   if (list->data.ptrvalue != NULL)
   {
     if (IS_Bioseq_set (list))
     {
       bssp = (BioseqSetPtr) list->data.ptrvalue;
       if (bssp->_class == BioseqseqSet_class_segset)
       {
         sep = bssp->seq_set;
         seg_bsp = NULL;
         parts = NULL;
         while (sep != NULL && (seg_bsp == NULL || parts == NULL))
         {
           if (IS_Bioseq (sep))
           {
             seg_bsp = sep->data.ptrvalue;
           }
           else if (IS_Bioseq_set (sep))
           {
             parts = sep->data.ptrvalue;
             if (parts != NULL && parts->_class != BioseqseqSet_class_parts)
             {
               parts = NULL;
             }
           }
           sep = sep->next;
         }
         if (seg_bsp != NULL)
         {
           /* remove old location */
           loc = (SeqLocPtr) seg_bsp->seq_ext;
           while (loc != NULL)
           {
             next_loc = loc->next;
             loc->next = NULL;
             loc = SeqLocFree (loc);
             loc = next_loc;
           }
           seg_bsp->seq_ext = NULL;
           /* put in new locations */
           sep = parts->seq_set;
           last_loc = NULL;
           while (sep != NULL)
           {
             if (IS_Bioseq (sep) && sep->data.ptrvalue != NULL)
             {
               loc = SeqLocWholeNew (sep->data.ptrvalue);
               if (loc != NULL)
               {
                 if (last_loc == NULL)
                 {
                   seg_bsp->seq_ext = loc;
                 }
                 else
                 {
                   last_loc->next = loc;
                 }
                 last_loc = loc;
               }
             }
             sep = sep->next;
           }
         }
       }
       else
       {
         ResetSegSetIDLists (bssp->seq_set);
       }
     }
   }
   ResetSegSetIDLists (list->next);
 }
 
 
 static Boolean ApplyIDAndTitleEditToSeqEntryList (SeqEntryPtr list, IDAndTitleEditPtr iatep)
 {
   Int4      i;
   SeqIdPtr  new_sip;
   BioseqPtr bsp;
   
   if (list == NULL || iatep == NULL)
   {
     return FALSE;
   }
   
   if (CountSequencesAndSegments (list, iatep->nuc_only) != iatep->num_sequences)
   {
     return FALSE;
   }
   
   for (i = 0; i < iatep->num_sequences; i++)
   {
     bsp = FindNthSequenceInSet (list, i, NULL, iatep->nuc_only);
     if (bsp != NULL)
     {
       new_sip = NULL;
       if (StringChr (iatep->id_list[i], '|') != NULL) {
         new_sip = SeqIdParse (iatep->id_list[i]);
       }
       if (new_sip == NULL) {
         new_sip = MakeSeqID (iatep->id_list [i]);
       }
       ReplaceIDAndTitleForBioseq (bsp, new_sip, StringSave (iatep->title_list [i]));
     }
   }
   ResetSegSetIDLists (list);
   return TRUE;
 }
 
 /* this section of code is used to read and parse the taxlist.txt 
  * and lineages.txt files */
 static ValNodePtr orglist = NULL;
 
 typedef struct orginfo 
 {
   CharPtr taxname;
   CharPtr common;
   Int4    ngcode;
   Int4    mgcode;
   CharPtr div;
   Int4    taxnum;
   CharPtr lineage;
 } OrgInfoData, PNTR OrgInfoPtr;
 
 static FILE *OpenSequinDataFile (CharPtr filename)
 {
   Char              str [PATH_MAX];
   CharPtr           ptr;
   FILE              *f = NULL;
 
   if (StringHasNoText (filename))
   {
     return NULL;
   }
 
   ProgramPath (str, sizeof (str));
   ptr = StringRChr (str, DIRDELIMCHR);
   if (ptr == NULL)
   {
     return NULL;
   }
   
   *ptr = '\0';
   FileBuildPath (str, NULL, filename);
   f = FileOpen (str, "r");
   if (f == NULL) {
     if (GetAppParam ("NCBI", "NCBI", "DATA", "", str, sizeof (str))) {
       FileBuildPath (str, NULL, filename);
       f = FileOpen (str, "r");
     }
   }
   return f;
 }
 
 static OrgInfoPtr FindByTaxNum (Int4 taxnum)
 {
   ValNodePtr vnp;
   OrgInfoPtr oip;
   
   for (vnp = orglist; vnp != NULL; vnp = vnp->next)
   {
     oip = (OrgInfoPtr) vnp->data.ptrvalue;
     if (oip != NULL && oip->taxnum == taxnum)
     {
       return oip;
     }
   }
   return NULL;
 }
 
 static OrgInfoPtr FindByTaxName (CharPtr taxname)
 {
   ValNodePtr vnp;
   OrgInfoPtr oip;
   
   if (StringHasNoText (taxname))
   {
     return NULL;
   }
   
   for (vnp = orglist; vnp != NULL; vnp = vnp->next)
   {
     oip = (OrgInfoPtr) vnp->data.ptrvalue;
     if (oip != NULL && StringICmp (oip->taxname, taxname) == 0)
     {
       return oip;
     }
   }
   return NULL;
 }
 
 static void AddLineagesToOrganismList (void)
 {
   ReadBufferData    rbd;
   CharPtr           line;
   CharPtr           ptr;
   FILE              *f;
   OrgInfoPtr        oip;
   Int4              taxnum;
 
   /* can only add lineages to existing list */
   if (orglist == NULL) return;
 
   /* now read in lineages */
   f = OpenSequinDataFile ("lineages.txt");
 
   if (f != NULL) 
   {
     rbd.fp = f;
     rbd.current_data = NULL;
     line = AbstractReadFunction (&rbd);
     line = AbstractReadFunction (&rbd);
     while (line != NULL)
     {
       ptr = StringChr (line, '\t');
       if (ptr != NULL) 
       {
         *ptr = '\0';
         if (StrToLong (line, &taxnum)) 
         {
           oip = FindByTaxNum (taxnum);
           if (oip != NULL)
           {
             oip->lineage = StringSave (ptr + 1);
           }
         }
       }
         line = AbstractReadFunction (&rbd);
     }
     FileClose (f);
   }
 }
 
 static CharPtr GetNextToken (CharPtr PNTR pstart)
 {
   CharPtr pend;
   CharPtr newval = NULL;
   
   if (pstart == NULL || *pstart == NULL)
   {
     return NULL;
   }
   
   pend = StringChr (*pstart, '\t');
   if (pend != NULL)
   {
     *pend = 0;
   }
   newval = StringSave (*pstart);
   if (pend == NULL)
   {
     *pstart = NULL;
   }
   else
   {
     *pstart = pend + 1;
   }
   return newval;
 }
 
 static void LoadOrganismList (void)
 {
   ReadBufferData    rbd;
   CharPtr           line;
   CharPtr           p_start, numval;
   FILE              *f;
   OrgInfoPtr        oip;
 
   if (orglist != NULL) return;
   
   f = OpenSequinDataFile ("taxlist.txt");
 
   if (f != NULL) {
     rbd.fp = f;
     rbd.current_data = NULL;
     line = AbstractReadFunction (&rbd);
     line = AbstractReadFunction (&rbd);
     while (line != NULL)
     {
       oip = (OrgInfoPtr) MemNew (sizeof (OrgInfoData));
       if (oip != NULL)
       {
         p_start = line;
         /* read in tax name */
         oip->taxname = GetNextToken (&p_start);
         
         /* read in common name */
         oip->common = GetNextToken (&p_start);
          
         /* read in nuclear genetic code */
         numval = GetNextToken (&p_start);
         if (numval != NULL)
         {
           StrToLong (numval, &(oip->ngcode));
           numval = MemFree (numval);
         }
         /* read in mitochondrial genetic code */
         numval = GetNextToken (&p_start);
         if (numval != NULL)
         {
           StrToLong (numval, &(oip->mgcode));
           numval = MemFree (numval);
         }
         
         /* read in div */
         oip->div = GetNextToken (&p_start);
         
         /* read in taxnum */
         numval = GetNextToken (&p_start);
         if (numval != NULL)
         {
           StrToLong (numval, &(oip->taxnum));
           numval = MemFree (numval);
         }
                 
         ValNodeAddPointer (&orglist, 0, oip);
       }
       line = MemFree (line);
         line = AbstractReadFunction (&rbd);
     }
     FileClose (f);
   }
   AddLineagesToOrganismList ();
 }
 
 /* This section of code is used for determining genetic codes based on
  * FASTA-defline values.
  */
 #define USE_NUCLEAR_GENETIC_CODE       1
 #define USE_MITOCHONDRIAL_GENETIC_CODE 2
 #define USE_OTHER_GENETIC_CODE         3
 
 static Int4 UseGeneticCodeForLocation (CharPtr location)
 {
   if (StringHasNoText (location))
   {
     return USE_NUCLEAR_GENETIC_CODE;
   }
   else if (StringICmp (location, "Mitochondrion") == 0
            || StringICmp (location, "Kinetoplast") == 0
            || StringICmp (location, "Hydrogenosome") == 0)
   {
     return USE_MITOCHONDRIAL_GENETIC_CODE;
   }
   else if (StringICmp (location, "Chloroplast") == 0
            || StringICmp (location, "Chromoplast") == 0
            || StringICmp (location, "plastid") == 0
            || StringICmp (location, "cyanelle") == 0
            || StringICmp (location, "apicoplast") == 0
            || StringICmp (location, "leucoplast") == 0
            || StringICmp (location, "proplastid") == 0)
   {
     return USE_OTHER_GENETIC_CODE;
   }
   else
   {
     return USE_NUCLEAR_GENETIC_CODE;
   }
 }
 
 
 static Int4 GetGeneticCodeForTaxNameAndLocation (CharPtr taxname, CharPtr location)
 {
   ValNodePtr vnp;
   OrgInfoPtr oip;
   Int4       use_code;
   
   use_code = UseGeneticCodeForLocation (location);
   if (use_code == USE_OTHER_GENETIC_CODE)
   {
     return 11;
   }
   else if (StringHasNoText (taxname))
   {
     return -1;
   }
   
   for (vnp = orglist; vnp != NULL; vnp = vnp->next)
   {
     if (vnp->data.ptrvalue == NULL)
     {
       continue;
     }
     oip = (OrgInfoPtr) vnp->data.ptrvalue;
     if (StringICmp (oip->taxname, taxname) == 0)
     {
       if (use_code == USE_NUCLEAR_GENETIC_CODE)
       {
         return oip->ngcode;
       }
       else
       {
         return oip->mgcode;
       }
     }
   }
   
   return -1;
 }
 
 static CharPtr GeneticCodeStringFromIntAndList (Int4 num, ValNodePtr list)
 {
   while (list != NULL)
   {
     if (list->choice == num)
     {
       return list->data.ptrvalue;
     }
     list = list->next;
   }
   return NULL;
 }
 
 
 /* these functions deal with commonly asked questions about package types - 
  * which ones are sets, which ones are single sequences, which ones have
  * which default molecule types.
  */
 static Boolean PackageTypeIsSet (Int2 seqPackage)
 {
   if (seqPackage == SEQ_PKG_POPULATION
       || seqPackage == SEQ_PKG_PHYLOGENETIC 
       || seqPackage == SEQ_PKG_MUTATION
       || seqPackage == SEQ_PKG_ENVIRONMENT
       || seqPackage == SEQ_PKG_GENBANK)
   {
     return TRUE;
   }
   else
   {
     return FALSE;
   }
   
 }
 
 static Boolean PackageTypeIsSingle (Int2 seqPackage)
 {
   if (seqPackage == SEQ_PKG_SINGLE
       || seqPackage == SEQ_PKG_SEGMENTED
       || seqPackage == SEQ_PKG_GAPPED)
   {
     return TRUE;
   }
   else
   {
     return FALSE;
   }
 }
 
 /* These functions are used to find titles in SeqEntries */
 static void FindFirstTitle (SeqEntryPtr sep, Pointer mydata, Int4 index, Int2 indent)
 
 {
   CharPtr PNTR  ttlptr;
 
   if (mydata == NULL) return;
   ttlptr = (CharPtr PNTR) mydata;
   if (*ttlptr != NULL) return;
   *ttlptr = SeqEntryGetTitle (sep);
 }
 
 static void FindFirstSeqEntryTitle (SeqEntryPtr sep, Pointer mydata, Int4 index, Int2 indent)
 
 {
   SeqEntryPtr PNTR  sepptr;
 
   if (mydata == NULL) return;
   sepptr = (SeqEntryPtr PNTR) mydata;
   if (*sepptr != NULL) return;
   if (SeqEntryGetSeqDescr (sep, Seq_descr_title, NULL) != NULL) {
    *sepptr = sep;
   }
 }
 
 /* These functions are used to change the values of modifiers in definition lines */
 
 extern void MakeSearchStringFromAlist (CharPtr str, CharPtr name)
 
 {
   Char     ch;
   CharPtr  ptr;
 
   StringCpy (str, "[");
   StringCat (str, name);
   StringCat (str, "=");
   ptr = str;
   ch = *ptr;
   while (*ptr != '\0') {
     *ptr = TO_LOWER (ch);
     ptr++;
     ch = *ptr;
   }
 }
 
 /* This section of code is used for parsing well-formatted definition lines.
  */
 typedef struct modifieralias 
 {
   CharPtr alias;
   CharPtr modifier;
 } ModifierAlias, PNTR ModifierAliasPtr;
 
 static ModifierAlias alias_list [] =
 {
   { "org", "organism" },
   { "mol-type", "moltype" },
   { "mol_type", "moltype" },
   { "note", "note-orgmod" },
   { "comment", "note-orgmod" },
   { "common-name", "common name"},
   { "subsource", "note-subsrc" },
   { "technique", "tech" },
   { "prot", "protein" },
   { "prot_desc", "protein_desc" }
 };
 
 static Int4 num_aliases = sizeof (alias_list) / sizeof (ModifierAlias);
 
 static CharPtr protein_modifier_names [] = 
 {
   "gene",
   "gene_syn",
   "protein",
   "protein_desc",
   "note",
   "comment",
   "orf",
   "function",
   "EC_number"
 };
 
 static Int4 num_protein_modifier_names = sizeof (protein_modifier_names) / sizeof (CharPtr);
 
 static CharPtr GetCanonicalName (CharPtr mod_name)
 {
   Int4 j;
   Uint1   subtype;
   
   if (StringHasNoText (mod_name))
   {
     return StringSave ("");
   }
   
   for (j = 0; j < num_protein_modifier_names; j++) {
     if (StringsAreEquivalent (mod_name, protein_modifier_names[j])) {
       return StringSave (protein_modifier_names[j]);
     }
   }
 
   subtype = EquivalentOrgMod (mod_name);
   if (subtype != 0) {
     return StringSave (GetOrgModQualName (subtype));
   }
 
   subtype = EquivalentSubSource (mod_name);
   if (subtype != 0) {
     return StringSave (GetSubsourceQualName (subtype));
   }
  
   for (j = 0; j < num_aliases; j++)
   {
     if (StringsAreEquivalent (alias_list [j].alias, mod_name))
     {
       return StringSave (alias_list [j].modifier);
     }
   }
   return StringSave (mod_name);
 }
 
 typedef enum {
     eModifierType_SourceQual = 0,
     eModifierType_Organism,
     eModifierType_Location,
     eModifierType_Lineage,
     eModifierType_GeneticCode,
     eModifierType_GeneticCodeComment,
     eModifierType_NucGeneticCode,
     eModifierType_MitoGeneticCode,
     eModifierType_MolType,
     eModifierType_Molecule,
     eModifierType_Origin,
     eModifierType_Topology,
     eModifierType_CommonName,
     eModifierType_Technique,
     eModifierType_Protein
 } EModifierType;
 
 typedef struct modifierinfo 
 {
   CharPtr       name;
   Uint1         subtype;
   CharPtr       value;
   EModifierType modtype;
 } ModifierInfoData, PNTR ModifierInfoPtr;
 
 static ModifierInfoPtr ModifierInfoNew (void)
 {
   ModifierInfoPtr mip;
   mip = (ModifierInfoPtr) MemNew (sizeof (ModifierInfoData));
   if (mip == NULL) return NULL;
   mip->name = NULL;
   mip->value = NULL;
   mip->modtype = eModifierType_SourceQual;
   return mip;
 }
 
 static ModifierInfoPtr ModifierInfoFree (ModifierInfoPtr mip)
 {
   if (mip == NULL) return NULL;
   mip->name = MemFree (mip->name);
   mip->value = MemFree (mip->value);
   mip = MemFree (mip);
   return mip;
 }
 
 static ValNodePtr ModifierInfoListFree (ValNodePtr list)
 {
   if (list == NULL) return NULL;
   ModifierInfoListFree (list->next);
   list->next = NULL;
   list->data.ptrvalue = ModifierInfoFree (list->data.ptrvalue);
   ValNodeFree (list);
   return NULL;
 }
 
 static EModifierType GetModifierType (CharPtr mod_name)
 {
   Int4 i;
   CharPtr canonical_name;
   EModifierType returntype;
   
   canonical_name = GetCanonicalName (mod_name);
   
   if (StringHasNoText (canonical_name))
   {
     returntype = eModifierType_SourceQual;
   }
   else if (StringICmp (canonical_name, "organism") == 0
            || StringICmp (canonical_name, "org") == 0)
   {
         returntype = eModifierType_Organism;
   }
   else if (StringICmp (canonical_name, "location") == 0)
   {
     returntype = eModifierType_Location;
   }
   else if (StringICmp (canonical_name, "lineage") == 0)
   {
     returntype = eModifierType_Lineage;
   }
   else if (StringICmp (canonical_name, "gcode") == 0)
   {
     returntype = eModifierType_NucGeneticCode;
   }
   else if (StringICmp (canonical_name, "mgcode") == 0)
   {
     returntype = eModifierType_MitoGeneticCode;
   }
   else if (StringICmp (canonical_name, "genetic_code") == 0)
   {
     returntype = eModifierType_GeneticCode;
   }
   else if (StringICmp (canonical_name, "gencode_comment") == 0)
   {
     returntype = eModifierType_GeneticCodeComment;
   }
   else if (StringICmp (canonical_name, "moltype") == 0)
   {
     returntype = eModifierType_MolType;
   }
   else if (StringICmp (canonical_name, "molecule") == 0)
   {
     returntype = eModifierType_Molecule;
   }
   else if (StringICmp (canonical_name, "origin") == 0)
   {
     returntype = eModifierType_Origin;
   }
   else if (StringICmp (canonical_name, "topology") == 0)
   {
     returntype = eModifierType_Topology;
   }
   else if (StringICmp (canonical_name, "common name") == 0)
   {
     returntype = eModifierType_CommonName;
   }
   else if (StringICmp (canonical_name, "tech") == 0)
   {
     returntype = eModifierType_Technique;
   }
   else
   {
     for (i = 0; i < num_protein_modifier_names; i++)
     {
       if (StringICmp (canonical_name, protein_modifier_names[i]) == 0)
       {
         returntype = eModifierType_Protein;
         canonical_name = MemFree (canonical_name);
         return returntype;
       }
     }
     returntype = eModifierType_SourceQual;   
   }
   
   canonical_name = MemFree (canonical_name);
   return returntype;
 }
 
 static Boolean AllowMultipleValues (CharPtr mod_name)
 {
   EModifierType mod_type;
   Boolean       rval = FALSE;
   
   mod_type = GetModifierType (mod_name);
   switch (mod_type)
   {
     case eModifierType_SourceQual:
       if (! IsNonTextModifier (mod_name))
       {
         rval = TRUE;
       }
       break;
     case eModifierType_CommonName:
       rval = TRUE;
       break;
     case eModifierType_Organism:
       rval = TRUE;
       break;
     default:
       rval = FALSE;
       break;
   }
   return rval;
 }
 
 typedef enum 
 {
   BRACKET_ERR_NO_ERR = 0,
   BRACKET_ERR_MISMATCHED_BRACKETS,
   BRACKET_ERR_MISSING_EQUALS,
   BRACKET_ERR_MULT_EQUALS,
   BRACKET_ERR_NO_MOD_NAME,
   BRACKET_ERR_MISMATCHED_QUOTES
 } bracketing_err_num;
 
 static Char ExpectToken (CharPtr cp)
 {
   CharPtr valstart;
   
   if (cp == NULL)
   {
     return 0;
   }
   else if (*cp == '[')
   {
     valstart = cp + 1 + StringSpn (cp + 1, " \t");
     if (StringLen (valstart) > 3 
         && (StringNICmp (valstart, "dna", 3) == 0 
             || StringNICmp (valstart, "rna", 3) == 0
             || StringNICmp (valstart, "orf", 3) == 0)
         && *(valstart + 3 + StringSpn (valstart + 3, " \t")) == ']')
     {
       return ']';    
     }
     else
     {
       return '=';
     }
   }
   else if (*cp == '=')
   {
     return ']';
   }
   else if (*cp == ']')
   {
     return '[';
   }
   else
   {
     return 0;
   }
 }
 
 /* When we are looking for double-quotation marks to use for delimiting
  * sections of a title that should not be parsed or values that may contain
  * brackets, equals signs, or other reserved characters, skip over
  * quotation marks that are preceded by the escape character (backslash).
  * This allows quotation marks to be included in a quoted string.
  */
 static CharPtr NextUnescapedQuote (CharPtr str)
 {
   CharPtr cp;
   
   if (StringHasNoText (str))
   {
     return NULL;
   }
   cp = StringChr (str, '"');
   if (cp != NULL && cp != str)
   {
     while (cp != NULL && *(cp - 1) == '\\')
     {
       cp = StringChr (cp + 1, '"');
     }
   }
   return cp;  
 }
 
 /* This function steps backward from str_end until it has located 
  * an unescaped double-quotation mark or it has reached the 
  * start of the string (str_start).
  */
 static CharPtr FindPreviousUnescapedQuote (CharPtr str_start, CharPtr str_end)
 {
   CharPtr cp;
   if (str_start == NULL || str_end == NULL || str_end < str_start)
   {
     return NULL;
   }
   
   cp = str_end;
   while (cp > str_start && (*cp != '"' || *(cp - 1) == '\\'))
   {
     cp--;
   }
   if (*cp != '"')
   {
     cp = NULL;
   }
   return cp;
 }
 
 
 /* This function finds the next bracketing token ([, =, or ]) in
  * the string that is not enclosed by unescaped quotation marks.
  */
 static CharPtr NextBracketToken (CharPtr str)
 {
   CharPtr next_quote;
   CharPtr cp;
   
   if (StringHasNoText (str))
   {
     return NULL;
   }
   
   cp = str;
   while (*cp != 0)
   {
     switch (*cp)
     {
       case '"':
         if (cp == str || (*(cp - 1) != '\\'))
         {
           next_quote = NextUnescapedQuote (cp + 1);
           if (next_quote == NULL)
           {
             return cp;
           }
           else
           {
             cp = next_quote + 1;;
           }
         }
         else
         {
           cp++;
         }
         break;
       case '[':
       case ']':
       case '=':
         return cp;
       default:
         cp++;
     }
   }
     
   return NULL;
 }
 
 static Int4 DetectBadBracketing (CharPtr str)
 {
   CharPtr cp;
   Char    expected_token;
   CharPtr last_token = NULL, namestart;
   
   if (StringHasNoText (str))
   {
     return BRACKET_ERR_NO_ERR;
   }
   
   expected_token = '[';
   cp = NextBracketToken (str);
   while (cp != NULL)
   {
     switch (*cp)
     {
       case '"':
         return BRACKET_ERR_MISMATCHED_QUOTES;
         break;
       case '[':
       case ']':
       case '=':
         if (expected_token == *cp)
         {
           if (expected_token == '=' && last_token != NULL)
           {
             namestart = last_token + 1 + StringSpn (last_token + 1, " \t");
             if (namestart == cp)
             {
               return BRACKET_ERR_NO_MOD_NAME;
             }
           }
           expected_token = ExpectToken (cp);
           last_token = cp;
         }
         else if (expected_token == '=')
         {
           if (cp - last_token - 1 == StringSpn (last_token + 1, " \t"))
           {
             return BRACKET_ERR_MISMATCHED_BRACKETS;
           }
           else
           {
             return BRACKET_ERR_MISSING_EQUALS;
           }
         }
         else if (*cp == '=')
         {
           if (expected_token == ']')
           {
             return BRACKET_ERR_MULT_EQUALS;
           }
           else
           {
             return BRACKET_ERR_MISMATCHED_BRACKETS;
           }
         }
         else
         {
           return BRACKET_ERR_MISMATCHED_BRACKETS;
         }
         break;
     }
     cp = NextBracketToken (cp + 1);
   }
   
   if (cp == NULL && expected_token != '[')
   {
     return BRACKET_ERR_MISMATCHED_BRACKETS;
   }
   
   return BRACKET_ERR_NO_ERR;
 }
 
 static ModifierInfoPtr 
 ParseOneBracketedModifier 
 (CharPtr      str, 
  CharPtr PNTR bracket_start,
  CharPtr PNTR bracket_stop)
 {
   CharPtr         start, stop, eq_loc;
   ModifierInfoPtr mip;
   Int4            value_len, name_len;
   CharPtr         canonical_name;
   
   start = NextBracketToken (str);
   while (start != NULL && *start != '[')
   {
     start = NextBracketToken (start + 1);
   }
   if (start == NULL) return NULL;
   eq_loc = NextBracketToken (start + 1);
   if (eq_loc == NULL) return NULL;
   if (*eq_loc == ']')
   {
     stop = eq_loc;
   }
   else if (*eq_loc == '=')
   {
     stop = NextBracketToken (eq_loc + 1);
   }
   else
   {
     return NULL;
   }
   
   if (stop == NULL || *stop != ']') return NULL;
       
   mip = ModifierInfoNew();
   if (mip == NULL) return NULL;
   
   /* copy in modifier name */
   name_len = eq_loc - start + 1;
   mip->name = (CharPtr) MemNew (name_len * sizeof (Char));
   if (mip->name == NULL)
   {
     mip = ModifierInfoFree (mip);
     return NULL;
   }
   StringNCpy (mip->name, start + 1, name_len - 2);
   mip->name [name_len - 1] = 0;
   TrimSpacesAroundString (mip->name);
   canonical_name = GetCanonicalName (mip->name);
   mip->name = MemFree (mip->name);
   mip->name = canonical_name;
   if (StringICmp (mip->name, "note") == 0)
   {
     mip->name = MemFree (mip->name);
     mip->name = StringSave ("Note-SubSrc");
   }
 
   /* [orf], [rna], and [dna] don't have values */  
   if (stop > eq_loc)
   {
     value_len = stop - eq_loc + 1;
     mip->value = (CharPtr) MemNew (value_len * sizeof (Char));
     if (mip->value == NULL)
     {
       mip = ModifierInfoFree (mip);
       return NULL;
     }
   
     StringNCpy (mip->value, eq_loc + 1, value_len - 2);
     mip->value [value_len - 1] = 0;
     TrimSpacesAroundString (mip->value);
   }
   
   mip->modtype = GetModifierType (mip->name);
   if (mip->modtype == eModifierType_SourceQual)
   {
     mip->subtype = FindTypeForModNameText (mip->name);
   }
   else
   {
     mip->subtype = 0;
   }
   
   if (bracket_start != NULL)
   {
     *bracket_start = start;
   }
   
   if (bracket_stop != NULL)
   {
     *bracket_stop = stop;
   }
   
   return mip;
 }
 
 static ValNodePtr ParseAllBracketedModifiers (CharPtr str)
 {
   CharPtr         stop, cp;
   ValNodePtr      list = NULL;
   ModifierInfoPtr mip;
   
   cp = str;
   mip = ParseOneBracketedModifier (cp, NULL, &stop);
   while (mip != NULL && stop != NULL)
   {
     ValNodeAddPointer (&list, 0, mip);
     cp = stop + 1;
     mip = ParseOneBracketedModifier (cp, NULL, &stop);  
   }
   return list;
 }
 
 static Boolean IsValueInEnumAssoc (CharPtr value, EnumFieldAssocPtr eap)
 {
   while (eap != NULL && eap->name != NULL) 
   {
     if (StringICmp (eap->name, value) == 0)
     {
       return TRUE;
     }
     eap++;
   }
   return FALSE;
 }
 
 static Int4 GeneticCodeFromStringAndList (CharPtr str, ValNodePtr list)
 {
   while (list != NULL)
   {
     if (StringICmp (str, list->data.ptrvalue) == 0)
     {
       return list->choice;
     }
     list = list->next;
   }
   return 0;
 }
 
 static Int4 GeneticCodeFromString (CharPtr str)
 {
   ValNodePtr gencodelist;
   Int4       gcode = 0;
   
   if (StringHasNoText (str))
   {
     gcode = 0;
   }
   else if (isdigit (str[0]))
   {
     gcode = atoi (str);
   }
   else
   {
     gencodelist = GetGeneticCodeValNodeList ();
     gcode = GeneticCodeFromStringAndList (str, gencodelist);
     gencodelist = ValNodeFreeData (gencodelist);
   }
   return gcode;
 }
 
 static Int4 MolTypeFromString (CharPtr str)
 {
   EnumFieldAssocPtr  eap;
 
   if (StringICmp (str, "dna") == 0)
   {
     return 253;
   }
   else if (StringICmp (str, "rna") == 0)
   {
     return 254;
   }
   else if (StringICmp (str, "genomic") == 0)
   {
     return 253;
   }
   for (eap = biomol_nucGen_alist; eap != NULL && eap->name != NULL; eap++)
   {
     if (StringsAreEquivalent (eap->name, str))
     {
       return eap->value;
     }
   }
   for (eap = biomol_nucX_alist; eap != NULL && eap->name != NULL; eap++)
   {
     if (StringsAreEquivalent (eap->name, str))
     {
       return eap->value;
     }
     else if (eap->name [0] == 'm'
              && StringICmp (eap->name, "mRNA [cDNA]") == 0
              && StringICmp (str, "mRNA") == 0)
     {
       return eap->value;
     }
   }
   return 0;
 }
 
 
 /* This function looks at a parsed modifier structure to determine whether the
  * value is acceptable for this modifier type.
  */
 static Boolean ModifierHasInvalidValue (ModifierInfoPtr mip)
 {
   Boolean rval = FALSE;
   
   if (mip != NULL
       && ((mip->modtype == eModifierType_Location
                   && !IsValueInEnumAssoc (mip->value, biosource_genome_simple_alist))
             || (mip->modtype == eModifierType_Origin
                   && !IsValueInEnumAssoc (mip->value, biosource_origin_alist))      
             || (mip->modtype == eModifierType_Topology
                   && !IsValueInEnumAssoc (mip->value, topology_nuc_alist))
             || (mip->modtype == eModifierType_Molecule
                   && !IsValueInEnumAssoc (mip->value, molecule_alist))
             || ((mip->modtype == eModifierType_GeneticCode
                       || mip->modtype == eModifierType_NucGeneticCode
                       || mip->modtype == eModifierType_MitoGeneticCode)
                      && GeneticCodeFromString (mip->value) == 0)
             || (mip->modtype == eModifierType_MolType
                      && MolTypeFromString (mip->value) == 0)
             || (mip->modtype == eModifierType_SourceQual
                      && IsNonTextModifier (mip->name)
                      && !StringHasNoText (mip->value)
                  && StringICmp (mip->value, "TRUE") != 0
                  && StringICmp (mip->value, "FALSE") != 0)))
   {
     rval = TRUE;
   }
 
   return rval;
 }
 
 /* This section contains functions for finding, changing, and removing 
  * bracketed value pairs in definition lines.
  * These functions include:
  *
  * FindValuePairInDefLine - returns pointer to position in title where 
  *                          the first bracketed pair with the specified 
  *                          modifier name (or one of its aliases) occurs.
  *                          Useful for non-text modifiers, which do not
  *                          have values.
  *
  * FindValueFromPairInDefline - returns value from the first bracketed
  *                              pair in the title with the specified
  *                              modifier name (or one of its aliases).
  *
  * RemoveValueFromDefline - removes the first bracketed pair in the title
  *                          with the specified modifier name (or one of its aliases)
  *
  * ReplaceValueInThisValuePair - replaces the value in the specified value pair.
  *                               if new value is empty, pair is removed.
  *
  * ReplaceValueInOneDefLine - finds the first bracketed pair in the title
  *                            with the specified modifier name (or one of its aliases).
  *                            If a pair is found, the value in that pair is replaced
  *                            with the new value; otherwise a new pair is added to
  *                            the title.  
  *
  * ReplaceOneModifierValue - finds all bracketed pairs in a title with the specified
  *                           modifier name or one of its aliases and the specified value
  *                           and replaces that value with the new value (or removes the
  *                           pair, if the new value is empty.
  *
  * RemoveAllDuplicatePairsFromOneTitle - removes all bracketed pairs that are duplicates
  *                                       in name and value of another pair already in
  *                                       the title.
  *
  * RemoveMeaninglessEmptyPairsFromOneTitle - removes bracketed pairs without values
  *                                           that are not non-text modifiers
  *
  * StripAllInstancesOfModNameFromTitle - removes all mentions of specified modifier
  *                                       name from title
  *
  */
 
 static CharPtr FindValuePairInDefLine (CharPtr mod_name, CharPtr def_line, CharPtr PNTR valstop)
 {
   CharPtr         cp, start, stop;
   ModifierInfoPtr mip;
   CharPtr         canonical_name;
   
   if (mod_name == NULL || def_line == NULL)
   {
     return NULL;
   }
   
   cp = NextBracketToken (def_line);
   if (cp == NULL)
   {
     return NULL;
   }
   
   canonical_name = GetCanonicalName (mod_name);
   
   mip = ParseOneBracketedModifier (cp, &start, &stop);
   while (mip != NULL && start != NULL && stop != NULL 
          && StringICmp (mip->name, canonical_name) != 0)
   {
     cp = NextBracketToken (stop + 1);
     mip = ModifierInfoFree (mip);
     mip = ParseOneBracketedModifier (cp, &start, &stop);
   }
   
   if (mip != NULL && StringICmp (mip->name, canonical_name) == 0)
   {
     mip = ModifierInfoFree (mip);
     if (valstop != NULL)
     {
       *valstop = stop;
     }
     canonical_name = MemFree (canonical_name);
     return start;
   }
   else
   {
     mip = ModifierInfoFree (mip);
     canonical_name = MemFree (canonical_name);
     return NULL;
   }
 }
 
 static CharPtr FindNthValuePairInDefLine (CharPtr title, CharPtr val_name, Int4 val_num, CharPtr PNTR p_val_end)
 {
   CharPtr val_loc, val_end = NULL;
   Int4    title_val_num;
   
   if (StringHasNoText (val_name))
   {
     return NULL;
   }
   
   val_loc = FindValuePairInDefLine (val_name, title, &val_end);
   title_val_num = 0;
   while (val_loc != NULL && val_end != NULL && title_val_num != val_num)
   {
     val_loc = FindValuePairInDefLine (val_name, val_end + 1, &val_end);
     title_val_num++;
   }
   if (p_val_end != NULL)
   {
     *p_val_end = val_end;
   }
   return val_loc;
 }
 
 static CharPtr FindValueFromPairInDefline (CharPtr mod_name, CharPtr def_line)
 {
   CharPtr bracket_start, eq_loc, bracket_end;
   CharPtr new_val = NULL;
   Int4 new_val_len;
   
   bracket_start = FindValuePairInDefLine (mod_name, def_line, &bracket_end);
   if (bracket_start == NULL || bracket_end == NULL)
   {
     return NULL;
   }
   
   eq_loc = NextBracketToken (bracket_start + 1);
   if (eq_loc == NULL || *eq_loc != '=')
   {
     return NULL;
   }
     
   new_val_len = bracket_end - eq_loc;
   new_val = (CharPtr) MemNew (new_val_len * sizeof (Char));
   if (new_val != NULL)
   {
     StringNCpy (new_val, eq_loc + 1, new_val_len - 1);
     new_val [new_val_len - 1] = 0;
   }
   TrimSpacesAroundString (new_val);
   return new_val;
 }
 
 static CharPtr FindValueFromPairInDeflineBeforeCharPtr (CharPtr mod_name, CharPtr def_line, CharPtr cp)
 {
   CharPtr bracket_start, bracket_end;
   
   bracket_start = FindValuePairInDefLine (mod_name, def_line, &bracket_end);
   if (bracket_start == NULL || (cp != NULL && bracket_start > cp))
   {
     return NULL;
   }
   else
   {
     return FindValueFromPairInDefline (mod_name, bracket_start);
   }
 }
 
 static void RemoveValuePairFromDefline (CharPtr pair_start, CharPtr pair_end, CharPtr defline)
 {
   CharPtr src, dst;
 
   if (pair_start == NULL || pair_end == NULL || defline == NULL
       || pair_end <= pair_start)
   {
     return;
   }
   
   dst = pair_start;
   src = pair_end;
   while (isspace (*src))
   {
     src++;
   }
   
   while (*src != 0)
   {
     *dst = *src;
     dst++;
     src++;
   }
   *dst = 0;
 }
 
 static void RemoveValueFromDefline (CharPtr mod_name, CharPtr def_line)
 {
   CharPtr bracket_start, bracket_end;
   
   bracket_start = FindValuePairInDefLine (mod_name, def_line, &bracket_end);
   if (bracket_start == NULL || bracket_end == NULL)
   {
     return;
   }
   
   RemoveValuePairFromDefline (bracket_start, bracket_end + 1, def_line);
 }
 
 static CharPtr AddQuotesToValueWithBrackets (CharPtr orig_value)
 {
   CharPtr first_bracket, first_quote;
   CharPtr cp, new_value = NULL, tmp_value;
   Char    bracket_buf [2];
   Int4    offset;
   
   if (orig_value == NULL)
   {
     return NULL;
   }
   else if (StringHasNoText (orig_value))
   {
     return StringSave (orig_value);
   }
   
   new_value = StringSave (orig_value);
   
   first_bracket = StringChr (new_value, '[');
   if (first_bracket == NULL)
   {
     first_bracket = StringChr (new_value, ']');
   }
   
   first_quote = NextUnescapedQuote (new_value);
   
   if (first_bracket == NULL && first_quote == NULL)
   {
     return new_value;
   }
   else if (first_bracket != NULL && first_quote == NULL)
   {
     tmp_value = (CharPtr) MemNew ((StringLen (new_value) + 3) * sizeof (Char));
     if (tmp_value == NULL)
     {
       new_value = MemFree (new_value);
       return NULL;
     }
     StringCat (tmp_value, "\"");
     StringCat (tmp_value, new_value);
     StringCat (tmp_value, "\"");
     new_value = MemFree (new_value);
     new_value = tmp_value;
     return new_value;
   }
   
   cp = orig_value;
   
   bracket_buf [0] = 0;
   bracket_buf [1] = 0;
   
   while (*cp != 0)
   {
     if (*cp == '"' && (cp == orig_value || *(cp - 1) != '\\'))
     {
       cp = NextUnescapedQuote (cp + 1);
       if (cp == NULL)
       {
         tmp_value = (CharPtr) MemNew ((StringLen (new_value) + 3) * sizeof (Char));
         if (tmp_value == NULL)
         {
           new_value = MemFree (new_value);
           return NULL;
         }
         StringCpy (tmp_value, new_value);
         if (new_value [StringLen (new_value) - 1] == '\\')
         {
           StringCat (tmp_value, " ");
         }
         StringCat (tmp_value, "\"");
         return tmp_value;
       }
       else
       {
         cp++;
       }
     }
     else if (*cp == '[' || *cp == ']')
     {
       tmp_value = (CharPtr) MemNew ((StringLen (new_value) + 3) * sizeof (Char));
       if (tmp_value == NULL)
       {
         new_value = MemFree (new_value);
         return new_value;
       }
       offset = cp - new_value;
       StringNCpy (tmp_value, new_value, offset);
       StringCat (tmp_value, "\"");
       bracket_buf [0] = *cp;
       StringCat (tmp_value, bracket_buf);
       StringCat (tmp_value, "\"");
       StringCat (tmp_value, cp + 1);
       new_value = MemFree (new_value);
       new_value = tmp_value;
       cp = new_value + offset + 3;      
     }
     else
     {
       cp++;
     }
   }
   
   return new_value;
 }
 
 static CharPtr
 ReplaceValueInThisValuePair 
 (CharPtr orig_defline,
  CharPtr value_loc, 
  CharPtr value_name,
  CharPtr end_loc, 
  CharPtr new_value)
 {
   CharPtr new_title;
   Int4    new_title_len = 0;
   Boolean is_nontext;
   CharPtr tmp_name;
   CharPtr fixed_value;
 
   if (StringHasNoText (orig_defline) || value_loc == NULL || end_loc == NULL
       || *value_loc != '[' || *end_loc != ']')
   {
     return orig_defline;
   }
 
   fixed_value = AddQuotesToValueWithBrackets (new_value);
   
   if (StringHasNoText (fixed_value))
   {
     RemoveValuePairFromDefline (value_loc, end_loc, orig_defline);
   }
   else
   {
     /* keep part before pair and after pair, insert new value in position */
     new_title_len = StringLen (orig_defline)
                                + StringLen (value_name)
                                + StringLen (fixed_value)
                                + 5;
     new_title = MemNew (new_title_len * sizeof (Char));
     if (new_title != NULL)
     {
       if (value_loc > orig_defline)
       {
         StringNCpy (new_title, orig_defline, value_loc - orig_defline);
       }
       StringCat (new_title, "[");
       tmp_name = StringSave (value_name);
       tmp_name [0] = TO_LOWER (tmp_name [0]);
       StringCat (new_title, tmp_name);
       is_nontext = IsNonTextModifier (tmp_name);
       tmp_name = MemFree (tmp_name);
       StringCat (new_title, "=");
       if (!is_nontext)
       {
         StringCat (new_title, fixed_value);
       }
       StringCat (new_title, "]");
       if (end_loc != NULL && *end_loc != 0)
       {
         if (*end_loc == ']')
         {
           StringCat (new_title, end_loc + 1);
         }
         else
         {
           StringCat (new_title, end_loc);
         }
       }
       orig_defline = MemFree (orig_defline);
       orig_defline = new_title;
     }
   }  
   TrimSpacesAroundString (orig_defline);
   
   fixed_value = MemFree (fixed_value);
   
   return orig_defline;
 }
 
 static CharPtr InsertStringAtOffset (CharPtr old_string, CharPtr new_string, Int4 offset)
 {
   Int4    new_len;
   CharPtr new_str = NULL;
   
   if (old_string == NULL)
   {
     new_str = StringSave (new_string);
   }
   else if (new_string == NULL)
   {
     new_str =  StringSave (old_string);
   }
   else
   {
     new_len = StringLen (old_string) + StringLen (new_string) + 1;
     new_str = (CharPtr) MemNew (new_len * sizeof (Char));
     if (new_str != NULL)
     {
       StringNCpy (new_str, old_string, offset);
       StringCat (new_str, new_string);
       if ((Uint4)offset < StringLen (old_string))
       {
         StringCat (new_str, old_string + offset);
       }
     }
   }
   return new_str;
 }
 
 static CharPtr 
 InsertValuePairAtOffset 
 (CharPtr orig_defline, 
  CharPtr value_name, 
  CharPtr value_str,
  Int4    offset)
 {
   CharPtr pair_string, fixed_value;
   
   if (StringHasNoText (value_name) || offset < 0)
   {
     return orig_defline;
   }
   
   fixed_value = AddQuotesToValueWithBrackets (value_str);
   
   pair_string = (CharPtr) MemNew ((StringLen (value_name) + StringLen (fixed_value) + 6) * sizeof (Char));
   if (pair_string != NULL)
   {
     if (IsNonTextModifier (value_name))
     {
       sprintf (pair_string, "[%s=]", value_name);
     }
     else
     {
       sprintf (pair_string, "[%s=%s]", value_name, fixed_value);
     }
     orig_defline = InsertStringAtOffset (orig_defline, pair_string, offset);
     pair_string = MemFree (pair_string);
   }
   fixed_value = MemFree (fixed_value);
   return orig_defline;
 }
 
 
 static CharPtr
 ReplaceValueInOneDefLineForOrganism
 (CharPtr orig_defline,
  CharPtr value_name, 
  CharPtr new_value,
  CharPtr organism)
 { 
   CharPtr value_loc = NULL, end_loc = NULL;
   CharPtr fixed_value;
   CharPtr next_org_loc = NULL, org_stop = NULL, first_org_stop = NULL;
   CharPtr first_organism;
   
   if (StringHasNoText (value_name))
   {
     return orig_defline;
   }
   
   /* if we want to add a value to a specific organism, we need to make sure
    * that we insert or replace a value after that organism name but before
    * the next organism name.
    */
    
   if (organism != NULL)
   {
     if (organism < orig_defline || organism - orig_defline > (Int4) StringLen (orig_defline))
     {
       organism = NULL;
     }
   }
   
   if (organism != NULL)
   {
     if (organism != FindValuePairInDefLine ("organism", organism, &org_stop))
     {
       return orig_defline;
     }
   }
   
   first_organism = FindValuePairInDefLine ("organism", orig_defline, &first_org_stop);
 
   
   if (organism == NULL)
   {
     organism = first_organism;
     org_stop = first_org_stop;
   }
   
   if (org_stop != NULL)
   {
     next_org_loc = FindValuePairInDefLine ("organism", org_stop + 1, NULL);
   }
   
   fixed_value = AddQuotesToValueWithBrackets (new_value);
   
   /* if this is the first organism, or if we have no organism, start looking for
    * a value to replace at the beginning of the line.
    */
   if (organism == NULL || organism == first_organism)
   {
     value_loc = FindValuePairInDefLine (value_name, orig_defline, &end_loc);
   }
   else
   {     
     value_loc = FindValuePairInDefLine (value_name, organism, &end_loc);
   }
   
   if (next_org_loc != NULL && value_loc > next_org_loc)
   {
     value_loc = NULL;
   }
   
   if (StringHasNoText (fixed_value))
   {
     if (value_loc == NULL)
     {
       /* old line had no value, no new value provided, no change */
     }
     else
     {
       RemoveValuePairFromDefline (value_loc, end_loc, orig_defline);
     }
   }
   else
   {
     if (value_loc == NULL)
     {
       /* add new value just before next organism */
       if (next_org_loc == NULL)
       {
         orig_defline = InsertValuePairAtOffset (orig_defline, value_name, new_value,
                                                 StringLen (orig_defline));
       }
       else
       {
         orig_defline = InsertValuePairAtOffset (orig_defline, value_name, new_value,
                                                 next_org_loc - orig_defline);
       }
     }
     else
     {
       /* replace this value */
       orig_defline = ReplaceValueInThisValuePair (orig_defline, value_loc, value_name,
                                                   end_loc, new_value);
     }
   }  
   TrimSpacesAroundString (orig_defline);
   
   fixed_value = MemFree (fixed_value);
   
   return orig_defline;
 }
 
 static CharPtr 
 ReplaceValueInOneDefLine 
 (CharPtr orig_defline,
  CharPtr value_name, 
  CharPtr new_value)
 {
   CharPtr value_loc = NULL, end_loc = NULL;
   
   if (StringHasNoText (value_name))
   {
     return orig_defline;
   }
   
   value_loc = FindValuePairInDefLine (value_name, orig_defline, &end_loc);
 
   if (value_loc == NULL)
   {
     if (StringHasNoText (new_value))
     {
       /* old line had no value, no new value provided, no change */    
       return orig_defline;
     }
     else
     {
       /* make sure value is added for first organism */
       orig_defline = ReplaceValueInOneDefLineForOrganism (orig_defline, value_name,
                                                           new_value, NULL);        
     }
   }
   else
   {
     orig_defline = ReplaceValueInThisValuePair (orig_defline, value_loc, value_name, end_loc, new_value);
   }  
   
   return orig_defline;
 }
 
 static CharPtr 
 ReplaceOneModifierValue 
 (CharPtr title,
  CharPtr orig_name, 
  CharPtr orig_value,
  CharPtr repl_value,
  Boolean is_nontext,
  Boolean copy_to_note)
 {
   CharPtr bracket_loc, eq_loc, end_bracket_loc, new_title;
   Int4    new_title_len;
   CharPtr orig_note, new_note;
   Boolean any_replaced = FALSE;
   
   if (StringHasNoText (title)
       || StringHasNoText (orig_name))
   {
     return title;
   }
   
   bracket_loc = FindValuePairInDefLine (orig_name, title, &end_bracket_loc);
   while (bracket_loc != NULL && end_bracket_loc != NULL)
   {  
     eq_loc = NextBracketToken (bracket_loc + 1);
     if (eq_loc == NULL || *eq_loc != '=')
     {
       return title;
     }
     if ((StringNCmp (orig_value, eq_loc + 1, StringLen (orig_value)) == 0
         && StringLen (orig_value) == end_bracket_loc - eq_loc - 1)
         || (StringHasNoText (orig_value) 
             && StringSpn (eq_loc + 1, " \t") == end_bracket_loc - eq_loc - 1))
     {
       new_title_len = StringLen (title) + StringLen (repl_value) - StringLen (orig_value) + 1;
       new_title = (CharPtr) MemNew (new_title_len * sizeof (Char));
       if (new_title == NULL)
       {
         return title;
       }
       if (is_nontext)
       {
         if (StringHasNoText (repl_value))
         {
           StringNCpy (new_title, title, bracket_loc - title);
           StringCat (new_title, end_bracket_loc + 1 + StringSpn (end_bracket_loc, " "));
         }
         else
         {
           StringNCpy (new_title, title, eq_loc - title + 1);
           StringCat (new_title, end_bracket_loc);
         }
       }
       else if (StringHasNoText (repl_value))
       {
         /* remove pair completely */
         StringNCpy (new_title, title, bracket_loc - title);
         StringCat (new_title, end_bracket_loc + 1);
       }
       else
       {
         StringNCpy (new_title, title, eq_loc - title + 1);
         StringCat (new_title, repl_value);
         StringCat (new_title, end_bracket_loc);        
       }
 
       title = MemFree (title);
       title = new_title;
       any_replaced = TRUE;
       bracket_loc = FindValuePairInDefLine (orig_name, title, &end_bracket_loc);
     }
     else
     {
       bracket_loc = FindValuePairInDefLine (orig_name, end_bracket_loc, &end_bracket_loc);
     }
   }
   
   if (any_replaced && copy_to_note && !StringHasNoText (repl_value) && !StringHasNoText (orig_value))
   {
     orig_note = FindValueFromPairInDefline ("note", title);
     if (StringHasNoText (orig_note))
     {
       new_note = (CharPtr) MemNew ((StringLen (orig_name) 
                                     + StringLen (orig_value) + 8) * sizeof (Char));
       if (new_note != NULL)
       {
         sprintf (new_note, "%s was %s", orig_name, orig_value);
       }
     }
     else
     {
       new_note = (CharPtr) MemNew ((StringLen (orig_note)
                                     + StringLen (orig_name) 
                                     + StringLen (orig_value) + 8) * sizeof (Char));
       if (new_note != NULL)
       {
         sprintf (new_note, "%s; %s was %s", orig_note, orig_name, orig_value);
       }
     }
 
     if (new_note != NULL)
     {
       title = ReplaceValueInOneDefLine (title, "note", new_note); 
     }
     
     orig_note = MemFree (orig_note);
     new_note = MemFree (new_note);
   }
   
   return title;
 }
 
 static Boolean IsUnrecognizedModifierName (ModifierInfoPtr mip, Boolean is_nuc);
 
 static void RemoveRecognizedModifiersFromTitle (CharPtr title, ValNodePtr modifier_info_list, Boolean is_nuc)
 {
   ValNodePtr      vnp;
   ModifierInfoPtr mip;
 
   for (vnp = modifier_info_list; vnp != NULL; vnp = vnp->next) {
     mip = (ModifierInfoPtr) vnp->data.ptrvalue;
     if (mip != NULL && ! IsUnrecognizedModifierName (mip, is_nuc)
         && (!is_nuc || mip->modtype != eModifierType_Protein)) {
       RemoveValueFromDefline (mip->name, title);
     }
   }
 }
 
 static void StripAllInstancesOfModNameFromTitle (CharPtr mod_name, CharPtr title)
 {
   CharPtr         valstr;
 
   valstr = FindValueFromPairInDefline (mod_name, title);
   while (valstr != NULL)
   {
     RemoveValueFromDefline (mod_name, title);
     valstr = MemFree (valstr);
     valstr = FindValueFromPairInDefline (mod_name, title);
   }     
 }
 
 static CharPtr RemoveAllDuplicatePairsFromOneTitle (CharPtr title)
 {
   CharPtr         start_bracket, end_bracket, tmp_title, new_title;
   ModifierInfoPtr mip;
   Int4            offset;
 
   mip = ParseOneBracketedModifier (title, &start_bracket, &end_bracket);
   while (mip != NULL && start_bracket != NULL && end_bracket != NULL)
   {
     offset = end_bracket - title + 1;
     tmp_title = StringSave (title + offset);
     tmp_title = ReplaceOneModifierValue (tmp_title, mip->name, mip->value, NULL,
                                      IsNonTextModifier (mip->name), FALSE);
     new_title = (CharPtr) MemNew ((StringLen (tmp_title) + offset + 1)* sizeof (Char));
     if (new_title != NULL)
     {
       StringNCpy (new_title, title, offset);
       StringCat (new_title, tmp_title);
     }
     tmp_title = MemFree (tmp_title);
     title = MemFree (title);
     title = new_title;
     mip = ModifierInfoFree (mip);
     mip = ParseOneBracketedModifier (title + offset, &start_bracket, &end_bracket);
   }
   mip = ModifierInfoFree (mip);
   return title;
 }
 
 static void ShiftString (CharPtr str, Int4 shift_size)
 {
   CharPtr src, dst;
   
   if (str == NULL)
   {
     return;
   }
   
   if (shift_size > (Int4) StringLen (str))
   {
     *str = 0;
   }
   else
   {
     src = str + shift_size;
     dst = str;
     while (*src != 0)
     {
       *dst = *src;
       dst++;
       src++;
     }
     *dst = 0;
   }  
 }
 
 static void RemoveMeaninglessEmptyPairsFromOneTitle (CharPtr title)
 {
   CharPtr         start_bracket, end_bracket;
   ModifierInfoPtr mip;
 
   mip = ParseOneBracketedModifier (title, &start_bracket, &end_bracket);
   while (mip != NULL && start_bracket != NULL && end_bracket != NULL)
   {
     if (StringHasNoText (mip->value) && ! IsNonTextModifier (mip->name))
     {
       ShiftString (start_bracket, end_bracket - start_bracket + 1);
       mip = ModifierInfoFree (mip);
       mip = ParseOneBracketedModifier (start_bracket, &start_bracket, &end_bracket);
     }
     else
     {
       mip = ModifierInfoFree (mip);
       mip = ParseOneBracketedModifier (end_bracket + 1, &start_bracket, &end_bracket);
     }
   }
   mip = ModifierInfoFree (mip);
 }
 
 static void ApplyOneModToSeqEntry (SeqEntryPtr sep, CharPtr mod_name, CharPtr mod_value)
 {
   BioseqPtr    bsp = NULL;
   SeqDescrPtr  sdp = NULL;
   
   if (sep == NULL || StringHasNoText (mod_name))
   {
     return;
   }
   
   if (IS_Bioseq (sep))
   {
     bsp = (BioseqPtr) sep->data.ptrvalue;
   }
   else if (IS_Bioseq_set (sep))
   {
     sep = FindNucSeqEntry (sep);
     if (sep != NULL && IS_Bioseq (sep))
     {
       bsp = (BioseqPtr) sep->data.ptrvalue;
     }
   }
   
   if (bsp == NULL)
   {
     return;
   }
   
   for (sdp = bsp->descr; sdp != NULL && sdp->choice != Seq_descr_title; sdp = sdp->next)
   {
   }
 
   if (sdp == NULL)
   {
     sdp = SeqDescrNew (NULL);
     sdp->choice = Seq_descr_title;
     if (bsp->descr == NULL)
     {
       bsp->descr = sdp;
     }
   }
   if (sdp != NULL)
   {
     sdp->data.ptrvalue = ReplaceValueInOneDefLine (sdp->data.ptrvalue,
                                                    mod_name, mod_value);
   }
   
   
 }
 
 static ModifierInfoPtr MakeModifierInfoFromNameAndValue (CharPtr value_name, CharPtr value_string)
 {
   ModifierInfoPtr mip;
   CharPtr tmp_pair;
   CharPtr fixed_value;
 
   fixed_value = AddQuotesToValueWithBrackets (value_string);  
   tmp_pair = (CharPtr) MemNew ((StringLen (value_name) + StringLen (fixed_value) + 4));
   if (tmp_pair == NULL)
   {
     return NULL;
   }
   sprintf (tmp_pair, "[%s=%s]", value_name == NULL ? "" : value_name,
                              fixed_value == NULL ? "" : fixed_value);
   mip = ParseOneBracketedModifier (tmp_pair, NULL, NULL);
   tmp_pair = MemFree (tmp_pair);
   fixed_value = MemFree (fixed_value);
   return mip;
 }
 
 /* This section is used to import tables of modifiers. */
 static CharPtr 
 ApplyImportModToTitle 
 (CharPtr title, 
  CharPtr value_name, 
  CharPtr value_string,
  Boolean erase_where_blank,
  Boolean parse_multiple)
 {
   ModifierInfoPtr mip;
   CharPtr next_semi, val_start, title_loc, title_end;
   CharPtr insert_point;
   Int4    insert_offset, title_val_num;
   Char    val_save_ch;
 
   if (StringHasNoText (value_name))
   {
     return title;
   }
   
   if (!erase_where_blank && StringHasNoText (value_string))
   {
     return title;
   }
   
   mip = MakeModifierInfoFromNameAndValue (value_name, value_string);
 
   if (mip == NULL 
       || (mip->modtype == eModifierType_SourceQual
                 && mip->subtype == 255
               && StringICmp (mip->name, "note-subsrc") != 0 
               && StringICmp (mip->name, "note-orgmod") != 0))
   {
     mip = ModifierInfoFree (mip);
     return title;
   }
   
   if (erase_where_blank && StringHasNoText (value_string))
   {
     RemoveValueFromDefline (value_name, title);
   }
   else if (parse_multiple
            && value_string [0] == '(' 
            && value_string [StringLen (value_string) - 1] == ')'
            && (next_semi = StringChr (value_string, ';')) != NULL)
   {
     val_start = value_string + 1;
     title_val_num = 0;
     while (next_semi != NULL)
     {
       /* temporarily truncate at end of value */
       val_save_ch = *next_semi;
       *next_semi = 0;
       
       title_loc = FindNthValuePairInDefLine (title, value_name, title_val_num, &title_end);
       if (StringHasNoText (val_start))
       {
         if (title_loc != NULL)
         {
           RemoveValuePairFromDefline (title_loc, title_end, title);
         }
         else
         {
           /* if text is empty and there is no value pair, nothing to do */
         }
         /* note - we do not increment title_val_num here because either we've
          * removed a value or there are no values left.
          */
       }
       else
       {
         if (title_loc == NULL)
         {
           /* need to insert a new value - if organism name, put at end of title,
            * otherwise insert before second organism name if any
            */
           if (StringICmp (value_name, "organism") == 0)
           {
             insert_offset = StringLen (title);
           }
           else
           {
             insert_point = FindNthValuePairInDefLine (title, "organism", 1, NULL);
             if (insert_point == NULL) 
             {
               insert_offset = StringLen (title);
             }
             else
             {
               insert_offset = insert_point - title;
             }
           }
           title = InsertValuePairAtOffset (title, value_name, val_start, insert_offset);
         }
         else
         {
           /* replace values in order */
           title = ReplaceValueInThisValuePair (title, title_loc, value_name, 
                                                title_end, val_start);
         }
         
         title_val_num++;
       }
       
       /* replace character */
       *next_semi = val_save_ch;
       /* advance to next value in list */
       val_start = next_semi + 1;      
       if (*next_semi == ';')
       {
         next_semi = StringChr (next_semi + 1, ';');
         if (next_semi == NULL)
         {
           next_semi = value_string + StringLen (value_string) - 1;
         }
       }
       else
       {
         next_semi = NULL;
       }
     }
   }
   else if (StringCmp (value_name, "organism") == 0)
   {
     title = ReplaceValueInOneDefLine (title, value_name, value_string);
   }
   else
   {
     title = ReplaceValueInOneDefLineForOrganism (title, value_name, value_string, NULL);
   }
  
   mip = ModifierInfoFree (mip);
   return title;
 }
 
 static ValNodePtr ReadRowListFromFile (void)
 {
   Char          path [PATH_MAX];
   ValNodePtr    header_line = NULL;
   FILE           *fp;
 
   path [0] = '\0';
   if (! GetInputFileName (path, sizeof (path), NULL, "TEXT")) return NULL;
   fp = FileOpen (path, "r");
   if (fp == NULL) {
     Message (MSG_ERROR, "Unable to open %s", path);
   } else {
     header_line = ReadTabTableFromFile (fp);
     FileClose (fp);
   }
   return header_line;
 }
 
 /* This function will find the sequence number in the IDAndTitleEdit
  * to use for each row and put that value in the sequence_numbers array.
  */
 static Boolean 
 ValidateModifierTableSequenceIDs 
 (ValNodePtr        header_line,
  IDAndTitleEditPtr iatep,
  Int4Ptr           sequence_numbers,
  Int4Ptr           num_rows)
 {
   ValNodePtr   not_found = NULL;
   ValNodePtr   found_more_than_once = NULL;
   CharPtr      too_many_msg = NULL, not_found_msg = NULL;
   Boolean      rval = TRUE;
   Int4         msg_len = 0;
   CharPtr      too_many_fmt = " found more than once\n";
   CharPtr      not_found_fmt = " not found\n";
   CharPtr      err_msg = NULL;
   ValNodePtr   row_vnp, col_vnp, prev_row, next_row;
   Int4         i, seq_num, other_instances;
   Boolean      found;
   Int4         row_number;
   Int4         deleted_rows;
   
   if (header_line == NULL || header_line->next == NULL || iatep == NULL
       || sequence_numbers == NULL || num_rows == NULL || *num_rows < ValNodeLen (header_line->next))
   {
     return FALSE;
   }
   
   for (row_vnp = header_line->next, row_number = 0; 
        row_vnp != NULL && row_number < *num_rows;
        row_vnp = row_vnp->next, row_number++)
   {
     col_vnp = row_vnp->data.ptrvalue;
     if (col_vnp == NULL || col_vnp->data.ptrvalue == NULL)
     {
       continue;
     }
     
     /* find correct sequence number */
     seq_num = -1;
     for (i = 0, found = FALSE; i < iatep->num_sequences && !found; i++)
     {
       if (StringCmp (iatep->id_list [i], col_vnp->data.ptrvalue) == 0)
       {
         seq_num = i;
         found = TRUE;
       }
     }
     sequence_numbers[row_number] = seq_num;
     
     if (!found)
     {
       ValNodeAddPointer (&not_found, 0, StringSave (col_vnp->data.ptrvalue));
     }
     else 
     {
       /* count the number of times this seq_num has already appeared in the list.*/
       other_instances = 0;
       for (prev_row = header_line->next; prev_row != row_vnp; prev_row = prev_row->next)
       {
         if (prev_row->choice == seq_num)
         {
           other_instances++;
         }
       }
       /* if the value was found exactly once, add this to the list of duplicates.
        * if the value was found more than once, it will already have been reported.
        */
       if (other_instances == 1)
       {
         ValNodeAddPointer (&found_more_than_once, 0, StringSave (col_vnp->data.ptrvalue));
       }
     }
   }
   
   if (found_more_than_once != NULL || not_found != NULL)
   {
     if (found_more_than_once != NULL)
     {
       too_many_msg = CreateListMessage ("Sequence ID", NULL, found_more_than_once);
       rval = FALSE;
       msg_len += StringLen (too_many_msg) + StringLen (too_many_fmt) + 5;
     }
     if (not_found != NULL)
     {
       not_found_msg = CreateListMessage ("Sequence ID", NULL, not_found);
       msg_len += StringLen (not_found_msg) + StringLen (not_found_fmt) + 5;
     }
     
     err_msg = (CharPtr) MemNew ((msg_len + 1) * sizeof (Char));
     if (err_msg != NULL)
     {
       if (too_many_msg != NULL)
       {
         StringCat (err_msg, too_many_msg);
         if (found_more_than_once->next != NULL)
         {
           StringCat (err_msg, " were");
         }
         else
         {
           StringCat (err_msg, " was");
         }
         StringCat (err_msg, too_many_fmt);
       }
       if (not_found_msg != NULL)
       {
         StringCat (err_msg, not_found_msg);
         if (not_found->next != NULL)
         {
           StringCat (err_msg, " were");
         }
         else
         {
           StringCat (err_msg, " was");
         }
         StringCat (err_msg, not_found_fmt);
       }
       if (rval)
       {
         if (ANS_NO == Message (MSG_YN, "%sContinue anyway?", err_msg))
         {
           rval = FALSE;
         }
       }
       else
       {
         Message (MSG_ERROR, "%sPlease correct your file.", err_msg);
       }
     }
     too_many_msg = MemFree (too_many_msg);
     not_found_msg = MemFree (not_found_msg);
     err_msg = MemFree (err_msg);
   }
   
   /* remove rows for sequence IDs that are not found */
   for (row_vnp = header_line->next, row_number = 0, prev_row = header_line; 
        row_vnp != NULL && row_number < *num_rows;
        row_vnp = next_row, row_number++)
   {
     next_row = row_vnp->next;
     if (sequence_numbers[row_number] < 0) {
       prev_row->next = next_row;
       row_vnp->next = NULL;
       row_vnp = FreeTableDisplayRowList (row_vnp);
     } else {
       prev_row = row_vnp;
     } 
   }
   
   /* now remove sequence_numbers entries */
   deleted_rows = 0;
   row_number = 0;
   while (row_number < *num_rows)
   {
     if (sequence_numbers[row_number] < 0) {
       for (i = row_number + 1; i < *num_rows; i++) {
         sequence_numbers[i - 1] = sequence_numbers[i];
       }
       (*num_rows)--;
     } else {
       row_number++;
     }
   }   
   
   return rval;
 }
 
 /* This checks the column names and puts the modifier type in the choice for each column */
 static Boolean ValidateImportModifierColumnNames (ValNodePtr header_line)
 {
   ValNodePtr      header_vnp;
   Boolean         rval = TRUE;
   ModifierInfoPtr mip;
   CharPtr         orig_name;
   Int4            col_num;
   
   if (header_line == NULL)
   {
     return FALSE;
   }
   
   header_vnp = header_line->data.ptrvalue;
   if (header_vnp == NULL || header_vnp->next == NULL)
   {
     return FALSE;
   }
   
   /* check ID column */
   if (StringICmp (header_vnp->data.ptrvalue, "local_id") != 0
       && StringICmp (header_vnp->data.ptrvalue, "local id") != 0
       && StringICmp (header_vnp->data.ptrvalue, "local-id") != 0
       && StringICmp (header_vnp->data.ptrvalue, "seq_id") != 0
       && StringICmp (header_vnp->data.ptrvalue, "seq id") != 0
       && StringICmp (header_vnp->data.ptrvalue, "seq-id") != 0
       && StringICmp (header_vnp->data.ptrvalue, "seqid") != 0
       && StringICmp (header_vnp->data.ptrvalue, "sequence_id") != 0
       && StringICmp (header_vnp->data.ptrvalue, "sequence id") != 0
       && StringICmp (header_vnp->data.ptrvalue, "sequence-id") != 0
       )
   {
     Message (MSG_ERROR, "Table file is missing header line!  Make sure first column header is seq_id");
     return FALSE;      
   }
   header_vnp = header_vnp->next;
   col_num = 1;
   while (header_vnp != NULL && rval)
   {
     mip = MakeModifierInfoFromNameAndValue (header_vnp->data.ptrvalue, NULL);
     if (mip == NULL 
       || (mip->modtype == eModifierType_SourceQual
                 && mip->subtype == 255
               && StringICmp (mip->name, "note-subsrc") != 0 
               && StringICmp (mip->name, "note-orgmod") != 0))
     {
       orig_name = (CharPtr) header_vnp->data.ptrvalue;
       rval = ReplaceImportModifierName (&orig_name, col_num);
       header_vnp->data.ptrvalue = orig_name;
     }
     else
     {
       header_vnp->data.ptrvalue = MemFree (header_vnp->data.ptrvalue);
       header_vnp->data.ptrvalue = StringSave (mip->name);
       header_vnp->choice = mip->modtype;
     }
     mip = ModifierInfoFree (mip);
     header_vnp = header_vnp->next;
     col_num++;
   }
   return rval;
 }
 
 static Boolean StringAlreadyInList (ValNodePtr list, CharPtr str)
 {
   while (list != NULL)
   {
     if (StringICmp (list->data.ptrvalue, str) == 0)
     {
       return TRUE;
     }
     list = list->next;
   }
   return FALSE;
 }
 
 static Boolean ValidateTableValues (ValNodePtr header_line)
 {
   ValNodePtr      header_vnp, row_vnp, col_vnp;
   Boolean         rval = TRUE;
   ModifierInfoPtr mip;
   Int4            col_num;
   ValNodePtr      bad_value_columns = NULL;
   ValNodePtr      bad_nontext_columns = NULL;
   CharPtr         err_msg;
   
   if (header_line == NULL || header_line->next == NULL 
       || header_line->data.ptrvalue == NULL)
   {
     return FALSE;
   }
     
   for (row_vnp = header_line->next; row_vnp != NULL; row_vnp = row_vnp->next)
   {
     /* skip rows with bad sequence IDs */
     if (row_vnp->data.ptrvalue == NULL)
     {
       continue;
     }
     
     header_vnp = header_line->data.ptrvalue;
     col_vnp = row_vnp->data.ptrvalue;
     /* skip ID column */
     header_vnp = header_vnp->next;
     col_vnp = col_vnp->next;
     for (col_num = 1; 
          header_vnp != NULL && col_vnp != NULL; 
          header_vnp = header_vnp->next, col_vnp = col_vnp->next, col_num++)
     {
       mip = MakeModifierInfoFromNameAndValue (header_vnp->data.ptrvalue, 
                                               col_vnp->data.ptrvalue);
       if (mip->modtype == eModifierType_SourceQual
                      && IsNonTextModifier (mip->name))
       {
         if (StringICmp (mip->value, "TRUE") != 0
             && StringICmp (mip->value, "FALSE") != 0)
         {
           if (!StringAlreadyInList (bad_nontext_columns, header_vnp->data.ptrvalue))
           {
             ValNodeAddPointer (&bad_nontext_columns, col_num, StringSave (header_vnp->data.ptrvalue));
           }
         }
       }
       else if (ModifierHasInvalidValue (mip))
       {
         if (!StringAlreadyInList (bad_value_columns, header_vnp->data.ptrvalue))
         {
           ValNodeAddPointer (&bad_value_columns, col_num, StringSave (header_vnp->data.ptrvalue));
         }
       }
       mip = ModifierInfoFree (mip);
     }
   }
   
   if (bad_value_columns != NULL)
   {
     err_msg = CreateListMessage ("Your file contains invalid values for column",
                                  ". Please edit your file to list valid values.",
                                  bad_value_columns);
     Message (MSG_ERROR, err_msg);                                 
     rval = FALSE;
   }
   if (bad_nontext_columns != NULL && rval)
   {
     err_msg = CreateListMessage ("Your file contains values other than TRUE or FALSE for column",
                                  ". These modifiers do not allow other text.  Click OK to "
                                  "discard this text and mark the values as TRUE.  If you "
                                  "wish to preserve this text under another modifier, click "
                                  "Cancel and change the column header in your file.",
                                  bad_nontext_columns);
     if (ANS_CANCEL == Message (MSG_OKC, err_msg))
     {
       rval = FALSE;
     }
   }
   
   bad_value_columns = ValNodeFreeData (bad_value_columns);
   bad_nontext_columns = ValNodeFreeData (bad_nontext_columns);
   return rval;
 }
 
 static Boolean 
 CheckModifiersForOverwrite 
 (ValNodePtr        header_line,
  IDAndTitleEditPtr iatep,
  Int4Ptr           sequence_numbers,
  Int4              num_rows,
  BoolPtr           erase_where_blank,
  BoolPtr           parse_multiple)
 {
   ValNodePtr row_vnp, header_vnp, col_vnp;
   CharPtr    title_val, data_val;
   ValNodePtr blank_column_list = NULL;
   ValNodePtr replace_column_list = NULL;
   ValNodePtr parse_multi_list = NULL;
   Int4       col_num, row_num;
   Boolean    rval = TRUE;
   CharPtr    err_msg;
   MsgAnswer  ans;
   
   if (header_line == NULL || header_line->next == NULL || iatep == NULL
       || sequence_numbers == NULL || num_rows < ValNodeLen (header_line->next)
       || erase_where_blank == NULL || parse_multiple == NULL)
   {
     return FALSE;
   }
   
   *erase_where_blank = FALSE;
   *parse_multiple = FALSE;
   
   for (row_vnp = header_line->next, row_num = 0;
        row_vnp != NULL && row_num < num_rows;
        row_vnp = row_vnp->next, row_num++)
   {
     if (row_vnp->data.ptrvalue == NULL)
     {
       continue;
     }
     header_vnp = header_line->data.ptrvalue;
     col_vnp = row_vnp->data.ptrvalue;
     
     /* skip ID column */
     header_vnp = header_vnp->next;
     col_vnp = col_vnp->next;
     
     col_num = 1;
     while (header_vnp != NULL && col_vnp != NULL)
     {
       /* if column name is blank, skip */
       if (header_vnp->data.ptrvalue != NULL)
       {
         title_val = FindValueFromPairInDefline (header_vnp->data.ptrvalue,
                                                 iatep->title_list [sequence_numbers[row_num]]);
         data_val = col_vnp->data.ptrvalue;
         if (!StringHasNoText (title_val))
         {
           if (StringHasNoText (data_val))
           {
             /* add to list of possible erasures */
             if (!StringAlreadyInList (blank_column_list, header_vnp->data.ptrvalue))
             {
               ValNodeAddPointer (&blank_column_list, col_num, StringSave (header_vnp->data.ptrvalue));
             }
           }
           else if (StringCmp (data_val, title_val) != 0)
           {
             /* add to list of possible replacements */
             if (!StringAlreadyInList (replace_column_list, header_vnp->data.ptrvalue))
             {
               ValNodeAddPointer (&replace_column_list, col_num, StringSave (header_vnp->data.ptrvalue));
             }
           }
         }
         title_val = MemFree (title_val);
         /* check for multival parsing */
         if (data_val != NULL 
             && data_val [0] == '(' && data_val [StringLen (data_val) - 1] == ')'
             && StringChr (data_val, ';') != NULL
             && !StringAlreadyInList (parse_multi_list, header_vnp->data.ptrvalue))
         {
           ValNodeAddPointer (&parse_multi_list, col_num, StringSave (header_vnp->data.ptrvalue));
         }
       }
       header_vnp = header_vnp->next;
       col_vnp = col_vnp->next;
       col_num++;
     }
   }
     
   if (replace_column_list != NULL)
   {
     err_msg = CreateListMessage ("Record already contains values for column",
                                  " also found in the import table.\n"
                                  "Do you wish to overwrite these values?",
                                  replace_column_list);
     if (ANS_NO == Message (MSG_YN, err_msg))
     {
       rval = FALSE;
     }
     err_msg = MemFree (err_msg);
   }
   
   if (blank_column_list != NULL && rval)
   {
     err_msg = CreateListMessage ("Your import table contains blanks in column",
                                  " where data already exists in the sequences.\n"
                                  "Do you wish to erase these values in the sequences?\n"
                                  "If you say no, the old values will remain.",
                                  blank_column_list);
     ans = Message (MSG_YNC, err_msg);
     err_msg = MemFree (err_msg);
     if (ans == ANS_CANCEL)
     {
       rval = FALSE;
     }
     else if (ans == ANS_YES)
     {
       *erase_where_blank = TRUE;
     }
   }
 
 #if 0  
   /* ability to parse multiple entry format removed (for now) */
   if (parse_multi_list != NULL && rval)
   {
     err_msg = CreateListMessage ("Your import table contains values in column",
                                  " where the values are in form '(value1;value2)'.\n"
                                  "Do you wish to parse these values into multiple modifiers?\n"
                                  "If you say no, the values will be applied to a single modifier.",
                                  parse_multi_list);
     ans = Message (MSG_YNC, err_msg);
     err_msg = MemFree (err_msg);
     if (ans == ANS_CANCEL)
     {
       rval = FALSE;
     }
     else if (ans == ANS_YES)
     {
       *parse_multiple = TRUE;
     }
   }
 #endif  
   
   blank_column_list = ValNodeFree (blank_column_list);  
   replace_column_list = ValNodeFreeData (replace_column_list);
   parse_multi_list = ValNodeFreeData (parse_multi_list);
   
   return rval;
 }
 
 static Boolean ImportModifiersToIDAndTitleEdit (IDAndTitleEditPtr iatep)
 {
   ValNodePtr   header_line, row_vnp, col_vnp, header_vnp;
   Boolean      erase_where_blank = FALSE, parse_multi = FALSE;
   Int4Ptr      sequence_numbers;
   Int4         num_rows, row_number;
   
   if (iatep == NULL)
   {
     return FALSE;
   }
 
   SendHelpScrollMessage (helpForm, "Organism Page", "Import Source Modifiers");  
   
   header_line = ReadRowListFromFile ();
   if (header_line == NULL || header_line->next == NULL)
   {
     header_line = FreeTableDisplayRowList (header_line);
     return FALSE;
   }
   
   header_vnp = header_line->data.ptrvalue;
   if (header_vnp == NULL || header_vnp->next == NULL)
   {
     header_line = FreeTableDisplayRowList (header_line);
     return FALSE;
   }
   
   num_rows = ValNodeLen (header_line->next);
   sequence_numbers = (Int4Ptr) MemNew (num_rows * sizeof (Int4));
   
   if (!ValidateModifierTableSequenceIDs (header_line, iatep, sequence_numbers, &num_rows))
   {
     header_line = FreeTableDisplayRowList (header_line);
     sequence_numbers = MemFree (sequence_numbers);
     return FALSE;
   }
   
   /* first, validate all column names and values */
   if (!ValidateImportModifierColumnNames (header_line))
   {
     header_line = FreeTableDisplayRowList (header_line);
     sequence_numbers = MemFree (sequence_numbers);
     return FALSE;
   }
   
   if (!ValidateTableValues (header_line))
   {
     header_line = FreeTableDisplayRowList (header_line);
     sequence_numbers = MemFree (sequence_numbers);
     return FALSE;
   }
   
   if (!CheckModifiersForOverwrite (header_line, iatep, 
                                    sequence_numbers, num_rows, 
                                    &erase_where_blank, &parse_multi))
   {
     header_line = FreeTableDisplayRowList (header_line);
     sequence_numbers = MemFree (sequence_numbers);
     return FALSE;
   }
   
   /* now apply */
   for (row_vnp = header_line->next, row_number = 0;
        row_vnp != NULL && row_number < num_rows; 
        row_vnp = row_vnp->next, row_number++)
   {
     if (row_vnp->data.ptrvalue == NULL)
     {
       continue;
     }
     header_vnp = header_line->data.ptrvalue;
     col_vnp = row_vnp->data.ptrvalue;
     
     /* skip the ID column */
     header_vnp = header_vnp->next;
     col_vnp = col_vnp->next;
     
     for (;
          header_vnp != NULL && col_vnp != NULL;
          header_vnp = header_vnp->next, col_vnp = col_vnp->next)
     {
       iatep->title_list [sequence_numbers [row_number]] = ApplyImportModToTitle (iatep->title_list [sequence_numbers[row_number]],
                                                                    header_vnp->data.ptrvalue,
                                                                    col_vnp->data.ptrvalue,
                                                                    erase_where_blank,
                                                                    parse_multi);
     }
   }
   sequence_numbers = MemFree (sequence_numbers);  
   return TRUE;
 }
 
 typedef struct fastapage {
   DIALOG_MESSAGE_BLOCK
   Char         path [PATH_MAX];
   SeqEntryPtr  list;
   ValNodePtr   errmsgs;
   DoC          doc;
   GrouP        instructions;
   GrouP        have_seq_instr_grp;
   GrouP        singleIdGrp;
   TexT         singleSeqID;  
   Boolean      is_na;
   Boolean      is_mrna;
   Boolean      is_delta;
   Boolean      parseSeqId;
   Boolean      single;
   Int2Ptr      seqPackagePtr;
   ButtoN       import_btn;
   ButtoN       clear_btn;
 } FastaPage, PNTR FastaPagePtr;
 
 static ParData faParFmt = {FALSE, FALSE, FALSE, FALSE, FALSE, 0, 0};
 static ColData faColFmt = {0, 0, 80, 0, NULL, 'l', TRUE, FALSE, FALSE, FALSE, TRUE};
 
 static void ResetFastaPage (FastaPagePtr fpp)
 
 {
   SeqEntryPtr  next;
   SeqEntryPtr  sep;
 
   if (fpp != NULL) {
     sep = fpp->list;
     while (sep != NULL) {
       next = sep->next;
       sep->next = NULL;
       SeqEntryFree (sep);
       sep = next;
     }
     fpp->list = NULL;
     fpp->errmsgs = ValNodeFreeData (fpp->errmsgs);
   }
 }
 
 static CharPtr GetModValueFromSeqEntry (SeqEntryPtr sep, CharPtr mod_name)
 {
   CharPtr ttl = NULL;
   CharPtr value = NULL;
   
   if (sep == NULL || StringHasNoText (mod_name))
   {
     return NULL;
   }
 
   SeqEntryExplore (sep, (Pointer) (&ttl), FindFirstTitle);
   if (StringHasNoText (ttl))
   {
     return NULL;
   }
   
   value =  FindValueFromPairInDefline (mod_name, ttl);
   
   return value;  
 }
 
 static void AddReportLine (CharPtr str, CharPtr name, CharPtr tmp)
 
 {
   StringCat (str, name);
   StringCat (str, ": ");
   StringCat (str, tmp);
   StringCat (str, "\n");
 }
 
 static CharPtr GetDisplayValue (CharPtr mod_name, CharPtr title, BoolPtr multi_found);
 static CharPtr GetDisplayValueFromModifierInfoList (CharPtr mod_name, ValNodePtr modifier_info_list, BoolPtr multi_found);
 
 static void ReportModifiers (CharPtr str, CharPtr report_name,
                              ValNodePtr modifier_info_list, CharPtr mod_name, CharPtr not_found_msg)
 {
   CharPtr valstr;
   Boolean multi_found = TRUE;
 
   valstr = GetDisplayValueFromModifierInfoList (mod_name, modifier_info_list, &multi_found);
   if (IsNonTextModifier (mod_name) && StringICmp (valstr, "FALSE") == 0)
   {
         valstr = MemFree (valstr);
   }
 
   if (!StringHasNoText (valstr)) {
     AddReportLine (str, report_name, valstr);
   } else if (!StringHasNoText (not_found_msg)) {
     StringCat (str, not_found_msg);
   }
   valstr = MemFree (valstr);
 }
 
 static void LookupAndAddReportLine (CharPtr str, CharPtr report_name, 
                                     CharPtr title, CharPtr mod_name, CharPtr not_found_msg)
 {
   CharPtr valstr;
   Boolean multi_found = TRUE;
   
   valstr = GetDisplayValue (mod_name, title, &multi_found);
   if (IsNonTextModifier (mod_name) && StringICmp (valstr, "FALSE") == 0)
   {
         valstr = MemFree (valstr);
   }
 
   if (!StringHasNoText (valstr)) {
     AddReportLine (str, report_name, valstr);
   } else if (!StringHasNoText (not_found_msg)) {
     StringCat (str, not_found_msg);
   }
   valstr = MemFree (valstr);
 }
 
 static void LookupAndAddLocationReportLine (CharPtr str, CharPtr title)
 {
   CharPtr valstr;
   
   valstr = FindValueFromPairInDefline ("location", title);
   if (!StringHasNoText (valstr) && StringICmp (valstr, "genomic") != 0) {
     AddReportLine (str, "Location", valstr);
   }
   valstr = MemFree (valstr);
 }
 
 static CharPtr singlewarn = "\
 ERROR - You may not enter multiple segments for a single sequence submission.\
 You should either clear the nucleotide and import a single FASTA record, or\
 return to the Sequence Format form and choose the proper submission type.\n\n";
 
 #define FastaFormatBufLen 2000
 
 static Int4 CountSegSetSegments (SeqEntryPtr sep)
 {
   BioseqSetPtr bssp;
   
   if (sep == NULL || sep->data.ptrvalue == NULL || ! IS_Bioseq_set (sep))
   {
     return 0;
   }
   
   bssp = (BioseqSetPtr) sep->data.ptrvalue;
   if (bssp->_class != BioseqseqSet_class_segset)
   {
     return 0;
   }
   sep = bssp->seq_set;
   
   while (sep != NULL)
   {
     if (IS_Bioseq_set (sep) && sep->data.ptrvalue != NULL)
     {
       bssp = (BioseqSetPtr) sep->data.ptrvalue;
       if (bssp->_class == BioseqseqSet_class_parts)
       {
         return ValNodeLen (bssp->seq_set);
       }
     }
     sep = sep->next;
   }
   return 0;
 }
 
 static void FormatFastaDoc (FastaPagePtr fpp)
 
 {
   Nlm_QualNameAssocPtr ap;
   BioseqPtr          bsp;
   Boolean            hasErrors;
   CharPtr            label;
   Int4               len;
   CharPtr            measure;
   SeqEntryPtr        nsep = NULL;
   Int2               num;
   CharPtr            plural;
   CharPtr            ptr;
   SeqIdPtr           sip;
   SeqEntryPtr        sep;
   CharPtr            str;
   CharPtr            title;
   CharPtr            ttl;
   CharPtr            tmp;
   ValNodePtr         vnp;
   Int4               num_seg;
   CharPtr            valstr;
   ValNodePtr         modifier_info_list = NULL;
 
   if (fpp != NULL) {
     str = MemNew (sizeof (char) * FastaFormatBufLen);
     tmp = MemNew (sizeof (char) * FastaFormatBufLen);
     if (str == NULL || tmp == NULL) return;
     num = 0;
     len = 0;
     hasErrors = FALSE;
     for (sep = fpp->list; sep != NULL; sep = sep->next) {
       num++;
       if (IS_Bioseq (sep)) {
         bsp = (BioseqPtr) sep->data.ptrvalue;
         if (bsp != NULL) {
           len += bsp->length;
         }
       } else if (IS_Bioseq_set (sep)) {
         nsep = FindNucSeqEntry (sep);
         if (nsep != NULL && IS_Bioseq (nsep)) {
           bsp = (BioseqPtr) nsep->data.ptrvalue;
           if (bsp != NULL) {
             len += bsp->length;
           }
         }
       }
     }
     if (num > 1) {
       plural = "s";
     } else {
       plural = "";
     }
     if (fpp->single && num > 1) {
       AppendText (fpp->doc, singlewarn, &faParFmt, &faColFmt, programFont);
       hasErrors = TRUE;
     }
     if (fpp->is_mrna) {
       label = "Message";
       measure = "nucleotides";
     } else if (fpp->is_na) {
       label = "Sequence";
       measure = "bases";
     } else {
       label = "Sequence";
       measure = "amino acids";
     }
     if (fpp->is_mrna) {
       sprintf (str, "%d transcript sequence%s, total length %ld %s\n",
                (int) num, plural, (long) len, measure);
     } else if (fpp->is_na) {
       sprintf (str, "%d nucleotide sequence%s, total length %ld %s\n",
                (int) num, plural, (long) len, measure);
     } else {
       sprintf (str, "%d protein sequence%s, total length %ld %s\n",
                (int) num, plural, (long) len, measure);
     }
     AppendText (fpp->doc, str, &faParFmt, &faColFmt, programFont);
     vnp = fpp->errmsgs;
     num = 0;
     for (sep = fpp->list; sep != NULL; sep = sep->next) {
       num++;
       len = 0;
       num_seg = CountSegSetSegments (sep);
       sip = NULL;
       tmp [0] = '\0';
       if (IS_Bioseq (sep)) {
         bsp = (BioseqPtr) sep->data.ptrvalue;
         if (bsp != NULL) {
           len = bsp->length;
           sip = SeqIdFindWorst (bsp->id);
           SeqIdWrite (sip, tmp, PRINTID_REPORT, FastaFormatBufLen);
         }
         nsep = sep;
       } else if (IS_Bioseq_set (sep)) {
         nsep = FindNucSeqEntry (sep);
         if (nsep != NULL && IS_Bioseq (nsep)) {
           bsp = (BioseqPtr) nsep->data.ptrvalue;
           if (bsp != NULL) {
             len = bsp->length;
             sip = SeqIdFindWorst (bsp->id);
             SeqIdWrite (sip, tmp, PRINTID_REPORT, FastaFormatBufLen);
           }
         }
       }
       
       /* if segmented set, show number of segments */
       if (num_seg > 0)
       {
         sprintf (str, "\nSegset %d Sequence ID: %s\nLength: %ld %s (%d segments)\n",
                  (int) num, tmp, (long) len, measure, num_seg);
       }
       else
       {
         sprintf (str, "\n%s %d Sequence ID: %s\nLength: %ld %s\n", label,
                  (int) num, tmp, (long) len, measure);
       }
       ttl = NULL;
       SeqEntryExplore (nsep, (Pointer) (&ttl), FindFirstTitle);
       title = StringSaveNoNull (ttl);
       modifier_info_list = ParseAllBracketedModifiers (title);
       if (title != NULL && (! fpp->is_na)) {
 
         ReportModifiers (str, "Gene", modifier_info_list, "gene", "No gene name detected\n");
         ReportModifiers (str, "Protein", modifier_info_list, "protein", "No protein name detected\n");
         ReportModifiers (str, "Gene Syn", modifier_info_list, "gene_syn", NULL);
         ReportModifiers (str, "Protein Desc", modifier_info_list, "protein_desc", NULL);
 
         ptr = StringISearch (title, "[orf]");
         if (ptr != NULL) {
         StringCat (str, "ORF indicated\n");
         }
         ReportModifiers (str, "Protein Comment", modifier_info_list, "comment", NULL);
       }
 
       if (title != NULL && fpp->is_na && (! fpp->is_mrna)) {
         ReportModifiers (str, "Organism", modifier_info_list, "organism", NULL);
         ReportModifiers (str, "Lineage", modifier_info_list, "lineage", NULL);
         for (ap = current_orgmod_subtype_alist; ap->name != NULL; ap++) {
           ReportModifiers (str, ap->name, modifier_info_list, ap->name, NULL); 
         }
         for (ap = current_subsource_subtype_alist; ap->name != NULL; ap++) {
           ReportModifiers (str, ap->name, modifier_info_list, ap->name, NULL); 
         }
         LookupAndAddReportLine (str, "Note", title, "note", NULL); 
         LookupAndAddReportLine (str, "Note", title, "subsource", NULL); 
         LookupAndAddReportLine (str, "Molecule", title, "molecule", NULL); 
         LookupAndAddReportLine (str, "MolType", title, "moltype", NULL); 
         LookupAndAddLocationReportLine (str, title); 
         LookupAndAddReportLine (str, "Genetic Code", title, "genetic_code", NULL);
       }
 
       if (title != NULL && fpp->is_na && fpp->is_mrna) {
         LookupAndAddReportLine (str, "Gene", title, "gene", "No gene name detected\n"); 
         valstr = FindValueFromPairInDefline ("mrna", title);
         if (!StringHasNoText (valstr)) {
           AddReportLine (str, "mRNA", valstr);
           valstr = MemFree (valstr);
         } else {
           valstr = MemFree (valstr);
           valstr = FindValueFromPairInDefline ("cdna", title);
           if (!StringHasNoText (valstr)) {
             AddReportLine (str, "cDNA", valstr);
           } else {
             StringCat (str, "No mRNA name detected\n");
           }
           valstr = MemFree (valstr);
         }
         LookupAndAddReportLine (str, "Comment", title, "comment", NULL); 
       }
       MemFree (title);
       ttl = NULL;
       SeqEntryExplore (nsep, (Pointer) (&ttl), FindFirstTitle);
       title = StringSaveNoNull (ttl);
       if (title != NULL) {
         RemoveRecognizedModifiersFromTitle (title, modifier_info_list, fpp->is_na);
         if (fpp->is_mrna) {
           StripAllInstancesOfModNameFromTitle ("gene", title);
           StripAllInstancesOfModNameFromTitle ("mrna", title);
           StripAllInstancesOfModNameFromTitle ("cdna", title);
           StripAllInstancesOfModNameFromTitle ("comment", title);
         } 
         TrimSpacesAroundString (title);
         if (! StringHasNoText (title)) {
           StringCat (str, "Title: ");
           StringNCat (str, title, 128);
           StringCat (str, "\n");
         } else {
           StringCat (str, "No title detected\n");
         }
       }
       MemFree (title);
       ModifierInfoListFree (modifier_info_list);
       if (vnp != NULL && vnp->data.ptrvalue != NULL) {
         hasErrors = TRUE;
         StringCat (str, (CharPtr) vnp->data.ptrvalue);
         StringCat (str, "\n");
       }
       AppendText (fpp->doc, str, &faParFmt, &faColFmt, programFont);
       if (vnp != NULL) {
         vnp = vnp->next;
       }
     }
     MemFree (str);
     MemFree (tmp);
     UpdateDocument (fpp->doc, 0, 0);
     if (hasErrors) {
       Beep ();
       Beep ();
       Beep ();
     }
   }
 }
 
 extern SeqEntryPtr ImportOneGappedSequence (FILE *fp)
 {
   BioseqPtr      bsp;
   Pointer        dataptr;
   Uint2          datatype;
   SeqEntryPtr    topsep;
   SeqSubmitPtr   ssp;
   ErrSev         oldsev;
   
   if (fp == NULL) return NULL;
   
   oldsev = ErrSetMessageLevel (SEV_MAX);
   bsp = ReadDeltaFasta (fp, NULL);
   ErrSetMessageLevel (oldsev);
   if (bsp == NULL)
   {
     topsep = NULL;
     dataptr = ReadAsnFastaOrFlatFile (fp, &datatype, NULL, FALSE, FALSE,
                                     TRUE, FALSE);
     if (dataptr != NULL)
     {
       /* Get a pointer to the new SeqEntry */
       if (datatype == OBJ_SEQENTRY)
       {
         topsep = (SeqEntryPtr) dataptr;
       }
       else if (datatype == OBJ_BIOSEQ || datatype == OBJ_BIOSEQSET)
       {
         topsep = SeqMgrGetSeqEntryForData (dataptr);
       }
       else if (datatype == OBJ_SEQSUB) 
       {
         ssp = (SeqSubmitPtr) dataptr;
         if (ssp != NULL && ssp->datatype == 1)
         {
           topsep = (SeqEntryPtr) ssp->data;
         }
       }
     }
   }
   else
   {
     topsep = SeqMgrGetSeqEntryForData (bsp);
   }
 
   return topsep;
 }
 
 static SeqEntryPtr SegsetFromSeqEntryList (SeqEntryPtr list)
 {
   SeqEntryPtr  first_sep, tmp_sep, next_sep;
   BioseqPtr    bsp;
   SeqDescrPtr  sdp = NULL, set_sdp;
   
   if (list == NULL)
   {
     return NULL;
   }
   
   first_sep = list;
   next_sep = first_sep->next;
   first_sep->next = NULL;
   
   /* grab title on first sequence to put on segmented bioseq */
   if (IS_Bioseq (first_sep) && first_sep->data.ptrvalue != NULL)
   {
     bsp = (BioseqPtr) first_sep->data.ptrvalue;
     sdp = bsp->descr;
     while (sdp != NULL && sdp->choice != Seq_descr_title)
     {
       sdp = sdp->next;
     }
   }
 
   while (next_sep != NULL)
   {
     tmp_sep = next_sep;
     next_sep = tmp_sep->next;
     tmp_sep->next = NULL;
     AddSeqEntryToSeqEntry (first_sep, tmp_sep, TRUE);
   }
   
   if (sdp != NULL && IS_Bioseq_set (first_sep))
   {
     tmp_sep = FindNucSeqEntry (first_sep);
     if (tmp_sep != NULL && IS_Bioseq (tmp_sep) && tmp_sep->data.ptrvalue != NULL)
     {
       bsp = tmp_sep->data.ptrvalue;
       set_sdp = bsp->descr;
       while (set_sdp != NULL && set_sdp->choice != Seq_descr_title)
       {
         set_sdp = set_sdp->next;
       }
       if (set_sdp == NULL)
       {
         set_sdp = CreateNewDescriptor (tmp_sep, Seq_descr_title);
       }
       if (set_sdp != NULL && StringHasNoText (set_sdp->data.ptrvalue))
       {
         /* make a copy, rather than removing the segment title */
         set_sdp->data.ptrvalue = MemFree (set_sdp->data.ptrvalue);
         set_sdp->data.ptrvalue = StringSave (sdp->data.ptrvalue);
       }
     }
   }  
   
   return first_sep;
 }
 
 static void ReplaceFakeIDWithIDFromTitle (BioseqPtr bsp);
 
 static SeqEntryPtr 
 ReadOneSegSet 
 (FILE            *fp,
  Boolean         parse_id,
  ValNodePtr PNTR err_msg_list,
  BoolPtr         chars_stripped)
 {
   SeqEntryPtr nextsep;
   CharPtr     errormsg = NULL;
   Char        lastchar;
   SeqEntryPtr seg_list = NULL, seg_list_last = NULL;
   BioseqPtr   bsp;
   
   if (fp == NULL)
   {
     return NULL;
   }
   
   /* note - we pass in FALSE for parse_id in SequinFastaToSeqEntryEx
    * because we do not want to use Sequin's auto-generated sequence IDs.
    * We then parse the sequence ID from the title ourselves using
    * ReplaceFakeIDWithIDFromTitle if parse_id is TRUE, or leave the ID
    * as blank to force the user to select a real ID later.
    */
   nextsep = SequinFastaToSeqEntryExEx (fp, TRUE, &errormsg, FALSE, &lastchar, chars_stripped);
   while (nextsep != NULL ||
          (lastchar != (Char) EOF && lastchar != NULLB && lastchar != (Char) 255
           && lastchar != ']')) 
   {
     if (nextsep != NULL) 
     {
       /* replace fake ID with ID from title */
       if (IS_Bioseq (nextsep) && nextsep->data.ptrvalue != NULL)
       {
         bsp = (BioseqPtr) nextsep->data.ptrvalue;
         if (parse_id)
         {
           ReplaceFakeIDWithIDFromTitle ((BioseqPtr) nextsep->data.ptrvalue);
         }
         else
         {
           bsp->id = SeqIdFree (bsp->id);
         }
       }
       SeqEntryPack (nextsep); 
       if (seg_list_last == NULL)
       {
         seg_list = nextsep;
       }
       else
       {
         seg_list_last->next = nextsep;
       }
       seg_list_last = nextsep;
       
       ValNodeAddPointer (err_msg_list, 0, errormsg);
       errormsg = NULL;
     }
     nextsep = SequinFastaToSeqEntryExEx (fp, TRUE, &errormsg, FALSE, &lastchar, chars_stripped);
   }
   nextsep = SegsetFromSeqEntryList (seg_list);
   return nextsep;
 }
 
 static void AddDefaultMoleculeTypeToIDAndTitleEdit (IDAndTitleEditPtr iatep)
 {
   Int4    seq_num;
   CharPtr old_value;
   
   if (iatep == NULL)
   {
     return;
   }
   
   for (seq_num = 0; seq_num < iatep->num_sequences; seq_num++)
   {
     if (iatep->is_seg != NULL && iatep->is_seg [seq_num])
     {
       continue;
     }
     old_value = FindValueFromPairInDefline("moltype", 
                                            iatep->title_list [seq_num]);
     if (StringHasNoText (old_value) || StringICmp (old_value, "dna") == 0)
     {
       iatep->title_list [seq_num] = ReplaceValueInOneDefLine(iatep->title_list [seq_num],
                                                              "moltype",
                                                              "Genomic DNA");
     }
     old_value = MemFree (old_value);
   }
 }
 
 static void AddDefaultLocationToIDAndTitleEdit (IDAndTitleEditPtr iatep)
 {
   Int4    seq_num;
   CharPtr old_value, first_organism, next_org_loc = NULL, org_stop;
   
   if (iatep == NULL)
   {
     return;
   }
   
   for (seq_num = 0; seq_num < iatep->num_sequences; seq_num++)
   {
     if (iatep->is_seg != NULL && iatep->is_seg [seq_num])
     {
       continue;
     }
     first_organism = FindValuePairInDefLine ("organism", iatep->title_list [seq_num], &org_stop);
     if (first_organism != NULL)
     {
       next_org_loc = FindValuePairInDefLine ("organism", org_stop + 1, NULL);
     }
     else
     {
       next_org_loc = NULL;
     }
     old_value = FindValueFromPairInDeflineBeforeCharPtr ("location", 
                                                          iatep->title_list [seq_num],
                                                          next_org_loc);
     if (StringHasNoText (old_value))
     {
       iatep->title_list [seq_num] = ReplaceValueInOneDefLineForOrganism (iatep->title_list [seq_num],
                                                                          "location",
                                                                          "genomic",
                                                                          first_organism);
     }
     old_value = MemFree (old_value);
   }
 }
 
 static void AddDefaultTopologyToIDAndTitleEdit (IDAndTitleEditPtr iatep)
 {
   Int4    seq_num;
   CharPtr old_value;
   
   if (iatep == NULL)
   {
     return;
   }
   
   for (seq_num = 0; seq_num < iatep->num_sequences; seq_num++)
   {
     if (iatep->is_seg != NULL && iatep->is_seg [seq_num])
     {
       continue;
     }
     old_value = FindValueFromPairInDefline ("topology", 
                                             iatep->title_list [seq_num]);
     if (StringHasNoText (old_value))
     {
       iatep->title_list [seq_num] = ReplaceValueInOneDefLine(iatep->title_list [seq_num],
                                                              "topology",
                                                              "Linear");
     }
     old_value = MemFree (old_value);
   }
 }
 
 static void AddDefaultGeneticCodesToIDAndTitleEdit (IDAndTitleEditPtr iatep)
 {
   CharPtr     taxname, location, gcode_name;
   Int4        gcode;
   ValNodePtr  gencodelist;
   Int4        seq_num;
   CharPtr     first_organism, next_org_loc = NULL, org_stop;
 
   if (iatep == NULL)
   {
     return;
   }
   
   gencodelist = GetGeneticCodeValNodeList ();
   for (seq_num = 0; seq_num < iatep->num_sequences; seq_num++)
   {
     if (iatep->is_seg != NULL && iatep->is_seg [seq_num])
     {
       continue;
     }
     first_organism = FindValuePairInDefLine ("organism", iatep->title_list [seq_num], &org_stop);
     if (first_organism != NULL)
     {
       next_org_loc = FindValuePairInDefLine ("organism", org_stop + 1, NULL);
     }
     else
     {
       next_org_loc = NULL;
     }
     
     taxname = FindValueFromPairInDefline ("organism", first_organism);
     location = FindValueFromPairInDeflineBeforeCharPtr ("location", 
                                                         iatep->title_list [seq_num],
                                                         next_org_loc);
     if (StringHasNoText (location))
     {
       location = StringSave ("genomic");
     }
     
     gcode = GetGeneticCodeForTaxNameAndLocation (taxname, location);
     taxname = MemFree (taxname);
     location = MemFree (location);
     
     if (gcode < 0)
     {
       gcode_name = FindValueFromPairInDeflineBeforeCharPtr ("genetic_code",
                                                             iatep->title_list [seq_num],
                                                             next_org_loc);
       if (StringHasNoText (gcode_name))
       {
         gcode_name = MemFree (gcode_name);
         gcode_name = GeneticCodeStringFromIntAndList (1, gencodelist);
         iatep->title_list [seq_num] = ReplaceValueInOneDefLineForOrganism (iatep->title_list [seq_num],
                                                                          "genetic_code",
                                                                          gcode_name,
                                                                          first_organism);
       }
       else
       {
         gcode_name = MemFree (gcode_name);
       }
     }
     else
     {
       gcode_name = GeneticCodeStringFromIntAndList (gcode, gencodelist);
       iatep->title_list [seq_num] = ReplaceValueInOneDefLineForOrganism (iatep->title_list [seq_num],
                                                                          "genetic_code",
                                                                          gcode_name,
                                                                          first_organism);
     }
   }
   ValNodeFreeData (gencodelist);
 }
 
 static void AddDefaultModifierValues (SeqEntryPtr seq_list)
 {
   IDAndTitleEditPtr iatep;
   
   iatep = SeqEntryListToIDAndTitleEdit (seq_list);
   AddDefaultMoleculeTypeToIDAndTitleEdit (iatep);
   AddDefaultLocationToIDAndTitleEdit (iatep);
   AddDefaultTopologyToIDAndTitleEdit (iatep);
   AddDefaultGeneticCodesToIDAndTitleEdit (iatep);
   ApplyIDAndTitleEditToSeqEntryList (seq_list, iatep);
   iatep = IDAndTitleEditFree (iatep);
 }
 
 static Boolean HasGapID (SeqEntryPtr sep)
 {
   BioseqPtr bsp;
   Char      id_str [128];
   Int4      j;
   
   if (sep == NULL || ! IS_Bioseq (sep) || (bsp = sep->data.ptrvalue) == NULL)
   {
     return FALSE;
   }
   
   SeqIdWrite (bsp->id, id_str, PRINTID_REPORT, sizeof (id_str));
   
   if (id_str [0] != '?')
   {
     return FALSE;
   }
   if (StringICmp (id_str + 1, "unk100") == 0)
   {
     return TRUE;
   }
   else 
   {
     /* make sure there are only numbers after the question mark */
     j = 1;
     while (isdigit (id_str [j]))
     {
       j++;
     }
     if (id_str [j] == 0)
     {
       return TRUE;
     }
     else
     {
       return FALSE;
     }
   }
 }
 
 static Boolean HasNoSeqID (SeqEntryPtr sep)
 {
   BioseqPtr bsp;
 
   if (sep == NULL || ! IS_Bioseq (sep) || (bsp = sep->data.ptrvalue) == NULL)
   {
     return FALSE;
   }
   if (bsp->id == NULL)
   {
     return TRUE;
   }
   else
   {
     return FALSE;
   }
 }
 
 static void PutDeflineIDBackInTitle (BioseqPtr bsp)
 {
   SeqDescrPtr sdp;
   CharPtr     id_txt;
   CharPtr     title_txt;
   
   if (bsp == NULL || bsp->id == NULL)
   {
     return;
   }
 
   sdp = bsp->descr;
   while (sdp != NULL && sdp->choice != Seq_descr_title)
   {
     sdp = sdp->next;
   }
   if (sdp == NULL)
   {
     sdp = CreateNewDescriptorOnBioseq (bsp, Seq_descr_title);
   }
   if (sdp == NULL)
   {
     return;
   }
   
   id_txt = SeqIdWholeLabel (bsp->id, PRINTID_REPORT);
   
   if (StringHasNoText (sdp->data.ptrvalue))
   {
     sdp->data.ptrvalue = MemFree (sdp->data.ptrvalue);
     sdp->data.ptrvalue = id_txt;
   }
   else
   {
     title_txt = (CharPtr) MemNew (sizeof (Char) * (StringLen (id_txt) + StringLen (sdp->data.ptrvalue) + 2));
     StringCpy (title_txt, id_txt);
     StringCat (title_txt, " ");
     StringCat (title_txt, sdp->data.ptrvalue);
     sdp->data.ptrvalue = MemFree (sdp->data.ptrvalue);
     sdp->data.ptrvalue = title_txt;
     id_txt = MemFree (id_txt);
   }
   
   bsp->id = SeqIdFree (bsp->id);  
 }
 
 static Char GetNextCharacterFromFile (FILE *fp, BoolPtr pIsASN)
 {
   FileCache    fc;
   CharPtr      str;
   Char         special_symbol;
   Char         line [128];
   Int4         pos;
   
   /* look ahead to see what character caused inability to interpret line */
   FileCacheSetup (&fc, fp);
   /* pos = FileCacheTell (&fc); */
   str = FileCacheReadLine (&fc, line, sizeof (line), NULL);
   if (str != NULL && StringDoesHaveText (str)) {
     TrimSpacesAroundString (str);
   }
   special_symbol = line [0];
   if (pIsASN != NULL)
   {
     if (StringStr (line, "::=") != NULL)
     {
       *pIsASN = TRUE;
     }
     else
     {
       *pIsASN = FALSE;
     }
   }
   /* seek to start of next line after one that could not be interpreted */
   pos = FileCacheTell (&fc);
   FileCacheSetup (&fc, fp);
   FileCacheSeek (&fc, pos);
   fseek (fp, pos, SEEK_SET);
   return special_symbol;
 }
 
 static Int4 FindLineForStartOfBadRead (FILE *fp, Int4 pos)
 {
   FileCache    fc;
   Int4         line_num = 0;
   Char         line [4096];
   CharPtr      str;
   
   if (fp == NULL || pos == 0) {
     return 0;
   }
 
   FileCacheSetup (&fc, fp);
   FileCacheSeek (&fc, 0);
   fseek (fp, 0, SEEK_SET);
   str = FileCacheReadLine (&fc, line, sizeof (line), NULL);
   while (str != NULL && FileCacheTell (&fc) < pos) {
       line_num++;
       str = FileCacheReadLine (&fc, line, sizeof (line), NULL);
   }
   return line_num;
 }
 
 
 static Int4 FindLineForBadReadChar (FILE *fp, Char badchar)
 {
   FileCache    fc;
   Int4         line_num = 0;
   Char         line [4096];
   CharPtr      str;
   
   if (fp == NULL) {
     return 0;
   }
 
   FileCacheSetup (&fc, fp);
   FileCacheSeek (&fc, 0);
   fseek (fp, 0, SEEK_SET);
   str = FileCacheReadLine (&fc, line, sizeof (line), NULL);
   while (str != NULL && StringChr (str, badchar) == NULL) {
       line_num++;
       str = FileCacheReadLine (&fc, line, sizeof (line), NULL);
   }
   return line_num;
 }
 
 
 static void CleanTitles (SeqEntryPtr sep, ValNodePtr PNTR special_list)
 {
   BioseqPtr    bsp;
   BioseqSetPtr bssp;
   SeqDescrPtr  sdp = NULL;
 
   while (sep != NULL)
   {
     sdp = NULL;
     if (sep->choice == 1)
     {
       bsp = sep->data.ptrvalue;
       if (bsp != NULL) 
       {
         sdp = bsp->descr;
       }
     }
     else if (sep->choice == 2)
     {
       bssp = sep->data.ptrvalue;
       if (bssp != NULL)
       {
         CleanTitles (bssp->seq_set, special_list);
         sdp = bssp->descr;
       }
     }
     while (sdp != NULL)
     {
       if (sdp->choice == Seq_descr_title)
       {
         SpecialCharFindWithContext ((CharPtr PNTR) &(sdp->data.ptrvalue), special_list, NULL, NULL);
       }
       sdp = sdp->next;
     }
     sep = sep->next;
   }
 }
 
 
 static SeqEntryPtr ImportOnlyProteinSequences 
 (FILE            *fp,
  SeqEntryPtr     sep_list,
  Boolean         parse_id,
  CharPtr         supplied_id_txt,
  ValNodePtr PNTR err_msg_list,
  BoolPtr         chars_stripped)
 {
   Pointer       dataptr;
   Uint2         datatype;
   SeqEntryPtr   new_list = NULL, nextsep, lastsep = NULL, oldscope;
   Boolean       error_reading = FALSE;
   Int4          pos, bad_start;
   BioseqPtr     bsp;
   ValNodePtr    special_list = NULL;
 
   oldscope = SeqEntrySetScope (NULL);
 
   pos = ftell (fp);  
   dataptr = ReadAsnFastaOrFlatFileEx (fp, &datatype, NULL, FALSE, TRUE,
                                     FALSE, FALSE, chars_stripped);
   while (dataptr != NULL) 
   {
     bsp = NULL;
     if (datatype == OBJ_SEQENTRY)
     {
       nextsep = (SeqEntryPtr) dataptr;
       if (IS_Bioseq(nextsep)) {
         bsp = nextsep->data.ptrvalue;
       } else {
         nextsep = NULL;
       }      
     }
     else if (datatype == OBJ_BIOSEQ)
     {
       bsp = dataptr;
       nextsep = SeqMgrGetSeqEntryForData(bsp);
     }
     if (bsp != NULL)
     {
       if (parse_id) 
       {
         ReplaceFakeIDWithIDFromTitle ((BioseqPtr) nextsep->data.ptrvalue);
       } 
       else 
       {
         if (!StringHasNoText (supplied_id_txt))
         {
           bsp->id = MakeSeqID (supplied_id_txt);
         }
       } 
       SeqEntryPack (nextsep);
       if (lastsep == NULL) {
         new_list = nextsep;
       } else {
         lastsep->next = nextsep;
       }
       lastsep = nextsep;
       pos = ftell (fp);  
       dataptr = ReadAsnFastaOrFlatFileEx (fp, &datatype, NULL, FALSE, TRUE,
                                           FALSE, FALSE, chars_stripped);
     }
     else
     {
       if (dataptr != NULL) {
         error_reading = TRUE;
       }
       dataptr = NULL;
     }
   }
   if (*chars_stripped || error_reading)
   {
     bad_start = FindLineForStartOfBadRead (fp, pos);
     Message (MSG_ERROR, "Unable to read file, starting at line %d!", bad_start);
     new_list = SeqEntryFree (new_list);
   }
   else
   {
     CleanTitles (new_list, &special_list);
     if (!FixSpecialCharactersForStringsInList (special_list, "Definition lines contain special characters.\nThe sequences cannot be imported unless the characters are replaced.", FALSE))
     {
       new_list = SeqEntryFree (new_list);
     }
     special_list = FreeContextList (special_list);
   }
   
   lastsep = sep_list;
   while (lastsep != NULL && lastsep->next != NULL) 
   {
     lastsep = lastsep->next;
   }
   if (lastsep == NULL)
   {
     sep_list = new_list;
   }
   else
   {
     lastsep->next = new_list;
   }
 
   SeqEntrySetScope (oldscope);
 
   return sep_list;
   
 }
  
 extern SeqEntryPtr 
 ImportSequencesFromFileEx
 (FILE           *fp, 
  SeqEntryPtr     sep_list,
  Boolean         is_na, 
  Boolean         parse_id,
  CharPtr         supplied_id_txt,
  ValNodePtr PNTR err_msg_list,
  BoolPtr         chars_stripped,
  Boolean         allow_char_stripping)
 {
   Int4          count;
   SeqEntryPtr   last;
   Char          lastchar;
   SeqEntryPtr   nextsep;
   CharPtr       errormsg = NULL;
   BioseqPtr     bsp = NULL;
   SeqEntryPtr   new_sep_list = NULL;
   ErrSev        oldsev;
   Boolean       read_from_delta;
   SeqEntryPtr   oldscope;
   Int4          pos, last_no_id_start = -1;
   Boolean       this_chars_stripped = FALSE;
   Boolean       isASN = FALSE, isOnlyFASTA = FALSE;
   Int4          bad_start = 0, bad_line = 0;
   ValNodePtr    special_list = NULL;
   
   if (chars_stripped != NULL)
   {
     *chars_stripped = FALSE;
   }
   
   if (!is_na) {
     return ImportOnlyProteinSequences (fp, sep_list, parse_id, supplied_id_txt, err_msg_list, chars_stripped);
   }
   
   count = 0;
   
   new_sep_list = NULL;
   last = NULL;
   
   oldscope = SeqEntrySetScope (NULL);
   
   pos = ftell (fp);
   
   bsp = NULL;
   oldsev = ErrSetMessageLevel (SEV_MAX);
   bsp = ReadDeltaFastaEx (fp, NULL, &this_chars_stripped);
   if (chars_stripped != NULL)
   {
     *chars_stripped |= this_chars_stripped;
   }
   if (bsp != NULL && !parse_id)
   {
     PutDeflineIDBackInTitle (bsp);
     if (!StringHasNoText (supplied_id_txt))
     {
       bsp->id = MakeSeqID (supplied_id_txt);
     }
   }
   ErrSetMessageLevel (oldsev);
   
   /* note - we pass in FALSE for parse_id in SequinFastaToSeqEntryEx
    * because we do not want to use Sequin's auto-generated sequence IDs.
    * We then parse the sequence ID from the title ourselves using
    * ReplaceFakeIDWithIDFromTitle if parse_id is TRUE, or leave the ID
    * as blank to force the user to select a real ID later.
    */
   
   if (bsp == NULL)
   {
     bsp = ReadFastaOnly (fp,
                          is_na, !is_na,
                          &this_chars_stripped,
                          &lastchar);
     if (bsp == NULL)
     {
       if (lastchar == 0)
       {
         lastchar = GetNextCharacterFromFile (fp, &isASN);
       }
     } else {
       isOnlyFASTA = TRUE;
     }
 
     nextsep = SeqMgrGetSeqEntryForData (bsp);
     if (chars_stripped != NULL)
     {
       *chars_stripped |= this_chars_stripped;
     }
     read_from_delta = FALSE;
   }
   else
   {
     nextsep = SeqMgrGetSeqEntryForData (bsp);
     lastchar = '\n';
     read_from_delta = TRUE;
   }
   while ((nextsep != NULL ||
          (lastchar == '\n' || lastchar == '['))
          && !isASN
          && (allow_char_stripping || !this_chars_stripped))
   {
     if (nextsep != NULL) 
     {
       if (!read_from_delta
           && IS_Bioseq (nextsep) 
           && nextsep->data.ptrvalue != NULL)
       {
         bsp = (BioseqPtr) nextsep->data.ptrvalue;
         /* replace fake ID with ID from title for sequences that aren't deltas */
         if (parse_id)
         {
           ReplaceFakeIDWithIDFromTitle ((BioseqPtr) nextsep->data.ptrvalue);
         }
         else
         {
           bsp->id = SeqIdFree (bsp->id);
           if (!StringHasNoText (supplied_id_txt))
           {
                 bsp->id = MakeSeqID (supplied_id_txt);
           }
         }
         SeqEntryPack (nextsep);
       }
       
       if (last_no_id_start > -1)
       {
         if (HasGapID (nextsep))
         {
           nextsep = SeqEntryFree (nextsep);
           bsp = last->data.ptrvalue;
           SeqMgrDeleteFromBioseqIndex (bsp);
           bsp = BioseqFree (bsp);
           fseek (fp, last_no_id_start, SEEK_SET);
           bsp = ReadDeltaFastaWithEmptyDefline (fp, NULL, chars_stripped);
           last->data.ptrvalue = bsp;
           bsp->id = SeqIdFree (bsp->id);
           last_no_id_start = -1;
         }
         else if (HasNoSeqID (nextsep))
         {
           last_no_id_start = pos;
         }
         else
         {
           last_no_id_start = -1;
         }
       }
       else if (HasNoSeqID (nextsep))
       {
         last_no_id_start = pos;
       }
       
       ValNodeAddPointer (err_msg_list, 0, errormsg);
       errormsg = NULL;
     }
     else if (lastchar == '[')
     {
       nextsep = ReadOneSegSet (fp, parse_id, err_msg_list, &this_chars_stripped);
       if (chars_stripped != NULL)
       {
         *chars_stripped |= this_chars_stripped;
       }      
     }
     if (nextsep != NULL)
     {
       if (last == NULL) 
       {
         new_sep_list = nextsep;
         last = nextsep;
       }
       else 
       {
         last->next = nextsep;
         last = nextsep;
       }
     } 
     
     pos = ftell (fp);
     bsp = NULL;
     if (isOnlyFASTA) 
     {
       lastchar = (Char) EOF;
       nextsep = NULL;
     }     
     else if (is_na)
     {
       oldsev = ErrSetMessageLevel (SEV_MAX);
       bsp = ReadDeltaFastaEx (fp, NULL, &this_chars_stripped);
       if (chars_stripped != NULL)
       {
         *chars_stripped |= this_chars_stripped;
       }      
       ErrSetMessageLevel (oldsev);
       if (!parse_id)
       {
         PutDeflineIDBackInTitle (bsp);
       }
     }
     
     if (isOnlyFASTA) {
       /* done with loop */
     }
     else if (bsp == NULL)
     {
       bsp = ReadFastaOnly (fp,
                            is_na, !is_na,
                            &this_chars_stripped,
                            &lastchar);
       if (bsp == NULL)
       {
         if (lastchar == 0)
         {
           lastchar = GetNextCharacterFromFile (fp, &isASN);
         }
       } 
       else 
       {
         isOnlyFASTA = TRUE;
       }
       nextsep = SeqMgrGetSeqEntryForData (bsp);
       if (chars_stripped != NULL)
       {
         *chars_stripped |= this_chars_stripped;
       }      
       read_from_delta = FALSE;
     }
     else
     {
       nextsep = SeqMgrGetSeqEntryForData (bsp);
       lastchar = '\n';
       read_from_delta = TRUE;
     }
   }
   
   if ((!allow_char_stripping && this_chars_stripped) || (lastchar != (Char) EOF && lastchar != NULLB && lastchar != (Char) 255))
   {
     if (!this_chars_stripped && !isASN) {
       bad_start = FindLineForStartOfBadRead (fp, pos);
       bad_line = FindLineForBadReadChar (fp, lastchar);
       Message (MSG_ERROR, "Unable to read file, starting at line %d (found bad character '%c' at line %d)!", bad_start, lastchar, bad_line);
     }
     new_sep_list = SeqEntryFree (new_sep_list);
   }
   else
   {
     CleanTitles (new_sep_list, &special_list);
     if (!FixSpecialCharactersForStringsInList (special_list, "Definition lines contain special characters.\nThe sequences cannot be imported unless the characters are replaced.", FALSE))
     {
       new_sep_list = SeqEntryFree (new_sep_list);
     }
     special_list = FreeContextList (special_list);
   }
   
   last = sep_list;
   while (last != NULL && last->next != NULL) 
   {
     last = last->next;
   }
   if (last == NULL)
   {
     sep_list = new_sep_list;
   }
   else
   {
     last->next = new_sep_list;
   }
 
   SeqEntrySetScope (oldscope);
 
   return sep_list;
 }
 
 
 extern SeqEntryPtr 
 ImportSequencesFromFile
 (FILE           *fp, 
  SeqEntryPtr     sep_list,
  Boolean         is_na, 
  Boolean         parse_id,
  CharPtr         supplied_id_txt,
  ValNodePtr PNTR err_msg_list,
  BoolPtr         chars_stripped)
 {
   return ImportSequencesFromFileEx (fp, sep_list, is_na, parse_id, supplied_id_txt, err_msg_list, chars_stripped, FALSE);
 }
 
 
 static Boolean CollectIDsAndTitles (SeqEntryPtr new_list, SeqEntryPtr current_list, Boolean is_nuc);
 
 static SeqEntryPtr RemoveZeroLengthSequences (SeqEntryPtr list, Int4Ptr pnum_seqs, Int4Ptr pnum_zero)
 {
   SeqEntryPtr  prev_sep, next_sep, this_sep;
   Int4         num_seqs = 0, num_zero = 0;
   BioseqPtr    bsp;
   BioseqSetPtr bssp;
   
   if (list == NULL)
   {
     return NULL;
   }
 
   prev_sep = NULL;
   this_sep = list;
   while (this_sep != NULL)
   {
     num_seqs++;
     next_sep = this_sep->next;
     if (this_sep->data.ptrvalue == NULL)
     {
       num_zero++;
       if (prev_sep == NULL)
       {
         list = next_sep;
       }
       else
       {
         prev_sep->next = next_sep;
       }
       this_sep->next = NULL;
       SeqEntryFree (this_sep);
     }
     else if (IS_Bioseq (this_sep))
     {
       bsp = (BioseqPtr) this_sep->data.ptrvalue;
       if (bsp->length == 0)
       {
         num_zero++;
         
         if (prev_sep == NULL)
         {
           list = next_sep;
         }
         else
         {
           prev_sep->next = next_sep;
         }
         this_sep->next = NULL;
         SeqEntryFree (this_sep);
       }
       else
       {
         prev_sep = this_sep;
       }
     }
     else if (IS_Bioseq_set (this_sep))
     {
       bssp = (BioseqSetPtr) this_sep->data.ptrvalue;
       bssp->seq_set = RemoveZeroLengthSequences (bssp->seq_set, pnum_seqs, pnum_zero);
       if (bssp->seq_set == NULL)
       {
         num_zero++;
         if (prev_sep == NULL)
         {
           list = next_sep;
         }
         else
         {
           prev_sep->next = next_sep;
         }
         this_sep->next = NULL;
         SeqEntryFree (this_sep);
       }
       else
       {
         prev_sep = this_sep;
       }
     }
     else
     {
       prev_sep = this_sep;
     }
     this_sep = next_sep;
   }
   
   if (pnum_seqs != NULL)
   {
     *pnum_seqs += num_seqs;
   }
   if (pnum_zero != NULL)
   {
     *pnum_zero += num_zero;
   }
   return list;
 }
 
 static Boolean RejectZeroLengthSequences (SeqEntryPtr PNTR new_list)
 {
   SeqEntryPtr next_sep;
   Int4        num_zero = 0, num_seq = 0;
   Boolean     rval = TRUE;
   Boolean     delete_all = FALSE;
   
   if (new_list == NULL)
   {
     return FALSE;
   }
   
   *new_list = RemoveZeroLengthSequences (*new_list, &num_seq, &num_zero);
 
   if (num_zero > 0)
   {
     ResetSegSetIDLists (*new_list);
     if (num_zero == num_seq)
     {
       Message (MSG_ERROR, "The sequences in your file are empty - you cannot import them.");
       delete_all = TRUE;
       rval = FALSE;
     }
     else if (ANS_CANCEL == Message (MSG_OKC, "%d sequences in your file are empty and cannot be imported.  "
                                     "Would you like to import the remaining sequences?", num_zero))
     {
       delete_all = TRUE;
       rval = FALSE;
     }
     if (delete_all)
     {
       
       while ((*new_list) != NULL)
       {
         next_sep = (*new_list)->next;
         (*new_list)->next = NULL;
         SeqEntryFree (*new_list);
         *new_list = next_sep;
       }
     }
   }
   return rval;
 }
 
 static Boolean RejectExtraSequences (SeqEntryPtr new_list, FastaPagePtr fpp)
 {
   SeqEntryPtr sep, next_sep;
   
   if (new_list == NULL || fpp == NULL)
   {
     return FALSE;
   }
   else if (!fpp->single || new_list->next == NULL)
   {
     return TRUE;
   }
 
   if (fpp->is_na 
            && fpp->seqPackagePtr != NULL 
            && *(fpp->seqPackagePtr) != SEQ_PKG_GENOMICCDNA)
   {
     if (Message (MSG_YN, "You are importing multiple sequences - did you intend to create a batch submission?") == ANS_YES)
     {
       *(fpp->seqPackagePtr) = SEQ_PKG_GENBANK;
       fpp->single = FALSE;
       SafeHide (fpp->singleIdGrp);
       return TRUE;
     }
   }
   if (Message (MSG_YN, "You cannot import multiple sequences - import the first one and ignore the rest?") == ANS_YES)
   {
     sep = new_list->next;
     new_list->next = NULL;
     while (sep != NULL)
     {
       next_sep = sep->next;
       sep->next = NULL;
       sep = SeqEntryFree (sep);
       sep = next_sep;
     }
     return TRUE;
   }
   else
   {
     return FALSE;
   }
 }
 
 static void ShowImportHelp (ButtoN b)
 {
   CharPtr help_msg;
   
   help_msg = (CharPtr) GetObjectExtra (b);
   if (help_msg == NULL)
   {
     return;
   }
   
   Message (MSG_OK, help_msg);
 }
 
 static Boolean OkToImport (CharPtr msg, CharPtr help_msg)
 {
   WindoW w;
   GrouP  h, c;
   PrompT p;
   ButtoN b;
   ModalAcceptCancelData acd;
   
   if (msg == NULL)
   {
     return TRUE;
   }
   acd.accepted = FALSE;
   acd.cancelled = FALSE;
   
   w = ModalWindow(-20, -13, -10, -10, NULL);
   h = HiddenGroup (w, -1, 0, NULL);
   
   p = StaticPrompt (h, msg, 0, 0, programFont, 'l');
   c = HiddenGroup (h, 3, 0, NULL);
   b = PushButton (c, "Yes", ModalAcceptButton);
   SetObjectExtra (b, &acd, NULL);
   b = PushButton (c, "No", ModalCancelButton);
   SetObjectExtra (b, &acd, NULL);
   if (help_msg != NULL)
   {
     b = PushButton (c, "Help", ShowImportHelp);
     SetObjectExtra (b, help_msg, NULL);
   }
   AlignObjects (ALIGN_CENTER, (HANDLE) p, (HANDLE) c, NULL);
   
   Show(w); 
   Select (w);
   while (!acd.accepted && ! acd.cancelled)
   {
     ProcessExternalEvent ();
     Update ();
   }
   ProcessAnEvent ();
   Remove (w);
   if (acd.accepted)
   {
     return TRUE;
   }
   else
   {
     return FALSE;
   }
 }
 
 static CharPtr segset_import_help_str = "Segmented sequence: a collection of non-overlapping, non-contiguous sequences that cover a specified genetic region. A standard example is a set of genomic DNA sequences that encode exons from a gene along with fragments of their flanking introns.";
 static CharPtr gapped_import_help_str = "Gapped sequence: a sequence with one or more gaps of known or unknown length.";
 
 
 static Boolean ImportedSequenceTypeOk (SeqEntryPtr list, Int2 seqPackage)
 {
   BioseqPtr bsp;
   Boolean   rval = TRUE;
   
   if (list == NULL || seqPackage != SEQ_PKG_SINGLE)
   {
     return TRUE;
   }
   if (list->choice == 1)
   {
     bsp = (BioseqPtr) list->data.ptrvalue;
     if (bsp != NULL && bsp->repr == Seq_repr_delta)
     {
       SendHelpScrollMessage (helpForm, "Sequence Format Form", NULL);
       rval = OkToImport ("You have imported a gapped sequence.  Did you mean to do that?",
                          gapped_import_help_str);
     }
   }
   else if (list->choice == 2)
   {
     SendHelpScrollMessage (helpForm, "Sequence Format Form", NULL);
     rval = OkToImport ("You have imported a segmented sequence.  Did you mean to do that?",
                        segset_import_help_str);
   }
   return rval;
 }
 
 static Boolean ImportFastaDialog (DialoG d, CharPtr filename)
 
 {
   CharPtr       extension;
   FILE          *f;
   FastaPagePtr  fpp;
   ValNodePtr    head;
   Char          path [PATH_MAX];
   RecT          r;
   SeqEntryPtr   sep, new_sep_list, new_sep, test_sep;
   Boolean       rval = FALSE;
   BioseqPtr     bsp;
   CharPtr       supplied_id_txt = NULL;
   Boolean       chars_stripped = FALSE;
 
   path [0] = '\0';
   StringNCpy_0 (path, filename, sizeof (path));
   fpp = (FastaPagePtr) GetObjectExtra (d);
   if (fpp != NULL) {
     if (fpp->list != NULL && fpp->single)
     {
       if (!fpp->is_na
           || fpp->seqPackagePtr == NULL
           || *fpp->seqPackagePtr == SEQ_PKG_GENOMICCDNA)
       {
         Message (MSG_ERROR, "Can't import additional sequences!");
         return FALSE;
       }
       else
       {
         if (Message (MSG_YN, "You are importing multiple sequences - did you intend to create a batch submission?") == ANS_NO)
         {
           Message (MSG_ERROR, "Can't import additional sequences!");
           return FALSE;
         }
         else
         {
           *(fpp->seqPackagePtr) = SEQ_PKG_GENBANK;
           fpp->single = FALSE;
           SafeHide (fpp->singleIdGrp);
         }
       }
     }
     extension = NULL;
     if (fpp->is_mrna) {
       extension = GetAppProperty ("FastaNucExtension");
     } else if (fpp->is_na) {
       extension = GetAppProperty ("FastaNucExtension");
     } else {
       extension = GetAppProperty ("FastaProtExtension");
     }
     if (path [0] != '\0' || GetInputFileName (path, sizeof (path), extension, "TEXT")) {
       WatchCursor ();
       StringCpy (fpp->path, path);
       ObjectRect (fpp->doc, &r);
       InsetRect (&r, 4, 4);
       faColFmt.pixWidth = r.right - r.left;
       /*
       ResetFastaPage (fpp);
       */
       Reset (fpp->doc);
       Update ();
       sep = fpp->list;
       head = fpp->errmsgs;
       f = FileOpen (fpp->path, "r");
       if (f == NULL)
       {
         Message (MSG_ERROR, "Unable to open %s", fpp->path);
         fpp->path[0] = 0;
       }
       else
       {
         if (fpp->singleSeqID != NULL)
         {
           supplied_id_txt = SaveStringFromText (fpp->singleSeqID);
         }
         new_sep_list = ImportSequencesFromFile (f, NULL, fpp->is_na, 
                                                 fpp->parseSeqId, 
                                                 supplied_id_txt,
                                                 &head, &chars_stripped);
         if (chars_stripped && new_sep_list != NULL)
         {
           if (ANS_CANCEL == Message (MSG_OKC, "Illegal characters will be stripped from your sequence data.  Do you want to continue?"))
           {
             new_sep_list = SeqEntryFree (new_sep_list);
             FileClose (f);
             fpp->path [0] = 0;
             ArrowCursor ();
             Update ();
             return FALSE;
           }
         }
         supplied_id_txt = MemFree (supplied_id_txt);                                              
         if (fpp->seqPackagePtr != NULL 
             && *(fpp->seqPackagePtr) == SEQ_PKG_SEGMENTED
             && new_sep_list != NULL
             && IS_Bioseq (new_sep_list))
         {
           new_sep_list = SegsetFromSeqEntryList (new_sep_list);
         }
         FileClose (f);
         
         if (new_sep_list != NULL
             && new_sep_list->next == NULL
             && fpp->single
             && fpp->list == NULL
             && fpp->is_na
             && new_sep_list->choice == 1
             && new_sep_list->data.ptrvalue != NULL)
         {
           bsp = (BioseqPtr) new_sep_list->data.ptrvalue;
           
           /* assign a fake ID if there is only one sequence being imported, 
            * the package type is single, and there are no other sequences
            * from previous imports.
            */
           
           if (bsp->id == NULL)
           {
             bsp->id = MakeSeqID ("nuc_1");
           }
         }
       
         if (new_sep_list == NULL)
         {
           Message (MSG_ERROR, "Unable to read sequences from %s", fpp->path);
           fpp->path [0] = 0;
         }
         else if (! RejectZeroLengthSequences (&new_sep_list))
         {
           fpp->path [0] = 0;
         }
         else if (! RejectExtraSequences (new_sep_list, fpp))
         {
           /* if unsuccessful, delete new list */ 
           new_sep = new_sep_list;   
           while (new_sep != NULL)
           {
             test_sep = new_sep->next;
             SeqEntryFree (new_sep);
             new_sep = test_sep;
           }
           fpp->path [0] = 0;
         }
         else if (fpp->seqPackagePtr != NULL
                  && ! ImportedSequenceTypeOk (new_sep_list, *(fpp->seqPackagePtr)))
         {
           /* if unsuccessful, delete new list */ 
           new_sep = new_sep_list;   
           while (new_sep != NULL)
           {
             test_sep = new_sep->next;
             SeqEntryFree (new_sep);
             new_sep = test_sep;
           }
           fpp->path [0] = 0;
         }
         else if (CollectIDsAndTitles (new_sep_list, fpp->list, (fpp->is_na && ! fpp->is_mrna)))
         {
           if (fpp->is_na)
           {
             /* add default molecule type, topology, location, and genetic codes */
             AddDefaultModifierValues (new_sep_list);
           }
         
           /* if successful, link old and new lists */
           ValNodeLink (&(fpp->list), new_sep_list);
           rval = TRUE;
         }
         else
         {
           /* if unsuccessful, delete new list */ 
           new_sep = new_sep_list;   
           while (new_sep != NULL)
           {
             test_sep = new_sep->next;
             SeqEntryFree (new_sep);
             new_sep = test_sep;
           }
           fpp->path [0] = 0;
         }
       }
       
       if (fpp->list == NULL)
       {
         SafeHide (fpp->have_seq_instr_grp);
         Reset (fpp->doc);
         SafeShow (fpp->instructions);
         Update ();
         SetTitle (fpp->import_btn, "Import Nucleotide FASTA");
         Enable (fpp->import_btn);
         Disable (fpp->clear_btn);
       }
       else
       {        
         SafeHide (fpp->instructions);
         Update ();
         if (! fpp->is_na || fpp->single 
             || fpp->seqPackagePtr == NULL 
             || *fpp->seqPackagePtr == SEQ_PKG_GENOMICCDNA)
         {
           Disable (fpp->import_btn);
         }
         else
         {
           Enable (fpp->import_btn);
           SetTitle (fpp->import_btn, "Import Additional Nucleotide FASTA");
         }
         Enable (fpp->clear_btn);
         FormatFastaDoc (fpp);
         SafeShow (fpp->have_seq_instr_grp);
       }
       ArrowCursor ();
       Update ();
       return rval;
     }
   }
   return FALSE;
 }
 
 #define EXPORT_PAGE_WIDTH 80
 
 static void ExportSeqIdAndTitle (SeqIdPtr sip, CharPtr title, FILE *fp)
 {
   CharPtr id_str = NULL;
 
   if (fp == NULL)
   {
     return;
   }
   
   id_str [0] = 0;
   if (sip == NULL)
   {
     id_str = StringSave ("unknown_id");
   }
   else
   {
     id_str = SeqIdWholeLabel (sip, PRINTID_REPORT);
   }
   
   if (StringCSpn (id_str, " \t") == StringLen (id_str))
   {
     fprintf (fp, ">%s %s\n", id_str, title == NULL ? "" : title);
   }
   else
   {
     fprintf (fp, ">'%s' %s\n", id_str, title == NULL ? "" : title);
   }
   id_str = MemFree (id_str);
 }
 
 static void ExportSeqPort (Int4 from, Int4 to, SeqPortPtr spp, FILE *fp)
 {
   Char        buffer [EXPORT_PAGE_WIDTH + 1];
   Int4        seq_offset, txt_out;
 
   if (spp == NULL || fp == NULL || from < 0 || to <= from)
   {
     return;
   }
   
   seq_offset = from;
   while (seq_offset < to)
   {
     txt_out = ReadBufferFromSep (spp, buffer, seq_offset, 
                                  MIN (seq_offset + EXPORT_PAGE_WIDTH, to), 0);
     if (txt_out == 0) break;
     seq_offset += txt_out;
     fprintf(fp, "%s\n", buffer);
   }
   
 }
 
 static void ExportOneRawSequence (BioseqPtr bsp, CharPtr title_master, FILE *fp)
 {
   SeqDescrPtr sdp;
   Char        buffer [EXPORT_PAGE_WIDTH + 1];
   SeqPortPtr  spp;
   CharPtr     title = NULL;
   CharPtr     combined_title = NULL;
   Boolean     free_combined = FALSE;
   
   if (bsp == NULL || fp == NULL || bsp->repr != Seq_repr_raw)
   {
     return;
   }  
   
   sdp = bsp->descr;
   while (sdp != NULL && sdp->choice != Seq_descr_title)
   {
     sdp = sdp->next;
   }
   if (sdp != NULL)
   {
     title = sdp->data.ptrvalue;
   }
   
   if (StringHasNoText (title_master))
   {
     combined_title = title;
   }
   else if (StringHasNoText (title))
   {
     combined_title = title_master;
   }
   else
   {
     combined_title = (CharPtr) MemNew ((StringLen (title_master) + StringLen (title) + 2) * sizeof (Char));
     if (combined_title != NULL)
     {
       StringCpy (combined_title, title_master);
       StringCat (combined_title, " ");
       StringCat (combined_title, title);
       free_combined = TRUE;
     }
   }
   
   ExportSeqIdAndTitle (bsp->id, combined_title, fp);
   if (free_combined)
   {
     combined_title = MemFree (combined_title);
   }
 
   buffer [EXPORT_PAGE_WIDTH] = 0;
   
   spp = SeqPortNew (bsp, 0, bsp->length-1, Seq_strand_plus, Seq_code_iupacna);
   
   ExportSeqPort (0, bsp->length, spp, fp);
 
   SeqPortFree (spp);
   fprintf (fp, "\n");  
 }
 
 static void ExportOneSegmentedBioseq (BioseqPtr bsp, FILE *fp)
 {
   SeqLocPtr   slp;
   BioseqPtr   bsp_seg;
   SeqDescrPtr sdp;
   CharPtr     title = NULL;
   
   if (bsp == NULL || fp == NULL || bsp->repr != Seq_repr_seg)
   {
     return;
   }
   
   fprintf (fp, "[\n");
   
   sdp = bsp->descr;
   while (sdp != NULL && sdp->choice != Seq_descr_title)
   {
     sdp = sdp->next;
   }
   if (sdp != NULL)
   {
     title = sdp->data.ptrvalue;
   }
 
   slp = (SeqLocPtr) bsp->seq_ext;
   while (slp != NULL)
   {
     bsp_seg = BioseqFind (SeqLocId (slp));
     ExportOneRawSequence (bsp_seg, title, fp);
     title = NULL;
     slp = slp->next;
   }
   fprintf (fp, "]\n\n");
 }
 
 static Boolean ExportOneDeltaBioseq (BioseqPtr bsp, FILE *fp)
 {
   SeqDescrPtr sdp;
   CharPtr     title = NULL;
   DeltaSeqPtr dsp;
   SeqLitPtr   slip;
   SeqPortPtr  spp;
   Char        buffer [EXPORT_PAGE_WIDTH + 1];
   Int4        seq_offset;
   
   if (bsp == NULL || fp == NULL || bsp->repr != Seq_repr_delta
       || bsp->seq_ext_type != 4 || bsp->seq_ext == NULL)
   {
     return FALSE;
   }
 
   dsp = (DeltaSeqPtr) bsp->seq_ext;
   while (dsp != NULL)
   {
     if (dsp->data.ptrvalue == NULL || dsp->choice != 2)
     {
       Message (MSG_ERROR, "Can't export badly formed delta sequence!");
       return FALSE;
     }
     dsp = dsp->next;
   }
   
   sdp = bsp->descr;
   while (sdp != NULL && sdp->choice != Seq_descr_title)
   {
     sdp = sdp->next;
   }
   if (sdp != NULL)
   {
     title = sdp->data.ptrvalue;
   }
 
   ExportSeqIdAndTitle (bsp->id, title, fp);
   
   buffer [EXPORT_PAGE_WIDTH] = 0;
   
   spp = SeqPortNew (bsp, 0, bsp->length-1, Seq_strand_plus, Seq_code_iupacna);
   
   seq_offset = 0;
   dsp = (DeltaSeqPtr) bsp->seq_ext;
   while (dsp != NULL)
   {
                 slip = (SeqLitPtr) (dsp->data.ptrvalue);
     if (IsDeltaSeqGap(dsp)) 
     {
       if (IsDeltaSeqUnknownGap (dsp))
       {
         fprintf (fp, ">?unk100\n");
       }
       else
       {
         fprintf (fp, ">?%d\n", slip->length);
       }
     }
     else
     {
       ExportSeqPort (seq_offset, seq_offset + slip->length, spp, fp);
                 }
     seq_offset += slip->length;
     dsp = dsp->next;
   }
   fprintf (fp, "\n");
   return TRUE;
 }
 
 static void ExportFASTASeqEntryList (SeqEntryPtr sep, FILE *fp)
 {
   BioseqPtr    bsp;
   BioseqSetPtr bssp;
   
   if (sep == NULL || sep->data.ptrvalue == NULL || fp == NULL)
   {
     return;
   }
   
   if (IS_Bioseq (sep))
   {
     bsp = (BioseqPtr) sep->data.ptrvalue;
     if (ISA_na (bsp->mol))
     {
       if (bsp->repr == Seq_repr_raw)
       {
         if (SeqMgrGetParentOfPart (bsp, NULL) == NULL)
         {
           ExportOneRawSequence (bsp, NULL, fp);
         }
       }
       else if (bsp->repr == Seq_repr_seg)
       {
         ExportOneSegmentedBioseq (bsp, fp);
       }
       else if (bsp->repr == Seq_repr_delta)
       {
         ExportOneDeltaBioseq (bsp, fp);    
       }
     }
   }
   else if (IS_Bioseq_set (sep))
   {
     bssp = (BioseqSetPtr) sep->data.ptrvalue;
     /* we don't export the parts set because we export them
      * when we do the master segment 
      */
     if (bssp->_class != BioseqseqSet_class_parts)
     {
       ExportFASTASeqEntryList (bssp->seq_set, fp);
     }
   }
   ExportFASTASeqEntryList (sep->next, fp);
 }
 
 static Boolean ExportNucleotideFASTADialog (DialoG d, CharPtr filename)
 {
   CharPtr       extension;
   FILE          *f;
   FastaPagePtr  fpp;
   Char          path [PATH_MAX];
   Boolean       rval = FALSE;
 
   fpp = (FastaPagePtr) GetObjectExtra (d);
   if (fpp == NULL) {
     return FALSE;
   }
   
   path [0] = '\0';
   StringNCpy_0 (path, filename, sizeof (path));
 
   extension = NULL;
   if (fpp->is_mrna) {
     extension = GetAppProperty ("FastaNucExtension");
   } else if (fpp->is_na) {
     extension = GetAppProperty ("FastaNucExtension");
   } else {
     extension = GetAppProperty ("FastaProtExtension");
   }
   if (path [0] != '\0' || GetOutputFileName (path, sizeof (path), extension)) {
     f = FileOpen (path, "w");
     if (f == NULL)
     {
       Message (MSG_ERROR, "Unable to open %s", path);
     }
     else
     {
       WatchCursor ();
       ExportFASTASeqEntryList (fpp->list, f);    
       FileClose (f);
       
       ArrowCursor ();
       Update ();
       rval = TRUE;
     }
   }
   return rval;
 }
 
 static void CleanupFastaDialog (GraphiC g, VoidPtr data)
 
 {
   FastaPagePtr  fpp;
 
   fpp = (FastaPagePtr) data;
   if (fpp != NULL) {
     ResetFastaPage (fpp);
   }
   MemFree (data);
 }
 
 static CharPtr  fastaNucMsg = "\
 \nClick on 'Import Nucleotide FASTA' to read a formatted FASTA file \
 or 'Add/Modify Sequences' to create the file here.  The FASTA definition \
 line must be in the following form:\n\n\
 >SeqID [organism=scientific name]\n\n\
 where the [ and ] brackets are actually in the text.\n\
 Properly formatted modifiers and a title can also be included in the FASTA definition line.";
 
 
 static CharPtr  fastaGenMsg = "\
 \nPlease enter information about the genomic \
 sequence in the spaces above.  Then click on either \
 'Add/Modify Sequences' to create your sequences with the editor or \
 'Import Genomic FASTA' to read a previously generated FASTA file that \
 contains the sequence (which can be in segments).  The \
 FASTA definition lines may be of the following form:\n\n\
 >ID [organism=scientific name] [strain=name] [clone=name] title\n\n\
 where the [ and ] brackets are actually in the text.";
 
 static CharPtr  fastaMrnaMsg  = "\
 \nPlease enter information about the transcript \
 sequences in the spaces above.  Then click on \
 'Import Transcript FASTA' to read a FASTA file that \
 contains the sequence (which can be in segments).  The \
 FASTA definition lines may be of the following form:\n\n\
 >ID [gene=symbol] [mrna=name] title\n\n\
 where the [ and ] brackets are actually in the text.";
 
 static CharPtr  fastaProtMsg = "\
 \nPlease enter information about the protein \
 sequences in the spaces above.  Then click on \
 'Import Protein FASTA' to read a FASTA file that \
 contains the sequences.  The FASTA definition lines should \
 be of the following form:\n\n\
 >ID [gene=symbol] [protein=name] title\n\n\
 where the [ and ] brackets are actually in the text.";
 
 static CharPtr GetFastaSettingName (FastaPagePtr fpp)
 {
   if (fpp == NULL)
   {
         return NULL;
   }
   else if (fpp->is_mrna)
   {
     return "PARSEMRNASEQID";    
   }
   else if (fpp->is_na)
   {
     return "PARSENUCSEQID";
   }
   else
   {
     return "PARSEPROTSEQID";
   }
 }
 
 static void ChangeIDParse (ButtoN b)
 {
   FastaPagePtr      fpp;
   CharPtr           setting_name;
 
   fpp = (FastaPagePtr) GetObjectExtra (b);
   if (fpp != NULL) {
     fpp->parseSeqId = GetStatus (b);
   
     setting_name = GetFastaSettingName (fpp);
   
     if (fpp->parseSeqId) {
       SetAppParam ("SEQUINCUSTOM", "PREFERENCES", setting_name, "TRUE");
       SafeHide (fpp->singleIdGrp);
     } else {
       SetAppParam ("SEQUINCUSTOM", "PREFERENCES", setting_name, "FALSE");
       if (fpp->single)
       {
         SafeShow (fpp->singleIdGrp);
       }
       else
       {
         SafeHide (fpp->singleIdGrp);
       }
     }
   }
 }
 
 extern DialoG CreateFastaDialog (GrouP h, CharPtr title,
                                  Boolean is_na, Boolean is_mrna, CharPtr text,
                                  Boolean single, Int2Ptr seqPackagePtr)
 
 {
   FastaPagePtr  fpp;
   GrouP         g;
   GrouP         m;
   GrouP         p;
   GrouP         s;
   PrompT        pr;
   CharPtr       setting_name;
   ButtoN        prs = NULL;
   Char          str [32];
   Boolean       parseSeqId;
 #ifdef WIN_MAC
   Int2          wid = 25;
 #else
   Int2          wid = 33;
 #endif
 
   p = HiddenGroup (h, 1, 0, NULL);
   SetGroupSpacing (p, 10, 10);
 
   fpp = (FastaPagePtr) MemNew (sizeof (FastaPage));
   if (fpp != NULL) {
 
     SetObjectExtra (p, fpp, CleanupFastaDialog);
     fpp->dialog = (DialoG) p;
     fpp->todialog = NULL;
     fpp->fromdialog = NULL;
     fpp->importdialog = ImportFastaDialog;
     if (is_na)
     {
       fpp->exportdialog = ExportNucleotideFASTADialog;
     }
     else
     {
       fpp->exportdialog = NULL;
     }
 
     fpp->seqPackagePtr = seqPackagePtr;
     if (title != NULL && title [0] != '\0') {
       s = NormalGroup (p, 0, -2, title, systemFont, NULL);
     } else {
       s = HiddenGroup (p, 0, -2, NULL);
     }
     m = HiddenGroup (s, -1, 0, NULL);
 
     fpp->path [0] = '\0';
     fpp->is_na = is_na;
     fpp->is_mrna = is_mrna;
     fpp->single = single;
 
     setting_name = GetFastaSettingName (fpp);
     
     if (GetAppParam ("SEQUINCUSTOM", "SETTINGS", "ALLOWNOSEQID", NULL, str, sizeof (str))
         && StringICmp (str, "TRUE") == 0)
     {
       prs = CheckBox (m, "Fasta definition line starts with sequence ID", ChangeIDParse);
       SetObjectExtra (prs, fpp, NULL);
     }
     parseSeqId = FALSE;
     if (GetAppParam ("SEQUINCUSTOM", "PREFERENCES", setting_name, NULL, str, sizeof (str))) {
       if (StringICmp (str, "TRUE") == 0) {
         parseSeqId = TRUE;
       }
     }
     else
     {
       parseSeqId = TRUE;
     }
     SetStatus (prs, parseSeqId);
     
     fpp->parseSeqId = parseSeqId;
     if (fpp->single) {
       fpp->singleIdGrp = HiddenGroup (m, 2, 0, NULL);
       StaticPrompt (fpp->singleIdGrp, "Enter unique identifier for this sequence", 0, dialogTextHeight, programFont, 'l');
       fpp->singleSeqID = DialogText (fpp->singleIdGrp, "", 6, NULL);
       if (parseSeqId) {
         Hide (fpp->singleIdGrp);
       }
     }
 
     g = HiddenGroup (m, 0, 0, NULL);
     fpp->instructions = MultiLinePrompt (g, text, 27 * stdCharWidth, programFont);
     fpp->have_seq_instr_grp = HiddenGroup (g, -1, 0, NULL);
     SetGroupSpacing (fpp->have_seq_instr_grp, 10, 10);
     fpp->doc = DocumentPanel (fpp->have_seq_instr_grp, stdCharWidth * wid, stdLineHeight * 12);
     SetDocAutoAdjust (fpp->doc, FALSE);
     pr = StaticPrompt (fpp->have_seq_instr_grp, "Choose Clear from the Edit menu to clear these sequences", 0, dialogTextHeight, systemFont, 'c');
     AlignObjects (ALIGN_CENTER, (HANDLE) fpp->doc, (HANDLE) pr, NULL);
     Hide (fpp->have_seq_instr_grp);
     AlignObjects (ALIGN_CENTER, (HANDLE) fpp->instructions,
                   (HANDLE) fpp->have_seq_instr_grp, NULL);
                   
     AlignObjects (ALIGN_CENTER, (HANDLE) g,
                                 (HANDLE) prs,
                                 (HANDLE) fpp->singleIdGrp,
                                 NULL);                  
   }
 
   return (DialoG) p;
 }
 
 typedef struct phylippage {
   DIALOG_MESSAGE_BLOCK
   Uint1        format;
   Char         path [PATH_MAX];
   SeqEntryPtr  sep;
   ValNodePtr   errmsgs;
   DoC          doc;
   GrouP        instructions;
   Char         extension [10];
   Int4         type;
   TSequenceInfoPtr aln_settings;
 
 } PhylipPage, PNTR PhylipPagePtr;
 
 
 #define PhylipFormatBufLen 1000
 
 static void FormatPhylipDoc (PhylipPagePtr ppp)
 
 {
   Nlm_QualNameAssocPtr ap;
   BioseqPtr          bsp;
   BioseqSetPtr       bssp;
   CharPtr            label;
   Int4               len;
   CharPtr            measure;
   SeqEntryPtr        nsep;
   Int2               num;
   CharPtr            plural;
   SeqIdPtr           sip;
   SeqEntryPtr        sep;
   CharPtr            str;
   CharPtr            title;
   CharPtr            ttl;
   CharPtr            tmp;
   CharPtr            valstr;
   ValNodePtr         vnp;
 
   if (ppp != NULL) {
     str = MemNew (sizeof (char) * PhylipFormatBufLen);
     tmp = MemNew (sizeof (char) * PhylipFormatBufLen);
     if (str == NULL || tmp == NULL) return;
     num = 0;
     len = 0;
     sep = ppp->sep;
     if (sep != NULL && IS_Bioseq_set (sep)) {
       bssp = (BioseqSetPtr) sep->data.ptrvalue;
       if (bssp != NULL && (bssp->_class == 7 ||
                            (IsPopPhyEtcSet (bssp->_class)))) {
         for (sep = bssp->seq_set; sep != NULL; sep = sep->next) {
           num++;
           if (IS_Bioseq (sep)) {
             bsp = (BioseqPtr) sep->data.ptrvalue;
             if (bsp != NULL) {
               len += bsp->length;
             }
           } else if (IS_Bioseq_set (sep)) {
             nsep = FindNucSeqEntry (sep);
             if (nsep != NULL && IS_Bioseq (nsep)) {
               bsp = (BioseqPtr) nsep->data.ptrvalue;
               if (bsp != NULL) {
                 len += bsp->length;
               }
             }
           }
         }
       }
     }
     if (num > 1) {
       plural = "s";
     } else {
       plural = "";
     }
     label = "Sequence";
     measure = "nucleotides";
     sprintf (str, "%d nucleotide sequence%s, total length %ld %s\n",
              (int) num, plural, (long) len, measure);
     AppendText (ppp->doc, str, &faParFmt, &faColFmt, programFont);
     vnp = ppp->errmsgs;
     num = 0;
     sep = ppp->sep;
     if (sep != NULL && IS_Bioseq_set (sep)) {
       bssp = (BioseqSetPtr) sep->data.ptrvalue;
       if (bssp != NULL && (bssp->_class == 7 ||
                            (IsPopPhyEtcSet (bssp->_class)))) {
         for (sep = bssp->seq_set; sep != NULL; sep = sep->next) {
           nsep = NULL;
           num++;
           len = 0;
           sip = NULL;
           tmp [0] = '\0';
           if (IS_Bioseq (sep)) {
             bsp = (BioseqPtr) sep->data.ptrvalue;
             if (bsp != NULL) {
               len = bsp->length;
               sip = SeqIdFindWorst (bsp->id);
               SeqIdWrite (sip, tmp, PRINTID_REPORT, FastaFormatBufLen);
             }
           } else if (IS_Bioseq_set (sep)) {
             nsep = FindNucSeqEntry (sep);
             if (nsep != NULL && IS_Bioseq (nsep)) {
               bsp = (BioseqPtr) nsep->data.ptrvalue;
               if (bsp != NULL) {
                 len = bsp->length;
                 sip = SeqIdFindWorst (bsp->id);
                 SeqIdWrite (sip, tmp, PRINTID_REPORT, FastaFormatBufLen);
               }
             }
           }
           sprintf (str, "\n%s %d\nLength: %ld %s\nSequence ID: %s\n", label,
                    (int) num, (long) len, measure, tmp);
           ttl = NULL;
           SeqEntryExplore (nsep, (Pointer) (&ttl), FindFirstTitle);
           title = StringSaveNoNull (ttl);
           if (title != NULL) {
             valstr = FindValueFromPairInDefline ("organism", title);
             if (!StringHasNoText (valstr)) {
               AddReportLine (str, "Organism", valstr);
             }
             valstr = MemFree (valstr);
             RemoveValueFromDefline ("organism", title);
             
             valstr = FindValueFromPairInDefline ("lineage", title);
             if (!StringHasNoText (valstr)) {
               AddReportLine (str, "Lineage", valstr);
             }
             valstr = MemFree (valstr);
             RemoveValueFromDefline ("lineage", title);
 
             for (ap = current_orgmod_subtype_alist; ap->name != NULL; ap++) {
               if (IsNonTextModifier (ap->name))
               {
                 if (FindValuePairInDefLine (ap->name, title, NULL) != NULL)
                 {
                   AddReportLine (str, ap->name, "TRUE");
                   RemoveValueFromDefline (ap->name, title);
                 }
               }
               else
               {
                 valstr = FindValueFromPairInDefline (ap->name, title);
                 if (!StringHasNoText (valstr)) {
                   AddReportLine (str, ap->name, title);  
                 }
                 valstr = MemFree (valstr);
                 RemoveValueFromDefline (ap->name, title);
               }
             }
             for (ap = current_subsource_subtype_alist; ap->name != NULL; ap++) {
               if (IsNonTextModifier (ap->name))
               {
                 if (FindValuePairInDefLine (ap->name, title, NULL) != NULL)
                 {
                   AddReportLine (str, ap->name, "TRUE");
                   RemoveValueFromDefline (ap->name, title);
                 }
               }
               else
               {
                 valstr = FindValueFromPairInDefline (ap->name, title);
                 if (!StringHasNoText (valstr)) {
                   AddReportLine (str, ap->name, title);  
                 }
                 valstr = MemFree (valstr);
                 RemoveValueFromDefline (ap->name, title);
               }
             }
             
             valstr = FindValueFromPairInDefline ("note-orgmod", title);
             if (!StringHasNoText (valstr)) {
               AddReportLine (str, "Note", valstr);
             }
             valstr = MemFree (valstr);
             RemoveValueFromDefline ("note-orgmod", title);
             
             valstr = FindValueFromPairInDefline ("note-subsrc", title);
             if (!StringHasNoText (valstr)) {
               AddReportLine (str, "Note", valstr);
             }
             valstr = MemFree (valstr);
             RemoveValueFromDefline ("note-subsrc", title);
             
             valstr = FindValueFromPairInDefline ("molecule", title);
             if (!StringHasNoText (valstr)) {
               AddReportLine (str, "Molecule", valstr);
             }
             valstr = MemFree (valstr);
             RemoveValueFromDefline ("molecule", title);
             
             valstr = FindValueFromPairInDefline ("moltype", title);
             if (!StringHasNoText (valstr)) {
               AddReportLine (str, "MolType", valstr);
             }
             valstr = MemFree (valstr);
             RemoveValueFromDefline ("moltype", title);
             
             valstr = FindValueFromPairInDefline ("location", title);
             if (!StringHasNoText (valstr)) {
               AddReportLine (str, "Location", valstr);
             }
             valstr = MemFree (valstr);
             RemoveValueFromDefline ("location", valstr);
 
             TrimSpacesAroundString (title);
             if (! StringHasNoText (title)) {
               StringCat (str, "Title: ");
               StringNCat (str, title, 128);
               StringCat (str, "\n");
             } else {
               StringCat (str, "No title detected\n");
             }
           }
           MemFree (title);
           if (vnp != NULL && vnp->data.ptrvalue != NULL) {
             StringCat (str, (CharPtr) vnp->data.ptrvalue);
             StringCat (str, "\n");
           }
           AppendText (ppp->doc, str, &faParFmt, &faColFmt, programFont);
           if (vnp != NULL) {
             vnp = vnp->next;
           }
         }
       }
     }
     MemFree (str);
     MemFree (tmp);
     UpdateDocument (ppp->doc, 0, 0);
   }
 }
 
 static void ResetPhylipPage (PhylipPagePtr ppp)
 
 {
   if (ppp != NULL) {
     ppp->sep = SeqEntryFree (ppp->sep);
     ppp->errmsgs = ValNodeFreeData (ppp->errmsgs);
   }
 }
 
 static CharPtr noOrgInTitleWarning =
 "sequences have organism information in titles. " \
 "It is critical to annotate the data file with organism and source information. " \
 "Please quit Sequin and read the Sequin Quick Guide section on preparing the data files before proceeding.";
 
 static void CountTitlesWithoutOrganisms (SeqEntryPtr sep)
 {
   IDAndTitleEditPtr iatep;
   Int4              seq_num;
   CharPtr           org_name;
   Int4              num_sequences = 0, num_with_orgs = 0;
   
   iatep = SeqEntryListToIDAndTitleEdit (sep);
   if (iatep == NULL)
   {
     return;
   }
   
   for (seq_num = 0; seq_num < iatep->num_sequences; seq_num++)
   {
     if (iatep->is_seg != NULL && iatep->is_seg [seq_num])
     {
       continue;
     }
     num_sequences ++;
     org_name = FindValueFromPairInDefline ("organism", iatep->title_list [seq_num]);
     if (!StringHasNoText (org_name))
     {
       num_with_orgs ++;
     }
     org_name = MemFree (org_name);
   }
   iatep = IDAndTitleEditFree (iatep);
   if (num_sequences != num_with_orgs && num_with_orgs != 0)
   {
     Message (MSG_OK, "%d of %d %s", num_sequences - num_with_orgs, (int) num_sequences, noOrgInTitleWarning);
   }
   
 }
 
 static CharPtr  phylipNucMsg = "\
 \nClick 'Import Nucleotide Alignment' to load your \
 nucleotide alignment file.\n\nClick on 'Custom Alignment Settings' \
 if Sequin has trouble reading your alignment file.";
 
 static void SetPhylipDocInstructions (PhylipPagePtr ppp)
 {
   if (ppp == NULL || ppp->doc == NULL) return;
   Reset (ppp->doc);
   AppendText (ppp->doc, phylipNucMsg, &faParFmt, &faColFmt, programFont);
   UpdateDocument (ppp->doc, 0, 0);
   Update ();
 }
 
 static Boolean ImportPhylipDialog (DialoG d, CharPtr filename)
 {
   Char           path [PATH_MAX];
   PhylipPagePtr  ppp;
   SeqEntryPtr    sep;
   RecT           r;
   FILE           *fp;
   ObjMgrDataPtr  omdptop;
   ObjMgrData     omdata;
   Uint2          parenttype;
   Pointer        parentptr;
   Char           errStr [PATH_MAX + 64];
   CharPtr        no_org_err_msg = NULL;
 
   if (d == NULL || filename == NULL) return FALSE;
 
   path [0] = '\0';
   StringNCpy_0 (path, filename, sizeof (path));
   ppp = (PhylipPagePtr) GetObjectExtra (d);
   if (ppp == NULL) {
     return FALSE;
   }
 
   if (path [0] != '\0' || GetInputFileName (path, sizeof (path), ppp->extension, "TEXT")) {
     WatchCursor ();
     StringCpy (ppp->path, path);
     ObjectRect (ppp->doc, &r);
     InsetRect (&r, 4, 4);
     faColFmt.pixWidth = r.right - r.left;
     Reset (ppp->doc);
     Update ();
     ppp->sep = SeqEntryFree (ppp->sep);
     fp = FileOpen (path, "r");
     if (fp != NULL) {
       ppp->sep = SeqEntryFromAlignmentFile (fp, ppp->aln_settings,
                                             Seq_mol_na, no_org_err_msg);
                                             
       /* check for bracketing issues here */
       if (CollectIDsAndTitles (ppp->sep, NULL, TRUE))
       {
         /* add default molecule type, topology, location, and genetic codes */
         AddDefaultModifierValues (ppp->sep);
       }        
       else
       {
         ppp->sep = SeqEntryFree (ppp->sep);
       }
                                                   
       sep = ppp->sep;
       if (sep != NULL) {
         SaveSeqEntryObjMgrData (ppp->sep, &omdptop, &omdata);
         GetSeqEntryParent (ppp->sep, &parentptr, &parenttype);
         SeqMgrLinkSeqEntry (sep, parenttype, parentptr);
         RestoreSeqEntryObjMgrData (sep, omdptop, &omdata);
 
         FormatPhylipDoc (ppp);
         SafeShow (ppp->doc);
 
         CountTitlesWithoutOrganisms (sep);
       } else {
         SendHelpScrollMessage (helpForm, "Nucleotide Page", "Nucleotide Page for Aligned Data Formats");
         SetPhylipDocInstructions (ppp);
       }
     } else {
       SetPhylipDocInstructions (ppp);
     }
   } else {
         sprintf (errStr, "ERROR: Unable to open file %s\n\n", path);
         AppendText (ppp->doc, errStr, &faParFmt, &faColFmt, programFont);
         AppendText (ppp->doc, strerror(errno), &faParFmt, &faColFmt, programFont);
         SafeShow (ppp->doc);
     Update ();
   }
   ArrowCursor ();
   Update ();
   return TRUE;
 }
 
 static void CleanupPhylipDialog (GraphiC g, VoidPtr data)
 
 {
   PhylipPagePtr  ppp;
 
   ppp = (PhylipPagePtr) data;
   if (ppp != NULL) {
     ResetPhylipPage (ppp);
     SequenceInfoFree (ppp->aln_settings);
     ppp->aln_settings = NULL;
   }
   MemFree (data);
 }
 
 
 static DialoG CreatePhylipDialog (GrouP h, CharPtr title, CharPtr text,
                                   Int2 format, CharPtr extension,
                                   Int4 type)
 
 {
   PhylipPagePtr  ppp;
   GrouP          g;
   GrouP          m;
   GrouP          p;
   GrouP          s;
   RecT          r;
 
   p = HiddenGroup (h, 1, 0, NULL);
   SetGroupSpacing (p, 10, 10);
 
   ppp = (PhylipPagePtr) MemNew (sizeof (PhylipPage));
   if (ppp != NULL) {
 
     SetObjectExtra (p, ppp, CleanupPhylipDialog);
     ppp->dialog = (DialoG) p;
     ppp->todialog = NULL;
     ppp->fromdialog = NULL;
     ppp->importdialog = ImportPhylipDialog;
     ppp->type = type;
 
     if (title != NULL && title [0] != '\0') {
       s = NormalGroup (p, 0, -2, title, systemFont, NULL);
     } else {
       s = HiddenGroup (p, 0, -2, NULL);
     }
     m = HiddenGroup (s, -1, 0, NULL);
 
     ppp->format = format;
     ppp->path [0] = '\0';
     StringNCpy_0 (ppp->extension, extension, sizeof (ppp->extension));
   
     g = HiddenGroup (m, 0, 0, NULL);
     ppp->doc = DocumentPanel (g, stdCharWidth * 27, stdLineHeight * 8);
     ObjectRect (ppp->doc, &r);
     InsetRect (&r, 4, 4);
     faColFmt.pixWidth = r.right - r.left;
 
     ppp->aln_settings = GetDefaultSequenceInfo();
 
     SetPhylipDocInstructions (ppp);
   }
 
   return (DialoG) p;
 }
 
 #define NUCLEOTIDE_PAGE   0
 #define ORGANISM_PAGE     1
 #define MRNA_PAGE         2
 #define PROTEIN_PAGE      3
 #define ANNOTATE_PAGE     4
 
 /*---------------------------------------------------------------------*/
 /*                                                                     */
 /* HasZeroLengthSequence () -- Checks to see if any of a submission's  */
 /*                             sequences are missing (ie -- zero       */
 /*                             length).                                */
 /*                                                                     */
 /*---------------------------------------------------------------------*/
 
 extern Boolean HasZeroLengthSequence (ForM newForm)
 {
   SequencesFormPtr  sqfp;
   FastaPagePtr      fpp;
   SeqEntryPtr       sep;
   BioseqPtr         bsp;
 
   /* Get the list of Bioseqs to check */
 
   sqfp = (SequencesFormPtr) GetObjectExtra (newForm);
   if (NULL == sqfp)
     return TRUE;
 
   fpp = GetObjectExtra (sqfp->dnaseq);
   sep = fpp->list;
 
   /* Check the list */
 
   while (NULL != sep) {
     if (sep->choice == 1) { 
       bsp = (BioseqPtr) sep->data.ptrvalue;
       if (bsp->length <= 0)
         return TRUE;
     }
     sep = sep->next;
   }
 
   /* If we made it to here, then */
   /* there were none found.      */
 
   return FALSE;
 }
 
 extern Boolean SequencesFormHasProteins (ForM f)
 
 {
   FastaPagePtr      fpp;
   SequencesFormPtr  sqfp;
 
   sqfp = (SequencesFormPtr) GetObjectExtra (f);
   if (sqfp != NULL) {
     if (PackageTypeIsSet (sqfp->seqPackage)) return TRUE;
     fpp = GetObjectExtra (sqfp->protseq);
     if (fpp != NULL) {
       if (fpp->path [0] != '\0') {
         return TRUE;
       }
     }
   }
   return FALSE;
 }
 
 extern SeqEntryPtr GetSequencesFormProteinList (ForM f)
 
 {
   FastaPagePtr      fpp;
   SequencesFormPtr  sqfp;
 
   sqfp = (SequencesFormPtr) GetObjectExtra (f);
   if (sqfp != NULL) {
     fpp = GetObjectExtra (sqfp->protseq);
     if (fpp != NULL) {
       return fpp->list;
     }
   }
   return NULL;
 }
 
 static SeqEntryPtr GetSeqEntryFromSequencesForm (SequencesFormPtr sqfp)
 {
   SeqEntryPtr list = NULL;
   FastaPagePtr       fpp;
   PhylipPagePtr      ppp;
   SeqEntryPtr        sep;
   BioseqSetPtr       bssp;
   
   if (sqfp == NULL) return NULL;
 
   if (sqfp->seqPackage == SEQ_PKG_SEGMENTED) 
   {
     fpp = (FastaPagePtr) GetObjectExtra (sqfp->dnaseq);
     if (fpp != NULL) 
     {
       list = fpp->list;
     }
   }
   else if (sqfp->seqFormat == SEQ_FMT_FASTA) {
     fpp = (FastaPagePtr) GetObjectExtra (sqfp->dnaseq);
     if (fpp != NULL) 
     {
       list = fpp->list;
     }
   } else if (sqfp->seqFormat == SEQ_FMT_ALIGNMENT) {
     ppp = (PhylipPagePtr) GetObjectExtra (sqfp->dnaseq);
     if (ppp != NULL) {
       sep = ppp->sep;
       if (sep != NULL && IS_Bioseq_set (sep)) {
         bssp = (BioseqSetPtr) sep->data.ptrvalue;
         if (bssp != NULL) {
           list = bssp->seq_set;
         }
       }
     }
   }
   return list;
 }
 
 extern SeqEntryPtr GetSequencesFormNucleotideList (ForM f)
 {
   SequencesFormPtr  sqfp;
 
   sqfp = (SequencesFormPtr) GetObjectExtra (f);
   if (sqfp != NULL) {
     return GetSeqEntryFromSequencesForm (sqfp);
   }
   return NULL;
 }
 
 extern Boolean SequencesFormHasTooManyNucleotides (ForM f)
 
 {
   FastaPagePtr      fpp;
   SequencesFormPtr  sqfp;
 
   sqfp = (SequencesFormPtr) GetObjectExtra (f);
   if (sqfp != NULL && PackageTypeIsSingle (sqfp->seqPackage))
   {
     fpp = GetObjectExtra (sqfp->dnaseq);
     if (fpp != NULL) {
       if (fpp->list != NULL && fpp->list->next != NULL) {
         return TRUE;
       }
     }
   }
   return FALSE;
 }
 
 extern DialoG CreateTagListDialogEx (GrouP h, Uint2 rows, Uint2 cols,
                                      Int2 spacing, Uint2Ptr types,
                                      Uint2Ptr textWidths, EnumFieldAssocPtr PNTR alists,
                                      Boolean useBar, Boolean noExtend,
                                      ToDialogFunc tofunc, FromDialogFunc fromfunc);
 
 static ValNodePtr 
 BuildModifierTypeList 
 (ValNodePtr type_list,
  CharPtr    new_title, 
  Boolean    allow_prot)
 {
   ValNodePtr      modifier_info_list;
   ValNodePtr      info_vnp, type_vnp;
   ModifierInfoPtr mip;
   
   modifier_info_list = ParseAllBracketedModifiers (new_title);
   for (info_vnp = modifier_info_list; info_vnp != NULL; info_vnp = info_vnp->next)
   {
     mip = (ModifierInfoPtr)info_vnp->data.ptrvalue;
     if (mip == NULL 
         || mip->modtype == eModifierType_Protein
         || mip->modtype == eModifierType_Organism)
     {
       continue;
     }
     if (mip->modtype == eModifierType_SourceQual)
     {
           for (type_vnp = type_list;
                type_vnp != NULL 
                  && (type_vnp->choice != mip->subtype 
                      || StringICmp (type_vnp->data.ptrvalue, mip->name) != 0); 
                type_vnp = type_vnp->next)
           {
           }
     }
     else
     {
           for (type_vnp = type_list;
                type_vnp != NULL && StringICmp (type_vnp->data.ptrvalue, mip->name) != 0;
                type_vnp = type_vnp->next)
           {
           }
     }
         if (type_vnp == NULL)
         {
           type_vnp = ValNodeNew (type_list);
           if (type_list == NULL) type_list = type_vnp;
           if (type_vnp != NULL)
           {
                 type_vnp->choice = mip->subtype;
                 type_vnp->data.ptrvalue = StringSave (mip->name);
           }
         }
   }
   ModifierInfoListFree (modifier_info_list);
   return type_list;
 }
 
 
 static Uint2 modedit_widths [] = {
   0, 0,
 };
 
 ENUM_ALIST(nontextmodedit_alist)
   {"FALSE",             0},
   {"TRUE",              1},
 END_ENUM_ALIST
 
 extern void ConfirmSequencesFormParsing (ForM f, FormActnFunc putItAllTogether)
 
 {
   SequencesFormPtr  sqfp;
 
   sqfp = (SequencesFormPtr) GetObjectExtra (f);
   if (sqfp != NULL && putItAllTogether != NULL) {
     putItAllTogether (sqfp->form);
   }
 }
 
 extern void AddToSubSource (BioSourcePtr biop, CharPtr title, CharPtr label, Uint1 subtype)
 
 {
   CharPtr       ptr;
   SubSourcePtr  ssp;
   CharPtr       str;
   SubSourcePtr  tmpssp;
 
   if (biop == NULL || title == NULL || label == NULL) return;
   str = MemNew (StringLen (title));
   if (str == NULL) return;
   ptr = StringISearch (title, label);
   if (ptr != NULL) {
     StringCpy (str, ptr + StringLen (label));
     ptr = StringChr (str, ']');
     if (ptr != NULL) {
       *ptr = '\0';
       TrimSpacesAroundString (str);
       ssp = SubSourceNew ();
       if (biop->subtype == NULL) {
         biop->subtype = ssp;
       } else {
         tmpssp = biop->subtype;
         while (tmpssp->next != NULL) {
           tmpssp = tmpssp->next;
         }
         tmpssp->next = ssp;
       }
       if (ssp != NULL) {
         ssp->subtype = subtype;
         ssp->name = StringSave (str);
       }
     }
   }
   MemFree (str);
 }
 
 extern void AddToOrgMod (BioSourcePtr biop, CharPtr title, CharPtr label, Uint1 subtype)
 
 {
   OrgModPtr   mod;
   OrgNamePtr  onp;
   OrgRefPtr   orp;
   CharPtr     ptr;
   CharPtr     str;
   OrgModPtr   tmpmod;
 
   if (biop == NULL || title == NULL || label == NULL) return;
   str = MemNew (StringLen (title));
   if (str == NULL) return;
   ptr = StringISearch (title, label);
   if (ptr != NULL) {
     StringCpy (str, ptr + StringLen (label));
     ptr = StringChr (str, ']');
     if (ptr != NULL) {
       *ptr = '\0';
       TrimSpacesAroundString (str);
       orp = biop->org;
       if (orp == NULL) {
         orp = OrgRefNew ();
         biop->org = orp;
       }
       if (orp != NULL) {
         onp = orp->orgname;
         if (onp == NULL) {
           onp = OrgNameNew ();
           orp->orgname = onp;
         }
         if (onp != NULL) {
           mod = OrgModNew ();
           if (onp->mod == NULL) {
             onp->mod = mod;
           } else {
             tmpmod = onp->mod;
             while (tmpmod->next != NULL) {
               tmpmod = tmpmod->next;
             }
             tmpmod->next = mod;
           }
           if (mod != NULL) {
             mod->subtype = subtype;
             mod->subname = StringSave (str);
           }
         }
       }
     }
   }
   MemFree (str);
 }
 
 #define PROC_NUC_STR_SIZE 4096
 
 static Int4 TopologyFromString (CharPtr str)
 {
   EnumFieldAssocPtr  eap;
 
   for (eap = topology_nuc_alist; eap != NULL && eap->name != NULL; eap++)
   {
     if (StringICmp (eap->name, str) == 0)
     {
       return eap->value;
     }
   }
   return 1; 
 }
 
 static BioSourcePtr AddOrgRef (BioSourcePtr biop)
 {
   if (biop == NULL)
   {
     biop = BioSourceNew ();
   }
   if (biop == NULL)
   {
     return NULL;
   }
   if (biop->org == NULL)
   {
     biop->org = OrgRefNew ();
   }
   if (biop->org == NULL)
   {
     biop = BioSourceFree (biop);
     return NULL;
   }
   return biop;
 }
 
 static BioSourcePtr AddOrgName (BioSourcePtr biop)
 {
   biop = AddOrgRef (biop);
   if (biop == NULL || biop->org == NULL)
   {
     biop = BioSourceFree (biop);
     return NULL; 
   }
   if (biop->org->orgname == NULL)
   {
     biop->org->orgname = OrgNameNew ();
     if (biop->org->orgname == NULL)
     {
       biop = BioSourceFree (biop);
       return NULL;
     }
   }
   return biop;
 }
 
 static BioSourcePtr SetGeneticCodeForBioSource (BioSourcePtr biop, Int4 gcode, Boolean is_nuc)
 {
   OrgRefPtr  orp;
   OrgNamePtr onp;
 
   if (gcode < 0)
   {
     return biop;
   }
 
   biop = AddOrgName (biop);
   if (biop == NULL)
   {
     return biop;
   }
   
   orp = biop->org;
   if (biop->org == NULL)
   {
     biop->org = OrgRefNew ();
     orp = biop->org;
   }
   if (orp != NULL) {
     onp = orp->orgname;
     if (onp == NULL) {
       onp = OrgNameNew ();
       orp->orgname = onp;
     }
     if (onp != NULL) {
       if (is_nuc)
       {
         onp->gcode = gcode;
       }
       else
       {
         onp->mgcode = gcode;
       }
     }
   }
   return biop;
 }
 
 static BioSourcePtr
 SetGeneticCodeFromTitle 
 (BioSourcePtr biop,
  CharPtr      title, 
  CharPtr      mod_name, 
  Boolean      is_nuc)
 {
   CharPtr    gcode_str;
   Int4       gcode;
   CharPtr    next_org_loc;
   
   if (StringHasNoText (title))
   {
     return biop;
   }
   
   next_org_loc = FindValuePairInDefLine ("organism", title, NULL);
   gcode_str = FindValueFromPairInDeflineBeforeCharPtr (mod_name, title, next_org_loc);
   if (!StringHasNoText (gcode_str))
   {
     gcode = GeneticCodeFromString (gcode_str);  
     biop = SetGeneticCodeForBioSource (biop, gcode, is_nuc);     
   }
   if (gcode_str != NULL)
   {
     RemoveValueFromDefline (mod_name, title);
   }
   gcode_str = MemFree (gcode_str);
   return biop;
 }
 
 static BioSourcePtr 
 SetAllGeneticCodesFromTitle 
 (BioSourcePtr biop,
  CharPtr      title)
 {
   Int4    code_to_use;
   CharPtr location;
   CharPtr next_org_loc;
   
   if (StringHasNoText (title))
   {
     return biop;
   }
   
   next_org_loc = FindValuePairInDefLine ("organism", title, NULL);
   location = FindValueFromPairInDeflineBeforeCharPtr ("location", title, next_org_loc);
   if (!StringHasNoText (location)) 
   {      
     code_to_use = UseGeneticCodeForLocation (location);
     if (code_to_use == USE_OTHER_GENETIC_CODE)
     {
       biop = SetGeneticCodeForBioSource (biop, 11, TRUE); 
       RemoveValueFromDefline ("genetic_code", title);    
     }
     else if (code_to_use == USE_NUCLEAR_GENETIC_CODE)
     {
       biop = SetGeneticCodeFromTitle (biop, title, "genetic_code", TRUE);
     }
     else if (code_to_use == USE_MITOCHONDRIAL_GENETIC_CODE)
     {
       biop = SetGeneticCodeFromTitle (biop, title, "genetic_code", FALSE);
     }
   }
   location = MemFree (location);
   
   biop = SetGeneticCodeFromTitle (biop, title, "gcode", TRUE);
   biop = SetGeneticCodeFromTitle (biop, title, "mgcode", FALSE);
 
   return biop;
 }
 
 static void 
 SetMoleculeAndMolTypeFromTitle 
 (BioseqPtr   bsp, 
  CharPtr     title,
  Int2        seqPackage)
 {
   SeqEntryPtr sep;
   ValNodePtr vnp;
   MolInfoPtr mip = NULL;
   Uint1      biomol;
   Int4       molecule;
   CharPtr    valstr;
   CharPtr    ptr;
   SeqLocPtr  slp;
   BioseqPtr  bsp_seg;
   
   if (bsp == NULL)
   {
     return;
   }
   
   sep = SeqMgrGetSeqEntryForData (bsp); 
   if (sep == NULL)
   {
     return;
   }
     
   vnp = SeqEntryGetSeqDescr (sep, Seq_descr_molinfo, NULL);
   if (vnp == NULL)
   {
     if (seqPackage == SEQ_PKG_SINGLE)
     {
       biomol = 3;
       molecule = Seq_mol_rna;
     }
     else 
     {
       biomol = 1;
       molecule = Seq_mol_dna;
     }
   }
   else
   {
     mip = (MolInfoPtr) vnp->data.ptrvalue;
     biomol = mip->biomol;
     molecule = bsp->mol;
   }
   
   /* get moltype from defline */
   valstr = FindValueFromPairInDefline ("moltype", title);
   if (!StringHasNoText (valstr))
   {
     biomol = MolTypeFromString (valstr);
     if (biomol == 1)
     {
       molecule = Seq_mol_na;
     }
     else if (biomol >= 2 && biomol <= 7)
     {
       molecule = Seq_mol_rna;
     }
     else if (biomol == 9)
     {
       molecule = Seq_mol_dna;
     }
     else if (biomol == 253)
     {
       molecule = Seq_mol_dna;
       biomol = 1;
     }
     else if (biomol == 254)
     {
       molecule = Seq_mol_rna;
       biomol = 1;
     }
     else if (biomol == 255)
     {
       molecule = Seq_mol_other;
     }
   }
   valstr = MemFree (valstr);
   
   RemoveValueFromDefline ("moltype", title);
 
   /* get molecule from defline */ 
   valstr = FindValueFromPairInDefline ("molecule", title);
   if (!StringHasNoText (valstr))
   {
     if (StringICmp (valstr, "dna") == 0) {
       molecule = Seq_mol_dna;
     } else if (StringICmp (valstr, "rna") == 0) {
       molecule = Seq_mol_rna;
     }
   }
   valstr = MemFree (valstr);
   RemoveValueFromDefline ("molecule", title);
   
   ptr = StringISearch (title, "[dna]");
   if (ptr != NULL)
   {
     molecule = Seq_mol_dna;
     ExciseString (title, "[dna", "]");
   }
   
   ptr = StringISearch (title, "[rna]");
   if (ptr != NULL)
   {
     molecule = Seq_mol_rna;
     ExciseString (title, "[rna", "]");
   }
   
   if (mip == NULL)
   {
     vnp = CreateNewDescriptor (sep, Seq_descr_molinfo);
     mip = MolInfoNew ();
     vnp->data.ptrvalue = mip;
   }
      
   mip->biomol = biomol;
   bsp->mol = molecule;  
 
   valstr = FindValueFromPairInDefline ("tech", title);
   if (!StringHasNoText (valstr))
   {
     ReadTechFromString (valstr, mip);
   }
   valstr = MemFree (valstr);
   RemoveValueFromDefline ("tech", title);
   
   if (bsp->repr == Seq_repr_seg)
   {
     slp = (SeqLocPtr) bsp->seq_ext;
     while (slp != NULL)
     {
       bsp_seg = BioseqFind (SeqLocId (slp));
       sep = SeqMgrGetSeqEntryForData (bsp_seg);
       if (bsp_seg != NULL)
       {
         bsp_seg->mol = bsp->mol;
       }
       vnp = SeqEntryGetSeqDescr (sep, Seq_descr_molinfo, NULL);
       if (vnp == NULL)
       {
         vnp = CreateNewDescriptor (sep, Seq_descr_molinfo);
       }
       if (vnp != NULL)
       {
         vnp->data.ptrvalue = MolInfoFree (vnp->data.ptrvalue);
         vnp->data.ptrvalue = (MolInfoPtr) AsnIoMemCopy (mip, (AsnReadFunc) MolInfoAsnRead,
                                                             (AsnWriteFunc) MolInfoAsnWrite);
       }
       slp = slp->next;
     }
   }
 }
 
 static void AddGeneticCodeComment (BioseqPtr bsp, CharPtr comment)
 {
   SeqDescPtr         sdp;
   UserObjectPtr      uop = NULL;
   ObjectIdPtr        oip;
   UserFieldPtr       ufp, last_ufp = NULL;
   CharPtr            comment_fmt = "Submitter genetic code: %s";
   CharPtr            new_comment;
   Int4               new_comment_len;
 
   if (bsp == NULL || StringHasNoText (comment))
   {
     return;
   }
   
   sdp = bsp->descr;
   while (sdp != NULL && uop == NULL)
   {
     if (sdp->choice == Seq_descr_user && sdp->data.ptrvalue != NULL)
     {
       uop = (UserObjectPtr) sdp->data.ptrvalue;
       oip = uop->type;
       if (oip == NULL || StringCmp (oip->str, "Submission") != 0)
       {
         uop = NULL;
       }
     }
     sdp = sdp->next;
   }
   
   
   if (uop == NULL)
   {
     uop = UserObjectNew ();
     if (uop == NULL)
     {
       return;
     }
     uop->type = ObjectIdNew ();
     uop->type->str = StringSave ("Submission");
     ValNodeAddPointer (&bsp->descr, Seq_descr_user, uop);  
   }
   
   ufp = uop->data;
   while (ufp != NULL 
          && (ufp->label == NULL 
            || StringCmp (ufp->label->str, "AdditionalComment") != 0))
   {
     last_ufp = ufp;
     ufp = ufp->next;
   }
   
   if (ufp == NULL)
   {
     ufp = UserFieldNew ();
     ufp->label = ObjectIdNew ();
     ufp->label->str = StringSave ("AdditionalComment");
     if (last_ufp == NULL)
     {
       uop->data = ufp;
     }
     else
     {
       last_ufp->next = ufp;
     }
   }
   
   new_comment_len = StringLen (comment) + StringLen (comment_fmt);
   if (!StringHasNoText (ufp->data.ptrvalue))
   {
     new_comment_len += StringLen (ufp->data.ptrvalue);
   }
   new_comment = (CharPtr) MemNew (new_comment_len * sizeof (Char));
   sprintf (new_comment, comment_fmt, comment);
   
   if (!StringHasNoText (ufp->data.ptrvalue))
   {
     StringCat (new_comment, ufp->data.ptrvalue);
   }
   
   ufp->data.ptrvalue = MemFree (ufp->data.ptrvalue);
   ufp->data.ptrvalue = new_comment;
 }
 
 static BioSourcePtr AddOrgModValue (BioSourcePtr biop, Uint1 subtype, CharPtr subname)
 {
   OrgModPtr    mod;
   
   if (subname == NULL)
   {
     return biop;
   }
 
   biop = AddOrgName (biop);
   if (biop != NULL)
   {
     mod = OrgModNew ();
     if (mod != NULL)
     {
       mod->subtype = subtype;
       mod->subname = subname;
       subname = NULL;
       mod->next = biop->org->orgname->mod;
       biop->org->orgname->mod = mod;
     }
   }
   subname = MemFree (subname);
   return biop;
 }
 
 static BioSourcePtr AddSubSourceValue (BioSourcePtr biop, Uint1 subtype, CharPtr subname)
 {
   SubSourcePtr ssp;
   
   if (subname == NULL)
   {
     return biop;
   }
 
   if (biop == NULL)
   {
     biop = BioSourceNew ();
   }
   if (biop != NULL)
   {
     ssp = SubSourceNew ();
     if (ssp != NULL)
     {
       ssp->subtype = subtype;
       ssp->name = subname;
       subname = NULL;
       ssp->next = biop->subtype;
       biop->subtype = ssp;
     }
   }
   subname = MemFree (subname);
   return biop;
 }
 
 extern BioSourcePtr 
 ExtractFromTitleToBioSourceOrgMod 
 (CharPtr      title,
  BioSourcePtr biop, 
  CharPtr      mod_name,
  Int4         subtype)
 {
   CharPtr valstr;
   CharPtr next_org_loc;
   
   next_org_loc = FindValuePairInDefLine ("organism", title, NULL);
   while ((valstr = FindValueFromPairInDeflineBeforeCharPtr (mod_name, title, next_org_loc)) != NULL)
   {
     biop = AddOrgModValue (biop, subtype, valstr);
     RemoveValueFromDefline (mod_name, title);
     next_org_loc = FindValuePairInDefLine ("organism", title, NULL);
   }  
   return biop;
 }
 
 extern BioSourcePtr 
 ExtractFromTitleToBioSourceSubSource 
 (CharPtr      title,
  BioSourcePtr biop, 
  CharPtr      mod_name,
  Int4         subtype)
 {
   CharPtr valstr;
   CharPtr next_org_loc;
   
   next_org_loc = FindValuePairInDefLine ("organism", title, NULL);
   while ((valstr = FindValueFromPairInDeflineBeforeCharPtr (mod_name, title, next_org_loc)) != NULL)
   {
     if (IsNonTextModifier (mod_name)) {
       if (StringICmp (valstr, "FALSE") == 0) {
         valstr = MemFree (valstr);
       } else if (StringICmp (valstr, "TRUE") == 0) {
         biop = AddSubSourceValue (biop, subtype, StringSave (""));
         valstr = MemFree (valstr);
       } else {
         biop = AddSubSourceValue (biop, subtype, valstr);
       }
     } else {
       biop = AddSubSourceValue (biop, subtype, valstr);
     }
     RemoveValueFromDefline (mod_name, title);
     next_org_loc = FindValuePairInDefLine ("organism", title, NULL);
   }  
   return biop;
 }
 
 /* this function collects all of the common names prior to the next organism name
  * and assembles a semicolon-delimited list.
  */
 extern BioSourcePtr 
 ExtractFromTitleToBioSourceCommonName 
 (CharPtr      title,
  BioSourcePtr biop)
 {
   CharPtr valstr, new_val;
   Int4    new_len;
   CharPtr next_org_loc;
   
   next_org_loc = FindValuePairInDefLine ("organism", title, NULL);  
   while ((valstr = FindValueFromPairInDeflineBeforeCharPtr ("common name", title, next_org_loc)) != NULL)
   {
     if (!StringHasNoText (valstr))
     {
       biop = AddOrgRef (biop);
       if (StringHasNoText (biop->org->common))
       {
         biop->org->common = MemFree (biop->org->common);
         biop->org->common = valstr;
         valstr = NULL;
       }
       else
       {
         new_len = StringLen (biop->org->common) + StringLen (valstr) + 3;
         new_val = (CharPtr) MemNew (new_len * sizeof (Char));
         if (new_val != NULL)
         {
           sprintf (new_val, "%s; %s", biop->org->common, valstr);
           biop->org->common = MemFree (biop->org->common);
           biop->org->common = new_val;
         }
       }
     }
     valstr = MemFree (valstr);
     RemoveValueFromDefline ("common name", title);
     next_org_loc = FindValuePairInDefLine ("organism", title, NULL);
   }  
   return biop;
 }
 
 /* When the user specifies multiple organisms on the definition line, modifiers after the
  * second organism go with the second organism, after the third organism go with the third
  * organism, etc.
  */
 extern BioSourcePtr ExtractFromDeflineToBioSource (CharPtr defline, BioSourcePtr biop)
 {
   CharPtr      taxname = NULL;
   OrgInfoPtr   oip = NULL;
   CharPtr      valstr;
   Nlm_EnumFieldAssocPtr ap;
   Nlm_QualNameAssocPtr  qp;
   CharPtr            next_org_loc;
   
   if (StringHasNoText (defline))
   {
     return NULL;
   }
   
   taxname = FindValueFromPairInDefline ("organism", defline);
   RemoveValueFromDefline ("organism", defline);
   if (StringHasNoText (taxname))
   {
     taxname = MemFree (taxname);
     return NULL;
   }
   else
   {
     biop = AddOrgRef (biop);
     if (biop == NULL)
     {
       return biop;
     }
     LoadOrganismList ();
     oip = FindByTaxName (taxname);
     SetTaxNameAndRemoveTaxRef (biop->org, taxname);
   }
   
   /* add division */
   if (oip != NULL && !StringHasNoText (oip->div))
   {
     biop = AddOrgName (biop);
     if (biop == NULL)
     {
       return biop;
     }    
     biop->org->orgname->div = StringSave (oip->div);
   }
   
   /* add common name (s) - if there are multiple entries, separate with semicolon */
   biop = ExtractFromTitleToBioSourceCommonName (defline, biop);
   /* if common name was not supplied in defline, use common name from organism list */
   if (biop->org == NULL || StringHasNoText (biop->org->common))
   {
     if (oip != NULL && !StringHasNoText (oip->common))
     {
       biop = AddOrgRef (biop);
       if (biop == NULL)
       {
         return biop;
       }
       biop->org->common = StringSave (oip->common);
     }
   }
   
   /* add lineage */
   if (oip != NULL && !StringHasNoText (oip->lineage))
   {
     biop = AddOrgName (biop);
     if (biop == NULL)
     {
       return biop;
     }
     biop->org->orgname->lineage = StringSave (oip->lineage);
   }
   
   /* add origin */
   next_org_loc = FindValuePairInDefLine ("organism", defline, NULL);
   valstr = FindValueFromPairInDeflineBeforeCharPtr ("origin", defline, next_org_loc);
   if (!StringHasNoText (valstr))
   {
     for (ap = biosource_origin_alist; ap->name != NULL; ap++) {
       if (StringICmp (valstr, ap->name) == 0) {
         if (biop == NULL)
         {
           biop = BioSourceNew ();
         }
         if (biop == NULL)
         {
           return biop;
         }
         biop->origin = (Uint1) ap->value;
       }
     }
   }
   if (valstr != NULL)
   {
     RemoveValueFromDefline ("origin", defline);
     next_org_loc = FindValuePairInDefLine ("organism", defline, NULL);
   }
   valstr = MemFree (valstr);
   
   valstr = FindValueFromPairInDeflineBeforeCharPtr ("lineage", defline, next_org_loc);
   if (!StringHasNoText (valstr))
   {
     biop = AddOrgName (biop);
   }
   if (!StringHasNoText (valstr) && StringCmp (valstr, biop->org->orgname->lineage) != 0)
   {
     biop = AddOrgModValue (biop, ORGMOD_old_lineage, valstr);
     valstr = NULL;
   }
   if (valstr != NULL)
   {
     RemoveValueFromDefline ("lineage", defline);
   }
   valstr = MemFree (valstr);
   
   biop = SetAllGeneticCodesFromTitle (biop, defline);
   next_org_loc = FindValuePairInDefLine ("organism", defline, NULL);
         
   for (qp = current_orgmod_subtype_alist; qp->name != NULL; qp++) {
     biop = ExtractFromTitleToBioSourceOrgMod (defline, biop, qp->name, qp->value);
   }
   for (qp = current_subsource_subtype_alist; qp->name != NULL; qp++) {
     biop = ExtractFromTitleToBioSourceSubSource (defline, biop, qp->name, qp->value);
   }
   
   biop = ExtractFromTitleToBioSourceOrgMod (defline, biop, "note-orgmod", 255);
   biop = ExtractFromTitleToBioSourceSubSource (defline, biop, "note-subsrc", 255);
   biop = ExtractFromTitleToBioSourceOrgMod (defline, biop, "note", 255);
   biop = ExtractFromTitleToBioSourceOrgMod (defline, biop, "comment", 255);
   biop = ExtractFromTitleToBioSourceSubSource (defline, biop, "subsource", 255);
 
 
   next_org_loc = FindValuePairInDefLine ("organism", defline, NULL);
 
   /* set location */
   valstr = FindValueFromPairInDeflineBeforeCharPtr ("location", defline, next_org_loc);
   if (StringHasNoText (valstr))
   {
     if (biop == NULL)
     {
       biop = BioSourceNew ();
     }
     if (biop == NULL)
     {
       return biop;
     }
     biop->genome = 1;
   }
   else if (StringICmp (valstr, "Mitochondrial") == 0)
   {
     if (biop == NULL)
     {
       biop = BioSourceNew ();
     }
     if (biop == NULL)
     {
       return biop;
     }
     biop->genome = 5;
   }
   else
   {
     for (ap = biosource_genome_simple_alist; ap->name != NULL; ap++) {
       if (StringICmp (valstr, ap->name) == 0) {
         if (biop == NULL)
         {
           biop = BioSourceNew ();
         }
         if (biop == NULL)
         {
           return biop;
         }
         biop->genome = (Uint1) ap->value;
       }
     }
   }
   if (valstr != NULL)
   {
     RemoveValueFromDefline ("location", defline);
   }
   valstr = MemFree (valstr);
  
   TrimSpacesAroundString (defline);
   
   return biop;
   
 }
 
 extern Boolean ProcessOneNucleotideTitle (Int2 seqPackage,
                                           SeqEntryPtr nsep, SeqEntryPtr top);
                                           
 
 static void ParseDeflineToBiop(CharPtr defline, BioSourcePtr biop) 
 {
   CharPtr      taxname = NULL;
   OrgInfoPtr   oip = NULL;
   CharPtr      valstr;
   EnumFieldAssocPtr  ap;
   Nlm_QualNameAssocPtr qp;
   CharPtr            next_org_loc;
   
   if (StringHasNoText (defline) || biop == NULL)
   {
     return;
   }
   
   taxname = FindValueFromPairInDefline ("organism", defline);
   RemoveValueFromDefline ("organism", defline);
   if (StringHasNoText (taxname))
   {
     taxname = MemFree (taxname);
   }
   else
   {
     biop = AddOrgRef (biop);
     biop->org->taxname = taxname;
     LoadOrganismList ();
     oip = FindByTaxName (taxname);
   }
   
   /* add division */
   if (oip != NULL && !StringHasNoText (oip->div))
   {
     biop = AddOrgName (biop);
     biop->org->orgname->div = StringSave (oip->div);
   }
   
   /* add common name (s) - if there are multiple entries, separate with semicolon */
   biop = ExtractFromTitleToBioSourceCommonName (defline, biop);
   /* if common name was not supplied in defline, use common name from organism list */
   if (biop->org == NULL || StringHasNoText (biop->org->common))
   {
     if (oip != NULL && !StringHasNoText (oip->common))
     {
       biop = AddOrgRef (biop);
       biop->org->common = StringSave (oip->common);
     }
   }
   
   /* add lineage */
   if (oip != NULL && !StringHasNoText (oip->lineage))
   {
     biop = AddOrgName (biop);
     biop->org->orgname->lineage = StringSave (oip->lineage);
   }
   
   /* add origin */
   next_org_loc = FindValuePairInDefLine ("organism", defline, NULL);
   valstr = FindValueFromPairInDeflineBeforeCharPtr ("origin", defline, next_org_loc);
   if (!StringHasNoText (valstr))
   {
     for (ap = biosource_origin_alist; ap->name != NULL; ap++) {
       if (StringICmp (valstr, ap->name) == 0) {
         biop->origin = (Uint1) ap->value;
       }
     }
   }
   if (valstr != NULL)
   {
     RemoveValueFromDefline ("origin", defline);
     next_org_loc = FindValuePairInDefLine ("organism", defline, NULL);
   }
   valstr = MemFree (valstr);
   
   valstr = FindValueFromPairInDeflineBeforeCharPtr ("lineage", defline, next_org_loc);
   if (!StringHasNoText (valstr))
   {
     biop = AddOrgName (biop);
   }
   if (!StringHasNoText (valstr) && StringCmp (valstr, biop->org->orgname->lineage) != 0)
   {
     biop = AddOrgModValue (biop, ORGMOD_old_lineage, valstr);
     valstr = NULL;
   }
   if (valstr != NULL)
   {
     RemoveValueFromDefline ("lineage", defline);
   }
   valstr = MemFree (valstr);
   
   biop = SetAllGeneticCodesFromTitle (biop, defline);
   next_org_loc = FindValuePairInDefLine ("organism", defline, NULL);
         
   for (qp = current_orgmod_subtype_alist; qp->name != NULL; qp++) {
     biop = ExtractFromTitleToBioSourceOrgMod (defline, biop, qp->name, qp->value);
   }
   for (qp = current_subsource_subtype_alist; qp->name != NULL; qp++) {
     biop = ExtractFromTitleToBioSourceSubSource (defline, biop, qp->name, qp->value);
   }
   
   biop = ExtractFromTitleToBioSourceOrgMod (defline, biop, "note-orgmod", 255);
   biop = ExtractFromTitleToBioSourceSubSource (defline, biop, "note-subsrc", 255);
   biop = ExtractFromTitleToBioSourceOrgMod (defline, biop, "note", 255);
   biop = ExtractFromTitleToBioSourceOrgMod (defline, biop, "comment", 255);
   biop = ExtractFromTitleToBioSourceSubSource (defline, biop, "subsource", 255);
 
 
   next_org_loc = FindValuePairInDefLine ("organism", defline, NULL);
 
   /* set location */
   valstr = FindValueFromPairInDeflineBeforeCharPtr ("location", defline, next_org_loc);
   if (StringHasNoText (valstr))
   {
     /* don't set defaults */
   }
   else if (StringICmp (valstr, "Mitochondrial") == 0)
   {
     biop->genome = 5;
   }
   else
   {
     for (ap = biosource_genome_simple_alist; ap->name != NULL; ap++) {
       if (StringICmp (valstr, ap->name) == 0) {
         biop->genome = (Uint1) ap->value;
       }
     }
   }
   if (valstr != NULL)
   {
     RemoveValueFromDefline ("location", defline);
   }
   valstr = MemFree (valstr);
  
   TrimSpacesAroundString (defline);
 }
 
 
 static void ParseModifiersFromDeflineCallback (BioseqPtr bsp, Pointer userdata)
 {
   CharPtr           title;
   SeqDescrPtr       sdp, sdp_biop, prev_sdp = NULL;
   BioSourcePtr      biop = NULL;
   CharPtr           valstr;
   SeqMgrDescContext context;
   
   if (bsp == NULL) return;
   
   if (ISA_aa(bsp->mol)) {
     return;
   }
   
   sdp = bsp->descr;
   while (sdp != NULL && sdp->choice != Seq_descr_title) {
     prev_sdp = sdp;
     sdp = sdp->next;
   }
   if (sdp == NULL || sdp->data.ptrvalue == NULL) {
     return;
   }
   
   title = sdp->data.ptrvalue;
   
   if (StringChr(title, '[') == NULL || StringChr(title, ']') == NULL) {
     return;
   }
   
   /* parse moltype values */
   SetMoleculeAndMolTypeFromTitle (bsp, title, SEQ_PKG_GENBANK);
   
   /* get topology from defline */
   valstr = FindValueFromPairInDefline ("topology", title);
   if (valstr != NULL)
   {
     if (!StringHasNoText (valstr))
     {
       bsp->topology = TopologyFromString (valstr);
     }
     RemoveValueFromDefline ("topology", title);
     valstr = MemFree (valstr);
   }
   
   /* add bankit comment for genetic code */
   valstr = FindValueFromPairInDefline ("gencode_comment", title);
   if (valstr != NULL)
   {
     AddGeneticCodeComment (bsp, valstr);
     RemoveValueFromDefline ("gencode_comment", title);
     valstr = MemFree (valstr);
   }
   
   sdp_biop = SeqMgrGetNextDescriptor (bsp, NULL, Seq_descr_source, &context);
 
   if(sdp_biop == NULL) {
     if (bsp->idx.parenttype == OBJ_BIOSEQSET 
         && bsp->idx.parentptr != NULL 
         && ((BioseqSetPtr)bsp->idx.parentptr)->_class == BioseqseqSet_class_parts) {
         /* don't put sources on parts */
     } else {
         biop = BioSourceNew();
         sdp_biop = SeqDescrNew(bsp->descr);
         sdp_biop->choice = Seq_descr_source;
         sdp_biop->data.ptrvalue = biop;
     }
   } else {
     biop = sdp_biop->data.ptrvalue;
   }          
   
   ParseDeflineToBiop (title, biop);
   
   if (StringHasNoText (title)) {
     /* remove empty defline */
     sdp->data.ptrvalue = MemFree (sdp->data.ptrvalue);
     if (prev_sdp == NULL) {
       bsp->descr = sdp->next;
     } else {
       prev_sdp->next = sdp->next;
     }
     sdp->next = NULL;
     sdp = SeqDescrFree (sdp);
   }
 }
 
                                          
 extern void ParseModifiersFromDefline (IteM i)
 {
   BaseFormPtr  bfp;
   SeqEntryPtr  sep;
 
 #ifdef WIN_MAC
   bfp = currentFormDataPtr;
 #else
   bfp = GetObjectExtra (i);
 #endif
   if (bfp == NULL) return;
   sep = GetTopSeqEntryForEntityID (bfp->input_entityID);
   if (sep == NULL) return;
   
   VisitBioseqsInSep (sep, NULL, ParseModifiersFromDeflineCallback);
   Update ();
   ObjMgrSetDirtyFlag (bfp->input_entityID, TRUE);
   ObjMgrSendMsg (OM_MSG_UPDATE, bfp->input_entityID, 0, 0);  
 }
                                     
                                           
 extern Boolean ProcessOneNucleotideTitle (Int2 seqPackage, 
                                           SeqEntryPtr nsep, SeqEntryPtr top)
 
 {
   BioSourcePtr       biop = NULL;
   BioseqSetPtr       bssp;
   BioseqPtr          nbsp;
   Boolean            needbiop;
   SeqEntryPtr        sep;
   CharPtr            str;
   CharPtr            valstr;
   CharPtr            title;
   ValNodePtr         vnp;
   Int4               topology;
 #if 0
   SeqFeatPtr         sfp;
 #endif  
 
   if (nsep == NULL || top == NULL) return FALSE;
   nbsp = (BioseqPtr) nsep->data.ptrvalue;
   if (nbsp == NULL) return FALSE;
   if (! ISA_na (nbsp->mol)) return FALSE;
   str = MemNew (PROC_NUC_STR_SIZE * sizeof (Char));
   if (str == NULL) return FALSE;
   sep = NULL;
  
   SeqEntryExplore (top, (Pointer) &sep, FindFirstSeqEntryTitle);
   sep = FindNucSeqEntry (sep);
   if (sep != NULL) {
     vnp = SeqEntryGetSeqDescr (sep, Seq_descr_title, NULL);
     if (vnp != NULL && vnp->data.ptrvalue != NULL) {
       title = (CharPtr) vnp->data.ptrvalue;
       
       SetMoleculeAndMolTypeFromTitle (nbsp, title, seqPackage);
 
       if (nbsp->topology == 0)
       {
         topology = TOPOLOGY_LINEAR;
       }
       else
       {
         topology = nbsp->topology;
       }
   
       /* get topology from defline */
       valstr = FindValueFromPairInDefline ("topology", title);
       if (valstr != NULL)
       {
         if (!StringHasNoText (valstr))
         {
           topology = TopologyFromString (valstr);
         }
         RemoveValueFromDefline ("topology", title);
         valstr = MemFree (valstr);
       }
       nbsp->topology = topology;
       
       /* add bankit comment for genetic code */
       valstr = FindValueFromPairInDefline ("gencode_comment", title);
       if (valstr != NULL)
       {
         AddGeneticCodeComment (nbsp, valstr);
         RemoveValueFromDefline ("gencode_comment", title);
         valstr = MemFree (valstr);
       }
 
       needbiop = FALSE;
       
       if (PackageTypeIsSet (seqPackage)
           || seqPackage == SEQ_PKG_GENBANK)
       {
         needbiop = TRUE;
         if (GetAppParam ("SEQUIN", "PREFERENCES", "BIOSRCONALL", NULL, str, PROC_NUC_STR_SIZE)) {
           if (StringICmp (str, "FALSE") == 0) {
             needbiop = FALSE;
           }
         }
       }
       
       vnp = SeqEntryGetSeqDescr (sep, Seq_descr_source, NULL);
       if (vnp == NULL)
       {
         biop = ExtractFromDeflineToBioSource (title, NULL);
         if (biop == NULL && needbiop)
         {
           biop = BioSourceNew ();
         }
 
         if (biop != NULL)
         {
           vnp = CreateNewDescriptor (top, Seq_descr_source);
           if (vnp != NULL) {
             vnp->data.ptrvalue = (Pointer) biop;
           }
         }
 #if 0        
         biop = BioSourceFromDefline (title);
         while (biop != NULL)
         {
           sfp = CreateNewFeature (sep, NULL, SEQFEAT_BIOSRC, NULL);
           if (sfp != NULL)
           {
             sfp->data.value.ptrvalue = biop;
           }
           biop = BioSourceFromDefline (title);
         }
 #endif        
       }
 
       if (StringHasNoText (title) || sep != top) {
         vnp = NULL;
         if (IS_Bioseq (sep)) {
           nbsp = (BioseqPtr) sep->data.ptrvalue;
           vnp = ValNodeExtract (&(nbsp->descr), Seq_descr_title);
         } else if (IS_Bioseq_set (sep)) {
           bssp = (BioseqSetPtr) sep->data.ptrvalue;
           vnp = ValNodeExtract (&(bssp->descr), Seq_descr_title);
         }
         if (vnp != NULL && StringHasNoText ((CharPtr) vnp->data.ptrvalue)) {
           vnp = ValNodeFreeData (vnp);
         }
         if (sep != top && vnp != NULL) {
           if (IS_Bioseq (top)) {
             nbsp = (BioseqPtr) top->data.ptrvalue;
             ValNodeLink (&(nbsp->descr), vnp);
           } else if (IS_Bioseq_set (top)) {
             bssp = (BioseqSetPtr) top->data.ptrvalue;
             ValNodeLink (&(bssp->descr), vnp);
           }
         }
       }
     }
   } else {
     needbiop = FALSE;
     if (PackageTypeIsSet (seqPackage)
         || seqPackage == SEQ_PKG_GENOMICCDNA)
     {
       needbiop = TRUE;
       if (GetAppParam ("SEQUIN", "PREFERENCES", "BIOSRCONALL", NULL, str, PROC_NUC_STR_SIZE)) {
         if (StringICmp (str, "FALSE") == 0) {
           needbiop = FALSE;
         }
       }
     }
   }
   MemFree (str);
   
   return TRUE;
 }
 
 static Boolean AutomaticNucleotideProcess (SequencesFormPtr sqfp, SeqEntryPtr nsep,
                                            SeqEntryPtr top)
 
 {
   BioseqSetPtr  bssp;
   Boolean       rsult;
   SeqEntryPtr   tmp;
 
   if (sqfp == NULL || nsep == NULL || top == NULL) return FALSE;
   if (IS_Bioseq_set (nsep)) {
     bssp = (BioseqSetPtr) nsep->data.ptrvalue;
     rsult = FALSE;
     if (bssp != NULL) {
       for (tmp = bssp->seq_set; tmp != NULL; tmp = tmp->next) {
         if (AutomaticNucleotideProcess (sqfp, tmp, top)) {
           rsult = TRUE;
         }
       }
     }
     return rsult;
   }
   return ProcessOneNucleotideTitle (sqfp->seqPackage, 
                                     nsep, top);
 }
 
 typedef struct idlist {
   BioseqPtr  bsp;
   CharPtr    key;
   struct idlist PNTR left;
   struct idlist PNTR right;
 } IdList, PNTR IdListPtr;
 
 static void BuildTree (IdListPtr PNTR head, BioseqPtr bsp, CharPtr x)
 
 {
   Int2       comp;
   IdListPtr  idlist;
   SeqIdPtr   sip;
   CharPtr    str;
 
   if (*head != NULL) {
     idlist = *head;
     comp = StringICmp (idlist->key, x);
     if (comp < 0) {
       BuildTree (&(idlist->right), bsp, x);
     } else if (comp > 0) {
       BuildTree (&(idlist->left), bsp, x);
     } else {
       sip = MakeNewProteinSeqId (NULL, NULL);
       if (sip != NULL) {
         bsp->id = SeqIdFree (bsp->id);
         bsp->id = sip;
         SeqMgrReplaceInBioseqIndex (bsp);
         str = SeqIdWholeLabel (SeqIdFindWorst (bsp->id), PRINTID_REPORT);
         BuildTree (head, bsp, str);
         str = MemFree (str);
       }
     }
   } else {
     idlist = MemNew (sizeof (IdList));
     if (idlist != NULL) {
       *head = idlist;
       idlist->bsp = bsp;
       idlist->key = SeqIdWholeLabel (SeqIdFindWorst (bsp->id), PRINTID_REPORT);
       idlist->left = NULL;
       idlist->right = NULL;
     }
   }
 }
 
 static void FreeTree (IdListPtr PNTR head)
 
 {
   IdListPtr  idlist;
 
   if (head != NULL && *head != NULL) {
     idlist = *head;
     FreeTree (&(idlist->left));
     FreeTree (&(idlist->right));
     MemFree (idlist->key);
     MemFree (idlist);
   }
 }
 
 static void ResolveCollidingIDs (IdListPtr PNTR head, SeqEntryPtr list)
 
 {
   BioseqPtr  bsp;
   CharPtr    str;
 
   if (head == NULL) return;
   while (list != NULL) {
     if (IS_Bioseq (list)) {
       bsp = (BioseqPtr) list->data.ptrvalue;
       if (bsp != NULL) {
         str = SeqIdWholeLabel (SeqIdFindWorst (bsp->id), PRINTID_REPORT);
         BuildTree (head, bsp, str);
         str = MemFree (str);
       }
     }
     list = list->next;
   }
 }
 
 
 static void PutMolInfoOnSeqEntry (SequencesFormPtr sqfp, SeqEntryPtr sep)
 
 {
   BioseqSetPtr bssp;
   MolInfoPtr   mip;
   ValNodePtr   vnp;
 
   if (sqfp != NULL && sep != NULL) {
     if (IS_Bioseq_set (sep))
     {
       bssp = (BioseqSetPtr) sep->data.ptrvalue;
       for (sep = bssp->seq_set; sep != NULL; sep = sep->next) 
       {
         PutMolInfoOnSeqEntry (sqfp, sep);
       }
       return;
     }
 
     vnp = SeqEntryGetSeqDescr (sep, Seq_descr_molinfo, NULL);
     if (vnp == NULL)
     {
       vnp = CreateNewDescriptor (sep, Seq_descr_molinfo);
     }
     if (vnp != NULL)
     {
       mip = (MolInfoPtr) vnp->data.ptrvalue;
       if (mip == NULL)
       {
         mip = MolInfoNew ();
         vnp->data.ptrvalue = mip;
       }
     }
   }
 }
 
 static void PrefixOrgToDefline (SeqEntryPtr sep)
 
 {
   BioSourcePtr  biop;
   BioseqPtr     bsp;
   BioseqSetPtr  bssp;
   CharPtr       def;
   OrgRefPtr     orp;
   CharPtr       ptr;
   CharPtr       str;
   Char          taxname [64];
   ValNodePtr    ttl;
   ValNodePtr    vnp;
 
   if (sep == NULL) return;
   if (IS_Bioseq_set (sep)) {
     bssp = (BioseqSetPtr) sep->data.ptrvalue;
     if (bssp != NULL && (bssp->_class == 7 ||
                          (IsPopPhyEtcSet (bssp->_class)))) {
       for (sep = bssp->seq_set; sep != NULL; sep = sep->next) {
         PrefixOrgToDefline (sep);
       }
       return;
     }
   }
 
   if (! IS_Bioseq (sep)) return;
   bsp = (BioseqPtr) sep->data.ptrvalue;
   if (bsp == NULL) return;
 
   taxname [0] = '\0';
   orp = NULL;
   biop = NULL;
   ttl = NULL;
   vnp = bsp->descr;
   for (vnp = bsp->descr; vnp != NULL; vnp = vnp->next) {
     if (vnp->choice == Seq_descr_source) {
       biop = (BioSourcePtr) vnp->data.ptrvalue;
     } else if (vnp->choice == Seq_descr_org) {
       orp = (OrgRefPtr) vnp->data.ptrvalue;
     } else if (vnp->choice == Seq_descr_title) {
       ttl = vnp;
     }
   }
   if (orp == NULL && biop != NULL) {
     orp = biop->org;
   }
   if (orp == NULL) return;
   if (ttl == NULL) return;
   StringNCpy_0 (taxname, orp->taxname, sizeof (taxname));
   ptr = StringSearch (taxname, "(");
   if (ptr != NULL) {
     *ptr = '\0';
   }
   TrimSpacesAroundString (taxname);
   if ((StringICmp (taxname, "Human immunodeficiency virus type 1") == 0) ||
       (StringICmp (taxname, "Human immunodeficiency virus 1") == 0)) {
     StringCpy (taxname, "HIV-1");
   } else if ((StringICmp (taxname,"Human immunodeficiency virus type 2")==0) ||
              (StringICmp (taxname,"Human immunodeficiency virus 2")==0)) {
     StringCpy (taxname, "HIV-2");
   }
 
   def = (CharPtr) ttl->data.ptrvalue;
   if (StringHasNoText (def)) return;
 
   ptr = StringISearch (def, taxname);
   if (ptr != NULL && ptr == def) return;
   str = MemNew ((StringLen (taxname) + StringLen (def) + 4) * sizeof (Char));
   if (str == NULL) return;
   StringCpy (str, taxname);
   StringCat (str, " ");
   StringCat (str, def);
   ttl->data.ptrvalue = MemFree (ttl->data.ptrvalue);
   ttl->data.ptrvalue = str;
 }
 
 static CharPtr onecomponent = "\
 Multiple sequence components are expected in this submission.\n\
 They should all be read in at the same time from the same file.";
 
 static void OnlyOneComponentWarning (SequencesFormPtr sqfp)
 
 {
   CharPtr  type;
 
   if (sqfp != NULL) {
     if (sqfp->seqPackage == SEQ_PKG_GENOMICCDNA
         || PackageTypeIsSingle (sqfp->seqPackage))
     {
       return;
     }
     switch (sqfp->seqPackage) {
       case SEQ_PKG_SEGMENTED :
         type = "segmented sequence";
         break;
       case SEQ_PKG_POPULATION :
         type = "population set";
         break;
       case SEQ_PKG_PHYLOGENETIC :
         type = "phylogenetic set";
         break;
       case SEQ_PKG_MUTATION :
         type = "mutation set";
         break;
       case SEQ_PKG_ENVIRONMENT :
         type = "environmental samples";
         break;
       case SEQ_PKG_GENBANK :
         type = "batch submission";
         break;
       default :
         type = "unknown set";
         break;
     }
     Message (MSG_OK, "WARNING - There is only one component in this %s.\n%s",
              type, onecomponent);
   }
 }
 
 /*---------------------------------*/
 /* Parse the gene and gene-related */
 /* fields from the title.          */
 /*---------------------------------*/
 extern void 
 AddGeneFeatureFromTitle 
 (SeqEntryPtr nucsep,
  CharPtr ttl, 
  SeqLocPtr slp)
 {
   CharPtr    gene = NULL;
   CharPtr    gene_desc = NULL;
   CharPtr    allele = NULL;
   CharPtr    gene_syn = NULL;
   GeneRefPtr grp = NULL;
   SeqFeatPtr sfp;
   SeqIdPtr   sip;
   BioseqPtr  nbsp, bsp;
   SeqLocPtr  gslp;
   Boolean    hasNulls;
   
   if (nucsep == NULL || !IS_Bioseq (nucsep) 
       || (nbsp = (BioseqPtr) nucsep->data.ptrvalue) == NULL
       || StringHasNoText (ttl) || slp == NULL)
   {
     return;
   }
   
   gene = FindValueFromPairInDefline ("gene", ttl);
   if (!StringHasNoText (gene))
   {
     gene_desc = StringChr (gene, ';');
     if (gene_desc != NULL) {
       *gene_desc = '\0';
       gene_desc++;
       allele = StringChr (gene_desc, ';');
       if (allele != NULL) {
         *allele = '\0';
         allele++;
       }
     }
     grp = CreateNewGeneRef (gene, allele, gene_desc, FALSE);
   }
   gene = MemFree (gene);
   
   /*-----------------------------------------*/
   /* Parse the gene_syn field from the title */
   /*-----------------------------------------*/
   
   gene_syn = FindValueFromPairInDefline ("gene_syn", ttl);
   if (!StringHasNoText (gene_syn))
   {
     if (grp == NULL) {
       grp = GeneRefNew ();
     }
     ValNodeCopyStr(&(grp->syn),0,gene_syn);
   }
   gene_syn = MemFree (gene_syn);
 
   /* Create the gene feature */
   if (grp != NULL) {
     if (ExtendGene (grp, nucsep, slp)) {
       grp = GeneRefFree (grp);
     } else {
       sfp = CreateNewFeature (nucsep, NULL, SEQFEAT_GENE, NULL);
       if (sfp != NULL) {
         sfp->data.value.ptrvalue = (Pointer) grp;
         sfp->location = SeqLocFree (sfp->location);
         sfp->location = AsnIoMemCopy ((Pointer) slp,
                                       (AsnReadFunc) SeqLocAsnRead,
                                       (AsnWriteFunc) SeqLocAsnWrite);
         sip = SeqLocId (sfp->location);
         if (sip != NULL) {
           bsp = BioseqFind (sip);
         } else {
           bsp = nbsp;
         }
         if (bsp != NULL) {
           gslp = SeqLocMerge (bsp, sfp->location, NULL, TRUE, FALSE, FALSE);
           if (gslp != NULL) {
             sfp->location = SeqLocFree (sfp->location);
             sfp->location = gslp;
             if (bsp->repr == Seq_repr_seg) {
               gslp = SegLocToPartsEx (bsp, sfp->location, TRUE);
               sfp->location = SeqLocFree (sfp->location);
               sfp->location = gslp;
               hasNulls = LocationHasNullsBetween (sfp->location);
               sfp->partial = (sfp->partial || hasNulls);
             }
             FreeAllFuzz (gslp);
           }
         }
       }
     }
     RemoveValueFromDefline ("gene", ttl);
     RemoveValueFromDefline ("gene_syn", ttl);
   }
 }
 
 extern SeqFeatPtr AddProteinFeatureFromDefline (SeqEntryPtr psep, CharPtr title)
 {
   CharPtr    activity = NULL;
   CharPtr    ec = NULL;
   CharPtr    prot_name = NULL;
   CharPtr    prot_desc = NULL;
   CharPtr    other_prot_desc = NULL, tmp_desc;
   ProtRefPtr prp;
   SeqFeatPtr sfp = NULL;
   
   if (psep == NULL)
   {
     return NULL;
   }
   
         /*-----------------------------------------*/
         /* Parse the function field from the title */
         /*-----------------------------------------*/
 
   activity = FindValueFromPairInDefline ("function", title);
 
         /*------------------------------------------*/
         /* Parse the EC_number field from the title */
         /*------------------------------------------*/
 
   ec = FindValueFromPairInDefline ("EC_number", title);
 
         /*---------------------------------*/
         /* Parse the protein and prot_desc */
         /* fields from the title.          */
         /*---------------------------------*/
 
   prot_name = FindValueFromPairInDefline ("protein", title);
 
         /*---------------------------------*/
         /* If we found a protein value ... */
         /*---------------------------------*/
   if (!StringHasNoText (prot_name))
   {
           /*----------------------------------------------*/
           /* ... search for a protein description, either */
           /*     in the prot field (seperated by a ';')   */
           /*     or in its own 'prot_desc' field.         */
           /*----------------------------------------------*/
 
     prot_desc = StringChr (prot_name, ';');
           if (prot_desc != NULL)
           {
                   *prot_desc = '\0';
                   prot_desc++;
                   /* ignore this description if empty */
                   if (StringHasNoText (prot_desc))
                   {
                     prot_desc = NULL;
                   }
                   else
                   {
                     prot_desc = StringSave (prot_desc);
                   }
           }
   }
         other_prot_desc = FindValueFromPairInDefline ("prot_desc", title);
         if (StringHasNoText (other_prot_desc))
         {
           other_prot_desc = MemFree (other_prot_desc);
         }
         else
         {
    if (prot_desc == NULL)
           {
             prot_desc = other_prot_desc;
             other_prot_desc = NULL;
           }
           else 
           {
       tmp_desc = (CharPtr) MemNew ((StringLen (prot_desc) + StringLen (other_prot_desc) + 3)
                                        * sizeof (Char));
             if (tmp_desc != NULL)
             {
               StringCpy (tmp_desc, prot_desc);
               StringCat (tmp_desc, ";");
             StringCat (tmp_desc, other_prot_desc);
               prot_desc = MemFree (prot_desc);
               other_prot_desc = MemFree (other_prot_desc);
               prot_desc = tmp_desc;
             }
           }
         }
         
         /*--------------------------------*/
         /* ... add the prot and prot_desc */
         /*     to the Seq Features.       */
         /*--------------------------------*/
 
         prp = CreateNewProtRef (prot_name, prot_desc, ec, activity);
         if (prp != NULL)
         {
                 sfp = CreateNewFeature (psep, NULL, SEQFEAT_PROT, NULL);
                 if (sfp != NULL)
                 {
                   sfp->data.value.ptrvalue = (Pointer) prp;
                   RemoveValueFromDefline ("protein", title);
                   RemoveValueFromDefline ("prot_desc", title);
                   RemoveValueFromDefline ("function", title);
                   RemoveValueFromDefline ("EC_number", title);
                 }
         }
   return sfp;
 }
 
 extern void 
 AddCodingRegionFieldsFromProteinTitle 
 (CdRegionPtr  crp,
  CharPtr      title, 
  CharPtr PNTR pcomment)
 {
   CharPtr comment, comment_loc, total_comment = NULL, tmp_comment;
   
   if (crp == NULL || StringHasNoText (title))
   {
     return;
   }
   
         /*---------------------*/
         /* Parse the ORF field */
         /*---------------------*/
   if (FindValuePairInDefLine ("orf", title, NULL) != NULL)
   {
     crp->orf = TRUE;
     RemoveValueFromDefline ("orf", title);
   }
 
   if (pcomment == NULL)
   {
     return;
   }
 
         /*-------------------------------*/
         /* Parse the comment/note fields */
         /*-------------------------------*/
   comment_loc = FindValuePairInDefLine ("comment", title, NULL);
   while (comment_loc != NULL)
   {
     comment = FindValueFromPairInDefline ("comment", comment_loc);
     if (!StringHasNoText (comment))
     {
       if (total_comment == NULL)
       {
         total_comment = comment;
         comment = NULL;
       }
       else
       {
         tmp_comment = (CharPtr) MemNew ((StringLen (total_comment) + StringLen (comment) + 3) * sizeof (Char));
         if (tmp_comment != NULL)
         {
           StringCpy (tmp_comment, total_comment);
           StringCat (tmp_comment, ";");
           StringCat (tmp_comment, comment);
           total_comment = MemFree (total_comment);
           total_comment = tmp_comment;
         }
       }
     }
     comment = MemFree (comment);
     RemoveValueFromDefline ("comment", title);
     comment_loc = FindValuePairInDefLine ("comment", title, NULL);
   }
   
   *pcomment = total_comment;
 }
 
 static void AutomaticMrnaProcess (SeqEntryPtr nucsep, SeqEntryPtr mrnasep, Boolean partial5, Boolean partial3)
 
 {
   CharPtr     mrna = NULL;
   CharPtr     comment = NULL;
   BioseqPtr   bsp;
   MolInfoPtr  mip;
   BioseqPtr   mrnabsp;
   BioseqPtr   nucbsp;
   SeqLocPtr   oldslp;
   RnaRefPtr   rrp;
   SeqFeatPtr  sfp;
   SeqIdPtr    sip;
   SeqLocPtr   slp;
   CharPtr     ttl;
   ValNodePtr  vnp;
 
   if (nucsep == NULL || mrnasep == NULL) return;
   if (IS_Bioseq (nucsep) && IS_Bioseq (mrnasep)) {
     nucbsp = (BioseqPtr) nucsep->data.ptrvalue;
     mrnabsp = (BioseqPtr) mrnasep->data.ptrvalue;
     if (nucbsp == NULL || mrnabsp == NULL) return;
     slp = AlignmRNA2genomic (nucbsp, mrnabsp);
     if (slp == NULL) return;
     sip = SeqLocId (slp);
     if (sip != NULL) {
       bsp = BioseqFind (sip);
       if (bsp != NULL) {
         if (bsp->repr == Seq_repr_seg) {
           oldslp = slp;
           slp = SegLocToParts (bsp, oldslp);
           FreeAllFuzz (slp);
           SeqLocFree (oldslp);
         }
       }
     }
     StripLocusFromSeqLoc (slp);
     ttl = NULL;
     vnp = ValNodeFindNext (mrnabsp->descr, NULL, Seq_descr_title);
     if (vnp != NULL) {
       ttl = (CharPtr) vnp->data.ptrvalue;
     }
     if (ttl != NULL) {
       AddGeneFeatureFromTitle (nucsep, ttl, slp);
     
       /* get mRNA name */
       mrna = FindValueFromPairInDefline ("mrna", ttl);
       RemoveValueFromDefline ("mrna", ttl);
       if (StringHasNoText (mrna))
       {
         mrna = MemFree (mrna);
         mrna = FindValueFromPairInDefline ("cdna", ttl);
         RemoveValueFromDefline ("cdna", ttl);
       }
     }
     rrp = RnaRefNew ();
     if (rrp != NULL) {
       rrp->type = 2;
       if (! StringHasNoText (mrna)) {
         rrp->ext.choice = 1;
         rrp->ext.value.ptrvalue = mrna;
         mrna = NULL;
       }
       sfp = CreateNewFeature (nucsep, NULL, SEQFEAT_RNA, NULL);
       if (sfp != NULL) {
         sfp->data.value.ptrvalue = (Pointer) rrp;
         sfp->location = SeqLocFree (sfp->location);
         sfp->location = AsnIoMemCopy ((Pointer) slp,
                                       (AsnReadFunc) SeqLocAsnRead,
                                       (AsnWriteFunc) SeqLocAsnWrite);
         SetSeqFeatProduct (sfp, mrnabsp);
         SetSeqLocPartial (sfp->location, partial5, partial3);
         sfp->partial = (sfp->partial || partial5 || partial3);
         if (ttl != NULL) {
           comment = FindValueFromPairInDefline ("comment", ttl);
           if (!StringHasNoText (comment)) {
             sfp->comment = comment;
           }
           else
           {
             comment = MemFree (comment);
           }
           RemoveValueFromDefline ("comment", ttl);
         }
       }
     }
     mrna = MemFree (mrna);
     SeqLocFree (slp);
     if (StringHasNoText (ttl)) {
       ValNodeExtract (&(mrnabsp->descr), Seq_descr_title);
     }
     mip = MolInfoNew ();
     if (mip != NULL) {
       mip->biomol = 3;
       if (partial5 && partial3) {
         mip->completeness = 5;
       } else if (partial5) {
         mip->completeness = 3;
       } else if (partial3) {
         mip->completeness = 4;
       }
       vnp = CreateNewDescriptor (mrnasep, Seq_descr_molinfo);
       if (vnp != NULL) {
         vnp->data.ptrvalue = (Pointer) mip;
       }
     }
     mrnabsp->mol = Seq_mol_rna;
   }
 }
 
 static CharPtr LookForValueInBioseq (SeqEntryPtr sep, Uint1 mol, CharPtr valname)
 {
   BioseqPtr   bsp;
   CharPtr     title;
   ValNodePtr  vnp;
 
   if (sep == NULL || StringHasNoText (valname)) return FALSE;
   if (! IS_Bioseq (sep)) return FALSE;
   bsp = (BioseqPtr) sep->data.ptrvalue;
   if (bsp == NULL || bsp->mol != mol || bsp->descr == NULL) return FALSE;
   vnp = ValNodeFindNext (bsp->descr, NULL, Seq_descr_title);
   if (vnp == NULL || vnp->data.ptrvalue == NULL) return FALSE;
   title = (CharPtr) vnp->data.ptrvalue;
   return FindValueFromPairInDefline (valname, title);
 }
 
 static void FindBioseqWithValue (SeqEntryPtr sep, Uint1 mol, CharPtr valname, CharPtr value, SeqEntryPtr PNTR rsult)
 {
   BioseqPtr     bsp = NULL;
   BioseqSetPtr  bssp = NULL;
   CharPtr       match_value;
 
   if (sep == NULL || sep->data.ptrvalue == NULL || rsult == NULL) return;
   if (IS_Bioseq (sep)) {
     bsp = (BioseqPtr) sep->data.ptrvalue;
     match_value = LookForValueInBioseq (sep, mol, valname);
     if (StringICmp (match_value, value))
     {
       *rsult = sep;
     }
     match_value = MemFree (match_value);
   } else if (IS_Bioseq_set (sep)) {
     bssp = (BioseqSetPtr) sep->data.ptrvalue;
     for (sep = bssp->seq_set; sep != NULL; sep = sep->next) {
       FindBioseqWithValue (sep, mol, valname, value, rsult);
     }
   }
 }
 
 static void RemoveValueFromBioseq (SeqEntryPtr sep, CharPtr valname)
 {
   BioseqPtr   bsp;
   ValNodePtr  vnp;
 
   if (sep == NULL) return;
   if (! IS_Bioseq (sep)) return;
   bsp = (BioseqPtr) sep->data.ptrvalue;
   if (bsp == NULL || bsp->descr == NULL) return;
   vnp = SeqEntryGetSeqDescr (sep, Seq_descr_title, NULL);
   if (vnp == NULL) return;
   RemoveValueFromDefline (valname, vnp->data.ptrvalue);
   if (StringHasNoText (vnp->data.ptrvalue)) {
     ValNodeExtract (&(bsp->descr), Seq_descr_title);
   }  
 }
 
 static SeqEntryPtr FindRnaByRefOnRna (SeqEntryPtr sep, SeqEntryPtr psep)
 
 {
   SeqEntryPtr  msep;
   CharPtr      prot_name;
 
   msep = NULL;
   if (sep == NULL || psep == NULL) return NULL;
   prot_name = LookForValueInBioseq (psep, Seq_mol_aa, "prot");
   if (!StringHasNoText (prot_name))
   {
     FindBioseqWithValue (sep, Seq_mol_rna, "prot", prot_name, &msep);
     RemoveValueFromBioseq (msep, "prot");
   }
   prot_name = MemFree (prot_name);
   return msep;
 }
 
 static void FindRnaByName (SeqEntryPtr sep, CharPtr str, SeqEntryPtr PNTR msep)
 
 {
   BioseqPtr     bsp = NULL;
   BioseqSetPtr  bssp = NULL;
   RnaRefPtr     rrp;
   SeqAnnotPtr   sap;
   SeqFeatPtr    sfp;
 
   if (sep == NULL || sep->data.ptrvalue == NULL) return;
   if (str == NULL || msep == NULL) return;
   if (IS_Bioseq (sep)) {
     bsp = (BioseqPtr) sep->data.ptrvalue;
     sap = bsp->annot;
   } else if (IS_Bioseq_set (sep)) {
     bssp = (BioseqSetPtr) sep->data.ptrvalue;
     sap = bssp->annot;
   } else return;
   while (sap != NULL) {
     if (sap->type == 1) {
       sfp = (SeqFeatPtr) sap->data;
       while (sfp != NULL) {
         if (sfp->data.choice == SEQFEAT_RNA) {
           rrp = (RnaRefPtr) sfp->data.value.ptrvalue;
           if (rrp != NULL && rrp->type == 2 && rrp->ext.choice == 1 && sfp->product != NULL) {
             if (StringICmp (rrp->ext.value.ptrvalue, str) == 0) {
               bsp = BioseqFind (SeqLocId (sfp->product));
               if (bsp != NULL) {
                 *msep = SeqMgrGetSeqEntryForData (bsp);
               }
             }
           }
         }
         sfp = sfp->next;
       }
     }
     sap = sap->next;
   }
   if (bssp != NULL) {
     for (sep = bssp->seq_set; sep != NULL; sep = sep->next) {
       FindRnaByName (sep, str, msep);
     }
   }
 }
 
 static SeqEntryPtr FindRnaByRefOnProtein (SeqEntryPtr sep, SeqEntryPtr psep)
 
 {
   SeqEntryPtr  msep;
   CharPtr      mrna_name;
 
   msep = NULL;
   if (sep == NULL || psep == NULL) return NULL;
   mrna_name = LookForValueInBioseq (psep, Seq_mol_aa, "mrna");
   if (!StringHasNoText (mrna_name))
   {
     FindRnaByName (sep, mrna_name, &msep);
     RemoveValueFromBioseq (msep, "mrna");
   }
   mrna_name = MemFree (mrna_name);
   return msep;
 }
 
 static void FindRnaByLocationOverlap (SeqEntryPtr sep, SeqLocPtr slp,
                                       Int4Ptr mindiff, SeqEntryPtr PNTR msep)
 
 {
   BioseqPtr     bsp = NULL;
   BioseqSetPtr  bssp = NULL;
   Int4          diff;
   RnaRefPtr     rrp;
   SeqAnnotPtr   sap;
   SeqFeatPtr    sfp;
 
   if (sep == NULL || sep->data.ptrvalue == NULL) return;
   if (slp == NULL || mindiff == NULL || msep == NULL) return;
   if (IS_Bioseq (sep)) {
     bsp = (BioseqPtr) sep->data.ptrvalue;
     sap = bsp->annot;
   } else if (IS_Bioseq_set (sep)) {
     bssp = (BioseqSetPtr) sep->data.ptrvalue;
     sap = bssp->annot;
   } else return;
   while (sap != NULL) {
     if (sap->type == 1) {
       sfp = (SeqFeatPtr) sap->data;
       while (sfp != NULL) {
         if (sfp->data.choice == SEQFEAT_RNA) {
           rrp = (RnaRefPtr) sfp->data.value.ptrvalue;
           if (rrp != NULL && rrp->type == 2 && sfp->product != NULL) {
             diff = SeqLocAinB (slp, sfp->location);
             if (diff >= 0) {
               if (diff < *mindiff) {
                 bsp = BioseqFind (SeqLocId (sfp->product));
                 if (bsp != NULL) {
                   *mindiff = diff;
                   *msep = SeqMgrGetSeqEntryForData (bsp);
                 }
               }
             }
           }
         }
         sfp = sfp->next;
       }
     }
     sap = sap->next;
   }
   if (bssp != NULL) {
     for (sep = bssp->seq_set; sep != NULL; sep = sep->next) {
       FindRnaByLocationOverlap (sep, slp, mindiff, msep);
     }
   }
 }
 
 static void FuseNucProtBiosources (SeqEntryPtr sep)
 
 {
   BioSourcePtr  biop1, biop2;
   BioseqPtr     bsp;
   BioseqSetPtr  bssp;
   ValNodePtr    PNTR prev;
   ValNodePtr    sdp1, sdp2;
   SeqEntryPtr   tmp;
 
   if (sep == NULL) return;
   if (! IS_Bioseq_set (sep)) return;
   bssp = (BioseqSetPtr) sep->data.ptrvalue;
   if (bssp == NULL || bssp->_class != BioseqseqSet_class_nuc_prot) return;
   tmp = FindNucSeqEntry (sep);
   if (tmp == NULL) return;
   if (! IS_Bioseq (tmp)) return;
   bsp = (BioseqPtr) tmp->data.ptrvalue;
   if (bsp == NULL) return;
   prev = &(bssp->descr);
   sdp1 = bssp->descr;
   while (sdp1 != NULL && sdp1->choice != Seq_descr_source) {
     prev = &(sdp1->next);
     sdp1 = sdp1->next;
   }
   if (sdp1 == NULL) return;
   sdp2 = SeqEntryGetSeqDescr (tmp, Seq_descr_source, NULL);
   if (sdp2 == NULL) return;
   biop1 = (BioSourcePtr) sdp1->data.ptrvalue;
   biop2 = (BioSourcePtr) sdp2->data.ptrvalue;
   if (CmpOrgById (biop1, biop2)) {
     *prev = sdp1->next;
     sdp1->next = NULL;
     SeqDescrFree (sdp1);
   }
 }
 
 static void AssignOneProtein 
 (SeqEntryPtr      prot_sep, 
  SequencesFormPtr sqfp,
  SeqEntryPtr      assign_sep,
  SeqLocPtr        use_this,
  BioseqPtr        nucbsp,
  Int2             code,
  Boolean          makeMRNA)
 {
   MolInfoPtr        mip;
   SeqEntryPtr       msep = NULL;
   BioseqPtr         protbsp;
   SeqLocPtr         slp;
   Int4              mindiff;
   Boolean           partialN;
   Boolean           partialC;
   ValNodePtr        vnp;
   
   if (prot_sep == NULL)
   {
     return;
   }
   
   mip = MolInfoNew ();
   if (mip != NULL) {
     mip->biomol = 8;
     if (sqfp == NULL) {
       /* no technique */
     } else if (GetStatus (sqfp->protTechBoth)) {
       mip->tech = 10;
     } else {
       mip->tech = 13;
     }
     if (sqfp == NULL) {
       if (use_this == NULL) {
         partialN = FALSE;
         partialC = FALSE;
       } else {
         CheckSeqLocForPartial (use_this, &partialN, &partialC);
       }
     } else {
       partialN = GetStatus (sqfp->partialN);
       partialC = GetStatus (sqfp->partialC);
     }
     if (partialN && partialC) {
       mip->completeness = 5;
     } else if (partialN) {
       mip->completeness = 3;
     } else if (partialC) {
       mip->completeness = 4;
     }
     vnp = CreateNewDescriptor (prot_sep, Seq_descr_molinfo);
     if (vnp != NULL) {
       vnp->data.ptrvalue = (Pointer) mip;
     }
   }
   if (assign_sep != NULL) {
     if (sqfp != NULL && sqfp->seqPackage == SEQ_PKG_GENOMICCDNA) {
       ClearBatchSuggestNucleotide ();
       msep = FindRnaByRefOnProtein (assign_sep, prot_sep);
       if (msep == NULL) {
         msep = FindRnaByRefOnRna (assign_sep, prot_sep);
       }
       if (msep == NULL && nucbsp != NULL && IS_Bioseq (prot_sep)) {
         protbsp = (BioseqPtr) prot_sep->data.ptrvalue;
         if (protbsp != NULL) {
           slp = PredictCodingRegion (nucbsp, protbsp, code);
           if (slp != NULL) {
             mindiff = INT4_MAX;
             FindRnaByLocationOverlap (assign_sep, slp, &mindiff, &msep);
           }
           SeqLocFree (slp);
         }
       }
     }
     if (msep != NULL) {
       msep = GetBestTopParentForDataEx (ObjMgrGetEntityIDForChoice (msep),
                                         (BioseqPtr) msep->data.ptrvalue, TRUE);
     }
     if (msep == NULL) {
       msep = assign_sep;
       if (IS_Bioseq (msep))
       {
         msep = GetBestTopParentForDataEx (ObjMgrGetEntityIDForChoice (msep),
                                           (BioseqPtr) msep->data.ptrvalue, TRUE);
       }
     }
     AddSeqEntryToSeqEntry (msep, prot_sep, TRUE);
     AutomaticProteinProcess (msep, prot_sep, code, makeMRNA, use_this);
   } else {
     AutomaticProteinProcess (assign_sep, prot_sep, code, makeMRNA, use_this);
   }  
 }
 
 static SeqEntryPtr FindSeqEntryWithTranscriptID (SeqEntryPtr sep, CharPtr transcript_id)
 {
   SeqEntryPtr  found_sep = NULL;
   BioseqPtr    nbsp;
   SeqIdPtr     sip, sip_next;
   CharPtr      tmp;
   BioseqSetPtr bssp;
   
   if (IS_Bioseq (sep))
   {
     nbsp = sep->data.ptrvalue;
     for (sip = nbsp->id; sip != NULL && found_sep == NULL; sip = sip_next)
     {
       sip_next = sip->next;
       sip->next = NULL;
       tmp = SeqIdWholeLabel (sip, PRINTID_REPORT);
       sip->next = sip_next;
       if (StringCmp (tmp, transcript_id) == 0)
       {
         found_sep = sep;
       }
       tmp = MemFree (tmp);
     }
   }
   else
   {
     bssp = (BioseqSetPtr) sep->data.ptrvalue;
     for (sep = bssp->seq_set; sep != NULL && found_sep == NULL; sep = sep->next)
     {
       found_sep = FindSeqEntryWithTranscriptID (sep, transcript_id);
     }
   }
   return found_sep; 
 }
 
 /* This section of code is used for matching up proteins to coding region locations
  * on the nucleotide sequences.
  */
 
 /* A ValNode list will be used to hold the list of pairings between protein and nucleotide
  * sequences.  There will be one ValNode per protein sequence.  The choice for the ValNode
  * indicates the position of the nucleotide sequence in the set plus one - a zero indicates
  * that there is no nucleotide for this protein.  The data.ptrvalue will be used to hold the
  * location of the coding region on the nucleotide.
  */
 
 /* This function frees the AssociationList. */ 
 extern NucProtAssocPtr FreeAssociationList (NucProtAssocPtr assoc_list)
 {
   if (assoc_list == NULL)
   {
     return NULL;
   }
   assoc_list->next = FreeAssociationList (assoc_list->next);
   assoc_list->loc = SeqLocFree (assoc_list->loc);
   assoc_list = MemFree (assoc_list);
   return assoc_list;
 }
 
 static NucProtAssocPtr NewAssociationList (NucProtAssocPtr PNTR assoc_list, Int4 position, SeqLocPtr loc)
 {
   NucProtAssocPtr last = NULL;
   NucProtAssocPtr new_assoc = (NucProtAssocPtr) MemNew (sizeof (NucProtAssocData));
   
   if (assoc_list == NULL) {
     return NULL;
   }
   if (new_assoc != NULL) {
     new_assoc->position = position;
     new_assoc->loc = loc;
     new_assoc->next = NULL;
     if (*assoc_list == NULL) {
       *assoc_list = new_assoc;
     } else {
       last = *assoc_list;
       while (last->next != NULL) {
         last = last->next;
       }
       last->next = new_assoc;
     }
   }
   return *assoc_list; 
 }
 
 /* This function copies the AssociationList */
 static NucProtAssocPtr CopyAssociationList (NucProtAssocPtr orig_assoc_list)
 {
   NucProtAssocPtr copy_assoc_list = NULL;
   
   if (orig_assoc_list == NULL)
   {
     return NULL;
   }
   copy_assoc_list = (NucProtAssocPtr) MemNew (sizeof (NucProtAssocData));
   if (copy_assoc_list != NULL)
   {
     copy_assoc_list->position = orig_assoc_list->position;
     copy_assoc_list->loc = SeqLocCopy (orig_assoc_list->loc);
     copy_assoc_list->next = CopyAssociationList (orig_assoc_list->next);
   }
   
   return copy_assoc_list;
 }
 
 
 /* This function determines whether all proteins have been assigned to 
  * nucleotide sequences. 
  */
 static Boolean AllLocationsProvided (NucProtAssocPtr vnp)
 {
   if (vnp == NULL)
   {
     return FALSE;
   }
   while (vnp != NULL)
   {
     if (vnp->position == 0)
     {
       return FALSE;
     }
     vnp = vnp->next;
   }
   return TRUE;
 }
 
 /* This function determines whether any proteins have been assigned to 
  * nucleotide sequences. 
  */
 static Boolean AnyLocationsProvided (NucProtAssocPtr vnp)
 {
   if (vnp == NULL)
   {
     return FALSE;
   }
   while (vnp != NULL)
   {
     if (vnp->position != 0)
     {
       return TRUE;
     }
     vnp = vnp->next;
   }
   return FALSE;
 }
 
 /* Given a nucleotide-protein pair, this function calculates a coding region location
  * using Suggest Intervals.  If no location is found, a location that includes the
  * entire sequence is returned instead.
  */
 static SeqLocPtr DefaultPairInterval (BioseqPtr nbsp, BioseqPtr pbsp, Int2 code)
 {
   SeqLocPtr slp;
   ErrSev    oldsev;
   Char      prot_str[3];
   Boolean   partial5 = FALSE, partial3 = FALSE;
   
   if (nbsp == NULL || pbsp == NULL)
   {
     return NULL;
   }
     
   /* need to suppress errors */  
   oldsev = ErrSetMessageLevel (SEV_MAX);
 
   /* try to get location using SuggestIntervals */
   SetBatchSuggestNucleotide (nbsp, code);
   slp = PredictCodingRegion (nbsp, pbsp, code);
   ClearBatchSuggestNucleotide ();  
   
   ErrSetMessageLevel (oldsev);
   
   /* if no location, use entire sequence */
   if (slp == NULL)
   {
     slp = SeqLocIntNew (0, nbsp->length - 1, Seq_strand_plus, nbsp->id); 
   }
 
   /* check for start and stop codons */  
   SeqPortStreamInt (pbsp, 0, 1, Seq_strand_plus, EXPAND_GAPS_TO_DASHES, (Pointer) (prot_str), NULL);
   if (prot_str[0] != 'M') {
     partial5 = TRUE;
   }
   
   if (SeqLocLen (slp) / 3 != pbsp->length + 1) {
     partial3 = TRUE;
   }
   
   SetSeqLocPartial (slp, partial5, partial3);
   
   return slp;
 }
 
 
 static Boolean FindFeaturesInIdenticalRegions (NucProtAssocPtr assoc_list)
 {
   Char       path [PATH_MAX];
   FILE       *fp;
   NucProtAssocPtr   vnp;
   SeqFeatPtr sfp;
   SeqMgrFeatContext fcontext;  
   Char        id_txt [128];
   Boolean     found_any = FALSE;
 
   if (assoc_list == NULL)
   {
     return FALSE;
   }
   
   TmpNam (path);
   fp = FileOpen (path, "wb");
   
   for (vnp = assoc_list; vnp != NULL; vnp = vnp->next) {
     if (vnp->loc != NULL) {
       sfp = SeqMgrGetOverlappingCDS (vnp->loc, &fcontext);
       if (sfp != NULL && SeqLocCompare (vnp->loc, sfp->location) == SLC_A_EQ_B) {
         if (fp == NULL) {
           return TRUE;
         } else {
           found_any = TRUE;
           SeqIdWrite (SeqLocId (vnp->loc), id_txt, PRINTID_REPORT, sizeof (id_txt) - 1);          
           fprintf (fp, "%s\n", id_txt);
         }
       }
     }
   }
   FileClose (fp);
 
   if (found_any) {
     LaunchGeneralTextViewer (path, "Sequences with pre-existing Coding Regions");
   }
   FileRemove (path);   
   return found_any;
 }
 
 
 static Int2 GetGeneticCodeFromBioseq (BioseqPtr bsp)
 {
   Int2 code = 1;
   SeqDescrPtr sdp;
   SeqMgrDescContext context;
   CharPtr location;
 
   if (bsp != NULL) {
     sdp = SeqMgrGetNextDescriptor (bsp, NULL, Seq_descr_title, &context);
     if (sdp != NULL) {
       location = FindValueFromPairInDeflineBeforeCharPtr ("location", sdp->data.ptrvalue, NULL);
       if (!StringHasNoText (location)) {      
         code = UseGeneticCodeForLocation (location);
       }
     }
   }
   return code;
 }
 
 
 /* This function takes a ValNode list where each ValNode represents
  * a protein in prot_list (in order).  The choice for each ValNode
  * represents the position of the chosen nucleotide in the nuc_list
  * (position includes segments in segmented sets, which is why 
  * FindNthSequenceInSet is used) plus one - zero indicates that there
  * is no nucleotide sequence for this protein.
  * The data.ptrvalue for the ValNode is to be populated with a
  * coding region SeqLoc, or NULL if there is no nucleotide for the protein.
  */
 static Boolean 
 PickCodingRegionLocationsForProteinNucleotidePairs 
 (NucProtAssocPtr  assoc_list,
  SeqEntryPtr nuc_list,
  SeqEntryPtr prot_list)
 {
   NucProtAssocPtr vnp_assoc;
   Int4       data_row;
   BioseqPtr  nbsp, pbsp;
   SeqLocPtr  slp;
   Char       path [PATH_MAX];
   FILE       *fp;
   Boolean    errors_found = FALSE;
   Char       n_idstr[128];
   Char       p_idstr[128];
   Int2       code;
   
   if (assoc_list == NULL || nuc_list == NULL || prot_list == NULL)
   {
     return FALSE;
   }
 
   TmpNam (path);
   fp = FileOpen (path, "wb");
 
   vnp_assoc = assoc_list;
   for (data_row = 0, vnp_assoc = assoc_list;
        vnp_assoc != NULL; 
        data_row++, vnp_assoc = vnp_assoc->next)
   {
     if (vnp_assoc->position > 0)
     {
       nbsp = FindNthSequenceInSet (nuc_list, vnp_assoc->position - 1, NULL, TRUE);
       pbsp = FindNthSequenceInSet (prot_list, data_row, NULL, FALSE);
       if (nbsp == NULL || pbsp == NULL) {
         slp = NULL;
       } else if ((nbsp->length +1) / 3 < pbsp->length) {
         if (fp != NULL) {
           SeqIdWrite (SeqIdFindWorst (nbsp->id), n_idstr, PRINTID_REPORT,
                       sizeof (n_idstr));
           SeqIdWrite (SeqIdFindWorst (pbsp->id), p_idstr, PRINTID_REPORT,
                       sizeof (p_idstr));
           fprintf (fp, "%s is too short to encode %s\n", n_idstr, p_idstr);
         }
         vnp_assoc->position = 0;
         errors_found = TRUE;
         slp = NULL;
       } else {
         code = GetGeneticCodeFromBioseq (nbsp);
         slp = DefaultPairInterval (nbsp, pbsp, code);
       }
     }
     else
     {
       slp = NULL;
     }
     vnp_assoc->loc = SeqLocFree (vnp_assoc->loc);
     vnp_assoc->loc = slp;
   }
   
   FileClose (fp);
   if (errors_found) {
     LaunchGeneralTextViewer (path, "Nucleotide-Protein Mismatches");
   }
   FileRemove (path);
   return !errors_found;
 }
 
 
 static Int2 FindGeneticCodeForBioseq (BioseqPtr bsp, Int2 default_code)
 {
   Int2         code = default_code;
   BioSourcePtr biop;
   SeqEntryPtr  nsep;
   BioseqSetPtr bssp;
   SeqDescrPtr  sdp = NULL;
 
   if (bsp == NULL) return default_code;
   nsep = GetBestTopParentForData (ObjMgrGetEntityIDForPointer (bsp), bsp);
   if (nsep == NULL || nsep->data.ptrvalue == NULL) return default_code;
   if (nsep->choice == 1)
   {
     bsp = nsep->data.ptrvalue;
     sdp = bsp->descr;
   }
   else if (nsep->choice == 2)
   {
     bssp = nsep->data.ptrvalue;
     sdp = bssp->descr;
   }
   while (sdp != NULL)
   {
     if (sdp->choice == Seq_descr_source && sdp->data.ptrvalue != NULL)
     {
       biop = (BioSourcePtr) sdp->data.ptrvalue;
       if (biop->org != NULL && biop->org->orgname != NULL)
       {
         code = BioSourceToGeneticCode (biop);
       }
     }
     sdp = sdp->next;
   }
   return code;
 }
 
 
 /* This function takes a ValNode list of coding region SeqLocs,
  * the list of nucleotide sequences, and the list of protein sequences
  * and creates the nuc-prot sets.
  */
 static void 
 AssignProteinsToSelectedNucleotides 
 (NucProtAssocPtr  assoc_list,
  SeqEntryPtr      nuc_list,
  SeqEntryPtr      prot_list,
  SequencesFormPtr sqfp, 
  Int2             code,
  Boolean          makeMRNA)
 {
   SeqEntryPtr prot_sep, nsep, prot_next;
   NucProtAssocPtr  vnp_assoc;
   BioseqPtr   nbsp;
   BioseqPtr PNTR bsp_array;
   Int4           prot_num;
   ValNodePtr     descr = NULL;
   Int2           genCode;
 
   if (assoc_list == NULL || nuc_list == NULL || prot_list == NULL)
   {
     return;
   }
 
   /* need to collect bioseqs before we start adding, otherwise the position in
    * the set changes */
   
   bsp_array = (BioseqPtr PNTR) MemNew (ValNodeLen (prot_list) * sizeof (BioseqPtr));
   if (bsp_array == NULL)
   {
     return;
   }
   
   for (prot_num = 0, vnp_assoc = assoc_list;
        vnp_assoc != NULL;
        prot_num++, vnp_assoc = vnp_assoc->next)
   {
     if (vnp_assoc->loc == NULL)
     {
       bsp_array [prot_num] = NULL;
     }
     else
     {
       bsp_array [prot_num] = FindNthSequenceInSet (nuc_list, vnp_assoc->position - 1, NULL, TRUE);
     }
   }
   
   for (prot_sep = prot_list, vnp_assoc = assoc_list, prot_num = 0;
        prot_sep != NULL && vnp_assoc != NULL;
        prot_sep = prot_next, vnp_assoc = vnp_assoc->next, prot_num++)
   {
     prot_next = prot_sep->next;
     prot_sep->next = NULL;
     
     if (vnp_assoc->loc == NULL)
     {
       /* discard protein */
       if (IS_Bioseq (prot_sep))
       {
         SeqMgrDeleteFromBioseqIndex (prot_sep->data.ptrvalue);
       }
       prot_sep = SeqEntryFree (prot_sep);
     }
     else
     {
       nbsp = bsp_array [prot_num];
       nsep = SeqMgrGetSeqEntryForData (nbsp);
       if (nbsp != NULL && nbsp->repr == Seq_repr_seg)
       {
         nsep = GetBestTopParentForData (ObjMgrGetEntityIDForPointer (nbsp), nbsp); 
       }
       genCode = FindGeneticCodeForBioseq (nbsp, code);
       if (nsep != NULL && nsep->data.ptrvalue == nbsp) {
         descr = ExtractBioSourceAndPubs (nsep);
       }
       AssignOneProtein (prot_sep, sqfp, nsep, vnp_assoc->loc, nbsp, 
                         genCode, makeMRNA);
       if (descr != NULL) {
         ReplaceBioSourceAndPubs (nsep, descr);
       }
       vnp_assoc->loc = NULL; /*SeqLoc was freed in AssignOneProtein */
     }
   }
   
   bsp_array = MemFree (bsp_array);
 }
 
 /* This function creates a new protein ID based on the nucleotide ID that will be
  * unique within the record - nucleotide and protein sequence IDs are checked
  * for matches.
  */
 static CharPtr 
 BuildProteinIDUniqueInIDAndTitleEdit 
 (CharPtr nuc_id,
  IDAndTitleEditPtr iatep_nuc,
  IDAndTitleEditPtr iatep_prot)
 {
   CharPtr new_id, cp;
   Int4    offset, seq_num;
   Boolean unique_found = FALSE;
   
   if (iatep_nuc == NULL || iatep_prot == NULL || StringHasNoText (nuc_id))
   {
     return NULL;
   }
   
   new_id = (CharPtr) MemNew ((StringLen (nuc_id) + 20) * sizeof (Char));
   if (new_id != NULL)
   {
     StringCpy (new_id, nuc_id);
     StringCat (new_id, "_");
     cp = new_id + StringLen (new_id);
     for (offset = 1; offset < INT4_MAX && ! unique_found; offset ++)
     {
       sprintf (cp, "%d", offset);
       unique_found = TRUE;
       for (seq_num = 0; seq_num < iatep_nuc->num_sequences && unique_found; seq_num++)
       {
         if (StringCmp (iatep_nuc->id_list [seq_num], new_id) == 0)
         {
           unique_found = FALSE;
         }
       }
       for (seq_num = 0; seq_num < iatep_prot->num_sequences && unique_found; seq_num++)
       {
         if (StringCmp (iatep_prot->id_list [seq_num], new_id) == 0)
         {
           unique_found = FALSE;
         }
       }
     }
   }
   if (unique_found)
   {
     return new_id;
   }
   else
   {
     new_id = MemFree (new_id);
     return StringSave ("too_many");
   }
 }
 
 static Boolean DoIdsMatch (CharPtr id1, CharPtr id2)
 {
   CharPtr tmp1, cp1 = NULL;
   CharPtr tmp2, cp2 = NULL;
   Boolean match = FALSE;
   
   tmp1 = StringChr (id1, '|');
   if (tmp1 == NULL) {
     tmp1 = id1;
   } else if (tmp1 == id1 + 2) {
     tmp1++;
     cp1 = StringChr (tmp1, '|');
     if (cp1 != NULL) {
       *cp1 = 0;
     }
   }
   
   tmp2 = StringChr (id2, '|');
   if (tmp2 == NULL) {
     tmp2 = id2;
   } else if (tmp2 == id2 + 2) {
     tmp2++;
     cp2 = StringChr (tmp2, '|');
     if (cp2 != NULL) {
       *cp2 = 0;
     }
   }
  
   if (StringCmp (tmp1, tmp2) == 0)
   {
     match = TRUE;
   }
   if (cp1 != NULL) {
     *cp1 = '|';
   }
   if (cp2 != NULL) {
     *cp2 = '|';
   }
   return match;
 }
 
 
 /* if the user gave the protein sequences the same IDs as the nucleotide sequences,
  * we need to create new sequence IDs for the proteins so that they will be unique.
  * We should also make sure that sequence IDs that don't match nucleotide sequence
  * IDs are unique.
  */
 static void ReplaceDuplicateProteinIDs (SeqEntryPtr nuc_list, SeqEntryPtr prot_list)
 {
   Int4              nuc_seq_num, prot_seq_num, prot_seq_num_check;
   IDAndTitleEditPtr iatep_nuc, iatep_prot;
   Boolean           found_nuc_match;
   CharPtr           tmp_str, cp;
   BioseqPtr         prot_bsp, nuc_bsp;
   
   if (nuc_list == NULL || prot_list == NULL)
   {
     return;
   }
   
   iatep_nuc = SeqEntryListToIDAndTitleEditEx (nuc_list, TRUE);
   iatep_prot = SeqEntryListToIDAndTitleEdit (prot_list);
   if (iatep_nuc != NULL && iatep_prot != NULL)
   {
     for (prot_seq_num = 0; prot_seq_num < iatep_prot->num_sequences; prot_seq_num++)
     {
       /* This part replaces any protein sequence IDs that match a nucleotide ID with
        * the nucleotide ID plus an underscore plus a number that makes the ID
        * unique.
        */
       found_nuc_match = FALSE;
       prot_bsp = FindNthSequenceInSet (prot_list, prot_seq_num, &(iatep_prot->is_seg[prot_seq_num]), FALSE);
       if (prot_bsp == NULL) continue;
       for (nuc_seq_num = 0;
            nuc_seq_num < iatep_nuc->num_sequences && ! found_nuc_match; 
            nuc_seq_num++)
       {
         nuc_bsp = FindNthSequenceInSet (nuc_list, nuc_seq_num, &(iatep_nuc->is_seg[prot_seq_num]), TRUE);
         if (nuc_bsp == NULL) continue;
       
         if (SeqIdIn (prot_bsp->id, nuc_bsp->id) || RelaxedSeqIdIn (prot_bsp->id, nuc_bsp->id)
             || DoIdsMatch (iatep_nuc->id_list [nuc_seq_num],
                            iatep_prot->id_list [prot_seq_num])) {
           tmp_str = iatep_nuc->id_list [nuc_seq_num];
           cp = StringChr (tmp_str, '|');
           if (cp == tmp_str + 2) {
             tmp_str += 3;
             cp = StringChr (tmp_str, '|');
           }
           if (cp != NULL) {
             *cp = 0;
           }
                         
           iatep_prot->id_list [prot_seq_num] = MemFree (iatep_prot->id_list [prot_seq_num]);
           iatep_prot->id_list [prot_seq_num] = BuildProteinIDUniqueInIDAndTitleEdit (tmp_str,
                                                                                      iatep_nuc,
                                                                                      iatep_prot);
           if (cp != NULL) {
             *cp = '|';
           }
           found_nuc_match = TRUE;
         }
       }
       /* This part replaces a protein sequence ID that matches a previous protein
        * sequence ID with the original protein sequence ID plus an underscore plus
        * a number that makes the ID unique.
        */
       if (!found_nuc_match)
       {
         for (prot_seq_num_check = prot_seq_num + 1; 
              prot_seq_num_check < iatep_prot->num_sequences;
              prot_seq_num_check ++)
         {
           if (StringCmp (iatep_prot->id_list [prot_seq_num],
                          iatep_prot->id_list [prot_seq_num_check]) == 0)
           {
             tmp_str = iatep_prot->id_list [prot_seq_num_check];
             cp = StringChr (tmp_str, '|');
             if (cp == tmp_str + 2) {
               tmp_str += 3;
               cp = StringChr (tmp_str, '|');
             }
             if (cp != NULL) {
               *cp = 0;
             }
             tmp_str = StringSave (tmp_str);
           
             iatep_prot->id_list [prot_seq_num_check] = MemFree (iatep_prot->id_list [prot_seq_num_check]);
             iatep_prot->id_list [prot_seq_num_check] = BuildProteinIDUniqueInIDAndTitleEdit (tmp_str,
                                                                                              iatep_nuc,
                                                                                              iatep_prot);
             tmp_str = MemFree (tmp_str);
           }
         }
       }
     }
   }
   ApplyIDAndTitleEditToSeqEntryList (prot_list, iatep_prot);
   iatep_prot = IDAndTitleEditFree (iatep_prot);
   iatep_nuc = IDAndTitleEditFree (iatep_nuc);
 }
 
 static Uint2 nucprotedit_types [] = {
   TAGLIST_PROMPT, TAGLIST_PROMPT, TAGLIST_POPUP, TAGLIST_TEXT, TAGLIST_TEXT
 };
 
 static Uint2 nucprotedit_widths [] = {
   5, 20, 10, 15, 15
 };
 
 #define NUCPROTEDIT_NUCID_COLUMN 2
 #define NUCPROTEDIT_GENE_COLUMN  3
 #define NUCPROTEDIT_PROT_COLUMN  4
 
 typedef struct nucprotedit
 {
   SeqEntryPtr nuc_list;
   SeqEntryPtr prot_list;
   DialoG      dlg;
   ButtoN      accept_btn;
   NucProtAssocPtr  assoc_list;
   TexT        all_gene_txt;
   TexT        all_prot_txt;
 } NucProtEditData, PNTR NucProtEditPtr;
 
 static void PopulateNucProtEdit (NucProtEditPtr npep)
 {
   IDAndTitleEditPtr     iatep_nuc, iatep_prot;
   ValNodePtr            row_list = NULL;
   NucProtAssocPtr       vnp_assoc;
   TagListPtr            tlp;
   CharPtr               data_string, gene_locus, prot_name;
   Int4                  data_len;
   Int4                  prot_num;
   Int4                  old_scroll_pos = 0;
   
   if (npep == NULL)
   {
     return;
   }
   
   tlp = (TagListPtr) GetObjectExtra (npep->dlg);
   if (tlp == NULL)
   {
     return;
   }
   
   /* need to get bar value and reset after populating */
   if (tlp->bar != NULL)  
   {
     old_scroll_pos = GetBarValue (tlp->bar);
   }
   
   iatep_nuc = SeqEntryListToIDAndTitleEditEx (npep->nuc_list, TRUE);
   iatep_prot = SeqEntryListToIDAndTitleEdit (npep->prot_list);
   if (iatep_nuc != NULL && iatep_prot != NULL)
   {
     vnp_assoc = npep->assoc_list;
     for (prot_num = 0; prot_num < iatep_prot->num_sequences; prot_num++)
     {
       /* first column is protein ID */
       /* second column is choice for nucleotide ID */
       /* third column is gene locus tag */
       /* fourth column is protein name */
       /* fifth column indicates presence of suggested interval */
       gene_locus = FindValueFromPairInDefline ("gene", iatep_prot->title_list [prot_num]);
       prot_name = FindValueFromPairInDefline ("protein", iatep_prot->title_list [prot_num]);
       
       data_len = StringLen (iatep_prot->id_list [prot_num])
                   + 20
                   + StringLen (gene_locus)
                   + StringLen (prot_name);
       data_string = (CharPtr) MemNew (data_len * sizeof (Char));                  
       if (data_string != NULL)
       {
         sprintf (data_string, "%d\t%s\t%d\t%s\t%s\n",
                                prot_num + 1,
                                iatep_prot->id_list [prot_num],
                                vnp_assoc == NULL ? 0 : vnp_assoc->position,
                                gene_locus == NULL ? "" : gene_locus,
                                prot_name == NULL ? "" : prot_name);
         ValNodeAddPointer (&row_list, 0, data_string);                               
       }
       gene_locus = MemFree (gene_locus);
       prot_name = MemFree (prot_name);
       if (vnp_assoc != NULL)
       {
         vnp_assoc = vnp_assoc->next;
       }
     }
     SendMessageToDialog (npep->dlg, VIB_MSG_RESET);
     tlp->vnp = row_list;
 
     if (iatep_prot->num_sequences > tlp->rows)
     {
       tlp->max = MAX ((Int2) 0, (Int2) (iatep_prot->num_sequences - tlp->rows));  
       CorrectBarMax (tlp->bar, tlp->max);
       CorrectBarPage (tlp->bar, tlp->rows - 1, tlp->rows - 1); 
       Enable (tlp->bar);
       SetBarValue (tlp->bar, old_scroll_pos);
     }
     else
     {
       Hide (tlp->bar);
     }
     SendMessageToDialog (npep->dlg, VIB_MSG_REDRAW);    
   }
   
   iatep_nuc = IDAndTitleEditFree (iatep_nuc);
   iatep_prot = IDAndTitleEditFree (iatep_prot);
 }
 
 static CharPtr 
 GetTagListValueEx (TagListPtr tlp, Int4 seq_num, Int4 col_num);
 
 static void ApplyGeneNameToAllSequences (ButtoN b)
 {
   NucProtEditPtr npep;
   CharPtr        all_gene_name, new_val;
   TagListPtr     tlp;
   Int4           seq_num;
   ValNodePtr     vnp;
   
   npep = (NucProtEditPtr) GetObjectExtra (b);
   if (npep == NULL)
   {
     return;
   }
   
   tlp = (TagListPtr) GetObjectExtra (npep->dlg);
   if (tlp == NULL)
   {
     return;
   }
   all_gene_name = SaveStringFromText (npep->all_gene_txt);
   if (ANS_YES == Message (MSG_YN, "Are you sure you want to set all of the gene locus values to %s?",
                           all_gene_name))
   {
     for (vnp = tlp->vnp, seq_num = 0;
          vnp != NULL;
          vnp = vnp->next, seq_num++)
     {
       new_val = ReplaceTagListColumn (vnp->data.ptrvalue, all_gene_name, NUCPROTEDIT_GENE_COLUMN);
       vnp->data.ptrvalue = MemFree (vnp->data.ptrvalue);
       vnp->data.ptrvalue = new_val;
     }
     SendMessageToDialog (npep->dlg, VIB_MSG_REDRAW);
   }
   all_gene_name = MemFree (all_gene_name);
 }
 
 static void ApplyProteinNameToAllSequences (ButtoN b)
 {
   NucProtEditPtr npep;
   CharPtr        all_prot_name, new_val;
   TagListPtr     tlp;
   Int4           seq_num;
   ValNodePtr     vnp;
   
   npep = (NucProtEditPtr) GetObjectExtra (b);
   if (npep == NULL)
   {
     return;
   }
   
   tlp = (TagListPtr) GetObjectExtra (npep->dlg);
   if (tlp == NULL)
   {
     return;
   }
   all_prot_name = SaveStringFromText (npep->all_prot_txt);
   if (ANS_YES == Message (MSG_YN, "Are you sure you want to set all of the protein names to %s?",
                           all_prot_name))
   {
     for (vnp = tlp->vnp, seq_num = 0;
          vnp != NULL;
          vnp = vnp->next, seq_num++)
     {
       new_val = ReplaceTagListColumn (vnp->data.ptrvalue, all_prot_name, NUCPROTEDIT_PROT_COLUMN);
       vnp->data.ptrvalue = MemFree (vnp->data.ptrvalue);
       vnp->data.ptrvalue = new_val;
     }
     SendMessageToDialog (npep->dlg, VIB_MSG_REDRAW);   
   }
   all_prot_name = MemFree (all_prot_name);
 }
 
 static void ApplyNucProtEditGeneAndProt (NucProtEditPtr npep)
 {