XStdLib.h

#if !defined(CEXSTDLIB_INCLUDE_H)
#define CEXSTDLIB_INCLUDE_H
 
#ifdef _MSC_VER
#pragma once
#endif // _MSC_VER
 
#ifdef __WINDOWS__
#include "./win/win_stdlib.h"
#elif __APPLE__
#include "./macos/macos_stdlib.h"
#elif __LINUX__
#include "./linux/linux_stdlib.h"
#endif
 
BEGIN_MOOTOOLS_NAMESPACE
 
inline void xwmemset(wchar_t *str, wchar_t value, SIZET count)
{
    wmemset(str, value, count);
}
 
inline void xmemset(void *str, char value, SIZET count)
{
    memset(str, value, count);
}
 
inline void xwmemmove_s(wchar_t *dst, SIZET dstcount, const wchar_t *src, SIZET srccount)
{
    wmemmove_s(dst, dstcount, src, srccount);
}
 
inline void xmemmove_s(void *dst, SIZET dstcount, const void *src, SIZET srccount)
{
    memmove_s(dst, dstcount, src, srccount);
}
 
inline void xwwmemcpy_s(wchar_t *dst, SIZET dstcount, const wchar_t *src, SIZET srccount)
{
    wmemcpy_s(dst, dstcount, src, srccount);
}
 
inline void xmemcpy_s(void *dst, SIZET dstcount, const void *src, SIZET srccount)
{
    memcpy_s(dst, dstcount, src, srccount);
}
 
inline int xmemcmp(const void* buf1, const void* buf2, SIZET count)
{
    return memcmp(buf1, buf2, count);
}
 
inline SIZET xwstrnlen(const wchar_t *str, SIZET bufsize)
{
    return wcsnlen(str, bufsize);
}
 
inline SIZET xstrnlen(const char *str, SIZET bufsize)
{
    return strnlen(str, bufsize);
}
 
inline SIZET xwstrlen(const wchar_t *str)
{
    return wcslen(str);
}
 
inline SIZET xstrlen(const char *str)
{
    return strlen(str);
}
 
inline bool xstrcpy_s(char *dst, size_t dstcount, const char *src)
{
    return (strcpy_s(dst, dstcount, src) == 0);
}
 
inline bool xwstrcpy_s(wchar_t *dst, size_t dstcount, const wchar_t *src)
{
    return (wcscpy_s(dst, dstcount, src) == 0);
}
 
inline bool xstrcat_s(char *dst, size_t dstcount, const char *src)
{
    return (strcat_s(dst, dstcount, src) == 0);
}
 
inline bool xwcscat_s(wchar_t *dst, size_t dstcount, const wchar_t *src)
{
    return (wcscat_s(dst, dstcount, src) == 0);
}
 
inline char *xstrncpy_s(char *dst, size_t dstcount, const char *src, size_t srccount)
{
    strncpy_s(dst, dstcount, src, srccount);
    return dst;
}
 
inline wchar_t *xwstrncpy_s(wchar_t *dst, size_t dstcount, const wchar_t *src, size_t srccount)
{
    wcsncpy_s(dst, dstcount, src, srccount);
    return dst;
}
 
inline bool xwstrlwr_s(wchar_t *char1, SIZET charCount)
{
    return (_wcslwr_s(char1, charCount) == 0);
}
 
inline bool xstrlwr_s(char *char1, SIZET charCount)
{
    return (_strlwr_s(char1, charCount) == 0);
}
 
inline bool xwstrupr_s(wchar_t *char1, SIZET charCount)
{
    return (_wcsupr_s(char1, charCount) == 0);
}
 
inline bool xstrupr_s(char *char1, SIZET charCount)
{
    return (_strupr_s(char1, charCount) == 0);
}
 
inline int xwisspace(wchar_t char1)
{
    return iswspace(char1);
}
 
inline int xisspace(char char1)
{
    return isspace(char1);
}
 
inline int xwisalpha(wchar_t char1)
{
    return iswalpha(char1);
}
    
inline int xisalpha(char char1)
{
    return isalpha(char1);
}
 
inline int xwtolower(const wchar_t char1)
{
    return _towlower_l(char1, NULL);
}
 
inline int xtolower(const char char1)
{
    return _tolower_l(char1, NULL);
}
 
inline int xwtoupper(const wchar_t char1)
{
    return _towupper_l(char1, NULL);
}
 
inline int xtoupper(const char char1)
{
    return _toupper_l(char1, NULL);
}
 
inline int xwisdigit(wchar_t c)
{
    return iswdigit(c);
}
 
inline int xisdigit(int c)
{
    return isdigit(c);
}
 
inline int xwstrcoll(const wchar_t *char1, const wchar_t *char2)
{
    return wcscoll(char1, char2);
}
 
inline int xstrcoll(const char *char1, const char *char2)
{
    return strcoll(char1, char2);
}
 
inline int xwstricoll(const wchar_t *char1, const wchar_t *char2)
{
    return _wcsicoll(char1, char2);
}
 
inline int xstricoll(const char *char1, const char *char2)
{
    return _stricoll(char1, char2);
}
 
inline int xwstrcmp(const wchar_t *char1, const wchar_t *char2)
{
    return wcscmp(char1, char2);
}
 
inline int xstrcmp(const char *char1, const char *char2)
{
    return strcmp(char1, char2);
}
 
inline int xwstricmp(const wchar_t *char1, const wchar_t *char2)
{
    return _wcsicmp(char1, char2);
}
 
inline int xstricmp(const char *char1, const char *char2)
{
    return _stricmp(char1, char2);
}
 
#if !defined(__WINDOWS__) || (_MSC_VER >= 1900)
inline int xwvscanf_s(const wchar_t *buffer, const wchar_t *format, va_list argptr)
{
    return vswscanf_s(buffer, format, argptr);
}
 
inline int xvscanf_s(const char *buffer, const char *format, va_list argptr)
{
    return vsscanf_s(buffer, format, argptr);
}
 
inline int xwvfscanf_s(FILE *stream, const wchar_t *format, va_list argptr)
{
    return vfwscanf_s(stream, format, argptr);
}
 
inline int xvfscanf_s(FILE *stream, const char *format, va_list argptr)
{
    return vfscanf_s(stream, format, argptr);
}
#endif
 
#ifdef __WINDOWS__
#pragma warning( push )
#pragma warning( disable : 4996 )
#endif
 
inline int xwsprintf(wchar_t *buffer, SIZET count, const wchar_t *format, ...)
{
    va_list args; va_start(args, format);
    int result = _vsnwprintf(buffer, count, format, args);
    va_end(args);
    return result;
}
 
inline int xsprintf(char *buffer, SIZET count, const char *format, ...)
{
    va_list args; va_start(args, format);
    int result = _vsnprintf(buffer, count, format, args);
    va_end(args);
    return result;
}
 
inline int xwvnprintf(wchar_t *buffer, SIZET count, const wchar_t *format, va_list argptr)
{
    return _vsnwprintf(buffer, count, format, argptr);
}
 
inline int xvnprintf(char *buffer, SIZET count, const char *format, va_list argptr)
{
    return _vsnprintf(buffer, count, format, argptr);
}
 
inline FILE *xfopen(const char *name, const char *mode)
{
    return fopen(name, mode);
}
 
inline FILE *xwfopen(const wchar_t *name, const wchar_t *mode)
{
    return _wfopen(name, mode);
}
 
#ifdef __WINDOWS__
#pragma warning( pop )
#endif
 
inline int xfileno(FILE *stream)
{
    return _fileno(stream);
}
 
inline FILE *xfdopen(int fd, const char *mode)
{
    return _fdopen(fd, mode);
}
 
inline FILE *xwfdopen(int fd, const wchar_t *mode)
{
    return _wfdopen(fd, mode);
}
 
inline int xfclose(FILE *stream)
{
    return fclose(stream);
}
 
inline int xferror(FILE *stream)
{
    return ferror(stream);
}
 
inline bool xfputs(const char *str, FILE *stream)
{
    return (fputs(str, stream) != EOF);
}
 
inline char *xfgets(char *str, int maxcount, FILE *stream)
{
    return fgets(str, maxcount, stream);
}
 
inline bool xwfputs(const wchar_t *str, FILE *stream)
{
    return (fputws(str, stream) != (int)WEOF);
}
 
inline wchar_t *xwfgets(wchar_t *str, int maxcount, FILE *stream)
{
    return fgetws(str, maxcount, stream);
}
 
inline fileuint xftell(FILE *stream)
{
    return _ftelli64(stream);
}
 
inline fileuint xfseek(FILE *stream, longint offset, int seekmode)
{
    return _fseeki64(stream, offset, seekmode);
}
 
#ifdef _UNICODE
    #define xtmemset xwmemset
    #define xtmemmove_s xwmemmove_s
    #define xtmemcpy_s xwwmemcpy_s
    #define xtstrnlen xwstrnlen
    #define xtstrlen xwstrlen
    #define xtstrcpy_s xwstrcpy_s
    #define xtstrncpy_s xwstrncpy_s
    #define xtstrcat_s xwcscat_s
    #define xtstrlwr_s xwstrlwr_s
    #define xtstrupr_s xwstrupr_s
    #define xtisspace xwisspace
    #define xtisalpha xwisalpha
    #define xttolower xwtolower
    #define xttoupper xwtoupper
    #define xtisdigit xwisdigit
    #define xtstrcoll xwstrcoll
    #define xtstricoll xwstricoll
    #define xtstrcmp xwstrcmp
    #define xtstricmp xwstricmp
    // scanf method is a define (not an inline) in OS overrides because the prototype has ... arguments. Using define allows the compiler to perform checks on the arguments.
    #define xtscanf xwscanf
    // scanf_s method is a define (not an inline) in OS overrides because the prototype has ... arguments. Using define allows the compiler to perform checks on the arguments.
    // Secured version for OS that support it: use SCANS_TEXT_PARAM(string, sizeofbuffer) for text param
    #define xtscanf_s xwscanf_s
    #define xtvscanf_s xwvscanf_s
    #define xtvfscanf_s xwvfscanf_s
    #define xtsprintf xwsprintf
    #define xtvnprintf xwvnprintf
    #define xtfopen xwfopen
    #define xtfdopen xwfdopen
    #define xtfgets xwfgets
    #define xtfputs xwfputs
#else
    #define xtmemset xmemset
    #define xtmemmove_s xmemmove_s
    #define xtmemcpy_s xmemcpy_s
    #define xtstrnlen xstrnlen
    #define xtstrlen xstrlen
    #define xtstrcpy_s xstrcpy_s
    #define xtstrncpy_s xstrncpy_s
    #define xtstrcat_s xstrcat_s
    #define xtstrlwr_s xstrlwr_s
    #define xtstrupr_s xstrupr_s
    #define xtisspace xisspace
    #define xtisalpha xisalpha
    #define xttolower xtolower
    #define xttoupper xtoupper
    #define xtisdigit xisdigit
    #define xtstrcoll xstrcoll
    #define xtstricoll xstricoll
    #define xtstrcmp xstrcmp
    #define xtstricmp xstricmp
    // scanf method is a define (not an inline) in OS overrides because the prototype has ... arguments. Using define allows the compiler to perform checks on the arguments.
    #define xtscanf xscanf
    // scanf_s method is a define (not an inline) in OS overrides because the prototype has ... arguments. Using define allows the compiler to perform checks on the arguments.
    // Secured version for OS that support it: use SCANS_TEXT_PARAM(string, sizeofbuffer) for text param
    #define xtscanf_s xscanf_s
    #define xtvscanf_s xvscanf_s
    #define xtvfscanf_s xvfscanf_s
    #define xtsprintf xsprintf
    #define xtvnprintf xvnprintf
    #define xtfopen fopen
    #define xtfdopen xfdopen
    #define xtfgets xfgets
    #define xtfputs xfputs
#endif
 
END_MOOTOOLS_NAMESPACE
 
 
#endif // !defined(CEXSTDLIB_INCLUDE_H);