stringex.cpp

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

// stringex.cpp

#include <windows.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <mbctype.h>
#include <limits.h>
#include <errno.h>
#include "msc.h"

#undef DEBUG_CONST_STRING
#include "stringex.h"



////////////////////////////////////////////
//               strend ()                //
////////////////////////////////////////////



// 暥帤楍偺廔抂傪曉偡乮UTF32斉乯
wchar32_t *wcsend32 ( const wchar32_t *string ) {

   while ( *string ) string ++ ;

   return (wchar32_t*) string ;
}



////////////////////////////////////////////
//               strcpy ()                //
////////////////////////////////////////////



// 暥帤楍傪僐僺乕偡傞乮UTF32斉乯
wchar32_t *wcscpy32 ( wchar32_t *dst, const wchar32_t *src ) {

   wchar32_t *p = dst ;
   while ( *p ++ = *src ++ ) ;

   return dst ;
}



////////////////////////////////////////////
//               strcat ()                //
////////////////////////////////////////////



// 暥帤楍傪楢寢偡傞乮UTF32斉乯
wchar32_t *wcscat32 ( wchar32_t *dst, const wchar32_t *src ) {

   wchar32_t *p = dst ;
   while ( *p ) p ++ ;
   while ( *p ++ = *src ++ ) ;

   return dst ;
}



////////////////////////////////////////////
//               strlcpy ()               //
////////////////////////////////////////////



// 巜掕偝傟偨挿偝傑偱暥帤楍傪僐僺乕偡傞乮ANSI斉乯
// bufsiz 偼 dst 偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
// src 偺暥帤悢傪曉偡乮廔抂僰儖暥帤傪娷傑側偄乯
size_t strlcpy ( char *dst, const char *src, size_t bufsiz ) {

   size_t srclen = strlen ( src ) ;

   if ( bufsiz ) {
      size_t cpylen = ( srclen < bufsiz ) ? srclen : bufsiz - 1 ;
      memmove ( dst, src, cpylen * sizeof(char) ) ;
      dst [ cpylen ] = 0 ;
   }

   return srclen ;
}



// 巜掕偝傟偨挿偝傑偱暥帤楍傪僐僺乕偡傞乮UNICODE斉乯
// bufsiz 偼 dst 偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
// src 偺暥帤悢傪曉偡乮廔抂僰儖暥帤傪娷傑側偄乯
size_t wcslcpy ( wchar_t *dst, const wchar_t *src, size_t bufsiz ) {

   size_t srclen = wcslen ( src ) ;

   if ( bufsiz ) {
      size_t cpylen = ( srclen < bufsiz ) ? srclen : bufsiz - 1 ;
      memmove ( dst, src, cpylen * sizeof(wchar_t) ) ;
      dst [ cpylen ] = 0 ;
   }

   return srclen ;
}



// 巜掕偝傟偨挿偝傑偱暥帤楍傪僐僺乕偡傞乮UTF16斉乯
// bufsiz 偼 dst 偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
// src 偺暥帤悢傪曉偡乮廔抂僰儖暥帤傪娷傑側偄乯
size_t wcslcpy16 ( wchar16_t *dst, const wchar16_t *src, size_t bufsiz ) {

   size_t srclen = wcslen16 ( src ) ;

   if ( bufsiz ) {
      size_t cpylen = ( srclen < bufsiz ) ? srclen : bufsiz - 1 ;
      memmove ( dst, src, cpylen * sizeof(wchar16_t) ) ;
      wcstrunc16 ( dst, cpylen ) ;
   }

   return srclen ;
}



// 巜掕偝傟偨挿偝傑偱暥帤楍傪僐僺乕偡傞乮UTF32斉乯
// bufsiz 偼 dst 偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
// src 偺暥帤悢傪曉偡乮廔抂僰儖暥帤傪娷傑側偄乯
size_t wcslcpy32 ( wchar32_t *dst, const wchar32_t *src, size_t bufsiz ) {

   size_t srclen = wcslen32 ( src ) ;

   if ( bufsiz ) {
      size_t cpylen = ( srclen < bufsiz ) ? srclen : bufsiz - 1 ;
      memmove ( dst, src, cpylen * sizeof(wchar32_t) ) ;
      dst [ cpylen ] = 0 ;
   }

   return srclen ;
}



// 巜掕偝傟偨挿偝傑偱暥帤楍傪僐僺乕偡傞乮MULTIBYTE斉乯
// bufsiz 偼 dst 偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
// src 偺暥帤悢傪曉偡乮廔抂僰儖暥帤傪娷傑側偄乯
size_t mbslcpy ( char *dst, const char *src, size_t bufsiz ) {

   size_t srclen = strlen ( src ) ;

   if ( bufsiz ) {
      size_t cpylen = ( srclen < bufsiz ) ? srclen : bufsiz - 1 ;
      memmove ( dst, src, cpylen * sizeof(char) ) ;
      mbstrunc ( dst, cpylen ) ;
   }

   return srclen ;
}



////////////////////////////////////////////
//               strlcat ()               //
////////////////////////////////////////////



// 巜掕偝傟偨挿偝傑偱暥帤楍傪楢寢偡傞乮ANSI斉乯
// bufsiz 偼 dst 偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
// src 偲 dst 偺暥帤悢偺崌寁傪曉偡乮廔抂僰儖暥帤傪娷傑側偄乯
size_t strlcat ( char *dst, const char *src, size_t bufsiz ) {

   size_t srclen = strlen ( src ) ;
   size_t dstlen = strlen ( dst ) ;

   if ( bufsiz > dstlen ) {
      size_t cpylen = ( srclen < bufsiz - dstlen ) ? srclen : bufsiz - dstlen - 1 ;
      memmove ( dst + dstlen, src, cpylen * sizeof(char) ) ;
      ( dst + dstlen ) [ cpylen ] = 0 ;
   }

   return srclen + dstlen ;
}



// 巜掕偝傟偨挿偝傑偱暥帤楍傪楢寢偡傞乮UNICODE斉乯
// bufsiz 偼 dst 偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
// src 偲 dst 偺暥帤悢偺崌寁傪曉偡乮廔抂僰儖暥帤傪娷傑側偄乯
size_t wcslcat ( wchar_t *dst, const wchar_t *src, size_t bufsiz ) {

   size_t srclen = wcslen ( src ) ;
   size_t dstlen = wcslen ( dst ) ;

   if ( bufsiz > dstlen ) {
      size_t cpylen = ( srclen < bufsiz - dstlen ) ? srclen : bufsiz - dstlen - 1 ;
      memmove ( dst + dstlen, src, cpylen * sizeof(wchar_t) ) ;
      ( dst + dstlen ) [ cpylen ] = 0 ;
   }

   return srclen + dstlen ;
}



// 巜掕偝傟偨挿偝傑偱暥帤楍傪楢寢偡傞乮UTF16斉乯
// bufsiz 偼 dst 偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
// src 偲 dst 偺暥帤悢偺崌寁傪曉偡乮廔抂僰儖暥帤傪娷傑側偄乯
size_t wcslcat16 ( wchar16_t *dst, const wchar16_t *src, size_t bufsiz ) {

   size_t srclen = wcslen16 ( src ) ;
   size_t dstlen = wcslen16 ( dst ) ;

   if ( bufsiz > dstlen ) {
      size_t cpylen = ( srclen < bufsiz - dstlen ) ? srclen : bufsiz - dstlen - 1 ;
      memmove ( dst + dstlen, src, cpylen * sizeof(wchar16_t) ) ;
      wcstrunc16 ( dst, dstlen + cpylen ) ;
   }

   return srclen + dstlen ;
}



// 巜掕偝傟偨挿偝傑偱暥帤楍傪楢寢偡傞乮UTF32斉乯
// bufsiz 偼 dst 偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
// src 偲 dst 偺暥帤悢偺崌寁傪曉偡乮廔抂僰儖暥帤傪娷傑側偄乯
size_t wcslcat32 ( wchar32_t *dst, const wchar32_t *src, size_t bufsiz ) {

   size_t srclen = wcslen32 ( src ) ;
   size_t dstlen = wcslen32 ( dst ) ;

   if ( bufsiz > dstlen ) {
      size_t cpylen = ( srclen < bufsiz - dstlen ) ? srclen : bufsiz - dstlen - 1 ;
      memmove ( dst + dstlen, src, cpylen * sizeof(wchar32_t) ) ;
      ( dst + dstlen ) [ cpylen ] = 0 ;
   }

   return srclen + dstlen ;
}



// 巜掕偝傟偨挿偝傑偱暥帤楍傪楢寢偡傞乮MULTIBYTE斉乯
// bufsiz 偼 dst 偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
// src 偲 dst 偺暥帤悢偺崌寁傪曉偡乮廔抂僰儖暥帤傪娷傑側偄乯
size_t mbslcat ( char *dst, const char *src, size_t bufsiz ) {

   size_t srclen = strlen ( src ) ;
   size_t dstlen = strlen ( dst ) ;

   if ( bufsiz > dstlen ) {
      size_t cpylen = ( srclen < bufsiz - dstlen ) ? srclen : bufsiz - dstlen - 1 ;
      memmove ( dst + dstlen, src, cpylen * sizeof(char) ) ;
      mbstrunc ( dst, dstlen + cpylen ) ;
   }

   return srclen + dstlen ;
}



////////////////////////////////////////////
//               strmove ()               //
////////////////////////////////////////////



// 暥帤楍傪僐僺乕偡傞乮ANSI斉乯
// src 偲 dst 偺椞堟偑廳側偭偰偄偰傕壜
char *strmove ( char *dst, const char *src ) {

   return (char*) memmove ( dst, src, ( strlen ( src ) + 1 ) * sizeof(char) ) ;
}



// 暥帤楍傪僐僺乕偡傞乮UNICODE斉乯
// src 偲 dst 偺椞堟偑廳側偭偰偄偰傕壜
wchar_t *wcsmove ( wchar_t *dst, const wchar_t *src ) {

   return (wchar_t*) memmove ( dst, src, ( wcslen ( src ) + 1 ) * sizeof(wchar_t) ) ;
}



// 暥帤楍傪僐僺乕偡傞乮UTF32斉乯
// src 偲 dst 偺椞堟偑廳側偭偰偄偰傕壜
wchar32_t *wcsmove32 ( wchar32_t *dst, const wchar32_t *src ) {

   return (wchar32_t*) memmove ( dst, src, ( wcslen32 ( src ) + 1 ) * sizeof(wchar32_t) ) ;
}



////////////////////////////////////////////
//              strinsert ()              //
////////////////////////////////////////////



// 暥帤楍傪憓擖乮ANSI斉乯
// 憓擖偟偨暥帤楍偺枛旜偺傾僪儗僗傪曉偡
char *strinsert ( char *dst, const char *src ) {

   size_t srclen = strlen ( src ) ;

   memmove ( dst + srclen, dst, ( strlen ( dst ) + 1 ) * sizeof(char) ) ;
   memmove ( dst, src, srclen * sizeof(char) ) ;

   return dst + srclen ;
}



// 暥帤楍傪憓擖乮UNICODE斉乯
// 憓擖偟偨暥帤楍偺枛旜偺傾僪儗僗傪曉偡
wchar_t *wcsinsert ( wchar_t *dst, const wchar_t *src ) {

   size_t srclen = wcslen ( src ) ;

   memmove ( dst + srclen, dst, ( wcslen ( dst ) + 1 ) * sizeof(wchar_t) ) ;
   memmove ( dst, src, srclen * sizeof(wchar_t) ) ;

   return dst + srclen ;
}



// 暥帤楍傪憓擖乮UTF32斉乯
// 憓擖偟偨暥帤楍偺枛旜偺傾僪儗僗傪曉偡
wchar32_t *wcsinsert32 ( wchar32_t *dst, const wchar32_t *src ) {

   size_t srclen = wcslen32 ( src ) ;

   memmove ( dst + srclen, dst, ( wcslen32 ( dst ) + 1 ) * sizeof(wchar32_t) ) ;
   memmove ( dst, src, srclen * sizeof(wchar32_t) ) ;

   return dst + srclen ;
}



////////////////////////////////////////////
//               strlset ()               //
////////////////////////////////////////////



// 僶僢僼傽傪暥帤偱杽傔傞乮ANSI斉乯
// bufsiz 偼 dst 偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
// 暥帤楍偺嵟屻偵偼僰儖暥帤傪晅壛
char *strlset ( char *dst, int c, size_t bufsiz ) {

   char *start = dst ;
   char *end = dst + bufsiz - 1 ;

   if ( bufsiz ) {
      while ( dst < end ) *dst ++ = c ;
      *dst = 0 ;
   }

   return start ;
}



// 僶僢僼傽傪暥帤偱杽傔傞乮UNICODE斉乯
// bufsiz 偼 dst 偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
// 暥帤楍偺嵟屻偵偼僰儖暥帤傪晅壛
wchar_t *wcslset ( wchar_t *dst, int c, size_t bufsiz ) {

   wchar_t *start = dst ;
   wchar_t *end = dst + bufsiz - 1 ;

   if ( bufsiz ) {
      while ( dst < end ) *dst ++ = c ;
      *dst = 0 ;
   }

   return start ;
}



// 僶僢僼傽傪暥帤偱杽傔傞乮UTF32斉乯
// bufsiz 偼 dst 偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
// 暥帤楍偺嵟屻偵偼僰儖暥帤傪晅壛
wchar32_t *wcslset32 ( wchar32_t *dst, int c, size_t bufsiz ) {

   wchar32_t *start = dst ;
   wchar32_t *end = dst + bufsiz - 1 ;

   if ( bufsiz ) {
      while ( dst < end ) *dst ++ = c ;
      *dst = 0 ;
   }

   return start ;
}



// 僶僢僼傽傪暥帤偱杽傔傞乮MULTIBYTE斉乯
// bufsiz 偼 dst 偵廂傔傞偙偲偺偱偒傞嵟戝偺暥帤悢乮廔抂僰儖暥帤傪娷傓乯
// 暥帤楍偺嵟屻偵偼僰儖暥帤傪晅壛
char *mbslset ( char *dst, int c, size_t bufsiz ) {

   char *start = dst ;
   char *end = dst + bufsiz - 1 ;

   if ( bufsiz ) {
      if ( c < 0x100 ) {
         while ( dst < end ) *dst ++ = c ;
         *dst = 0 ;
      }
      else {
         while ( dst < end - 1 ) {
            *dst ++ = ( c >> 8 ) & 0xFF ;
            *dst ++ = c & 0xFF ;
         }
         *dst = 0 ;
      }
   }

   return start ;
}



////////////////////////////////////////////
//               strcmp ()                //
////////////////////////////////////////////



// 暥帤楍傪斾妑乮UTF32斉乯
int wcscmp32 ( const wchar32_t *string1, const wchar32_t *string2 ) {
   return wcsnicmp32 ( string1, string2, SIZE_MAX ) ;
}



////////////////////////////////////////////
//               strncmp ()               //
////////////////////////////////////////////



// 暥帤楍偺 count 暥帤傪斾妑乮UTF32斉乯
int wcsncmp32 ( const wchar32_t *string1, const wchar32_t *string2, size_t count ) {

   int c1, c2 ;

   while ( 1 ) {
      if ( ! count ) return 0 ;
      c1 = *string1 ;
      c2 = *string2 ;
      if ( ! c1 || c1 != c2 ) break ;
      string1 ++ ;
      string2 ++ ;
      count -- ;
   }

   return c1 - c2 ;
}



////////////////////////////////////////////
//               stricmp ()               //
////////////////////////////////////////////



// 暥帤楍傪 ignore case 偱斾妑乮ANSI斉乯
int stricmp ( const char *string1, const char *string2 ) {
   return strnicmp ( string1, string2, SIZE_MAX ) ;
}



// 暥帤楍傪 ignore case 偱斾妑乮UNICODE斉乯
int wcsicmp ( const wchar_t *string1, const wchar_t *string2 ) {
   return wcsnicmp ( string1, string2, SIZE_MAX ) ;
}



// 暥帤楍傪 ignore case 偱斾妑乮UTF32斉乯
int wcsicmp32 ( const wchar32_t *string1, const wchar32_t *string2 ) {
   return wcsnicmp32 ( string1, string2, SIZE_MAX ) ;
}



// 暥帤楍傪 ignore case 偱斾妑乮MULTIBYTE斉乯
int mbsicmp ( const char *string1, const char *string2 ) {
   return mbsnicmp ( string1, string2, SIZE_MAX ) ;
}