← Back to branch summary

~ubuntu-branches/ubuntu/saucy/ncbi-tools6/saucy-proposed

« back to all changes in this revision

Viewing changes to api/sqnutil1.c

  • Committer: Bazaar Package Importer
  • Author(s): Aaron M. Ucko
  • Date: 2009-08-11 22:03:47 UTC
  • mfrom: (1.4.1 upstream)
  • mto: This revision was merged to the branch mainline in revision 10.
  • Revision ID: james.westby@ubuntu.com-20090811220347-g4b6lzdvphvvbpiu
* New upstream release.
* debian/libncbi6.symbols: update accordingly.
* debian/control: clean up obsolete or redundant relationship declarations.

Show diffs side-by-side

added added

removed removed

Lines of Context:
api/sqnutil1.c
29
29
*
30
30
* Version Creation Date:   9/2/97
31
31
*
32
 
* $Revision: 6.508 $
 
32
* $Revision: 6.534 $
33
33
*
34
34
* File Description: 
35
35
*
64
64
  Seq_descr_title,
65
65
  Seq_descr_source,
66
66
  Seq_descr_molinfo,
67
 
  Seq_descr_genbank,
68
 
  Seq_descr_embl,
69
 
  Seq_descr_sp,
70
 
  Seq_descr_pir,
71
 
  Seq_descr_prf,
72
 
  Seq_descr_pdb,
73
67
  Seq_descr_het,
74
 
  Seq_descr_create_date,
75
 
  Seq_descr_update_date,
76
68
  Seq_descr_pub,
77
69
  Seq_descr_comment,
78
70
  Seq_descr_name,
85
77
  Seq_descr_modif,
86
78
  Seq_descr_method,
87
79
  Seq_descr_org,
 
80
  Seq_descr_sp,
 
81
  Seq_descr_pir,
 
82
  Seq_descr_prf,
 
83
  Seq_descr_pdb,
 
84
  Seq_descr_embl,
 
85
  Seq_descr_genbank,
 
86
  Seq_descr_create_date,
 
87
  Seq_descr_update_date,
88
88
  0
89
89
};
90
90
 
1653
1653
  return 0;
1654
1654
}
1655
1655
 
 
1656
NLM_EXTERN int LIBCALLBACK SortVnpByStringCS (VoidPtr ptr1, VoidPtr ptr2)
 
1657
 
 
1658
{
 
1659
  CharPtr     str1;
 
1660
  CharPtr     str2;
 
1661
  ValNodePtr  vnp1;
 
1662
  ValNodePtr  vnp2;
 
1663
 
 
1664
  if (ptr1 != NULL && ptr2 != NULL) {
 
1665
    vnp1 = *((ValNodePtr PNTR) ptr1);
 
1666
    vnp2 = *((ValNodePtr PNTR) ptr2);
 
1667
    if (vnp1 != NULL && vnp2 != NULL) {
 
1668
      str1 = (CharPtr) vnp1->data.ptrvalue;
 
1669
      str2 = (CharPtr) vnp2->data.ptrvalue;
 
1670
      if (str1 != NULL && str2 != NULL) {
 
1671
        return StringCmp (str1, str2);
 
1672
      }
 
1673
    }
 
1674
  }
 
1675
  return 0;
 
1676
}
 
1677
 
 
1678
NLM_EXTERN int LIBCALLBACK SortVnpByStringCI (VoidPtr ptr1, VoidPtr ptr2)
 
1679
 
 
1680
{
 
1681
  CharPtr     str1;
 
1682
  CharPtr     str2;
 
1683
  ValNodePtr  vnp1;
 
1684
  ValNodePtr  vnp2;
 
1685
 
 
1686
  if (ptr1 != NULL && ptr2 != NULL) {
 
1687
    vnp1 = *((ValNodePtr PNTR) ptr1);
 
1688
    vnp2 = *((ValNodePtr PNTR) ptr2);
 
1689
    if (vnp1 != NULL && vnp2 != NULL) {
 
1690
      str1 = (CharPtr) vnp1->data.ptrvalue;
 
1691
      str2 = (CharPtr) vnp2->data.ptrvalue;
 
1692
      if (str1 != NULL && str2 != NULL) {
 
1693
        return StringCmp (str1, str2);
 
1694
      }
 
1695
    }
 
1696
  }
 
1697
  return 0;
 
1698
}
 
1699
 
 
1700
NLM_EXTERN int LIBCALLBACK SortVnpByStringCIUCFirst (VoidPtr ptr1, VoidPtr ptr2)
 
1701
 
 
1702
{
 
1703
  int         comp;
 
1704
  CharPtr     str1;
 
1705
  CharPtr     str2;
 
1706
  ValNodePtr  vnp1;
 
1707
  ValNodePtr  vnp2;
 
1708
 
 
1709
  if (ptr1 != NULL && ptr2 != NULL) {
 
1710
    vnp1 = *((ValNodePtr PNTR) ptr1);
 
1711
    vnp2 = *((ValNodePtr PNTR) ptr2);
 
1712
    if (vnp1 != NULL && vnp2 != NULL) {
 
1713
      str1 = (CharPtr) vnp1->data.ptrvalue;
 
1714
      str2 = (CharPtr) vnp2->data.ptrvalue;
 
1715
      if (str1 != NULL && str2 != NULL) {
 
1716
        comp = StringICmp (str1, str2);
 
1717
        if (comp != 0) return comp;
 
1718
        return StringCmp (str1, str2);
 
1719
      }
 
1720
    }
 
1721
  }
 
1722
  return 0;
 
1723
}
 
1724
 
 
1725
NLM_EXTERN int LIBCALLBACK SortVnpByStringCILCFirst (VoidPtr ptr1, VoidPtr ptr2)
 
1726
 
 
1727
{
 
1728
  int         comp;
 
1729
  CharPtr     str1;
 
1730
  CharPtr     str2;
 
1731
  ValNodePtr  vnp1;
 
1732
  ValNodePtr  vnp2;
 
1733
 
 
1734
  if (ptr1 != NULL && ptr2 != NULL) {
 
1735
    vnp1 = *((ValNodePtr PNTR) ptr1);
 
1736
    vnp2 = *((ValNodePtr PNTR) ptr2);
 
1737
    if (vnp1 != NULL && vnp2 != NULL) {
 
1738
      str1 = (CharPtr) vnp1->data.ptrvalue;
 
1739
      str2 = (CharPtr) vnp2->data.ptrvalue;
 
1740
      if (str1 != NULL && str2 != NULL) {
 
1741
        comp = StringICmp (str1, str2);
 
1742
        if (comp != 0) return comp;
 
1743
        return StringCmp (str2, str1);
 
1744
      }
 
1745
    }
 
1746
  }
 
1747
  return 0;
 
1748
}
 
1749
 
 
1750
NLM_EXTERN ValNodePtr UniqueValNode (ValNodePtr list)
 
1751
 
 
1752
{
 
1753
  CharPtr       last;
 
1754
  ValNodePtr    next;
 
1755
  Pointer PNTR  prev;
 
1756
  CharPtr       str;
 
1757
  ValNodePtr    vnp;
 
1758
 
 
1759
  if (list == NULL) return NULL;
 
1760
  last = (CharPtr) list->data.ptrvalue;
 
1761
  vnp = list->next;
 
1762
  prev = (Pointer PNTR) &(list->next);
 
1763
  while (vnp != NULL) {
 
1764
    next = vnp->next;
 
1765
    str = (CharPtr) vnp->data.ptrvalue;
 
1766
    if (StringICmp (last, str) == 0) {
 
1767
      vnp->next = NULL;
 
1768
      *prev = next;
 
1769
      ValNodeFreeData (vnp);
 
1770
    } else {
 
1771
      last = (CharPtr) vnp->data.ptrvalue;
 
1772
      prev = (Pointer PNTR) &(vnp->next);
 
1773
    }
 
1774
    vnp = next;
 
1775
  }
 
1776
 
 
1777
  return list;
 
1778
}
 
1779
 
 
1780
NLM_EXTERN ValNodePtr UniqueStringValNodeCS (ValNodePtr list)
 
1781
 
 
1782
{
 
1783
  CharPtr       last;
 
1784
  ValNodePtr    next;
 
1785
  Pointer PNTR  prev;
 
1786
  CharPtr       str;
 
1787
  ValNodePtr    vnp;
 
1788
 
 
1789
  if (list == NULL) return NULL;
 
1790
  last = (CharPtr) list->data.ptrvalue;
 
1791
  vnp = list->next;
 
1792
  prev = (Pointer PNTR) &(list->next);
 
1793
  while (vnp != NULL) {
 
1794
    next = vnp->next;
 
1795
    str = (CharPtr) vnp->data.ptrvalue;
 
1796
    if (StringCmp (last, str) == 0) {
 
1797
      vnp->next = NULL;
 
1798
      *prev = next;
 
1799
      ValNodeFreeData (vnp);
 
1800
    } else {
 
1801
      last = (CharPtr) vnp->data.ptrvalue;
 
1802
      prev = (Pointer PNTR) &(vnp->next);
 
1803
    }
 
1804
    vnp = next;
 
1805
  }
 
1806
 
 
1807
  return list;
 
1808
}
 
1809
 
 
1810
NLM_EXTERN ValNodePtr UniqueStringValNodeCI (ValNodePtr list)
 
1811
 
 
1812
{
 
1813
  CharPtr       last;
 
1814
  ValNodePtr    next;
 
1815
  Pointer PNTR  prev;
 
1816
  CharPtr       str;
 
1817
  ValNodePtr    vnp;
 
1818
 
 
1819
  if (list == NULL) return NULL;
 
1820
  last = (CharPtr) list->data.ptrvalue;
 
1821
  vnp = list->next;
 
1822
  prev = (Pointer PNTR) &(list->next);
 
1823
  while (vnp != NULL) {
 
1824
    next = vnp->next;
 
1825
    str = (CharPtr) vnp->data.ptrvalue;
 
1826
    if (StringICmp (last, str) == 0) {
 
1827
      vnp->next = NULL;
 
1828
      *prev = next;
 
1829
      ValNodeFreeData (vnp);
 
1830
    } else {
 
1831
      last = (CharPtr) vnp->data.ptrvalue;
 
1832
      prev = (Pointer PNTR) &(vnp->next);
 
1833
    }
 
1834
    vnp = next;
 
1835
  }
 
1836
 
 
1837
  return list;
 
1838
}
 
1839
 
1656
1840
NLM_EXTERN int LIBCALLBACK SortByIntvalue (VoidPtr ptr1, VoidPtr ptr2)
1657
1841
 
1658
1842
{
1675
1859
  return 0;
1676
1860
}
1677
1861
 
1678
 
NLM_EXTERN ValNodePtr UniqueValNode (ValNodePtr list)
1679
 
 
1680
 
{
1681
 
  CharPtr       last;
1682
 
  ValNodePtr    next;
1683
 
  Pointer PNTR  prev;
1684
 
  CharPtr       str;
1685
 
  ValNodePtr    vnp;
1686
 
 
1687
 
  if (list == NULL) return NULL;
1688
 
  last = (CharPtr) list->data.ptrvalue;
1689
 
  vnp = list->next;
1690
 
  prev = (Pointer PNTR) &(list->next);
1691
 
  while (vnp != NULL) {
1692
 
    next = vnp->next;
1693
 
    str = (CharPtr) vnp->data.ptrvalue;
1694
 
    if (StringICmp (last, str) == 0) {
1695
 
      vnp->next = NULL;
1696
 
      *prev = next;
1697
 
      ValNodeFreeData (vnp);
1698
 
    } else {
1699
 
      last = (CharPtr) vnp->data.ptrvalue;
1700
 
      prev = (Pointer PNTR) &(vnp->next);
1701
 
    }
1702
 
    vnp = next;
1703
 
  }
1704
 
 
1705
 
  return list;
1706
 
}
1707
 
 
1708
1862
NLM_EXTERN ValNodePtr UniqueIntValNode (ValNodePtr list)
1709
1863
 
1710
1864
{
3877
4031
          return TRUE;
3878
4032
        }
3879
4033
      }
3880
 
      if (rrp->type == 255) {
 
4034
      if (rrp->type == 255 || rrp->type == 8 || rrp->type == 9 || rrp->type == 10) {
3881
4035
        /* new convention follows ASN.1 spec comments, allows new RNA types */
3882
4036
        return FALSE;
3883
4037
      }
3897
4051
      /* return FALSE; */
3898
4052
      return TRUE;
3899
4053
    }
 
4054
    if (rrp->type == 8 || rrp->type == 9 || rrp->type == 10) {
 
4055
      /* new convention follows ASN.1 spec comments, allows new RNA types */
 
4056
      return FALSE;
 
4057
    }
3900
4058
    if (rrp->ext.choice == 1 && rrp->ext.value.ptrvalue != NULL) {
3901
4059
      rrp->ext.value.ptrvalue = MemFree (rrp->ext.value.ptrvalue);
3902
4060
    }
4045
4203
    return FALSE;
4046
4204
  }
4047
4205
 
 
4206
  if (StringICmp (gbq->qual, "UniProtKB_evidence") == 0) {
 
4207
    return FALSE;
 
4208
  }
 
4209
 
4048
4210
  return TRUE; /* all other gbquals not appropriate on protein features */
4049
4211
}
4050
4212
 
4348
4510
  gbq->val = str;
4349
4511
}
4350
4512
 
4351
 
static void ExpandParenGroup (GBQualPtr headgbq)
 
4513
static Boolean ExpandParenGroup (GBQualPtr headgbq)
4352
4514
 
4353
4515
{
 
4516
  Char       ch;
4354
4517
  GBQualPtr  lastgbq;
 
4518
  size_t     len;
 
4519
  Int2       nesting;
4355
4520
  GBQualPtr  newgbq;
4356
4521
  GBQualPtr  nextqual;
4357
4522
  CharPtr    ptr;
4360
4525
 
4361
4526
  nextqual = headgbq->next;
4362
4527
  lastgbq = headgbq;
4363
 
  tmp = StringSave (headgbq->val);
4364
 
  str = tmp + 1;
 
4528
  ptr = headgbq->val;
 
4529
  tmp = StringSave (ptr + 1);
 
4530
  len = StringLen (tmp);
 
4531
  if (len > 0 && tmp [len - 1] == ')') {
 
4532
    tmp [len - 1] = '\0';
 
4533
  }
 
4534
  str = tmp;
 
4535
  nesting = 0;
 
4536
  ptr = str;
 
4537
  ch = *ptr;
 
4538
  while (ch != '\0') {
 
4539
    if (ch == '(') {
 
4540
      nesting++;
 
4541
    } else if (ch == ')') {
 
4542
      nesting--;
 
4543
      if (nesting < 0) {
 
4544
        MemFree (tmp);
 
4545
        return FALSE;
 
4546
      }
 
4547
    } else if (ch == ',') {
 
4548
      if (nesting < 0) {
 
4549
        MemFree (tmp);
 
4550
        return FALSE;
 
4551
      }
 
4552
    }
 
4553
    ptr++;
 
4554
    ch = *ptr;
 
4555
  }
4365
4556
  while (! StringHasNoText (str)) {
4366
4557
    ptr = StringChr (str, ',');
4367
4558
    if (ptr == NULL) {
4368
 
      ptr = StringChr (str, ')');
 
4559
      ptr = StringRChr (str, ')');
4369
4560
    }
4370
4561
    if (ptr != NULL) {
4371
4562
      *ptr = '\0';
4383
4574
    str = ptr;
4384
4575
  }
4385
4576
  MemFree (tmp);
 
4577
  return TRUE;
4386
4578
}
4387
4579
 
4388
4580
static Boolean IsBaseRange (CharPtr str)
4432
4624
    }
4433
4625
    nextqual = gbq->next;
4434
4626
    unlink = TRUE;
4435
 
    if (StringICmp (gbq->qual, "rpt_type") == 0 ||
 
4627
    if (StringICmp (gbq->qual, "rpt_unit_seq") == 0) {
 
4628
      str = gbq->val;
 
4629
      len = StringLen (str);
 
4630
      if (len > 1 && *str == '{' && str [len - 1] == '}') {
 
4631
        *str = '(';
 
4632
        str [len - 1] = ')';
 
4633
      }
 
4634
      if (len > 1 && *str == '(' && str [len - 1] == ')' /* && StringChr (str + 1, '(') == NULL */) {
 
4635
        if (ExpandParenGroup (gbq)) {
 
4636
          nextqual = gbq->next;
 
4637
          /* individual parsed out (xxx,xxx) qualifiers will be processed next, now get rid of original */
 
4638
          unlink = TRUE;
 
4639
        } else {
 
4640
          unlink = FALSE;
 
4641
        }
 
4642
      } else {
 
4643
        unlink = FALSE;
 
4644
      }
 
4645
    } else if (StringICmp (gbq->qual, "rpt_type") == 0 ||
4436
4646
        StringICmp (gbq->qual, "rpt_unit") == 0 ||
4437
4647
        StringICmp (gbq->qual, "rpt_unit_range") == 0 ||
4438
4648
        StringICmp (gbq->qual, "rpt_unit_seq") == 0 ||
4442
4652
        StringICmp (gbq->qual, "usedin") == 0) {
4443
4653
      str = gbq->val;
4444
4654
      len = StringLen (str);
 
4655
      if (len > 1 && *str == '{' && str [len - 1] == '}') {
 
4656
        *str = '(';
 
4657
        str [len - 1] = ')';
 
4658
      }
4445
4659
      if (len > 1 && *str == '(' && str [len - 1] == ')' && StringChr (str + 1, '(') == NULL) {
4446
 
        ExpandParenGroup (gbq);
4447
 
        nextqual = gbq->next;
4448
 
        /* individual parsed out (xxx,xxx) qualifiers will be processed next, now get rid of original */
4449
 
        unlink = TRUE;
 
4660
        if (ExpandParenGroup (gbq)) {
 
4661
          nextqual = gbq->next;
 
4662
          /* individual parsed out (xxx,xxx) qualifiers will be processed next, now get rid of original */
 
4663
          unlink = TRUE;
 
4664
        } else {
 
4665
          unlink = FALSE;
 
4666
        }
4450
4667
      } else {
4451
4668
        unlink = FALSE;
4452
4669
      }
5437
5654
{
5438
5655
  Char               ch;
5439
5656
  CharPtr            dst;
 
5657
  Int2               i;
 
5658
  Boolean            in_brackets = FALSE;
5440
5659
  SubSourcePtr       last = NULL;
5441
5660
  SubSourcePtr       next;
5442
5661
  SubSourcePtr PNTR  prev;
5444
5663
  CharPtr            src;
5445
5664
  SubSourcePtr       ssp;
5446
5665
  CharPtr            str;
 
5666
  CharPtr            tmp;
5447
5667
  Boolean            unlink;
5448
5668
  /*
5449
5669
  SubSourcePtr       fwd_seq = NULL, rev_seq = NULL, fwd_name = NULL, rev_name = NULL;
5504
5724
          ptr++;
5505
5725
          ch = *ptr;
5506
5726
        }
5507
 
        /* remove any spaces in sequence */
 
5727
        /* remove any spaces in sequence outisde of <modified base> */
5508
5728
        src = ssp->name;
5509
5729
        dst = ssp->name;
5510
5730
        ch = *src;
5511
5731
        while (ch != '\0') {
5512
 
          if (ch != ' ') {
 
5732
          if (ch == '<') {
 
5733
            in_brackets = TRUE;
 
5734
            *dst = ch;
 
5735
            dst++;
 
5736
          } else if (ch == '>') {
 
5737
            in_brackets = FALSE;
 
5738
            *dst = ch;
 
5739
            dst++;
 
5740
          } else if (ch != ' ') {
 
5741
            *dst = ch;
 
5742
            dst++;
 
5743
          } else if (in_brackets) {
5513
5744
            *dst = ch;
5514
5745
            dst++;
5515
5746
          }
5517
5748
          ch = *src;
5518
5749
        }
5519
5750
        *dst = '\0';
 
5751
        /* upper case modified base <OTHER> */
 
5752
        ptr = ssp->name;
 
5753
        tmp = StringStr (ptr, "<other>");
 
5754
        while (tmp != NULL) {
 
5755
          ptr = tmp + 7;
 
5756
          for (i = 1; i < 6; i++) {
 
5757
            ch = tmp [i];
 
5758
            tmp [i] = TO_UPPER (ch);
 
5759
          }
 
5760
          tmp = StringStr (ptr, "<other>");
 
5761
        }
5520
5762
      }
5521
5763
    }
5522
5764
    /*
7276
7518
              TrimSpacesAroundString (str);
7277
7519
            }
7278
7520
          }
 
7521
          str = nsp->names [4];
 
7522
          len = StringLen (str);
 
7523
          if (len > 4 && StringHasNoText (nsp->names [5])) {
 
7524
            if (StringCmp (str + len - 4, ".Jr.") == 0 ||
 
7525
                StringCmp (str + len - 4, ".Sr.") == 0) {
 
7526
              nsp->names [5] = StringSave (str + len - 3);
 
7527
              str [len - 3] = '\0';
 
7528
              TrimSpacesAroundString (str);
 
7529
            }
 
7530
          }
7279
7531
          if (StringHasNoText (nsp->names [0]) &&
7280
7532
              StringHasNoText (nsp->names [1]) &&
7281
7533
              StringHasNoText (nsp->names [2]) &&
8446
8698
  CharPtr  ptr;
8447
8699
 
8448
8700
  if (StringHasNoText (str)) return NULL;
8449
 
  if (StringChr (str, '&') == NULL) return FALSE;
 
8701
  if (StringChr (str, '&') == NULL) return NULL;
8450
8702
 
8451
8703
  ascii_len = Sgml2AsciiLen (str);
8452
 
  if (ascii_len + 2 >= sizeof (buf)) return FALSE;
 
8704
  if (ascii_len + 2 >= sizeof (buf)) return NULL;
8453
8705
 
8454
8706
  buf [0] = '\0';
8455
8707
  Sgml2Ascii (str, buf, ascii_len + 1);
8470
8722
  return StringSave (buf);
8471
8723
}
8472
8724
 
 
8725
/* special exception for genome pipeline rRNA names */
 
8726
 
 
8727
static Boolean NotExceptedRibosomalName (
 
8728
  CharPtr name
 
8729
)
 
8730
 
 
8731
{
 
8732
  Char     ch;
 
8733
  CharPtr  str;
 
8734
 
 
8735
  str = StringStr (name, " ribosomal");
 
8736
  if (str == NULL) return FALSE;
 
8737
 
 
8738
  str += 10;
 
8739
  ch = *str;
 
8740
  while (ch != '\0') {
 
8741
    if (ch == ' ' || IS_DIGIT (ch)) {
 
8742
      /* okay */
 
8743
    } else {
 
8744
      return TRUE;
 
8745
    }
 
8746
    str++;
 
8747
    ch = *str;
 
8748
  }
 
8749
 
 
8750
  return FALSE;
 
8751
}
 
8752
 
8473
8753
static void CleanupFeatureStrings (
8474
8754
  SeqFeatPtr sfp,
8475
8755
  Boolean isJscan,
8592
8872
        HandleXrefOnGene (sfp);
8593
8873
      }
8594
8874
      CleanVisString (&(grp->locus));
 
8875
      /*
8595
8876
      if (isJscan && StringDoesHaveText (grp->locus)) {
8596
8877
        ptr = CleanUpSgml (grp->locus);
8597
8878
        if (ptr != NULL) {
8599
8880
          grp->locus = StringSave (ptr);
8600
8881
        }
8601
8882
      }
 
8883
      */
8602
8884
      CleanVisString (&(grp->allele));
8603
8885
      CleanVisString (&(grp->desc));
8604
8886
      CleanVisString (&(grp->maploc));
8605
8887
      CleanVisString (&(grp->locus_tag));
8606
8888
      ExpandGeneSynList (grp);
 
8889
      /*
8607
8890
      if (isJscan && grp->syn != NULL) {
8608
8891
        for (vnp = grp->syn; vnp != NULL; vnp = vnp->next) {
8609
8892
          str = (CharPtr) vnp->data.ptrvalue;
8615
8898
          }
8616
8899
        }
8617
8900
      }
8618
 
      CleanVisStringList (&(grp->syn));
8619
 
      grp->syn = ValNodeSort (grp->syn, SortVnpByString);
8620
 
      grp->syn = UniqueValNode (grp->syn);
 
8901
      */
 
8902
      CleanVisStringListCaseSensitive (&(grp->syn));
 
8903
      grp->syn = ValNodeSort (grp->syn, SortVnpByStringCS);
 
8904
      grp->syn = UniqueStringValNodeCS (grp->syn);
 
8905
      grp->syn = ValNodeSort (grp->syn, SortVnpByStringCILCFirst);
8621
8906
      CleanDoubleQuote (grp->locus);
8622
8907
      CleanDoubleQuote (grp->allele);
8623
8908
      CleanDoubleQuote (grp->desc);
 
8909
      /*
8624
8910
      if (isJscan && StringDoesHaveText (grp->desc)) {
8625
8911
        ptr = CleanUpSgml (grp->desc);
8626
8912
        if (ptr != NULL) {
8628
8914
          grp->desc = StringSave (ptr);
8629
8915
        }
8630
8916
      }
 
8917
      */
8631
8918
      CleanDoubleQuote (grp->maploc);
8632
8919
      CleanDoubleQuote (grp->locus_tag);
8633
8920
      CleanDoubleQuoteList (grp->syn);
8848
9135
      if (rrp->type == 4) {
8849
9136
        name = (CharPtr) rrp->ext.value.ptrvalue;
8850
9137
        len = StringLen (name);
8851
 
        if (len > 5) {
 
9138
        if (len > 5 && NotExceptedRibosomalName (name)) {
8852
9139
          suff = NULL;
8853
9140
          str = StringStr (name, " ribosomal");
8854
9141
          if (str != NULL) {
10161
10448
            if (StringCmp (gbq->qual, "product") != 0) continue;
10162
10449
            name = gbq->val;
10163
10450
            if (StringHasNoText (name)) continue;
 
10451
            /*
10164
10452
            if (StringICmp (name, "internal transcribed spacer 1") == 0) {
10165
10453
              if (StringICmp (comment, "its1") == 0 || StringICmp (comment, "its 1") == 0) return TRUE;
10166
10454
            } else if (StringICmp (name, "internal transcribed spacer 2") == 0) {
10168
10456
            } else if (StringICmp (name, "internal transcribed spacer 3") == 0) {
10169
10457
              if (StringICmp (comment, "its3") == 0 || StringICmp (comment, "its 3") == 0) return TRUE;
10170
10458
            }
 
10459
            */
10171
10460
          }
10172
10461
        }
10173
10462
      } else if (rrp->type == 3 && rrp->ext.choice == 2) {
10343
10632
        ifp->key = MemFree (ifp->key);
10344
10633
        ifp->key = StringSave ("repeat_region");
10345
10634
        sfp->idx.subtype = FEATDEF_repeat_region;
 
10635
      } else if (StringCmp (ifp->key, "misc_bind") == 0) {
 
10636
        ifp->key = MemFree (ifp->key);
 
10637
        ifp->key = StringSave ("misc_binding");
 
10638
        sfp->idx.subtype = FEATDEF_misc_binding;
10346
10639
      } else if (StringCmp (ifp->key, "satellite") == 0 ) {
10347
10640
        ifp->key = MemFree (ifp->key);
10348
10641
        ifp->key = StringSave ("repeat_region");
10528
10821
    sfp->comment = MemFree (sfp->comment);
10529
10822
  }
10530
10823
 
 
10824
  /* sort and unique gbquals again after recent processing */
 
10825
  sfp->qual = SortFeatureGBQuals (sfp->qual);
 
10826
  CleanupDuplicateGBQuals (&(sfp->qual));
 
10827
  sfp->qual = SortIllegalGBQuals (sfp->qual);
 
10828
 
10531
10829
  CheckSeqLocForPartial (sfp->location, &partial5, &partial3);
10532
10830
  hasNulls = LocationHasNullsBetween (sfp->location);
10533
10831
  sfp->partial = (sfp->partial || partial5 || partial3 || hasNulls);
10549
10847
  }
10550
10848
}
10551
10849
 
 
10850
static void CleanUpSeqGraph (SeqGraphPtr sgp)
 
10851
 
 
10852
{
 
10853
  if (sgp == NULL) return;
 
10854
  if (sgp->loc != NULL) {
 
10855
    CleanupSeqLoc (sgp->loc);
 
10856
  }
 
10857
}
10552
10858
 
10553
10859
static void RemoveZeroLengthSeqLits (BioseqPtr bsp)
10554
10860
{
10649
10955
}
10650
10956
 
10651
10957
 
 
10958
static void RemoveDuplicateSeqIds (BioseqPtr bsp)
 
10959
{
 
10960
  SeqIdPtr sip, sip_cmp, sip_prev, sip_next;
 
10961
 
 
10962
  if (bsp == NULL) {
 
10963
    return;
 
10964
  }
 
10965
 
 
10966
  for (sip = bsp->id; sip != NULL; sip = sip->next) {
 
10967
    sip_prev = sip;
 
10968
    for (sip_cmp = sip->next; sip_cmp != NULL; sip_cmp = sip_next) {
 
10969
      sip_next = sip_cmp->next;
 
10970
      if (SeqIdComp (sip, sip_cmp) == SIC_YES) {
 
10971
        sip_prev->next = sip_cmp->next;
 
10972
        sip_cmp->next = NULL;
 
10973
        sip_cmp = SeqIdFree (sip_cmp);
 
10974
      } else {
 
10975
        sip_prev = sip_cmp;
 
10976
      }
 
10977
    }
 
10978
  }
 
10979
}
 
10980
 
10652
10981
 
10653
10982
static void BasicSeqEntryCleanupInternal (
10654
10983
  SeqEntryPtr sep,
10671
11000
  SeqAnnotPtr   sap = NULL;
10672
11001
  ValNodePtr    sdp = NULL;
10673
11002
  SeqFeatPtr    sfp;
 
11003
  SeqGraphPtr   sgp;
10674
11004
  SeqEntryPtr   tmp;
10675
11005
 
10676
11006
  if (sep == NULL) return;
10677
11007
  if (IS_Bioseq (sep)) {
10678
11008
    bsp = (BioseqPtr) sep->data.ptrvalue;
10679
11009
    if (bsp == NULL) return;
 
11010
    /* remove duplicate SeqIds on the same Bioseq */
 
11011
    RemoveDuplicateSeqIds (bsp);
 
11012
 
10680
11013
    /* repair damaged delta sequences */
10681
11014
    RemoveZeroLengthSeqLits (bsp);
10682
11015
 
10683
11016
    sap = bsp->annot;
10684
11017
    sdp = bsp->descr;
10685
 
    /* repair if bsp.mol is not-set */
10686
 
    if (bsp->mol == 0) {
10687
 
      desc = GetNextDescriptorUnindexed (bsp, Seq_descr_molinfo, NULL);
10688
 
      if (desc != NULL && desc->choice == Seq_descr_molinfo) {
10689
 
        mip = (MolInfoPtr) desc->data.ptrvalue;
10690
 
        if (mip != NULL) {
 
11018
    desc = GetNextDescriptorUnindexed (bsp, Seq_descr_molinfo, NULL);
 
11019
    if (desc != NULL && desc->choice == Seq_descr_molinfo) {
 
11020
      mip = (MolInfoPtr) desc->data.ptrvalue;
 
11021
      if (mip != NULL) {
 
11022
        /* repair if bsp.mol is not-set */
 
11023
        if (bsp->mol == 0) {
10691
11024
          switch (mip->biomol) {
10692
11025
            case MOLECULE_TYPE_GENOMIC :
10693
11026
              bsp->mol = Seq_mol_na;
10717
11050
            default :
10718
11051
              break;
10719
11052
          }
 
11053
        } else if (bsp->mol != Seq_mol_rna 
 
11054
                   && (mip->biomol == MOLECULE_TYPE_CRNA || mip->biomol == MOLECULE_TYPE_MRNA)) {
 
11055
          bsp->mol = Seq_mol_rna;
10720
11056
        }
10721
11057
      }
10722
11058
    }
10740
11076
        CleanUpSeqFeat (sfp, isEmblOrDdbj, isJscan, stripSerial, publist);
10741
11077
        sfp = sfp->next;
10742
11078
      }
 
11079
    } else if (sap->type == 3) {
 
11080
      sgp = (SeqGraphPtr) sap->data;
 
11081
      while (sgp != NULL) {
 
11082
        CleanUpSeqGraph (sgp);
 
11083
        sgp = sgp->next;
 
11084
      }
10743
11085
    }
10744
11086
    sap = sap->next;
10745
11087
  }
12095
12437
NLM_EXTERN SeqIdPtr MakeSeqID (CharPtr str)
12096
12438
 
12097
12439
{
12098
 
  Char      buf [64];
 
12440
  CharPtr   buf;
 
12441
  Int4      len;
12099
12442
  SeqIdPtr  sip;
12100
12443
 
12101
12444
  sip = NULL;
12103
12446
    if (StringChr (str, '|') != NULL) {
12104
12447
      sip = SeqIdParse (str);
12105
12448
    } else {
12106
 
      if (StringLen (str) < 60) {
12107
 
        StringCpy (buf, "lcl|");
12108
 
        StringCat (buf, str);
12109
 
        sip = SeqIdParse (buf);
12110
 
      }
 
12449
      len = StringLen (str) + 5;
 
12450
      buf = (CharPtr) MemNew (sizeof (Char) * len);
 
12451
      sprintf (buf, "lcl|%s", str);
 
12452
      sip = SeqIdParse (buf);
 
12453
      buf = MemFree (buf);
12111
12454
    }
12112
12455
  }
12113
12456
  return sip;
13756
14099
}
13757
14100
 
13758
14101
 
13759
 
NLM_EXTERN Int4 ScanBioseqSetRelease (CharPtr inputFile, Boolean binary, Boolean compressed, Pointer userdata, ScanBioseqSetFunc callback)
 
14102
static Int4 ScanBioseqSetReleaseInt (
 
14103
  CharPtr inputFile,
 
14104
  Boolean binary,
 
14105
  Boolean compressed,
 
14106
  Pointer userdata,
 
14107
  ScanBioseqSetFunc callback,
 
14108
  Boolean freesep,
 
14109
  TNlmMutexPtr mutex
 
14110
)
13760
14111
 
13761
14112
{
13762
14113
  AsnIoPtr      aip;
13846
14197
 
13847
14198
  while ((atp = AsnReadId (aip, amp, atp)) != NULL) {
13848
14199
    if (atp == atp_se) {
 
14200
      if (mutex != NULL) {
 
14201
        NlmMutexLockEx (mutex);
 
14202
      }
 
14203
      SeqMgrHoldIndexing (TRUE);
13849
14204
      sep = SeqEntryAsnRead (aip, atp);
 
14205
      SeqMgrHoldIndexing (FALSE);
 
14206
      if (mutex != NULL) {
 
14207
        NlmMutexUnlock (*mutex);
 
14208
      }
13850
14209
      callback (sep, userdata);
13851
 
      SeqEntryFree (sep);
 
14210
      if (freesep) {
 
14211
        SeqEntryFree (sep);
 
14212
      }
13852
14213
      index++;
13853
14214
    } else {
13854
14215
      AsnReadVal (aip, atp, NULL);
13869
14230
  return index;
13870
14231
}
13871
14232
 
13872
 
 
13873
 
NLM_EXTERN Int4 ScanEntrezgeneSetRelease (CharPtr inputFile, Boolean binary, Boolean compressed, Pointer userdata, ScanEntrezgeneSetFunc callback)
 
14233
NLM_EXTERN Int4 ScanBioseqSetRelease (
 
14234
  CharPtr inputFile,
 
14235
  Boolean binary,
 
14236
  Boolean compressed,
 
14237
  Pointer userdata,
 
14238
  ScanBioseqSetFunc callback
 
14239
)
 
14240
 
 
14241
{
 
14242
  return ScanBioseqSetReleaseInt (inputFile, binary, compressed, userdata, callback, TRUE, NULL);
 
14243
}
 
14244
 
 
14245
static TNlmMutex  scan_bioseq_set_release_mutex = NULL;
 
14246
 
 
14247
NLM_EXTERN Int4 ScanBioseqSetReleaseMT (
 
14248
  CharPtr inputFile,
 
14249
  Boolean binary,
 
14250
  Boolean compressed,
 
14251
  Pointer userdata,
 
14252
  ScanBioseqSetFunc callback
 
14253
)
 
14254
 
 
14255
{
 
14256
  return ScanBioseqSetReleaseInt (inputFile, binary, compressed, userdata, callback, FALSE, &scan_bioseq_set_release_mutex);
 
14257
}
 
14258
 
 
14259
NLM_EXTERN SeqEntryPtr LIBCALL FreeScanSeqEntryMT (
 
14260
  SeqEntryPtr sep
 
14261
)
 
14262
 
 
14263
{
 
14264
  if (sep == NULL) return NULL;
 
14265
 
 
14266
  NlmMutexLockEx (&scan_bioseq_set_release_mutex);
 
14267
 
 
14268
  SeqMgrHoldIndexing (TRUE);
 
14269
  SeqEntryFree (sep);
 
14270
  SeqMgrHoldIndexing (FALSE);
 
14271
 
 
14272
  NlmMutexUnlock (scan_bioseq_set_release_mutex);
 
14273
 
 
14274
  return NULL;
 
14275
}
 
14276
 
 
14277
NLM_EXTERN Int4 ScanEntrezgeneSetRelease (
 
14278
  CharPtr inputFile,
 
14279
  Boolean binary,
 
14280
  Boolean compressed,
 
14281
  Pointer userdata,
 
14282
  ScanEntrezgeneSetFunc callback
 
14283
)
13874
14284
 
13875
14285
{
13876
14286
  AsnIoPtr       aip;