tchar.h

希望我上传的这些东西可以对搞编程的程序员有点小小的帮助！谢谢！

#define _tcsnicmp       _mbsnbicmp
#define _tcsnccmp       _mbsncmp
#define _tcsncicmp      _mbsnicmp

/* todo : correct the mapping of these functions and add the new functions */
#define _tcscoll        _mbscoll
#define _tcsncoll       _mbsnbcoll
#define _tcsnccoll      _mbsncoll
#define _tcsicoll       _mbsicoll
#define _tcsnicoll      _mbsnbicoll
#define _tcsncicoll     _mbsnicoll

/* @: logical-character functions */

#define _tcsclen        _mbslen
#define _tcsnccat       _mbsncat
#define _tcsnccpy       _mbsncpy
#define _tcsncset       _mbsnset

/* @: misc. functions */

#define _tcsdec         _mbsdec
#define _tcsinc         _mbsinc
#define _tcsnbcnt       _mbsnbcnt
#define _tcsnccnt       _mbsnccnt
#define _tcsnextc       _mbsnextc
#define _tcsninc        _mbsninc
#define _tcsspnp        _mbsspnp

#define _tcslwr         _mbslwr
#define _tcsupr         _mbsupr

#define _tclen          _mbclen
#define _tccpy          _mbccpy

/* @!(_tccmp,_mbsncmp) */
/* @- */
#define _tccmp(__a,__b) _mbsncmp(__a,__b,1)

#else /* _MBC_USE_MACROS */

#if (!defined ( __cplusplus) || defined( _NO_INLINING ))

/* String functions */

char * _RTLENTRY  _EXPFUNC _tcschr(const char *, unsigned int);
_SIZE_T _RTLENTRY  _EXPFUNC _tcscspn(const char *, const char *);
char * _RTLENTRY  _EXPFUNC _tcsncat(char *, const char *, _SIZE_T);
char * _RTLENTRY  _EXPFUNC _tcsncpy(char *, const char *, _SIZE_T);
char * _RTLENTRY  _EXPFUNC _tcspbrk(const char *, const char *);
char * _RTLENTRY  _EXPFUNC _tcsrchr(const char *, int);
_SIZE_T _RTLENTRY  _EXPFUNC _tcsspn(const char *, const char *);
char * _RTLENTRY  _EXPFUNC _tcsstr(const char *, const char *);
char * _RTLENTRY  _EXPFUNC _tcstok(char *, const char *);

char * _RTLENTRY  _EXPFUNC _tcsnset(char *, unsigned int, _SIZE_T);
char * _RTLENTRY  _EXPFUNC _tcsrev(char *);
char * _RTLENTRY  _EXPFUNC _tcsset(char *, unsigned int);

int _RTLENTRY  _EXPFUNC _tcscmp(const char *, const char *);
int _RTLENTRY  _EXPFUNC _tcsicmp(const char *, const char *);
int _RTLENTRY  _EXPFUNC _tcsnccmp(const char *, const char *, _SIZE_T);
int _RTLENTRY  _EXPFUNC _tcsncmp(const char *, const char *, _SIZE_T);
int _RTLENTRY  _EXPFUNC _tcsncicmp(const char *, const char *, _SIZE_T);
int _RTLENTRY  _EXPFUNC _tcsnicmp(const char *, const char *, _SIZE_T);

int _RTLENTRY  _EXPFUNC _tcscoll(const char *, const char *);
int _RTLENTRY  _EXPFUNC _tcsicoll(const char *, const char *);
int _RTLENTRY  _EXPFUNC _tcsnccoll(const char *, const char *, _SIZE_T);
int _RTLENTRY  _EXPFUNC _tcsncoll(const char *, const char *, _SIZE_T);
int _RTLENTRY  _EXPFUNC _tcsncicoll(const char *, const char *, _SIZE_T);
int _RTLENTRY  _EXPFUNC _tcsnicoll(const char *, const char *, _SIZE_T);


/* "logical-character" functions */

_SIZE_T _RTLENTRY  _EXPFUNC _tcsclen(const char *);
char * _RTLENTRY  _EXPFUNC _tcsnccat(char *, const char *, _SIZE_T);
char * _RTLENTRY  _EXPFUNC _tcsnccpy(char *, const char *, _SIZE_T);
char * _RTLENTRY  _EXPFUNC _tcsncset(char *, unsigned int, _SIZE_T);


/* MBCS-specific functions */

char * _RTLENTRY  _EXPFUNC _tcsdec(const char *, const char *);
char * _RTLENTRY  _EXPFUNC _tcsinc(const char *);
_SIZE_T _RTLENTRY  _EXPFUNC _tcsnbcnt(const char *, _SIZE_T);
_SIZE_T _RTLENTRY  _EXPFUNC _tcsnccnt(const char *, _SIZE_T);
unsigned int _RTLENTRY  _EXPFUNC _tcsnextc (const char *);
char * _RTLENTRY  _EXPFUNC _tcsninc(const char *, _SIZE_T);
char * _RTLENTRY  _EXPFUNC _tcsspnp(const char *, const char *);

char * _RTLENTRY  _EXPFUNC _tcslwr(char *);
char * _RTLENTRY  _EXPFUNC _tcsupr(char *);

_SIZE_T _RTLENTRY  _EXPFUNC _tclen(const char *);
void   _RTLENTRY  _EXPFUNC _tccpy(char *, const char *);
int    _RTLENTRY  _EXPFUNC _tccmp(const char *, const char *);

#else  /* (!defined( __cplusplus) || defined( _NO_INLINING )) */

inline char * _tcschr(const char * __s1,unsigned int __c) {return (char *)_mbschr((const unsigned char *)__s1,__c);}
inline _SIZE_T _tcscspn(const char * __s1,const char * __s2) {return _mbscspn((const unsigned char *)__s1,(const unsigned char *)__s2);}
inline char * _tcsncat(char * __s1,const char * __s2,_SIZE_T __n) {return (char *)_mbsnbcat((unsigned char *)__s1,(const unsigned char *)__s2,__n);}
inline char * _tcsncpy(char * __s1,const char * __s2,_SIZE_T __n) {return (char *)_mbsnbcpy((unsigned char *)__s1,(const unsigned char *)__s2,__n);}
inline char * _tcspbrk(const char * __s1,const char * __s2) {return (char *)_mbspbrk((const unsigned char *)__s1,(const unsigned char *)__s2);}
inline char * _tcsrchr(const char * __s1,unsigned int __c) {return (char *)_mbsrchr((const unsigned char *)__s1,__c);}
inline _SIZE_T _tcsspn(const char * __s1,const char * __s2) {return _mbsspn((const unsigned char *)__s1,(const unsigned char *)__s2);}
inline char * _tcsstr(const char * __s1,const char * __s2) {return (char *)_mbsstr((const unsigned char *)__s1,(const unsigned char *)__s2);}
inline char * _tcstok(char * __s1,const char * __s2) {return (char *)_mbstok((unsigned char *)__s1,(const unsigned char *)__s2);}

inline char * _tcsnset(char * __s1,unsigned int __c,_SIZE_T __n) {return (char *)_mbsnbset((unsigned char *)__s1,__c,__n);}
inline char * _tcsrev(char * __s1) {return (char *)_mbsrev((unsigned char *)__s1);}
inline char * _tcsset(char * __s1,unsigned int __c) {return (char *)_mbsset((unsigned char *)__s1,__c);}

inline int _tcscmp(const char * __s1,const char * __s2) {return _mbscmp((const unsigned char *)__s1,(const unsigned char *)__s2);}
inline int _tcsicmp(const char * __s1,const char * __s2) {return _mbsicmp((const unsigned char *)__s1,(const unsigned char *)__s2);}
inline int _tcsnccmp(const char * __s1,const char * __s2,_SIZE_T __n) {return _mbsncmp((const unsigned char *)__s1,(const unsigned char *)__s2,__n);}
inline int _tcsncmp(const char * __s1,const char * __s2,_SIZE_T __n) {return _mbsnbcmp((const unsigned char *)__s1,(const unsigned char *)__s2,__n);}
inline int _tcsncicmp(const char * __s1,const char * __s2,_SIZE_T __n) {return _mbsnicmp((const unsigned char *)__s1,(const unsigned char *)__s2,__n);}
inline int _tcsnicmp(const char * __s1,const char * __s2,_SIZE_T __n) {return _mbsnbicmp((const unsigned char *)__s1,(const unsigned char *)__s2,__n);}

inline int _tcscoll(const char * __s1,const char * __s2) {return _mbscoll((const unsigned char *)__s1,(const unsigned char *)__s2);}
inline int _tcsicoll(const char * __s1,const char * __s2) {return _mbsicoll((const unsigned char *)__s1,(const unsigned char *)__s2);}
inline int _tcsnccoll(const char * __s1,const char * __s2,_SIZE_T __n) {return _mbsncoll((const unsigned char *)__s1,(const unsigned char *)__s2,__n);}
inline int _tcsncoll(const char * __s1,const char * __s2,_SIZE_T __n) {return _mbsnbcoll((const unsigned char *)__s1,(const unsigned char *)__s2,__n);}
inline int _tcsncicoll(const char * __s1,const char * __s2,_SIZE_T __n) {return _mbsnicoll((const unsigned char *)__s1,(const unsigned char *)__s2,__n);}
inline int _tcsnicoll(const char * __s1,const char * __s2,_SIZE_T __n) {return _mbsnbicoll((const unsigned char *)__s1,(const unsigned char *)__s2,__n);}


/* logical-character functions */

inline _SIZE_T _tcsclen(const char * __s1) {return _mbslen((const unsigned char *)__s1);}
inline char * _tcsnccat(char * __s1,const char * __s2,_SIZE_T __n) {return (char *)_mbsncat((unsigned char *)__s1,(const unsigned char *)__s2,__n);}
inline char * _tcsnccpy(char * __s1,const char * __s2,_SIZE_T __n) {return (char *)_mbsncpy((unsigned char *)__s1,(const unsigned char *)__s2,__n);}
inline char * _tcsncset(char * __s1,unsigned int __c,_SIZE_T __n) {return (char *)_mbsnset((unsigned char *)__s1,__c,__n);}


/* MBCS-specific functions */

inline char * _tcsdec(const char * __s1,const char * __s2) {return (char *)_mbsdec((const unsigned char *)__s1,(const unsigned char *)__s2);}
inline char * _tcsinc(const char * __s1) {return (char *)_mbsinc((const unsigned char *)__s1);}
inline _SIZE_T _tcsnbcnt(const char * __s1,_SIZE_T __n) {return _mbsnbcnt((const unsigned char *)__s1,__n);}
inline _SIZE_T _tcsnccnt(const char * __s1,_SIZE_T __n) {return _mbsnccnt((const unsigned char *)__s1,__n);}

inline unsigned int _tcsnextc(const char * __s1)
{
   const unsigned char *__p = (const unsigned char *) __s1;
   return (_ismbblead(*__p)) ? (((unsigned int)*__p << 8) | __p[0]) : *__p;
}

inline char * _tcsninc(const char * __s1,_SIZE_T __n) {return (char *)_mbsninc((const unsigned char *)__s1,__n);}
inline char * _tcsspnp(const char * __s1,const char * __s2) {return (char *)_mbsspnp((const unsigned char *)__s1,(const unsigned char *)__s2);}
inline char * _tcslwr(char * __s1) {return (char *)_mbslwr((unsigned char *)__s1);}
inline char * _tcsupr(char * __s1) {return (char *)_mbsupr((unsigned char *)__s1);}

inline _SIZE_T _tclen(const char * __s1) {return _mbclen((const unsigned char *)__s1);}
inline void   _tccpy(char * __s1,const char * __s2) {_mbccpy((unsigned char *)__s1,(const unsigned char *)__s2); return;}
inline int    _tccmp(const char *__s1, const char *__s2){ return  _mbsncmp((const unsigned char *)__s1,(const unsigned char *)__s2,1);}

#endif  /* (!defined ( __cplusplus) || defined( _NO_INLINING )) */

#endif  /* _MBC_USE_MACROS */

/* @+(MBCS) comparison functions */

#define _tcscmpi        _tcsicmp
#define _tcsncmpi       _tcsnicmp

/* @: ctype functions */

#define _istalnum       _ismbcalnum
#define _istalpha       _ismbcalpha
#define _istdigit       _ismbcdigit
#define _istgraph       _ismbcgraph
#define _istlower       _ismbclower
#define _istprint       _ismbcprint
#define _istpunct       _ismbcpunct
#define _istspace       _ismbcspace
#define _istupper       _ismbcupper
#define _istlegal       _ismbclegal

#define _totlower       _mbctolower
#define _totupper       _mbctoupper

#define _istlead        _ismbblead
#define _istleadbyte    _ismbblead

/* @- */
#else  /* _MBCS */

/* ------------------- SBCS functions ----------------------- */


/* @+(SBCS) string functions */

#define _tcschr         strchr
#define _tcscspn        strcspn
#define _tcsncpy        strncpy
#define _tcsncat        strncat
#define _tcspbrk        strpbrk
#define _tcsrchr        strrchr
#define _tcsspn         strspn
#define _tcsstr         strstr
#define _tcstok         strtok

#define _tcsnset        strnset
#define _tcsrev         strrev
#define _tcsset         strset

#define _tcscmp         strcmp
#define _tcsicmp        stricmp
#define _tcsnccmp       strncmp
#define _tcsncmp        strncmp
#define _tcsncicmp      strnicmp
#define _tcsnicmp       strnicmp
#define _tcscmpi        strcmpi
#define _tcsncmpi       strncmpi

#define _tcscoll        strcoll
#define _tcsicoll       _stricoll
#define _tcsnccoll      _strncoll
#define _tcsncoll       _strncoll
#define _tcsncicoll     _strnicoll
#define _tcsnicoll      _strnicoll
#define _tcsxfrm        strxfrm

#define _ltcscoll       _lstrcoll
#define _ltcsicoll      _lstricoll
#define _ltcsnccoll     _lstrncoll
#define _ltcsncoll      _lstrncoll
#define _ltcsncicoll    _lstrnicoll
#define _ltcsnicoll     _lstrnicoll
#define _ltcsxfrm       _lstrxfrm

/* A few MBCS-like functions */

#define _tcsdec         _strdec
#define _tcsinc         _strinc
#define _tcsnbcnt       _strncnt
#define _tcsnccnt       _strncnt
#define _tcsnextc       _strnextc
#define _tcsninc        _strninc
#define _tcsspnp        _strspnp

#define _tcslwr         strlwr
#define _tcsupr         strupr

/* @!:_istlegal */
/* @!:_istlead */
/* @!:_istleadbyte */

#define _istlegal(__a)    (1)
#define _istlead(__a)     (0)
#define _istleadbyte(__a) (0)


#if (!defined ( __cplusplus) || defined( _NO_INLINING ))

/* @!:_tclen */
/* @!:_tccpy */
/* @!:_tccmp */

#define _tclen(__a)         (1)
#define _tccpy(__a,__b)     ((*(__a))=(*(__b)))
#define _tccmp(__a,__b)     ((*(__a))-(*(__b)))

#else  /* (!defined ( __cplusplus) || defined( _NO_INLINING )) */

inline _SIZE_T _RTLENTRY _tclen(const char *__s ){return (1); }
inline void   _RTLENTRY _tccpy(char *__s1, const char *__s2) {*(__s1) = *(__s2); }
inline int    _RTLENTRY _tccmp(const char *__s1, const char *__s2){ return (int) ( ((unsigned char*)__s1)-((unsigned char*)__s2)); }

#endif  /* (!defined ( __cplusplus) || defined( _NO_INLINING )) */

/* @: logical-character functions */

#define _tcsclen        strlen
#define _tcsnccat       strncat
#define _tcsnccpy       strncpy
#define _tcsncset       strnset

/* @: ctype functions */

#define _istalnum       isalnum
#define _istalpha       isalpha
#define _istdigit       isdigit
#define _istgraph       isgraph
#define _istlower       islower
#define _istprint       isprint
#define _istpunct       ispunct
#define _istspace       isspace
#define _istupper       isupper
#define _istascii       isascii
#define _istcntrl       iscntrl
#define _istxdigit      isxdigit

#define _totlower       tolower
#define _totupper       toupper

#if (!defined (__cplusplus) || defined( _NO_INLINING ))

#define _strinc(__a)       ((__a)+1)
#define _strdec(__a, __b)    ((__b)-1)
#define _strnextc(__a)     ((unsigned int) ((__a) ? (__a)[0] : 0))
#define _strninc(__a, __b)   ((__a)+(__b))
#define _strncnt(__a, __b)   ((strlen(__a)>__b) ? __b : strlen(__a))
#define _strspnp(__a, __b)   ((*((__a)+strspn(__a,__b))) ? ((__a)+strspn(__a,__b)) : NULL)

#else  /* (!defined( __cplusplus) || defined( _NO_INLINING )) */

inline char * _RTLENTRY strinc(const char * __s) { return (char *)(__s+1); }
inline char * _RTLENTRY strdec(const char * __s1, const char * __s2) { return (char *)(__s1,(__s2-1)); }

inline char * _RTLENTRY _strinc(const char * __s) { return (char *)(__s+1); }
inline char * _RTLENTRY _strdec(const char * __s1, const char * __s2) { return (char *)(__s1,(__s2-1)); }
inline unsigned int _RTLENTRY _strnextc(const char *__s) { return (unsigned int) (__s ? __s[0] : 0); }
inline char * _RTLENTRY _strninc(const char * __s, _SIZE_T __n) { return (char *)(__s+__n); }
inline _SIZE_T _RTLENTRY _strncnt( const char * __s, _SIZE_T __n) { _SIZE_T __len; __len = strlen(__s); return (__len>__n) ? __n : __len; }
inline char * _RTLENTRY _strspnp( const char * __s1, const char * __s2) { return (*(__s1 += strspn(__s1,__s2))!='\0') ? (char*)__s1 : NULL; }

#endif /* (!defined (__cplusplus) || defined( _NO_INLINING )) */