开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数值算法/人工智能 > 生物技术 > 查看源码
ncbistr.cpp
资源名称：ncbi_cxx_win--Jul_08_2004.zip　[点击查看]
上传用户：yhdzpy8989
上传日期：2007-06-13
资源大小：13604k
文件大小：54k
源码类别：

生物技术

开发平台：

C/C++

ncbistr.cpp：源码内容
  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: ncbistr.cpp,v $
  4.  * PRODUCTION Revision 1000.6  2004/06/01 19:09:21  gouriano
  5.  * PRODUCTION PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.109
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  10. /*  $Id: ncbistr.cpp,v 1000.6 2004/06/01 19:09:21 gouriano Exp $
  11.  * ===========================================================================
  12.  *
  13.  *                            PUBLIC DOMAIN NOTICE
  14.  *               National Center for Biotechnology Information
  15.  *
  16.  *  This software/database is a "United States Government Work" under the
  17.  *  terms of the United States Copyright Act.  It was written as part of
  18.  *  the author's official duties as a United States Government employee and
  19.  *  thus cannot be copyrighted.  This software/database is freely available
  20.  *  to the public for use. The National Library of Medicine and the U.S.
  21.  *   Government have not placed any restriction on its use or reproduction.
  22.  *
  23.  *  Although all reasonable efforts have been taken to ensure the accuracy
  24.  *  and reliability of the software and data, the NLM and the U.S.
  25.  *  Government do not and cannot warrant the performance or results that
  26.  *  may be obtained by using this software or data. The NLM and the U.S.
  27.  *  Government disclaim all warranties, express or implied, including
  28.  *  warranties of performance, merchantability or fitness for any particular
  29.  *  purpose.
  30.  *
  31.  *  Please cite the author in any work or product based on this material.
  32.  *
  33.  * ===========================================================================
  34.  *
  35.  * Authors:  Eugene Vasilchenko, Denis Vakatov
  36.  *
  37.  * File Description:
  38.  *   Some helper functions
  39.  *
  40.  */
  42. #include <ncbi_pch.hpp>
  43. #include <corelib/ncbistd.hpp>
  44. #include <corelib/ncbi_limits.h>
  45. #include <memory>
  46. #include <algorithm>
  47. #include <ctype.h>
  48. #include <errno.h>
  49. #include <stdio.h>
  52. BEGIN_NCBI_SCOPE
  55. inline
  56. std::string::size_type s_DiffPtr(const char* end, const char* start)
  57. {
  58.     if (end) {
  59.         return end - start;
  60.     }
  61.     return 0;
  62. }
  64. const char *const kEmptyCStr = "";
  66. #ifndef NCBI_OS_MSWIN
  67. const string* CNcbiEmptyString::m_Str = 0;
  68. const string& CNcbiEmptyString::FirstGet(void) {
  69.     static const string s_Str = "";
  70.     m_Str = &s_Str;
  71.     return s_Str;
  72. }
  73. #endif // NCBI_OS_MSWIN
  76. int NStr::CompareCase(const string& str, SIZE_TYPE pos, SIZE_TYPE n,
  77.                       const char* pattern)
  78. {
  79.     if (pos == NPOS  ||  !n  ||  str.length() <= pos) {
  80.         return *pattern ? -1 : 0;
  81.     }
  82.     if ( !*pattern ) {
  83.         return 1;
  84.     }
  86.     if (n == NPOS  ||  n > str.length() - pos) {
  87.         n = str.length() - pos;
  88.     }
  90.     const char* s = str.data() + pos;
  91.     while (n  &&  *pattern  &&  *s == *pattern) {
  92.         s++;  pattern++;  n--;
  93.     }
  95.     if (n == 0) {
  96.         return *pattern ? -1 : 0;
  97.     }
  99.     return *s - *pattern;
  100. }
  103. int NStr::CompareNocase(const string& str, SIZE_TYPE pos, SIZE_TYPE n,
  104.                         const char* pattern)
  105. {
  106.     if (pos == NPOS  ||  !n  ||  str.length() <= pos) {
  107.         return *pattern ? -1 : 0;
  108.     }
  109.     if ( !*pattern ) {
  110.         return 1;
  111.     }
  113.     if (n == NPOS  ||  n > str.length() - pos) {
  114.         n = str.length() - pos;
  115.     }
  117.     const char* s = str.data() + pos;
  118.     while (n  &&  *pattern  &&  toupper(*s) == toupper(*pattern)) {
  119.         s++;  pattern++;  n--;
  120.     }
  122.     if (n == 0) {
  123.         return *pattern ? -1 : 0;
  124.     }
  126.     return toupper(*s) - toupper(*pattern);
  127. }
  130. int NStr::CompareCase(const string& str, SIZE_TYPE pos, SIZE_TYPE n,
  131.                       const string& pattern)
  132. {
  133.     if (pos == NPOS  ||  !n  ||  str.length() <= pos) {
  134.         return pattern.empty() ? 0 : -1;
  135.     }
  136.     if ( pattern.empty() ) {
  137.         return 1;
  138.     }
  140.     if (n == NPOS  ||  n > str.length() - pos) {
  141.         n = str.length() - pos;
  142.     }
  144.     SIZE_TYPE n_cmp = n;
  145.     if (n_cmp > pattern.length()) {
  146.         n_cmp = pattern.length();
  147.     }
  148.     const char* s = str.data() + pos;
  149.     const char* p = pattern.data();
  150.     while (n_cmp  &&  *s == *p) {
  151.         s++;  p++;  n_cmp--;
  152.     }
  154.     if (n_cmp == 0) {
  155.         if (n == pattern.length())
  156.             return 0;
  157.         return n > pattern.length() ? 1 : -1;
  158.     }
  160.     return *s - *p;
  161. }
  164. int NStr::CompareNocase(const string& str, SIZE_TYPE pos, SIZE_TYPE n,
  165.                         const string& pattern)
  166. {
  167.     if (pos == NPOS  ||  !n  ||  str.length() <= pos) {
  168.         return pattern.empty() ? 0 : -1;
  169.     }
  170.     if ( pattern.empty() ) {
  171.         return 1;
  172.     }
  174.     if (n == NPOS  ||  n > str.length() - pos) {
  175.         n = str.length() - pos;
  176.     }
  178.     SIZE_TYPE n_cmp = n;
  179.     if (n_cmp > pattern.length()) {
  180.         n_cmp = pattern.length();
  181.     }
  182.     const char* s = str.data() + pos;
  183.     const char* p = pattern.data();
  184.     while (n_cmp  &&  toupper(*s) == toupper(*p)) {
  185.         s++;  p++;  n_cmp--;
  186.     }
  188.     if (n_cmp == 0) {
  189.         if (n == pattern.length())
  190.             return 0;
  191.         return n > pattern.length() ? 1 : -1;
  192.     }
  194.     return toupper(*s) - toupper(*p);
  195. }
  198. // NOTE: This code is used also in the CDirEntry::MatchesMask.
  200. bool NStr::MatchesMask(const char* str, const char* mask) 
  201. {
  202.     char c;
  203.     bool infinite = true;
  205.     while (infinite) {
  206.         // Analyze symbol in mask
  207.         switch ( c = *mask++ ) {
  208.         
  209.         case '':
  210.             return *str == '';
  212.         case '?':
  213.             if ( *str == '' ) {
  214.                 return false;
  215.             }
  216.             ++str;
  217.             break;
  219.         case '*':
  220.             c = *mask;
  221.             // Collapse multiple stars
  222.             while ( c == '*' ) {
  223.                 c = *++mask;
  224.             }
  225.             if (c == '') {
  226.                 return true;
  227.             }
  228.             // General case, use recursion
  229.             while ( *str ) {
  230.                 if ( MatchesMask(str, mask) ) {
  231.                     return true;
  232.                 }
  233.                 ++str;
  234.             }
  235.             return false;
  237.         default:
  238.             // Compare nonpattern character in mask and name
  239.             if ( c != *str++ ) {
  240.                 return false;
  241.             }
  242.             break;
  243.         }
  244.     }
  245.     return false;
  246. }
  249. char* NStr::ToLower(char* str)
  250. {
  251.     char* s;
  252.     for (s = str;  *str;  str++) {
  253.         *str = tolower(*str);
  254.     }
  255.     return s;
  256. }
  259. string& NStr::ToLower(string& str)
  260. {
  261.     NON_CONST_ITERATE (string, it, str) {
  262.         *it = tolower(*it);
  263.     }
  264.     return str;
  265. }
  268. char* NStr::ToUpper(char* str)
  269. {
  270.     char* s;
  271.     for (s = str;  *str;  str++) {
  272.         *str = toupper(*str);
  273.     }
  274.     return s;
  275. }
  278. string& NStr::ToUpper(string& str)
  279. {
  280.     NON_CONST_ITERATE (string, it, str) {
  281.         *it = toupper(*it);
  282.     }
  283.     return str;
  284. }
  287. int NStr::StringToNumeric(const string& str)
  288. {
  289.     if (str.empty()  ||  !isdigit(*str.begin())) {
  290.         return -1;
  291.     }
  292.     errno = 0;
  293.     char* endptr = 0;
  294.     unsigned long value = strtoul(str.c_str(), &endptr, 10);
  295.     if (errno  ||  !endptr  ||  value > (unsigned long) kMax_Int  ||
  296.         *endptr != ''  ||  endptr == str.c_str()) {
  297.         return -1;
  298.     }
  299.     return (int) value;
  300. }
  302. # define CHECK_ENDPTR(conv)                                           
  303.     if (check_endptr == eCheck_Need  &&  *endptr != '') {           
  304.         NCBI_THROW2(CStringException, eBadArgs,                       
  305.             "String cannot be converted to " conv " - trailing junk", 
  306.             s_DiffPtr(endptr, str.c_str()));                          
  307.     }
  309. int NStr::StringToInt(const string& str, int base /* = 10 */,
  310.                       ECheckEndPtr check_endptr   /* = eCheck_Need */ )
  311. {
  312.     errno = 0;
  313.     char* endptr = 0;
  314.     long value = strtol(str.c_str(), &endptr, base);
  315.     if (errno  ||  !endptr  ||  endptr == str.c_str()  ||
  316.         value < kMin_Int || value > kMax_Int) {
  317.         NCBI_THROW2(CStringException, eConvert,
  318.                     "String cannot be converted to int",
  319.                     s_DiffPtr(endptr, str.c_str()));
  320.     }
  321.     CHECK_ENDPTR("int");
  322.     return (int) value;
  323. }
  326. unsigned int NStr::StringToUInt(const string& str, int base /* =10 */,
  327.                                 ECheckEndPtr check_endptr   /* =eCheck_Need */)
  328. {
  329.     errno = 0;
  330.     char* endptr = 0;
  331.     unsigned long value = strtoul(str.c_str(), &endptr, base);
  332.     if (errno  ||  !endptr  ||  endptr == str.c_str()  ||  value > kMax_UInt) {
  333.         NCBI_THROW2(CStringException, eConvert,
  334.                     "String cannot be converted unsigned int",
  335.                     s_DiffPtr(endptr, str.c_str()));
  336.     }
  337.     CHECK_ENDPTR("unsigned int");
  338.     return (unsigned int) value;
  339. }
  342. long NStr::StringToLong(const string& str, int base /* = 10 */,
  343.                         ECheckEndPtr check_endptr   /* = eCheck_Need */ )
  344. {
  345.     errno = 0;
  346.     char* endptr = 0;
  347.     long value = strtol(str.c_str(), &endptr, base);
  348.     if (errno  ||  !endptr  ||  endptr == str.c_str()) {
  349.         NCBI_THROW2(CStringException, eConvert,
  350.                     "String cannot be converted to long",
  351.                     s_DiffPtr(endptr, str.c_str()));
  352.     }
  353.     CHECK_ENDPTR("long");
  354.     return value;
  355. }
  358. unsigned long NStr::StringToULong(const string& str, int base /*=10 */,
  359.                                   ECheckEndPtr check_endptr   /*=eCheck_Need*/)
  360. {
  361.     errno = 0;
  362.     char* endptr = 0;
  363.     unsigned long value = strtoul(str.c_str(), &endptr, base);
  364.     if (errno  ||  !endptr  ||  endptr == str.c_str()) {
  365.         NCBI_THROW2(CStringException, eConvert,
  366.                     "String cannot be converted to unsigned long",
  367.                     s_DiffPtr(endptr, str.c_str()));
  368.     }
  369.     CHECK_ENDPTR("unsigned long");
  370.     return value;
  371. }
  374. double NStr::StringToDouble(const string& str,
  375.                             ECheckEndPtr check_endptr /* = eCheck_Need */ )
  376. {
  377.     errno = 0;
  378.     char* endptr = 0;
  379.     double value = strtod(str.c_str(), &endptr);
  380.     if (errno  ||  !endptr  ||  endptr == str.c_str()) {
  381.         NCBI_THROW2(CStringException, eConvert,
  382.                     "String cannot be converted to double",
  383.                     s_DiffPtr(endptr, str.c_str()));
  384.     }
  385.     if (*(endptr - 1) != '.'  &&  *endptr == '.')
  386.         endptr++;
  387.     CHECK_ENDPTR("double");
  388.     return value;
  389. }
  392. string NStr::IntToString(long value, bool sign /* = false */ )
  393. {
  394.     char buffer[64];
  395.     ::sprintf(buffer, sign ? "%+ld" : "%ld", value);
  396.     return buffer;
  397. }
  399. void NStr::IntToString(string& out_str, long value, bool sign)
  400. {
  401.     char buffer[64];
  402.     ::sprintf(buffer, sign ? "%+ld" : "%ld", value);
  403.     out_str = buffer;
  404. }
  406. string NStr::UIntToString(unsigned long value)
  407. {
  408.     char buffer[64];
  409.     ::sprintf(buffer, "%lu", value);
  410.     return buffer;
  411. }
  413. void NStr::UIntToString(string& out_str, unsigned long value)
  414. {
  415.     char buffer[64];
  416.     ::sprintf(buffer, "%lu", value);
  417.     out_str = buffer;
  418. }
  420. string NStr::Int8ToString(Int8 value, bool sign /* = false */ )
  421. {
  422.     string ret;
  423.     NStr::Int8ToString(ret, value, sign);
  424.     return ret;
  425. }
  427. void NStr::Int8ToString(string& out_str, Int8 value, bool sign)
  428. {
  429.     const size_t kBufSize = (sizeof(value) * CHAR_BIT) / 3 + 2;
  430.     char buffer[kBufSize];
  431.     char* pos = buffer + kBufSize;
  433.     if (value == 0) {
  434.         *--pos = '0';
  435.     }
  436.     else {
  437.         bool is_negative = value < 0;
  438.         if ( is_negative )
  439.             value = -value;
  441.         do {
  442.             *--pos = char('0' + (value % 10));
  443.             value /= 10;
  444.         } while ( value );
  446.         if ( is_negative )
  447.             *--pos = '-';
  448.         else if ( sign )
  449.             *--pos = '+';
  450.     }
  452.     out_str.resize(0);
  453.     out_str.append(pos, buffer + kBufSize - pos);
  454. }
  457. Int8 NStr::StringToInt8(const string& str)
  458. {
  459.     bool sign = false;
  460.     const char* pc = str.c_str();
  462.     switch (*pc) {
  463.     case '-':
  464.         sign = true;
  465.         /*FALLTHRU*/
  466.     case '+':
  467.         ++pc;
  468.         /*FALLTHRU*/
  469.     default:
  470.         break;
  471.     }
  473.     Int8 n = 0;
  474.     Int8 limdiv = kMax_I8 / 10;
  475.     Int8 limoff = kMax_I8 % 10;
  477.     do {
  478.         if (!isdigit(*pc)) {
  479.             NCBI_THROW2(CStringException, eConvert,
  480.                         "String cannot be converted to Int8 - bad digit",
  481.                         s_DiffPtr(pc, str.c_str()));
  482.         }
  483.         int delta = *pc - '0';
  484.         n *= 10;
  486.         // Overflow checking
  487.         if (n > limdiv || (n == limdiv && delta > limoff)) {
  488.             NCBI_THROW2(CStringException, eConvert,
  489.                         "String cannot be converted Int8 - overflow",
  490.                         s_DiffPtr(pc, str.c_str()));
  491.         }
  493.         n += delta;
  494.     } while (*++pc);
  496.     return sign ? -n : n;
  497. }
  500. Uint8 NStr::StringToUInt8(const string& str, int base /* = 10  */)
  501. {
  502.     const char* pc = str.c_str();
  504.     if (*pc == '+')
  505.         ++pc;
  507.  
  508.     Uint8 n = 0;
  509.     Uint8 limdiv = kMax_UI8 / base;
  510.     int   limoff = int(kMax_UI8 % base);
  512.     do {
  513.         // Do a sanity check for common radixes
  514.         int ch = *pc; 
  515.         if (base == 10  &&  !isdigit(ch)              ||
  516.             base == 16  &&  !isxdigit(ch)             ||
  517.             base == 8   &&  (ch < '0'  ||  ch > '7')  ||
  518.             base == 2   &&  (ch < '0'  ||  ch > '1')) {
  520.             NCBI_THROW2(CStringException, eConvert,
  521.                         "String cannot be converted to UInt8 - bad digit",
  522.                         s_DiffPtr(pc, str.c_str()));
  523.         }
  525.         int delta;  // corresponding numeric value of *pc
  526.         if (isdigit(ch)) {
  527.             delta = ch - '0';
  528.         } else {
  529.             ch = tolower(ch);
  530.             // Got to be 'a' to 'f' because of previous sanity checks
  531.             delta = ch - 'a' + 10;
  532.         }
  534.         n *= base;
  536.         // Overflow checking
  537.         if (n > limdiv  ||  (n == limdiv  &&  delta > limoff)) {
  538.             NCBI_THROW2(CStringException, eConvert,
  539.                         "String cannot be converted to UInt8 - overflow",
  540.                         s_DiffPtr(pc, str.c_str()));
  541.         }
  543.         n += delta;
  544.     } while (*++pc);
  546.     return n;
  547. }
  549. void NStr::UInt8ToString(string& out_str, Uint8 value)
  550. {
  551.     const size_t kBufSize = (sizeof(value) * CHAR_BIT) / 3 + 2;
  552.     char buffer[kBufSize];
  553.     char* pos = buffer + kBufSize;
  554.     if ( value == 0 ) {
  555.         *--pos = '0';
  556.     }
  557.     else {
  558.         do {
  559.             *--pos = char('0' + (value % 10));
  560.             value /= 10;
  561.         } while ( value );
  562.     }
  563.     out_str.resize(0);
  564.     out_str.append(pos, buffer + kBufSize - pos);
  565. }
  567. string NStr::UInt8ToString(Uint8 value)
  568. {
  569.     string ret;
  570.     NStr::UInt8ToString(ret, value);
  571.     return ret;
  572. }
  576. // A maximal double precision used in the double to string conversion
  577. #if defined(NCBI_OS_MSWIN)
  578. const unsigned int kMaxDoublePrecision = 200;
  579. #else
  580. const unsigned int kMaxDoublePrecision = 308;
  581. #endif
  582. // A maximal size of a double value in a string form.
  583. // Exponent size + sign + dot + ending '' + max.precision
  584. const unsigned int kMaxDoubleStringSize = 308 + 3 + kMaxDoublePrecision;
  587. string NStr::DoubleToString(double value)
  588. {
  589.     char buffer[kMaxDoubleStringSize];
  590.     ::sprintf(buffer, "%g", value);
  591.     return buffer;
  592. }
  594. void NStr::DoubleToString(string& out_str, double value)
  595. {
  596.     char buffer[kMaxDoubleStringSize];
  597.     ::sprintf(buffer, "%g", value);
  598.     out_str = buffer;
  599. }
  601. string NStr::DoubleToString(double value, unsigned int precision)
  602. {
  603.     char buffer[kMaxDoubleStringSize];
  604.     SIZE_TYPE n = DoubleToString(value, precision, buffer,
  605.                                  kMaxDoubleStringSize);
  606.     buffer[n] = '';
  607.     return buffer;
  608. }
  611. SIZE_TYPE NStr::DoubleToString(double value, unsigned int precision,
  612.                                char* buf, SIZE_TYPE buf_size)
  613. {
  614.     char buffer[kMaxDoubleStringSize];
  615.     if (precision > kMaxDoublePrecision) {
  616.         precision = kMaxDoublePrecision;
  617.     }
  618.     int n = ::sprintf(buffer, "%.*f", (int) precision, value);
  619.     SIZE_TYPE n_copy = min((SIZE_TYPE) n, buf_size);
  620.     memcpy(buf, buffer, n_copy);
  621.     return n_copy;
  622. }
  625. string NStr::PtrToString(const void* value)
  626. {
  627.     char buffer[64];
  628.     ::sprintf(buffer, "%p", value);
  629.     return buffer;
  630. }
  632. void NStr::PtrToString(string& out_str, const void* value)
  633. {
  634.     char buffer[64];
  635.     ::sprintf(buffer, "%p", value);
  636.     out_str = buffer;
  637. }
  639. const void* NStr::StringToPtr(const string& str)
  640. {
  641.     void *ptr = NULL;
  642.     ::sscanf(str.c_str(), "%p", &ptr);
  643.     return ptr;
  644. }
  647. static const string s_kTrueString  = "true";
  648. static const string s_kFalseString = "false";
  649. static const string s_kTString     = "t";
  650. static const string s_kFString     = "f";
  651. static const string s_kYesString   = "yes";
  652. static const string s_kNoString    = "no";
  653. static const string s_kYString     = "y";
  654. static const string s_kNString     = "n";
  657. const string& NStr::BoolToString(bool value)
  658. {
  659.     return value ? s_kTrueString : s_kFalseString;
  660. }
  663. bool NStr::StringToBool(const string& str)
  664. {
  665.     if ( AStrEquiv(str, s_kTrueString,  PNocase())  ||
  666.          AStrEquiv(str, s_kTString,     PNocase())  ||
  667.          AStrEquiv(str, s_kYesString,   PNocase())  ||
  668.          AStrEquiv(str, s_kYString,     PNocase()) )
  669.         return true;
  671.     if ( AStrEquiv(str, s_kFalseString, PNocase())  ||
  672.          AStrEquiv(str, s_kFString,     PNocase())  ||
  673.          AStrEquiv(str, s_kNoString,    PNocase())  ||
  674.          AStrEquiv(str, s_kNString,     PNocase()) )
  675.         return false;
  677.     NCBI_THROW2(CStringException, eConvert,
  678.                 "String cannot be converted to bool", 0);
  679. }
  682. string NStr::FormatVarargs(const char* format, va_list args)
  683. {
  684. #ifdef HAVE_VASPRINTF
  685.     char* s;
  686.     int n = vasprintf(&s, format, args);
  687.     if (n >= 0) {
  688.         string str(s, n);
  689.         free(s);
  690.         return str;
  691.     } else {
  692.         return kEmptyStr;
  693.     }
  694. #elif defined(NCBI_COMPILER_GCC) && defined(NO_PUBSYNC)
  695.     CNcbiOstrstream oss;
  696.     oss.vform(format, args);
  697.     return CNcbiOstrstreamToString(oss);
  698. #elif defined(HAVE_VSNPRINTF)
  699.     // deal with implementation quirks
  700.     size_t size = 1024;
  701.     AutoPtr<char, ArrayDeleter<char> > buf(new char[size]);
  702.     buf.get()[size-1] = buf.get()[size-2] = 0;
  703.     size_t n = vsnprintf(buf.get(), size, format, args);
  704.     while (n >= size  ||  buf.get()[size-2]) {
  705.         if (buf.get()[size-1]) {
  706.             ERR_POST(Warning << "Buffer overrun by buggy vsnprintf");
  707.         }
  708.         size = max(size << 1, n);
  709.         buf.reset(new char[size]);
  710.         buf.get()[size-1] = buf.get()[size-2] = 0;
  711.         n = vsnprintf(buf.get(), size, format, args);
  712.     }
  713.     return (n > 0) ? string(buf.get(), n) : kEmptyStr;
  714. #elif defined(HAVE_VPRINTF)
  715.     char buf[1024];
  716.     buf[sizeof(buf) - 1] = 0;
  717.     vsprintf(buf, format, args);
  718.     if (buf[sizeof(buf) - 1]) {
  719.         ERR_POST(Warning << "Buffer overrun by vsprintf");
  720.     }
  721.     return buf;
  722. #else
  723. #  error Please port this code to your system.
  724. #endif
  725. }
  728. SIZE_TYPE NStr::FindNoCase(const string& str, const string& pattern,
  729.                            SIZE_TYPE start, SIZE_TYPE end, EOccurrence where)
  730. {
  731.     string    pat(pattern, 0, 1);
  732.     SIZE_TYPE l = pattern.size();
  733.     if (isupper(pat[0])) {
  734.         pat += (char)tolower(pat[0]);
  735.     } else if (islower(pat[0])) {
  736.         pat += (char)toupper(pat[0]);
  737.     }
  738.     if (where == eFirst) {
  739.         SIZE_TYPE pos = str.find_first_of(pat, start);
  740.         while (pos != NPOS  &&  pos <= end
  741.                &&  CompareNocase(str, pos, l, pattern) != 0) {
  742.             pos = str.find_first_of(pat, pos + 1);
  743.         }
  744.         return pos > end ? NPOS : pos;
  745.     } else { // eLast
  746.         SIZE_TYPE pos = str.find_last_of(pat, end);
  747.         while (pos != NPOS  &&  pos >= start
  748.                &&  CompareNocase(str, pos, l, pattern) != 0) {
  749.             if (pos == 0) {
  750.                 return NPOS;
  751.             }
  752.             pos = str.find_last_of(pat, pos - 1);
  753.         }
  754.         return pos < start ? NPOS : pos;
  755.     }
  756. }
  759. string NStr::TruncateSpaces(const string& str, ETrunc where)
  760. {
  761.     SIZE_TYPE beg = 0;
  762.     if (where == eTrunc_Begin  ||  where == eTrunc_Both) {
  763.         while (beg < str.length()  &&  isspace(str[beg]))
  764.             beg++;
  765.         if (beg == str.length())
  766.             return kEmptyStr;
  767.     }
  768.     SIZE_TYPE end = str.length() - 1;
  769.     if (where == eTrunc_End  ||  where == eTrunc_Both) {
  770.         while ( isspace(str[end]) )
  771.             end--;
  772.     }
  773.     _ASSERT( beg <= end );
  774.     return str.substr(beg, end - beg + 1);
  775. }
  778. string& NStr::Replace(const string& src,
  779.                       const string& search, const string& replace,
  780.                       string& dst, SIZE_TYPE start_pos, size_t max_replace)
  781. {
  782.     // source and destination should not be the same
  783.     if (&src == &dst) {
  784.         NCBI_THROW2(CStringException, eBadArgs,
  785.                     "String replace called with source == destination", 0);
  786.     }
  788.     dst = src;
  790.     if( start_pos + search.size() > src.size() ||
  791.         search == replace)
  792.         return dst;
  794.     for(size_t count = 0; !(max_replace && count >= max_replace); count++) {
  795.         start_pos = dst.find(search, start_pos);
  796.         if(start_pos == NPOS)
  797.             break;
  798.         dst.replace(start_pos, search.size(), replace);
  799.         start_pos += replace.size();
  800.     }
  801.     return dst;
  802. }
  805. string NStr::Replace(const string& src,
  806.                      const string& search, const string& replace,
  807.                      SIZE_TYPE start_pos, size_t max_replace)
  808. {
  809.     string dst;
  810.     return Replace(src, search, replace, dst, start_pos, max_replace);
  811. }
  814. list<string>& NStr::Split(const string& str, const string& delim,
  815.                           list<string>& arr, EMergeDelims merge)
  816. {
  817.     for (size_t pos = 0; ; ) {
  818.         size_t prev_pos = (merge == eMergeDelims
  819.                            ? str.find_first_not_of(delim, pos)
  820.                            : pos);
  821.         if (prev_pos == NPOS) {
  822.             break;
  823.         }
  824.         pos = str.find_first_of(delim, prev_pos);
  825.         if (pos == NPOS) {
  826.             arr.push_back(str.substr(prev_pos));
  827.             break;
  828.         } else {
  829.             arr.push_back(str.substr(prev_pos, pos - prev_pos));
  830.             ++pos;
  831.         }
  832.     }
  833.     return arr;
  834. }
  837. vector<string>& NStr::Tokenize(const string& str, const string& delim,
  838.                                vector<string>& arr, EMergeDelims merge)
  839. {
  840.     if (delim.empty()) {
  841.         arr.push_back(str);
  842.         return arr;
  843.     }
  845.     size_t pos, prev_pos;
  847.     // Count number of tokens to determine the array size
  848.     size_t tokens = 0;
  850.     for (pos = prev_pos = 0; pos < str.length(); ++pos) {
  851.         char c = str[pos];
  852.         size_t dpos = delim.find(c);
  853.         if (dpos != string::npos) ++tokens;
  854.     }
  856.     arr.reserve(arr.size() + tokens + 1);
  858.     // Tokenization
  859.     for (pos = 0; ; ) {
  860.         prev_pos = (merge == eMergeDelims ? str.find_first_not_of(delim, pos)
  861.                     : pos);
  862.         if (prev_pos == NPOS) {
  863.             break;
  864.         }
  865.         pos = str.find_first_of(delim, prev_pos);
  866.         if (pos == NPOS) {
  867.             arr.push_back(str.substr(prev_pos));
  868.             break;
  869.         } else {
  870.             arr.push_back(str.substr(prev_pos, pos - prev_pos));
  871.             ++pos;
  872.         }
  873.     }
  875.     return arr;
  876. }
  879. bool NStr::SplitInTwo(const string& str, const string& delim,
  880.                       string& str1, string& str2)
  881. {
  882.     SIZE_TYPE delim_pos = str.find_first_of(delim);
  883.     if (NPOS == delim_pos) {   // only one piece.
  884.         str1 = str;
  885.         str2 = kEmptyStr;
  886.         return false;
  887.     }
  888.     str1 = str.substr(0, delim_pos);
  889.     str2 = str.substr(delim_pos + 1); // skip only one delimiter character.
  891.     return true;
  892. }
  895. template <typename T>
  896. string s_NStr_Join(const T& arr, const string& delim)
  897. {
  898.     if (arr.empty()) {
  899.         return kEmptyStr;
  900.     }
  902.     string                       result = arr.front();
  903.     typename T::const_iterator   it     = arr.begin();
  904.     SIZE_TYPE needed = result.size();
  905.     while (++it != arr.end()) {
  906.         needed += delim.size() + it->size();
  907.     }
  908.     result.reserve(needed);
  909.     it = arr.begin();
  910.     while (++it != arr.end()) {
  911.         result += delim;
  912.         result += *it;
  913.     }
  914.     return result;
  915. }
  917. string NStr::Join(const list<string>& arr, const string& delim)
  918. {
  919.     return s_NStr_Join(arr, delim);
  920. }
  922. string NStr::Join(const vector<string>& arr, const string& delim)
  923. {
  924.     return s_NStr_Join(arr, delim);
  925. }
  928. string NStr::PrintableString(const string&      str,
  929.                              NStr::ENewLineMode nl_mode)
  930. {
  931.     static const char s_Hex[] = "0123456789ABCDEF";
  932.     ITERATE ( string, it, str ) {
  933.         if ( !isprint(*it) || *it == '"' || *it == '\' ) {
  934.             // bad character - convert via CNcbiOstrstream
  935.             CNcbiOstrstream out;
  936.             // write first good characters in one chunk
  937.             out.write(str.data(), it-str.begin());
  938.             // convert all other characters one by one
  939.             do {
  940.                 if ( isprint(*it) ) {
  941.                     // escape '"' and '\' anyway
  942.                     if ( *it == '"' || *it == '\' )
  943.                         out.put('\');
  944.                     out.put(*it);
  945.                 }
  946.                 else if (*it == 'n') {
  947.                     // newline needs special processing
  948.                     if (nl_mode == eNewLine_Quote) {
  949.                         out.write("\n", 2);
  950.                     }
  951.                     else {
  952.                         out.put('n');
  953.                     }
  954.                 } else {
  955.                     // all other non-printable characters need to be escaped
  956.                     out.put('\');
  957.                     if (*it == 't') {
  958.                         out.put('t');
  959.                     } else if (*it == 'r') {
  960.                         out.put('r');
  961.                     } else if (*it == 'v') {
  962.                         out.put('v');
  963.                     } else {
  964.                         // hex string for non-standard codes
  965.                         out.put('x');
  966.                         out.put(s_Hex[(unsigned char) *it >> 4]);
  967.                         out.put(s_Hex[(unsigned char) *it & 15]);
  968.                     }
  969.                 }
  970.             } while (++it < it_end); // it_end is from ITERATE macro
  971.             return CNcbiOstrstreamToString(out);
  972.         }
  973.     }
  974.     // all characters are good - return orignal string
  975.     return str;
  976. }
  979. string NStr::ParseEscapes(const string& str)
  980. {
  981.     string out;
  982.     out.reserve(str.size()); // can only be smaller
  983.     SIZE_TYPE pos = 0;
  984.     while (pos < str.size()) {
  985.         SIZE_TYPE pos2 = str.find('\', pos);
  986.         if (pos2 == NPOS) {
  987.             out += str.substr(pos);
  988.             break;
  989.         }
  990.         out += str.substr(pos, pos2 - pos);
  991.         if (++pos2 == str.size()) {
  992.             NCBI_THROW2(CStringException, eFormat,
  993.                         "Unterminated escape sequence", pos2);
  994.         }
  995.         switch (str[pos2]) {
  996.         case 'a':  out += 'a';  break;
  997.         case 'b':  out += 'b';  break;
  998.         case 'f':  out += 'f';  break;
  999.         case 'n':  out += 'n';  break;
  1000.         case 'r':  out += 'r';  break;
  1001.         case 't':  out += 't';  break;
  1002.         case 'v':  out += 'v';  break;
  1003.         case 'x':
  1004.         {
  1005.             pos = pos2 + 1;
  1006.             while (pos2 <= pos  &&  pos2 + 1 < str.size()
  1007.                    &&  isxdigit(str[pos2 + 1])) {
  1008.                 ++pos2;
  1009.             }
  1010.             if (pos2 >= pos) {
  1011.                 out += static_cast<char>
  1012.                     (StringToUInt(str.substr(pos, pos2 - pos + 1), 16));
  1013.             } else {
  1014.                 NCBI_THROW2(CStringException, eFormat,
  1015.                             "\x used with no following digits", pos);
  1016.             }
  1017.             break;
  1018.         }
  1019.         case '0':  case '1':  case '2':  case '3':
  1020.         case '4':  case '5':  case '6':  case '7':
  1021.         {
  1022.             pos = pos2;
  1023.             unsigned char c = str[pos2] - '0';
  1024.             while (pos2 < pos + 3  &&  pos2 + 1 < str.size()
  1025.                    &&  str[pos2 + 1] >= '0'  &&  str[pos2 + 1] <= '7') {
  1026.                 c = (c << 3) | (str[++pos2] - '0');
  1027.             }
  1028.             out += c;
  1029.         }
  1030.         default:
  1031.             out += str[pos2];
  1032.         }
  1033.         pos = pos2 + 1;
  1034.     }
  1035.     return out;
  1036. }
  1039. // Determines the end of an HTML <...> tag, accounting for attributes
  1040. // and comments (the latter allowed only within <!...>).
  1041. static SIZE_TYPE s_EndOfTag(const string& str, SIZE_TYPE start)
  1042. {
  1043.     _ASSERT(start < str.size()  &&  str[start] == '<');
  1044.     bool comments_ok = (start + 1 < str.size()  &&  str[start + 1] == '!');
  1045.     for (SIZE_TYPE pos = start + 1;  pos < str.size();  ++pos) {
  1046.         switch (str[pos]) {
  1047.         case '>': // found the end
  1048.             return pos;
  1050.         case '"': // start of "string"; advance to end
  1051.             pos = str.find('"', pos + 1);
  1052.             if (pos == NPOS) {
  1053.                 NCBI_THROW2(CStringException, eFormat,
  1054.                             "Unclosed string in HTML tag", start);
  1055.                 // return pos;
  1056.             }
  1057.             break;
  1059.         case '-': // possible start of -- comment --; advance to end
  1060.             if (comments_ok  &&  pos + 1 < str.size()
  1061.                 &&  str[pos + 1] == '-') {
  1062.                 pos = str.find("--", pos + 2);
  1063.                 if (pos == NPOS) {
  1064.                     NCBI_THROW2(CStringException, eFormat,
  1065.                                 "Unclosed comment in HTML tag", start);
  1066.                     // return pos;
  1067.                 } else {
  1068.                     ++pos;
  1069.                 }
  1070.             }
  1071.         }
  1072.     }
  1073.     NCBI_THROW2(CStringException, eFormat, "Unclosed HTML tag", start);
  1074.     // return NPOS;
  1075. }
  1078. // Determines the end of an HTML &foo; character/entity reference
  1079. // (which might not actually end with a semicolon :-/)
  1080. static SIZE_TYPE s_EndOfReference(const string& str, SIZE_TYPE start)
  1081. {
  1082.     _ASSERT(start < str.size()  &&  str[start] == '&');
  1083. #ifdef NCBI_STRICT_HTML_REFS
  1084.     return str.find(';', start + 1);
  1085. #else
  1086.     SIZE_TYPE pos = str.find_first_not_of
  1087.         ("#0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",
  1088.          start + 1);
  1089.     if (pos == NPOS  ||  str[pos] == ';') {
  1090.         return pos;
  1091.     } else {
  1092.         return pos - 1;
  1093.     }
  1094. #endif
  1095. }
  1098. static SIZE_TYPE s_VisibleWidth(const string& str, bool is_html)
  1099. {
  1100.     if (is_html) {
  1101.         SIZE_TYPE width = 0, pos = 0;
  1102.         for (;;) {
  1103.             SIZE_TYPE pos2 = str.find_first_of("<&", pos);
  1104.             if (pos2 == NPOS) {
  1105.                 width += str.size() - pos;
  1106.                 break;
  1107.             } else {
  1108.                 width += pos2 - pos;
  1109.                 if (str[pos2] == '&') {
  1110.                     ++width;
  1111.                     pos = s_EndOfReference(str, pos);
  1112.                 } else {
  1113.                     pos = s_EndOfTag(str, pos);
  1114.                 }
  1115.                 if (pos == NPOS) {
  1116.                     break;
  1117.                 } else {
  1118.                     ++pos;
  1119.                 }
  1120.             }
  1121.         }
  1122.         return width;
  1123.     } else {
  1124.         return str.size();
  1125.     }
  1126. }
  1129. list<string>& NStr::Wrap(const string& str, SIZE_TYPE width,
  1130.                          list<string>& arr, NStr::TWrapFlags flags,
  1131.                          const string* prefix, const string* prefix1)
  1132. {
  1133.     if (prefix == 0) {
  1134.         prefix = &kEmptyStr;
  1135.     }
  1137.     const string* pfx = prefix1 ? prefix1 : prefix;
  1138.     SIZE_TYPE     pos = 0, len = str.size();
  1139.     string        hyphen; // "-" or empty
  1140.     bool          is_html  = flags & fWrap_HTMLPre ? true : false;
  1142.     enum EScore { // worst to best
  1143.         eForced,
  1144.         ePunct,
  1145.         eSpace,
  1146.         eNewline
  1147.     };
  1149.     while (pos < len) {
  1150.         SIZE_TYPE column     = s_VisibleWidth(*pfx, is_html);
  1151.         SIZE_TYPE column0    = column;
  1152.         // the next line will start at best_pos
  1153.         SIZE_TYPE best_pos   = NPOS;
  1154.         EScore    best_score = eForced;
  1155.         for (SIZE_TYPE pos2 = pos;  pos2 < len && column <= width;
  1156.              ++pos2, ++column) {
  1157.             EScore    score     = eForced;
  1158.             SIZE_TYPE score_pos = pos2;
  1159.             char      c         = str[pos2];
  1161.             if (c == 'n') {
  1162.                 best_pos   = pos2;
  1163.                 best_score = eNewline;
  1164.                 break;
  1165.             } else if (isspace(c)) {
  1166.                 if (pos2 > 0  &&  isspace(str[pos2 - 1])) {
  1167.                     continue; // take the first space of a group
  1168.                 }
  1169.                 score = eSpace;
  1170.             } else if (is_html  &&  c == '<') {
  1171.                 // treat tags as zero-width...
  1172.                 pos2 = s_EndOfTag(str, pos2);
  1173.                 --column;
  1174.             } else if (is_html  &&  c == '&') {
  1175.                 // ...and references as single characters
  1176.                 pos2 = s_EndOfReference(str, pos2);
  1177.             } else if (ispunct(c)) {
  1178.                 if (c == '('  ||  c == '['  ||  c == '{'  ||  c == '<'
  1179.                     ||  c == '`') { // opening element
  1180.                     score = ePunct;
  1181.                 } else if (score_pos < len - 1) {
  1182.                     // Prefer breaking *after* most types of punctuation.
  1183.                     score = ePunct;
  1184.                     ++score_pos;
  1185.                 }
  1186.             }
  1188.             if (score >= best_score) {
  1189.                 best_pos   = score_pos;
  1190.                 best_score = score;
  1191.             }
  1193.             while (pos2 < len - 1  &&  str[pos2 + 1] == 'b') {
  1194.                 // Account for backspaces
  1195.                 ++pos2;
  1196.                 if (column > column0) {
  1197.                     --column;
  1198.                 }
  1199.             }
  1200.         }
  1202.         if (best_score != eNewline  &&  column <= width) {
  1203.             // If the whole remaining text can fit, don't split it...
  1204.             best_pos = len;
  1205.         } else if (best_score == eForced  &&  (flags & fWrap_Hyphenate)) {
  1206.             hyphen = "-";
  1207.             --best_pos;
  1208.         }
  1209.         arr.push_back(*pfx);
  1210.         {{ // eat backspaces and the characters (if any) that precede them
  1211.             string    line(str, pos, best_pos - pos);
  1212.             SIZE_TYPE bs = 0;
  1213.             while ((bs = line.find('b', bs)) != NPOS) {
  1214.                 if (bs > 0) {
  1215.                     line.erase(bs - 1, 2);
  1216.                 } else {
  1217.                     line.erase(0, 1);
  1218.                 }
  1219.             }
  1220.             arr.back() += line;
  1221.         }}
  1222.         arr.back() += hyphen;
  1223.         pos    = best_pos;
  1224.         pfx    = prefix;
  1225.         hyphen = kEmptyStr;
  1227.         if (best_score == eSpace) {
  1228.             // If breaking at a group of spaces, skip over the whole group
  1229.             while (pos < len  &&  isspace(str[pos])  &&  str[pos] != 'n') {
  1230.                 ++pos;
  1231.             }
  1232.         } else if (best_score == eNewline) {
  1233.             ++pos;
  1234.         }
  1235.         while (pos < len  &&  str[pos] == 'b') {
  1236.             ++pos;
  1237.         }
  1238.     }
  1240.     return arr;
  1241. }
  1244. list<string>& NStr::WrapList(const list<string>& l, SIZE_TYPE width,
  1245.                              const string& delim, list<string>& arr,
  1246.                              NStr::TWrapFlags flags, const string* prefix,
  1247.                              const string* prefix1)
  1248. {
  1249.     if (l.empty()) {
  1250.         return arr;
  1251.     }
  1253.     const string* pfx      = prefix1 ? prefix1 : prefix;
  1254.     string        s        = *pfx;
  1255.     bool          is_html  = flags & fWrap_HTMLPre ? true : false;
  1256.     SIZE_TYPE     column   = s_VisibleWidth(s,     is_html);
  1257.     SIZE_TYPE     delwidth = s_VisibleWidth(delim, is_html);
  1258.     bool          at_start = true;
  1259.     ITERATE (list<string>, it, l) {
  1260.         SIZE_TYPE term_width = s_VisibleWidth(*it, is_html);
  1261.         if (at_start) {
  1262.             if (column + term_width <= width) {
  1263.                 s += *it;
  1264.                 column += term_width;
  1265.                 at_start = false;
  1266.             } else {
  1267.                 // Can't fit, even on its own line; break separately.
  1268.                 Wrap(*it, width, arr, flags, prefix, pfx);
  1269.                 pfx      = prefix;
  1270.                 s        = *prefix;
  1271.                 column   = s_VisibleWidth(s, is_html);
  1272.                 at_start = true;
  1273.             }
  1274.         } else if (column + delwidth + term_width <= width) {
  1275.             s += delim;
  1276.             s += *it;
  1277.             column += delwidth + term_width;
  1278.             at_start = false;
  1279.         } else {
  1280.             // Can't fit on this line; break here and try again.
  1281.             arr.push_back(s);
  1282.             pfx      = prefix;
  1283.             s        = *prefix;
  1284.             column   = s_VisibleWidth(s, is_html);
  1285.             at_start = true;
  1286.             --it;
  1287.         }
  1288.     }
  1290.     arr.push_back(s);
  1291.     return arr;
  1292. }
  1295. #if !defined(HAVE_STRDUP)
  1296. extern char* strdup(const char* str)
  1297. {
  1298.     if ( !str )
  1299.         return 0;
  1301.     size_t size   = strlen(str) + 1;
  1302.     void*  result = malloc(size);
  1303.     return (char*) (result ? memcpy(result, str, size) : 0);
  1304. }
  1305. #endif
  1308. /////////////////////////////////////////////////////////////////////////////
  1309. //  CStringUTF8
  1311. void CStringUTF8::x_Append(const char* src)
  1312. {
  1313.     const char* srcBuf;
  1314.     size_t needed = 0;
  1315.     for (srcBuf = src; *srcBuf; ++srcBuf) {
  1316.         Uint1 ch = *srcBuf;
  1317.         if (ch < 0x80) {
  1318.             ++needed;
  1319.         } else {
  1320.             needed += 2;
  1321.         }
  1322.     }
  1324.     if ( !needed )
  1325.         return;
  1327.     reserve(length()+needed+1);
  1328.     for (srcBuf = src; *srcBuf; ++srcBuf) {
  1329.         Uint1 ch = *srcBuf;
  1330.         if (ch < 0x80) {
  1331.             append(1, ch);
  1332.         } else {
  1333.             append(1, Uint1((ch >> 6) | 0xC0));
  1334.             append(1, Uint1((ch & 0x3F) | 0x80));
  1335.         }
  1336.     }
  1337. }
  1340. #if defined(HAVE_WSTRING)
  1341. void CStringUTF8::x_Append(const wchar_t* src)
  1342. {
  1343.     const wchar_t* srcBuf;
  1344.     size_t needed = 0;
  1345.     for (srcBuf = src; *srcBuf; ++srcBuf) {
  1346.         Uint2 ch = *srcBuf;
  1347.         if (ch < 0x80) {
  1348.             ++needed;
  1349.         } else if (ch < 0x800) {
  1350.             needed += 2;
  1351.         } else {
  1352.             needed += 3;
  1353.         }
  1354.     }
  1356.     if ( !needed )
  1357.         return;
  1359.     reserve(length()+needed+1);
  1360.     for (srcBuf = src; *srcBuf; ++srcBuf) {
  1361.         Uint2 ch = *srcBuf;
  1362.         if (ch < 0x80) {
  1363.             append(1, ch);
  1364.         }
  1365.         else if (ch < 0x800) {
  1366.             append(1, Uint2((ch >> 6) | 0xC0));
  1367.             append(1, Uint2((ch & 0x3F) | 0x80));
  1368.         } else {
  1369.             append(1, Uint2((ch >> 12) | 0xE0));
  1370.             append(1, Uint2(((ch >> 6) & 0x3F) | 0x80));
  1371.             append(1, Uint2((ch & 0x3F) | 0x80));
  1372.         }
  1373.     }
  1374. }
  1375. #endif // HAVE_WSTRING
  1378. string CStringUTF8::AsAscii(void) const
  1379. {
  1380.     string result;
  1381.     const char* srcBuf;
  1382.     size_t needed = 0;
  1383.     bool bad = false;
  1384.     bool enough = true;
  1385.     for (srcBuf = c_str(); *srcBuf; ++srcBuf) {
  1386.         Uint1 ch = *srcBuf;
  1387.         if ((ch & 0x80) == 0) {
  1388.             ++needed;
  1389.         } else if ((ch & 0xE0) == 0xC0) {
  1390.             enough = (ch & 0x1F) <= 0x03;
  1391.             if (enough) {
  1392.                 ++needed;
  1393.                 ch = *(++srcBuf);
  1394.                 bad = (ch & 0xC0) != 0x80;
  1395.             }
  1396.         } else if ((ch & 0xF0) == 0xE0) {
  1397.             enough = false;
  1398.         } else {
  1399.             bad = true;
  1400.         }
  1401.         if (!enough) {
  1402.             NCBI_THROW2(CStringException, eConvert,
  1403.                         "Cannot convert UTF8 string to single-byte string",
  1404.                         s_DiffPtr(srcBuf,c_str()));
  1405.         }
  1406.         if (bad) {
  1407.             NCBI_THROW2(CStringException, eFormat,
  1408.                         "Wrong UTF8 format",
  1409.                         s_DiffPtr(srcBuf,c_str()));
  1410.         }
  1411.     }
  1412.     result.reserve( needed+1);
  1413.     for (srcBuf = c_str(); *srcBuf; ++srcBuf) {
  1414.         Uint1 chRes;
  1415.         size_t more;
  1416.         Uint1 ch = *srcBuf;
  1417.         if ((ch & 0x80) == 0) {
  1418.             chRes = ch;
  1419.             more = 0;
  1420.         } else {
  1421.             chRes = (ch & 0x1F);
  1422.             more = 1;
  1423.         }
  1424.         while (more--) {
  1425.             ch = *(++srcBuf);
  1426.             chRes = (chRes << 6) | (ch & 0x3F);
  1427.         }
  1428.         result += chRes;
  1429.     }
  1430.     return result;
  1431. }
  1434. #if defined(HAVE_WSTRING)
  1435. wstring CStringUTF8::AsUnicode(void) const
  1436. {
  1437.     wstring result;
  1438.     const char* srcBuf;
  1439.     size_t needed = 0;
  1440.     bool bad = false;
  1441.     for (srcBuf = c_str(); *srcBuf; ++srcBuf) {
  1442.         Uint1 ch = *srcBuf;
  1443.         if ((ch & 0x80) == 0) {
  1444.             ++needed;
  1445.         } else if ((ch & 0xE0) == 0xC0) {
  1446.             ++needed;
  1447.             ch = *(++srcBuf);
  1448.             bad = (ch & 0xC0) != 0x80;
  1449.         } else if ((ch & 0xF0) == 0xE0) {
  1450.             ++needed;
  1451.             ch = *(++srcBuf);
  1452.             bad = (ch & 0xC0) != 0x80;
  1453.             if (!bad) {
  1454.                 ch = *(++srcBuf);
  1455.                 bad = (ch & 0xC0) != 0x80;
  1456.             }
  1457.         } else {
  1458.             bad = true;
  1459.         }
  1460.         if (bad) {
  1461.             NCBI_THROW2(CStringException, eFormat,
  1462.                         "Wrong UTF8 format",
  1463.                         s_DiffPtr(srcBuf,c_str()));
  1464.         }
  1465.     }
  1466.     result.reserve( needed+1);
  1467.     for (srcBuf = c_str(); *srcBuf; ++srcBuf) {
  1468.         Uint2 chRes;
  1469.         size_t more;
  1470.         Uint1 ch = *srcBuf;
  1471.         if ((ch & 0x80) == 0) {
  1472.             chRes = ch;
  1473.             more = 0;
  1474.         } else if ((ch & 0xE0) == 0xC0) {
  1475.             chRes = (ch & 0x1F);
  1476.             more = 1;
  1477.         } else {
  1478.             chRes = (ch & 0x0F);
  1479.             more = 2;
  1480.         }
  1481.         while (more--) {
  1482.             ch = *(++srcBuf);
  1483.             chRes = (chRes << 6) | (ch & 0x3F);
  1484.         }
  1485.         result += chRes;
  1486.     }
  1487.     return result;
  1488. }
  1489. #endif // HAVE_WSTRING
  1492. END_NCBI_SCOPE
  1495. /*
  1496.  * ===========================================================================
  1497.  * $Log: ncbistr.cpp,v $
  1498.  * Revision 1000.6  2004/06/01 19:09:21  gouriano
  1499.  * PRODUCTION: UPGRADED [GCC34_MSVC7] Dev-tree R1.109
  1500.  *
  1501.  * Revision 1.109  2004/05/26 19:21:25  ucko
  1502.  * FindNoCase: avoid looping in eLastMode when there aren't any full
  1503.  * matches but the first character of the string matches the first
  1504.  * character of the pattern.
  1505.  *
  1506.  * Revision 1.108  2004/05/14 13:59:27  gorelenk
  1507.  * Added include of ncbi_pch.hpp
  1508.  *
  1509.  * Revision 1.107  2004/03/11 18:49:48  gorelenk
  1510.  * Removed(condionaly) implementation of class CNcbiEmptyString.
  1511.  *
  1512.  * Revision 1.106  2004/03/05 12:26:43  ivanov
  1513.  * Moved CDirEntry::MatchesMask() to NStr class.
  1514.  *
  1515.  * Revision 1.105  2004/03/04 13:38:57  kuznets
  1516.  * + set of ToString conversion functions taking outout string as a parameter,
  1517.  * not a return value (should give a performance advantage in some cases)
  1518.  *
  1519.  * Revision 1.104  2004/02/19 16:44:55  vasilche
  1520.  * WorkShop compiler doesn't support static templates.
  1521.  *
  1522.  * Revision 1.103  2004/02/18 20:54:47  shomrat
  1523.  * bug fix (pos -> pos2)
  1524.  *
  1525.  * Revision 1.102  2003/12/12 20:06:44  rsmith
  1526.  * Take out un-needed include of stdarg.h (included in ncbistr.hpp).
  1527.  *
  1528.  * Revision 1.101  2003/12/12 20:04:24  rsmith
  1529.  * make sure stdarg.h is included to define va_list.
  1530.  *
  1531.  * Revision 1.100  2003/12/12 17:26:54  ucko
  1532.  * +FormatVarargs
  1533.  *
  1534.  * Revision 1.99  2003/12/01 20:45:47  ucko
  1535.  * Extend Join to handle vectors as well as lists (common code templatized).
  1536.  * Add ParseEscapes (inverse of PrintableString).
  1537.  *
  1538.  * Revision 1.98  2003/10/31 13:15:20  lavr
  1539.  * Fix typos in the log of the previous commit :-)
  1540.  *
  1541.  * Revision 1.97  2003/10/31 12:59:46  lavr
  1542.  * Better diagnostics messages from exceptions; some other cosmetic changes
  1543.  *
  1544.  * Revision 1.96  2003/10/03 15:16:02  ucko
  1545.  * NStr::Join: preallocate as much space as we need for result.
  1546.  *
  1547.  * Revision 1.95  2003/09/17 15:18:29  vasilche
  1548.  * Reduce memory allocations in NStr::PrintableString()
  1549.  *
  1550.  * Revision 1.94  2003/08/19 15:17:20  rsmith
  1551.  * Add NStr::SplitInTwo() function.
  1552.  *
  1553.  * Revision 1.93  2003/06/16 15:19:03  ucko
  1554.  * FindNoCase: always honor both start and end (oops).
  1555.  *
  1556.  * Revision 1.92  2003/05/22 20:09:29  gouriano
  1557.  * added UTF8 strings
  1558.  *
  1559.  * Revision 1.91  2003/05/14 21:52:09  ucko
  1560.  * Move FindNoCase out of line and reimplement it to avoid making
  1561.  * lowercase copies of both strings.
  1562.  *
  1563.  * Revision 1.90  2003/03/25 22:15:40  lavr
  1564.  * NStr::PrintableString():: Print NUL char as x00 instead of 
  1565.  *
  1566.  * Revision 1.89  2003/03/20 13:27:52  dicuccio
  1567.  * Oops.  Removed old code wrapped in #if 0...#endif.
  1568.  *
  1569.  * Revision 1.88  2003/03/20 13:27:11  dicuccio
  1570.  * Changed NStr::StringToPtr() - now symmetric with NSrt::PtrToString (there were
  1571.  * too many special cases).
  1572.  *
  1573.  * Revision 1.87  2003/03/17 12:49:26  dicuccio
  1574.  * Fixed indexing error in NStr::PtrToString() - buffer is 0-based index, not
  1575.  * 1-based
  1576.  *
  1577.  * Revision 1.86  2003/03/11 16:57:12  ucko
  1578.  * Process backspaces in NStr::Wrap, allowing in particular the use of
  1579.  * " b" ("-b") to indicate mid-word break (hyphenation) points.
  1580.  *
  1581.  * Revision 1.85  2003/03/10 18:57:08  kuznets
  1582.  * iterate->ITERATE
  1583.  *
  1584.  * Revision 1.84  2003/03/04 00:02:21  vakatov
  1585.  * NStr::PtrToString() -- use runtime check for "0x"
  1586.  * NStr::StringToPtr() -- minor polishing
  1587.  *
  1588.  * Revision 1.83  2003/02/27 15:34:01  lavr
  1589.  * Bugfix in converting string to double [spurious dots], some reformatting
  1590.  *
  1591.  * Revision 1.82  2003/02/26 21:07:52  siyan
  1592.  * Remove const for base parameter for StringToUInt8
  1593.  *
  1594.  * Revision 1.81  2003/02/26 20:34:11  siyan
  1595.  * Added/deleted whitespaces to conform to existing coding style
  1596.  *
  1597.  * Revision 1.80  2003/02/26 16:45:53  siyan
  1598.  * Reimplemented NStr::StringToUInt8 to support additional base parameters
  1599.  * that can take radix values such as 10(default), 16, 8, 2.
  1600.  * Reimplemented StringToPtr to support 64 bit addresses.
  1601.  *
  1602.  * Revision 1.79  2003/02/25 19:14:53  kuznets
  1603.  * NStr::StringToBool changed to understand YES/NO
  1604.  *
  1605.  * Revision 1.78  2003/02/25 15:43:40  dicuccio
  1606.  * Added #ifdef'd hack for MSVC's non-standard sprintf() in PtrToString(),
  1607.  * '%p' lacks a leading '0x'
  1608.  *
  1609.  * Revision 1.77  2003/02/25 14:43:53  dicuccio
  1610.  * Added handling of special NULL pointer encoding in StringToPtr()
  1611.  *
  1612.  * Revision 1.76  2003/02/24 20:25:59  gouriano
  1613.  * use template-based errno and parse exceptions
  1614.  *
  1615.  * Revision 1.75  2003/02/21 21:20:01  vakatov
  1616.  * Fixed some types, did some casts to avoid compilation warnings in 64-bit
  1617.  *
  1618.  * Revision 1.74  2003/02/20 18:41:28  dicuccio
  1619.  * Added NStr::StringToPtr()
  1620.  *
  1621.  * Revision 1.73  2003/02/11 22:11:03  ucko
  1622.  * Make NStr::WrapList a no-op if the input list is empty.
  1623.  *
  1624.  * Revision 1.72  2003/02/06 21:31:35  ucko
  1625.  * Fixed an off-by-one error in NStr::Wrap.
  1626.  *
  1627.  * Revision 1.71  2003/02/04 21:54:12  ucko
  1628.  * NStr::Wrap: when breaking on punctuation, try to position the break
  1629.  * *after* everything but opening delimiters.
  1630.  *
  1631.  * Revision 1.70  2003/01/31 03:39:11  lavr
  1632.  * Heed int->bool performance warning
  1633.  *
  1634.  * Revision 1.69  2003/01/27 20:06:59  ivanov
  1635.  * Get rid of compilation warnings in StringToUInt8() and DoubleToString()
  1636.  *
  1637.  * Revision 1.68  2003/01/24 16:59:27  ucko
  1638.  * Add an optional parameter to Split and Tokenize indicating whether to
  1639.  * merge adjacent delimiters; clean up WrapList slightly.
  1640.  *
  1641.  * Revision 1.67  2003/01/21 23:22:22  vakatov
  1642.  * NStr::Tokenize() to return reference, and not a new "vector<>".
  1643.  *
  1644.  * Revision 1.66  2003/01/21 20:08:01  ivanov
  1645.  * Added function NStr::DoubleToString(value, precision, buf, buf_size)
  1646.  *
  1647.  * Revision 1.65  2003/01/14 22:13:56  kuznets
  1648.  * Overflow check reimplemented for NStr::StringToInt
  1649.  *
  1650.  * Revision 1.64  2003/01/14 21:16:46  kuznets
  1651.  * +Nstr::Tokenize
  1652.  *
  1653.  * Revision 1.63  2003/01/13 14:47:16  kuznets
  1654.  * Implemented overflow checking for StringToInt8 function
  1655.  *
  1656.  * Revision 1.62  2003/01/10 22:17:06  kuznets
  1657.  * Implemented NStr::String2Int8
  1658.  *
  1659.  * Revision 1.61  2003/01/10 16:49:54  kuznets
  1660.  * Cosmetics
  1661.  *
  1662.  * Revision 1.60  2003/01/10 15:27:12  kuznets
  1663.  * Eliminated int -> bool performance warning
  1664.  *
  1665.  * Revision 1.59  2003/01/10 00:08:17  vakatov
  1666.  * + Int8ToString(),  UInt8ToString()
  1667.  *
  1668.  * Revision 1.58  2003/01/06 16:42:45  ivanov
  1669.  * + DoubleToString() with 'precision'
  1670.  *
  1671.  * Revision 1.57  2002/10/18 20:48:56  lavr
  1672.  * +ENewLine_Mode and 'n' translation in NStr::PrintableString()
  1673.  *
  1674.  * Revision 1.56  2002/10/17 14:41:20  ucko
  1675.  * * Make s_EndOf{Tag,Reference} actually static (oops).
  1676.  * * Pull width-determination code from WrapList into a separate function
  1677.  *   (s_VisibleWidth) and make Wrap{,List} call it for everything rather
  1678.  *   than assuming prefixes and delimiters to be plain text.
  1679.  * * Add a column variable to WrapList, as it may not equal s.size().
  1680.  *
  1681.  * Revision 1.55  2002/10/16 19:30:36  ucko
  1682.  * Add support for wrapping HTML <PRE> blocks.  (Not yet tested, but
  1683.  * behavior without fWrap_HTMLPre should stay the same.)
  1684.  *
  1685.  * Revision 1.54  2002/10/11 19:41:48  ucko
  1686.  * Clean up NStr::Wrap a bit more, doing away with the "limit" variables
  1687.  * for ease of potential extension.
  1688.  *
  1689.  * Revision 1.53  2002/10/03 14:44:35  ucko
  1690.  * Tweak the interfaces to NStr::Wrap* to avoid publicly depending on
  1691.  * kEmptyStr, removing the need for fWrap_UsePrefix1 in the process; also
  1692.  * drop fWrap_FavorPunct, as WrapList should be a better choice for such
  1693.  * situations.
  1694.  *
  1695.  * Revision 1.52  2002/10/02 20:15:09  ucko
  1696.  * Add Join, Wrap, and WrapList functions to NStr::.
  1697.  *
  1698.  * Revision 1.51  2002/09/04 15:16:57  lavr
  1699.  * Backslashed double quote (") in PrintableString()
  1700.  *
  1701.  * Revision 1.50  2002/07/15 18:17:25  gouriano
  1702.  * renamed CNcbiException and its descendents
  1703.  *
  1704.  * Revision 1.49  2002/07/11 14:18:28  gouriano
  1705.  * exceptions replaced by CNcbiException-type ones
  1706.  *
  1707.  * Revision 1.48  2002/05/02 15:25:37  ivanov
  1708.  * Added new parameter to String-to-X functions for skipping the check
  1709.  * the end of string on zero
  1710.  *
  1711.  * Revision 1.47  2002/04/11 21:08:03  ivanov
  1712.  * CVS log moved to end of the file
  1713.  *
  1714.  * Revision 1.46  2002/02/22 17:50:52  ivanov
  1715.  * Added compatible compare functions strcmp, strncmp, strcasecmp, strncasecmp.
  1716.  * Was speed-up some Compare..() functions.
  1717.  *
  1718.  * Revision 1.45  2001/08/30 00:36:45  vakatov
  1719.  * + NStr::StringToNumeric()
  1720.  * Also, well-groomed the code and get rid of some compilation warnings.
  1721.  *
  1722.  * Revision 1.44  2001/05/30 15:56:25  vakatov
  1723.  * NStr::CompareNocase, NStr::CompareCase -- get rid of the possible
  1724.  * compilation warning (ICC compiler:  "return statement missing").
  1725.  *
  1726.  * Revision 1.43  2001/05/17 15:04:59  lavr
  1727.  * Typos corrected
  1728.  *
  1729.  * Revision 1.42  2001/04/12 21:39:44  vakatov
  1730.  * NStr::Replace() -- check against source and dest. strings being the same
  1731.  *
  1732.  * Revision 1.41  2001/04/11 20:15:29  vakatov
  1733.  * NStr::PrintableString() -- cast "char" to "unsigned char".
  1734.  *
  1735.  * Revision 1.40  2001/03/16 19:38:35  grichenk
  1736.  * Added NStr::Split()
  1737.  *
  1738.  * Revision 1.39  2001/01/03 17:45:35  vakatov
  1739.  * + <ncbi_limits.h>
  1740.  *
  1741.  * Revision 1.38  2000/12/15 15:36:41  vasilche
  1742.  * Added header corelib/ncbistr.hpp for all string utility functions.
  1743.  * Optimized string utility functions.
  1744.  * Added assignment operator to CRef<> and CConstRef<>.
  1745.  * Add Upcase() and Locase() methods for automatic conversion.
  1746.  *
  1747.  * Revision 1.37  2000/12/12 14:20:36  vasilche
  1748.  * Added operator bool to CArgValue.
  1749.  * Various NStr::Compare() methods made faster.
  1750.  * Added class Upcase for printing strings to ostream with automatic conversion
  1751.  *
  1752.  * Revision 1.36  2000/12/11 20:42:50  vakatov
  1753.  * + NStr::PrintableString()
  1754.  *
  1755.  * Revision 1.35  2000/11/16 23:52:41  vakatov
  1756.  * Porting to Mac...
  1757.  *
  1758.  * Revision 1.34  2000/11/07 04:06:08  vakatov
  1759.  * kEmptyCStr (equiv. to NcbiEmptyCStr)
  1760.  *
  1761.  * Revision 1.33  2000/10/11 21:03:49  vakatov
  1762.  * Cleanup to avoid 64-bit to 32-bit values truncation, etc.
  1763.  * (reported by Forte6 Patch 109490-01)
  1764.  *
  1765.  * Revision 1.32  2000/08/03 20:21:29  golikov
  1766.  * Added predicate PCase for AStrEquiv
  1767.  * PNocase, PCase goes through NStr::Compare now
  1768.  *
  1769.  * Revision 1.31  2000/07/19 19:03:55  vakatov
  1770.  * StringToBool() -- short and case-insensitive versions of "true"/"false"
  1771.  * ToUpper/ToLower(string&) -- fixed
  1772.  *
  1773.  * Revision 1.30  2000/06/01 19:05:40  vasilche
  1774.  * NStr::StringToInt now reports errors for tailing symbols in release version
  1775.  * too
  1776.  *
  1777.  * Revision 1.29  2000/05/01 19:02:25  vasilche
  1778.  * Force argument in NStr::StringToInt() etc to be full number.
  1779.  * This check will be in DEBUG version for month.
  1780.  *
  1781.  * Revision 1.28  2000/04/19 18:36:04  vakatov
  1782.  * Fixed for non-zero "pos" in s_Compare()
  1783.  *
  1784.  * Revision 1.27  2000/04/17 04:15:08  vakatov
  1785.  * NStr::  extended Compare(), and allow case-insensitive string comparison
  1786.  * NStr::  added ToLower() and ToUpper()
  1787.  *
  1788.  * Revision 1.26  2000/04/04 22:28:09  vakatov
  1789.  * NStr::  added conversions for "long"
  1790.  *
  1791.  * Revision 1.25  2000/02/01 16:48:09  vakatov
  1792.  * CNcbiEmptyString::  more dancing around the Sun "feature" (see also R1.24)
  1793.  *
  1794.  * Revision 1.24  2000/01/20 16:24:42  vakatov
  1795.  * Kludging around the "NcbiEmptyString" to ensure its initialization when
  1796.  * it is used by the constructor of a statically allocated object
  1797.  * (I believe that it is actually just another Sun WorkShop compiler "feature")
  1798.  *
  1799.  * Revision 1.23  1999/12/28 18:55:43  vasilche
  1800.  * Reduced size of compiled object files:
  1801.  * 1. avoid inline or implicit virtual methods (especially destructors).
  1802.  * 2. avoid std::string's methods usage in inline methods.
  1803.  * 3. avoid string literals ("xxx") in inline methods.
  1804.  *
  1805.  * Revision 1.22  1999/12/17 19:04:09  vasilche
  1806.  * NcbiEmptyString made extern.
  1807.  *
  1808.  * Revision 1.21  1999/11/26 19:29:09  golikov
  1809.  * fix
  1810.  *
  1811.  * Revision 1.20  1999/11/26 18:45:17  golikov
  1812.  * NStr::Replace added
  1813.  *
  1814.  * Revision 1.19  1999/11/17 22:05:04  vakatov
  1815.  * [!HAVE_STRDUP]  Emulate "strdup()" -- it's missing on some platforms
  1816.  *
  1817.  * Revision 1.18  1999/10/13 16:30:30  vasilche
  1818.  * Fixed bug in PNocase which appears under GCC implementation of STL.
  1819.  *
  1820.  * Revision 1.17  1999/07/08 16:10:14  vakatov
  1821.  * Fixed a warning in NStr::StringToUInt()
  1822.  *
  1823.  * Revision 1.16  1999/07/06 15:21:06  vakatov
  1824.  * + NStr::TruncateSpaces(const string& str, ETrunc where=eTrunc_Both)
  1825.  *
  1826.  * Revision 1.15  1999/06/15 20:50:05  vakatov
  1827.  * NStr::  +BoolToString, +StringToBool
  1828.  *
  1829.  * Revision 1.14  1999/05/27 15:21:40  vakatov
  1830.  * Fixed all StringToXXX() functions
  1831.  *
  1832.  * Revision 1.13  1999/05/17 20:10:36  vasilche
  1833.  * Fixed bug in NStr::StringToUInt which cause an exception.
  1834.  *
  1835.  * Revision 1.12  1999/05/04 00:03:13  vakatov
  1836.  * Removed the redundant severity arg from macro ERR_POST()
  1837.  *
  1838.  * Revision 1.11  1999/04/22 14:19:04  vasilche
  1839.  * Added _TRACE_THROW() macro, which can be configured to produce coredump
  1840.  * at a point of throwing an exception.
  1841.  *
  1842.  * Revision 1.10  1999/04/14 21:20:33  vakatov
  1843.  * Dont use "snprintf()" as it is not quite portable yet
  1844.  *
  1845.  * Revision 1.9  1999/04/14 19:57:36  vakatov
  1846.  * Use limits from <ncbitype.h> rather than from <limits>.
  1847.  * [MSVC++]  fix for "snprintf()" in <ncbistd.hpp>.
  1848.  *
  1849.  * Revision 1.8  1999/04/09 19:51:37  sandomir
  1850.  * minor changes in NStr::StringToXXX - base added
  1851.  *
  1852.  * Revision 1.7  1999/01/21 16:18:04  sandomir
  1853.  * minor changes due to NStr namespace to contain string utility functions
  1854.  *
  1855.  * Revision 1.6  1999/01/11 22:05:50  vasilche
  1856.  * Fixed CHTML_font size.
  1857.  * Added CHTML_image input element.
  1858.  *
  1859.  * Revision 1.5  1998/12/28 17:56:39  vakatov
  1860.  * New CVS and development tree structure for the NCBI C++ projects
  1861.  *
  1862.  * Revision 1.4  1998/12/21 17:19:37  sandomir
  1863.  * VC++ fixes in ncbistd; minor fixes in Resource
  1864.  *
  1865.  * Revision 1.3  1998/12/17 21:50:45  sandomir
  1866.  * CNCBINode fixed in Resource; case insensitive string comparison predicate
  1867.  * added
  1868.  *
  1869.  * Revision 1.2  1998/12/15 17:36:33  vasilche
  1870.  * Fixed "double colon" bug in multithreaded version of headers.
  1871.  *
  1872.  * Revision 1.1  1998/12/15 15:43:22  vasilche
  1873.  * Added utilities to convert string <> int.
  1874.  * ===========================================================================
  1875.  */