stringex.cpp

This software performs code conversion of Chinese characters, including GB2312/GBK and BIG5. It a

// U+00乣U+FF 偺暥帤偵懳墳
wchar_t *wcsuprex ( wchar_t *string ) {

   for ( wchar_t *current = string ; *current ; current ++ ) {
      if ( *current >= 'a' && *current <= 'z' ) *current += 'A' - 'a' ;
      else if ( *current >= 0xE0 && *current <= 0xFE && *current != 0xF7 ) *current += 0xC0 - 0xE0 ;
   }

   return string ;
}



////////////////////////////////////////////
//               strrev ()                //
////////////////////////////////////////////



// 暥帤楍傪媡揮乮UTF16斉乯
wchar16_t *wcsrev16 ( wchar16_t *string ) {

   for ( wchar16_t *current = string ; *current ; current ++ ) {
      if ( IsHighSurrogate ( *current ) ) {
         if ( *( current + 1 ) ) {
            int c = *( current + 1 ) ;
            *( current + 1 ) = *current ;
            *current = c ;
            current ++ ;
            continue ;
         }
         else {
            *current = 0 ;
            break ;
         }
      }
   }

   return wcsrev ( string ) ;
}



// 暥帤楍傪媡揮乮UTF32斉乯
wchar32_t *wcsrev32 ( wchar32_t *string ) {

   wchar32_t *start = string ;
   wchar32_t *left = string ;

   while ( *string ++ ) ;
   string -= 2 ;

   while ( left < string ) {
      int c = *left ;
      *left ++ = *string ;
      *string -- = c ;
   }

   return start ;
}



// 暥帤楍傪媡揮乮MULTIBYTE斉乯
char *mbsrev ( char *string ) {

   for ( char *current = string ; *current ; current ++ ) {
      if ( ismbblead ( (unsigned char) *current ) ) {
         if ( *( current + 1 ) ) {
            int c = *( current + 1 ) ;
            *( current + 1 ) = *current ;
            *current = c ;
            current ++ ;
            continue ;
         }
         else {
            *current = 0 ;
            break ;
         }
      }
   }

   return strrev ( string ) ;
}



////////////////////////////////////////////
//               strtrunc ()              //
////////////////////////////////////////////



// 暥帤楍傪抁弅乮ANSI斉乯
// len 偼嵟戝帤悢乮廔抂僰儖暥帤傪娷傑側偄乯
char *strtrunc ( char *string, size_t len ) {

   char *end = string + len ;

   for ( char *current = string ; *current ; current ++ ) {
      if ( current >= end ) {
         *current = 0 ;
         break ;
      }
   }

   return string ;
}



// 暥帤楍傪抁弅乮UNICODE斉乯
// len 偼嵟戝帤悢乮廔抂僰儖暥帤傪娷傑側偄乯
wchar_t *wcstrunc ( wchar_t *string, size_t len ) {

   wchar_t *end = string + len ;

   for ( wchar_t *current = string ; *current ; current ++ ) {
      if ( current >= end ) {
         *current = 0 ;
         break ;
      }
   }

   return string ;
}



// 暥帤楍傪抁弅乮UTF16斉乯
// len 偼嵟戝帤悢乮廔抂僰儖暥帤傪娷傑側偄乯
wchar16_t *wcstrunc16 ( wchar16_t *string, size_t len ) {

   wchar16_t *end = string + len ;

   for ( wchar16_t *current = string ; *current ; current ++ ) {
      if ( IsHighSurrogate ( *current ) && current + 1 >= end ) {
         *current = 0 ;
         break ;
      }
      if ( current >= end ) {
         *current = 0 ;
         break ;
      }
   }

   return string ;
}



// 暥帤楍傪抁弅乮UTF32斉乯
// len 偼嵟戝帤悢乮廔抂僰儖暥帤傪娷傑側偄乯
wchar32_t *wcstrunc32 ( wchar32_t *string, size_t len ) {

   wchar32_t *end = string + len ;

   for ( wchar32_t *current = string ; *current ; current ++ ) {
      if ( current >= end ) {
         *current = 0 ;
         break ;
      }
   }

   return string ;
}



// 暥帤楍傪抁弅乮MULTIBYTE斉乯
// len 偼嵟戝帤悢乮廔抂僰儖暥帤傪娷傑側偄乯
char *mbstrunc ( char *string, size_t len ) {

   char *end = string + len ;

   for ( char *current = string ; *current ; current ++ ) {
      if ( ismbblead ( (unsigned char) *current ) ) {
         if ( current >= end - 1 || ! *( current + 1 ) ) {
            *current = 0 ;
            break ;
         }
         current ++ ;
      }
      else {
         if ( current >= end ) {
            *current = 0 ;
            break ;
         }
      }
   }

   return string ;
}



////////////////////////////////////////////
//                strlen ()               //
////////////////////////////////////////////



// 暥帤悢傪曉偡乮UTF32斉乯
size_t wcslen32 ( const wchar32_t *string ) {

   size_t n ;

   for ( n = 0 ; *string ; n ++, string ++ ) ;

   return n ;
}



// 暥帤悢傪曉偡乮MULTIBYTE斉乯
// 俀僶僀僩暥帤偼侾暥帤偲偟偰悢偊傞
size_t mbslen ( const char *string ) {

   size_t n ;

   for ( n = 0 ; *string ; n ++, string ++ ) {
      if ( ismbblead ( (unsigned char) *string ) && *( string + 1 ) ) string ++ ;
   }

   return n ;
}



////////////////////////////////////////////
//                strdup ()               //
////////////////////////////////////////////



// 暥帤楍傪暋惢偡傞乮UTF32斉乯
wchar32_t *wcsdup32 ( const wchar32_t *string ) {

   size_t len = wcslen32 ( string ) ;

   wchar32_t *buffer = (wchar32_t*) malloc ( ( len + 1 ) * sizeof(wchar32_t) ) ;
   if ( buffer ) wcscpy32 ( buffer, string ) ;

   return buffer ;
}



////////////////////////////////////////////
//            strdup_expand ()            //
////////////////////////////////////////////



// 嵟戝挿傪巜掕偟偰暥帤傪暋惢偡傞乮UTF32斉乯
// string 偺挿偝偑 maxlen 埲忋側傜 NULL 傪曉偡
// 巜掕偝傟偨挿偝傪梋暘偵妋曐偡傞
wchar32_t *wcsdup_expand32 ( const wchar32_t *string, size_t maxlen, size_t addlen ) {

   size_t len = wcslen32 ( string ) ;
   if ( len >= maxlen ) return NULL ;

   wchar32_t *buffer = (wchar32_t*) malloc ( ( len + addlen + 1 ) * sizeof(wchar32_t) ) ;
   if ( buffer ) wcscpy32 ( buffer, string ) ;

   return buffer ;
}



////////////////////////////////////////////
//               strldup ()               //
////////////////////////////////////////////



// 巜掕偝傟偨挿偝傑偱暥帤楍傪暋惢偡傞乮ANSI斉乯
// bufsiz 偼怴偟偄暥帤楍偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
char *strldup ( const char *string, size_t bufsiz ) {

   size_t len = strlen ( string ) ;
   if ( len >= bufsiz ) len = bufsiz - 1 ;

   char *buffer = (char*) malloc ( ( len + 1 ) * sizeof(char) ) ;
   if ( buffer ) {
      memmove ( buffer, string, len * sizeof(char) ) ;
      buffer [ len ] = 0 ;
   }

   return buffer ;
}



// 巜掕偝傟偨挿偝傑偱暥帤楍傪暋惢偡傞乮UNICODE斉乯
// bufsiz 偼怴偟偄暥帤楍偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
wchar_t *wcsldup ( const wchar_t *string, size_t bufsiz ) {

   size_t len = wcslen ( string ) ;
   if ( len >= bufsiz ) len = bufsiz - 1 ;

   wchar_t *buffer = (wchar_t*) malloc ( ( len + 1 ) * sizeof(wchar_t) ) ;
   if ( buffer ) {
      memmove ( buffer, string, len * sizeof(wchar_t) ) ;
      buffer [ len ] = 0 ;
   }

   return buffer ;
}



// 巜掕偝傟偨挿偝傑偱暥帤楍傪暋惢偡傞乮UTF16斉乯
// bufsiz 偼怴偟偄暥帤楍偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
wchar16_t *wcsldup16 ( const wchar16_t *string, size_t bufsiz ) {

   size_t len = wcslen16 ( string ) ;
   if ( len >= bufsiz ) len = bufsiz - 1 ;

   wchar16_t *buffer = (wchar16_t*) malloc ( ( len + 1 ) * sizeof(wchar16_t) ) ;
   if ( buffer ) {
      memmove ( buffer, string, len * sizeof(wchar16_t) ) ;
      wcstrunc16 ( buffer, len ) ;
   }

   return buffer ;
}



// 巜掕偝傟偨挿偝傑偱暥帤楍傪暋惢偡傞乮UTF32斉乯
// bufsiz 偼怴偟偄暥帤楍偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
wchar32_t *wcsldup32 ( const wchar32_t *string, size_t bufsiz ) {

   size_t len = wcslen32 ( string ) ;
   if ( len >= bufsiz ) len = bufsiz - 1 ;

   wchar32_t *buffer = (wchar32_t*) malloc ( ( len + 1 ) * sizeof(wchar32_t) ) ;
   if ( buffer ) {
      memmove ( buffer, string, len * sizeof(wchar32_t) ) ;
      buffer [ len ] = 0 ;
   }

   return buffer ;
}



// 巜掕偝傟偨挿偝傑偱暥帤楍傪暋惢偡傞乮MULTIBYTE斉乯
// bufsiz 偼怴偟偄暥帤楍偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
char *mbsldup ( const char *string, size_t bufsiz ) {

   size_t len = strlen ( string ) ;
   if ( len >= bufsiz ) len = bufsiz - 1 ;

   char *buffer = (char*) malloc ( ( len + 1 ) * sizeof(char) ) ;
   if ( buffer ) {
      memmove ( buffer, string, len * sizeof(char) ) ;
      mbstrunc ( buffer, len ) ;
   }

   return buffer ;
}



////////////////////////////////////////////
//               mbsbtype ()              //
////////////////////////////////////////////



// 儅儖僠僶僀僩暥帤傪敾掕
int mbsbtype ( const char *string, size_t count ) {

   int isprevlead = 0 ;

   for ( const char *current = string ; *current ; current ++ ) {
      if ( size_t ( current - string ) == count ) {
         if ( isprevlead ) {
            if ( ismbbtrail ( (unsigned char) *current ) ) return _MBC_TRAIL ;
            else                                           return _MBC_ILLEGAL ;
         }
         else {
            if ( ismbblead ( (unsigned char) *current ) ) return _MBC_LEAD ;
            else if ( *current )                          return _MBC_SINGLE ;
            else                                          return _MBC_ILLEGAL ;
         }
      }
      if ( ! isprevlead && ismbblead ( (unsigned char) *current ) ) isprevlead = 1 ;
      else                                                          isprevlead = 0 ;
   }

   return _MBC_ILLEGAL ;
}



// 儅儖僠僶僀僩暥帤傪敾掕
int ismbslead ( const char *string, const char *current ) {
   if ( mbsbtype ( string, current - string ) == _MBC_LEAD ) return -1 ;
   return 0 ;
}



// 儅儖僠僶僀僩暥帤傪敾掕
int ismbstrail ( const char *string, const char *current ) {
   if ( mbsbtype ( string, current - string ) == _MBC_TRAIL ) return -1 ;
   return 0 ;
}



////////////////////////////////////////////
//               strtokex ()              //
////////////////////////////////////////////



// 暥帤楍傪嬻敀暥帤偱愗傝暘偗傞乮ANSI斉乯
// 擇廳堷梡晞傪擣幆偡傞
// 愭摢偺嬻敀偼撉傒旘偽偡
// next 偼 NULL 偱傕壜
// 愗傝暘偗偨暥帤楍傪曉偡
// 暥帤楍偺廔抂偵払偟偨傜 NULL 傪曉偡
// next 偑暥帤楍偺廔抂偵払偟偨傜廔抂偺傾僪儗僗傪奿擺偡傞
char *strtokex ( char *string, char **next ) {

   if ( ! string ) {
      if ( next ) *next = string ;
      return NULL ;
   }

   while ( *string && isascii ( *string ) && isspace ( *string ) ) string ++ ;
   if ( ! *string ) {
      if ( next ) *next = string ;
      return NULL ;
   }

   int mode = 0 ;
   size_t countquote = 0 ;
   char *start ;

   for ( start = string ; *string ; string ++ ) {
      if ( *string == '\"' ) {
         mode = ! mode ;
         if ( string == start ) start ++ ;
         else                   countquote ++ ;
      }
      if ( ! mode && isascii ( *string ) && isspace ( *string ) ) break ;
   }

   if ( *string ) { if ( next ) *next = string + 1 ; }
   else           { if ( next ) *next = string ; }
   *string = 0 ;

   for ( string = start ; *string && countquote ; string ++ ) {
      if ( *string == '\"' ) {
         memmove ( string, string + 1, ( strlen ( string + 1 ) + 1 ) * sizeof(char) ) ;
         string -- ;
         countquote -- ;
      }
   }

   return start ;
}



// 暥帤楍傪嬻敀暥帤偱愗傝暘偗傞乮UNICODE斉乯
// 擇廳堷梡晞傪擣幆偡傞
// 愭摢偺嬻敀偼撉傒旘偽偡
// next 偼 NULL 偱傕壜
// 愗傝暘偗偨暥帤楍傪曉偡
// 暥帤楍偺廔抂偵払偟偨傜 NULL 傪曉偡
// next 偑暥帤楍偺廔抂偵払偟偨傜廔抂偺傾僪儗僗傪奿擺偡傞
wchar_t *wcstokex ( wchar_t *string, wchar_t **next ) {

   if ( ! string ) {
      if ( next ) *next = string ;
      return NULL ;
   }

   while ( *string && isascii ( *string ) && isspace ( *string ) ) string ++ ;
   if ( ! *string ) {
      if ( next ) *next = string ;
      return NULL ;
   }

   int mode = 0 ;
   size_t countquote = 0 ;
   wchar_t *start ;

   for ( start = string ; *string ; string ++ ) {
      if ( *string == '\"' ) {
         mode = ! mode ;
         if ( string == start ) start ++ ;
         else