wchar2.h

Go to the documentation of this file.

/*
    MIT License

    Copyright (c) 2018 PS
    GitHub: https://github.com/ClnViewer/LibWchar2

    Permission is hereby granted, free of charge, to any person obtaining a copy
    of this software and associated documentation files (the "Software"), to deal
    in the Software without restriction, including without limitation the rights
    to use, copy, modify, merge, publish, distribute, sub license, and/or sell
    copies of the Software, and to permit persons to whom the Software is
    furnished to do so, subject to the following conditions:

    The above copyright notice and this permission notice shall be included in all
    copies or substantial portions of the Software.

    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
    SOFTWARE.
 */


/*
  Missing curent, TODO ?:
      wcscoll   Locale-specific wide-character string compare
      wcscpy    Copy wide-character string
      wcscspn   Count wide characters not in string
      wcsxfrm   Locale-specific wide-character string transformation
 */

#ifndef WCHAR2_LIBC_H
#define WCHAR2_LIBC_H

#if defined(WCHAR2EXT_MSVC_H)
#   error "Only one header include, wchar2.h or wchar2ext.h"
#endif

#include <wctype.h>
#include <wchar.h>

#if !defined(__SIZEOF_WCHAR_T__)
#  error "'__SIZEOF_WCHAR_T__' NOT defined, system not supported"
#endif

#if defined(__SIZEOF_WCHAR_T__) && (__SIZEOF_WCHAR_T__ != 2)
#  error "size of 'wchar_t' != '2'; Use gcc key: '-fshort-wchar', or clang key: '-fwchar-type=short' '-fno-signed-wchar'"
#endif

#if ( \
        defined(_WIN32) || defined(__WIN32__) || defined(_Windows) || \
        defined(_WIN64) || defined(__WIN64__) || \
        defined(__CYGWIN__) || defined(__MINGW32__) || defined(__MINGW64__))

#  error "NOT include <wchar2.h>, for WINxx platform! use <wchar2ext.h> and libwchar2ext.* instead"
#endif

#if !defined(UINTMAX_MAX)
typedef unsigned long long int uintmax_t;
#endif
#if !defined(INTMAX_MAX)
typedef long long int intmax_t;
#endif

#define USED_WCHAR2LIB 1 
#define __WS(x) __WS_(x) 
#define __WSTR wchar_t   
#define __WSTRFREE __attribute__((cleanup(__wsfree))) __WSTR 
#define __WSTR_FMT "ls" 
#define __WCHR_FMT "lc" 
#define __WCSZ(x) ((x->sz + 1) * sizeof(wchar_t)) 
#define __WS_(x) L##x
#define __WEV_(A,B) A ## B
#define __WEV(A,B)  __WEV_(A,B)
#define __WEVFA_(_11, _10, _9, _8, _7, _6, _5, _4, _3, _2, _1, N, ...) N
#define __WEVFA(...) __WEVFA_(__VA_ARGS__, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#define wsizeof(x) (unsigned long)(sizeof(x) / sizeof(wchar_t)) 
#if ((!defined(__STDC_VERSION__) || (__STDC_VERSION__ < 199901L)) && \
      !defined(__STDC_C99) && !defined(__C99_RESTRICT))
#   if !defined(restrict)
#      if defined(__GNUC__) || defined(__clang__) || defined(_MSC_VER)
#         define restrict __restrict
#      elif defined(__SUNPRO_C)
#         define restrict _Restrict
#      else
#         define restrict
#      endif
#   endif
#endif

#ifdef __cplusplus
extern "C" {
#endif

typedef struct
{
    wchar_t *str; 
    size_t   sz;  
} string_ws;

typedef struct _wdirent
{
    unsigned int   d_ino;        
    long int       d_off;        
    unsigned short d_reclen;     
    unsigned char  d_type;       
#   if defined(_DIRENT_HAVE_D_NAMLEN)
    unsigned char  d_namlen;     
#   endif
    wchar_t        d_name[256];  
} wdirent_t;

typedef void WDIR_t;

typedef enum
{
    ISERR        = -1, 
    ISUNK        =  0, 
    ISFIL        =  1, 
    ISLNK        =  2, 
    ISDIR        =  3, 
    ISCHR        =  4, 
    ISBLK        =  5, 
    ISSOCK       =  6, 
    ISFIFO       =  7, 
    ISWHT        =  8, 
    DIRNODIR     =  9, 
    DIRNOROOT    = 10, 
    DIRENTRYSIZE = 11  
} access_e;

typedef void (*wdir_cb)(unsigned int, access_e, long long, string_ws*, void*);

typedef void (*split_cb)(wchar_t*, size_t, long, void*);

const char * wchar2version(void);

wchar_t   _towupper(wchar_t);

wchar_t   _towlower(wchar_t);

wchar_t   _towctrans(wchar_t, wctrans_t);

wctype_t  _wctype(const char*);

wctrans_t _wctrans(const char*);

int       _wcwidth(wchar_t);

int       _wcswidth(const wchar_t*, size_t);

int       _iswctype(wchar_t, wctype_t);

int       _iswxdigit(wchar_t);

int       _iswupper(wchar_t);

int       _iswspace(wchar_t);

int       _iswpunct(wchar_t);

int       _iswprint(wchar_t);

int       _iswlower(wchar_t);

int       _iswgraph(wchar_t);

int       _iswdigit(wchar_t);

int       _iswcntrl(wchar_t);

int       _iswblank(wchar_t);

int       _iswalpha(wchar_t);

int       _iswalnum(wchar_t);

double                 _wcstod(const wchar_t*, wchar_t**);

float                  _wcstof(const wchar_t*, wchar_t**);

long double            _wcstold(const wchar_t*, wchar_t**);

long int               _wcstol(const wchar_t*, wchar_t**, int);

long long int          _wcstoll(const wchar_t*, wchar_t**, int);

unsigned long int      _wcstoul(const wchar_t*, wchar_t**, int);

unsigned long long int _wcstoull(const wchar_t*, wchar_t**, int);

intmax_t               _wcstoimax(const wchar_t*, wchar_t**, int);

uintmax_t              _wcstoumax(const wchar_t*, wchar_t**, int);


size_t    _wcstombs(char *restrict, const wchar_t *restrict, size_t);

size_t    _wcstombs_s(char *restrict, const wchar_t *restrict, size_t);

size_t    _wcsrtombs(char *restrict, const wchar_t **restrict, size_t, mbstate_t *restrict);

size_t    _wcrtomb(char *restrict, wchar_t, mbstate_t *restrict);

size_t    _mbstowcs(wchar_t *restrict, const char *restrict, size_t);

size_t    _mbsrtowcs(wchar_t *restrict, const char **restrict, size_t, mbstate_t *restrict);

size_t    _wcsnrtombs(char *restrict, const wchar_t **restrict, size_t, size_t, mbstate_t *restrict);

size_t    _mbsnrtowcs(wchar_t *restrict, const char **restrict, size_t, size_t, mbstate_t *restrict);

size_t    _mbrtowc(wchar_t *restrict, const char *restrict src, size_t, mbstate_t *restrict);

size_t    _mbrlen(const char *restrict, size_t, mbstate_t *restrict);

int       _mblen(const char*, size_t);

int       _mbsinit(const mbstate_t*);

int       _mbtowc(wchar_t *restrict, const char *restrict, size_t);

int       _wctomb(char*, wchar_t);

int       _wctob(wchar_t);

wchar_t   _btowc(int);

void      wcprint(wchar_t*);

int       wcstocscmp(const char*, wchar_t*, size_t); // ASCII range only

wchar_t * wcsregexp(wchar_t *restrict, wchar_t *restrict, int*);

size_t    u8stowcs(wchar_t*, const char*);

size_t    wcstou8s(char*, const wchar_t*);

int       u8sverify(const char*);

wchar_t * _wcpcpy(wchar_t*, const wchar_t*);

wchar_t * _wcpncpy(wchar_t*, const wchar_t*, size_t);

wchar_t * _wcscat(wchar_t*, const wchar_t*);

wchar_t * _wcsncat(wchar_t*, const wchar_t*, size_t);

wchar_t * _wcsncpy(wchar_t*, const wchar_t*, size_t);

wchar_t * _wcspbrk(const wchar_t*, const wchar_t*);

wchar_t * _wcschr(const wchar_t*, wchar_t);

wchar_t * _wcsrchr(const wchar_t*, wchar_t);

wchar_t * _wcsstr(const wchar_t*, const wchar_t*);

wchar_t * _wcstok(wchar_t*, const wchar_t*, wchar_t**);

wchar_t * _wmemchr(const wchar_t*, wchar_t, size_t);

wchar_t * _wmemcpy(wchar_t*, const wchar_t*, size_t);

wchar_t * _wmemmove(wchar_t*, const wchar_t*, size_t);

wchar_t * _wmemset(wchar_t*, wchar_t, size_t);

size_t    _wcslcat(wchar_t*, const wchar_t*, size_t);
size_t    _wcslcpy(wchar_t*, const wchar_t*, size_t);

size_t    _wcslen(const wchar_t*);

size_t    _wcsnlen(const wchar_t*, size_t);

size_t    _wcsspn(const wchar_t*, const wchar_t*);

int       _wcscasecmp(const wchar_t*, const wchar_t*);

int       _wcsncasecmp(const wchar_t*, const wchar_t*, size_t);

int       _wcscmp(const wchar_t*, const wchar_t*);
int       _wcsncmp(const wchar_t*, const wchar_t*, size_t);

int       _wmemcmp(const wchar_t*, const wchar_t*, size_t);

int       _vfprintf(FILE *restrict, const char *restrict, va_list)
__attribute__((__nonnull__, __format__(__printf__, 2, 0)));

int       _vsnprintf(char *restrict, size_t, const char *restrict, va_list)
__attribute__((__format__(__printf__, 3, 0)));

int       _fprintf(FILE *restrict, const char *restrict, ...)
__attribute__((__nonnull__, __format__(__printf__, 2, 0)));

int       _printf(const char *restrict fmt, ...)
__attribute__((__nonnull__, __format__(__printf__, 1, 0)));

int       _snprintf(char *restrict, size_t, const char *restrict, ...)
__attribute__((__format__(__printf__, 3, 0)));

int       _vfwprintf(FILE *restrict, const wchar_t *restrict, va_list)
/* __attribute__((__nonnull__, __format__(__wprintf__, 2, 0))) */ ;

int       _vswprintf(wchar_t *restrict, size_t, const wchar_t *restrict, va_list)
/* __attribute__((__format__(__wprintf__, 3, 0))) */ ;

int       _fwprintf(FILE *restrict, const wchar_t *restrict, ...)
/* __attribute__((__nonnull__, __format__(__wprintf__, 2, 0))) */ ;

int       _swprintf(wchar_t *restrict, size_t, const wchar_t *restrict, ...)
/* __attribute__((__format__(__wprintf__, 3, 0))) */ ;

int       _wprintf(const wchar_t *restrict fmt, ...)
/* __attribute__((__format__(__wprintf__, 1, 0))) */ ;

int       _fputws(const wchar_t *restrict, FILE *restrict);

wchar_t   _fputwc(wchar_t, FILE *restrict);

size_t    _wcsftime(wchar_t *restrict, size_t sz, const wchar_t *restrict, const void *restrict);

wchar_t * _wcsptime(const wchar_t*, const wchar_t*, void*);

FILE    * _wfopen(const wchar_t*, const wchar_t*)
__attribute__((warn_unused_result));

FILE    * _wfopen_s(const wchar_t*, size_t, const wchar_t*)
__attribute__((warn_unused_result));

FILE    * _wfopen_ws(const string_ws*, const wchar_t*)
__attribute__((warn_unused_result));

FILE    * _wfopen_selector(int, const void*, size_t, const void*)
__attribute__((warn_unused_result));

FILE    * u8wfopen(const wchar_t*, const wchar_t*)
__attribute__((warn_unused_result));

int       _wstat(const wchar_t*, void*);

int       _wstat_s(const wchar_t*, size_t, void*);

int       _wstat_ws(const string_ws*, void*);

int       _wstat_selector(int, const void*, size_t, const void*);

int       u8wstat(const wchar_t*, void*);

int       _wrename(const wchar_t*, const wchar_t*);

int       _wrename_s(const wchar_t*, size_t, const wchar_t*, size_t);

int       _wrename_ws(const string_ws*, const string_ws*);

int       _wrename_selector(int, const void*, size_t, const void*, size_t);

int       u8wrename(const wchar_t*, const wchar_t*);

int       _wremove(const wchar_t*);

int       _wremove_s(const wchar_t*, size_t);

int       _wremove_ws(const string_ws*);

int       _wremove_selector(int, const void*, size_t);

int       u8wremove(const wchar_t*);

int       _wmkdir(const wchar_t*, mode_t);

int       _wmkdir_s(const wchar_t*, size_t, mode_t);

int       _wmkdir_ws(const string_ws*, mode_t);

int       _wmkdir_selector(int, const void*, size_t, mode_t);

int       u8wmkdir(const wchar_t*, mode_t);


access_e  _waccess(const wchar_t*, int);
access_e  _waccess_s(const wchar_t*, size_t, int);
access_e  _waccess_ws(const string_ws*, int);
access_e  _waccess_selector(int, const void*, size_t, int);
access_e  u8waccess(const wchar_t*, int);

wchar_t * _wbasename(const wchar_t*);
wchar_t * _wbasename_ws(const string_ws*);
void *    _wbasename_selector(int, const void*);

wchar_t * _wbaseext(const wchar_t*);
wchar_t * _wbaseext_ws(const string_ws*);
void *    _wbaseext_selector(int, const void*);

wchar_t * _wbasedir(const wchar_t*, int)
__attribute__((warn_unused_result));
wchar_t * _wbasedir_ws(const string_ws*, int)
__attribute__((warn_unused_result));
void *    _wbasedir_selector(int, const void*, int)
__attribute__((warn_unused_result));

wchar_t * _wpathnormalize(const wchar_t*, size_t)
__attribute__((warn_unused_result));
wchar_t * _wpathnormalize_ws(const string_ws*)
__attribute__((warn_unused_result));

char *    u8wpathnormalize(const wchar_t*)
__attribute__((warn_unused_result));


/*
 * \~English
 * \section wchar2wstring API use structure string_ws
 *
 * \~Russian
 * \section wchar2wstring API - Работа со структорой string_ws
 *
 */

void      wstring_free(string_ws *restrict);

size_t    wstring_alloc(string_ws *restrict, size_t);

char    * wstring_wstocs_alloc(const wchar_t *restrict)
__attribute__((warn_unused_result));

char    * wstring_swstocs_alloc(const string_ws *restrict)
__attribute__((warn_unused_result));

wchar_t * wstring_cstows_alloc(const char *restrict)
__attribute__((warn_unused_result));

size_t    wstring_cstows_ws_alloc(string_ws *restrict, const char *restrict);

size_t    wstring_format(string_ws*, const wchar_t *restrict, ...);

size_t    wstring_append(string_ws*, const wchar_t *restrict, size_t);

size_t    wstring_appends_(string_ws*, ...);

#define   wstring_appends(A,...) wstring_appends_(A,__VA_ARGS__,NULL)

size_t    wstring_append_cvt(string_ws*, const char *restrict, size_t);

size_t    wstring_cstows(wchar_t [], size_t, const char *restrict, size_t);

size_t    wstring_wstocs(char [], size_t, const wchar_t *restrict, size_t);

size_t    wstring_wstocs_ws(char [], size_t, const string_ws *restrict);

wchar_t * wstring_timeformat(const wchar_t *restrict, size_t, const wchar_t *restrict, const wchar_t *restrict)
__attribute__((warn_unused_result));

wchar_t * wstring_timeformat_ws(const string_ws *restrict, const wchar_t *restrict, const wchar_t *restrict)
__attribute__((warn_unused_result));

long      wstring_split_cb(const string_ws*, wchar_t, split_cb, void*);


int       wstring_isempty(const wchar_t *restrict s, int);

string_ws wstring_trunc(const wchar_t *ws, int);

size_t    wstring_trunc_alloc(string_ws *restrict, const wchar_t*, int);

int        _wclosedir(WDIR_t*);

WDIR_t    *_wopendir(const wchar_t*);

wdirent_t *_wreaddir(WDIR_t*);

int        _wreaddir_r(WDIR_t*, wdirent_t*, wdirent_t**);

int        _wreaddir_cb(wchar_t*, long, wdir_cb, void*);

#define    wreaddir_cb_opt(opt,val) ((opt) | (1L << (val)))

void       _wrewinddir(WDIR_t*);

void       _wseekdir(WDIR_t*, long int);

long int   _wtelldir(WDIR_t*);

int        wmkstemp(wchar_t *);


/* declaration from stdlib.h */
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wredundant-decls"
void free(void*);
#pragma GCC diagnostic pop

static inline void __attribute__((always_inline)) __wsfree(void *v)
{
    if (v)
    {
        void *x = *(void**)v;
        if (x)
        {
            free(x);
            // cppcheck-suppress unreadVariable
            x = ((void*)0);
        }
    }
}

#ifdef __cplusplus
}
#endif

#if defined(__clang__)
#   pragma clang diagnostic ignored "-Wlanguage-extension-token"
#endif

#define __wchar_type_id(A)                                           \
       __builtin_types_compatible_p(typeof(A),         wchar_t*) * 1 \
    +  __builtin_types_compatible_p(typeof(A),   const wchar_t*) * 1 \
    +  __builtin_types_compatible_p(typeof(A),        wchar_t[]) * 1 \
    +  __builtin_types_compatible_p(typeof(A),  const wchar_t[]) * 1 \
    +  __builtin_types_compatible_p(typeof(A),       string_ws*) * 2 \
    +  __builtin_types_compatible_p(typeof(A), const string_ws*) * 2 \
    +  __builtin_types_compatible_p(typeof(A),            char*) * 3 \
    +  __builtin_types_compatible_p(typeof(A),      const char*) * 3 \
    +  __builtin_types_compatible_p(typeof(A),           char[]) * 3 \
    +  __builtin_types_compatible_p(typeof(A),     const char[]) * 3

#   define EV_FOPEN_ARG_3(_1,_2,_3) _wfopen_selector(4,_1,_3,_2)
#   define EV_FOPEN_ARG_2(_1,_2) _wfopen_selector(__wchar_type_id(_1),_1,0,_2)
#   define EV_FOPEN_ARG_1(_1) _wfopen_selector(__wchar_type_id(_1),_1,0,(const char*)&"r")
#   define EV_FOPEN_ARG_0(...)

#   define _wfopen_macro(...) \
        __WEV(EV_FOPEN_ARG_, __WEVFA(__VA_ARGS__))(__VA_ARGS__)

#   define EV_MKDIR_ARG_3(_1,_2,_3) _wmkdir_selector(4,_1,_3,_2)
#   define EV_MKDIR_ARG_2(_1,_2) _wmkdir_selector(__wchar_type_id(_1),_1,0,_2)
#   define EV_MKDIR_ARG_1(_1) _wmkdir_selector(__wchar_type_id(_1),_1,0,S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH)
#   define EV_MKDIR_ARG_0(...)

#   define _wmkdir_macro(...) \
        __WEV(EV_MKDIR_ARG_, __WEVFA(__VA_ARGS__))(__VA_ARGS__)

#   define EV_REMOVE_ARG_2(_1,_2) _wremove_selector(__wchar_type_id(_1),_1,_2)
#   define EV_REMOVE_ARG_1(_1) _wremove_selector(__wchar_type_id(_1),_1,0)
#   define EV_REMOVE_ARG_0(...)

#   define _wremove_macro(...) \
        __WEV(EV_REMOVE_ARG_, __WEVFA(__VA_ARGS__))(__VA_ARGS__)

#   define EV_RENAME_ARG_4(_1,_2,_3,_4) _wrename_selector(4,_1,_2,_3,_4)
#   define EV_RENAME_ARG_3(_1,_2,_3) _wrename_selector(__wchar_type_id(_1),_1,0,_2,0)
#   define EV_RENAME_ARG_2(_1,_2) _wrename_selector(__wchar_type_id(_1),_1,0,_2,0)
#   define EV_RENAME_ARG_1(_1)
#   define EV_RENAME_ARG_0(...)

#   define _wrename_macro(...) \
        __WEV(EV_RENAME_ARG_, __WEVFA(__VA_ARGS__))(__VA_ARGS__)

#   define EV_STAT_ARG_3(_1,_2,_3) _wstat_selector(4,_1,_3,_2)
#   define EV_STAT_ARG_2(_1,_2) _wstat_selector(__wchar_type_id(_1),_1,0,_2)
#   define EV_STAT_ARG_1(_1) _wstat_selector(__wchar_type_id(_1),_1,0,NULL)
#   define EV_STAT_ARG_0(...)

#   define _wstat_macro(...) \
        __WEV(EV_STAT_ARG_, __WEVFA(__VA_ARGS__))(__VA_ARGS__)

#   define EV_ACCESS_ARG_3(_1,_2,_3) _waccess_selector(4,_1,_3,_2)
#   define EV_ACCESS_ARG_2(_1,_2) _waccess_selector(__wchar_type_id(_1),_1,_2,0)
#   define EV_ACCESS_ARG_1(_1) _waccess_selector(__wchar_type_id(_1),_1,0,0)
#   define EV_ACCESS_ARG_0(...)

#   define _waccess_macro(...) \
        __WEV(EV_ACCESS_ARG_, __WEVFA(__VA_ARGS__))(__VA_ARGS__)

#   define EV_BNAME_ARG_2(_1,_2) _wbasename_selector(_1,_2)
#   define EV_BNAME_ARG_1(_1) _wbasename_selector(__wchar_type_id(_1),_1)
#   define EV_BNAME_ARG_0(...)

#   define _wbasename_macro(...) \
        __WEV(EV_BNAME_ARG_, __WEVFA(__VA_ARGS__))(__VA_ARGS__)

#   define EV_BEXT_ARG_2(_1,_2) _wbaseext_selector(_1,_2)
#   define EV_BEXT_ARG_1(_1) _wbaseext_selector(__wchar_type_id(_1),_1)
#   define EV_BEXT_ARG_0(...)

#   define _wbaseext_macro(...) \
        __WEV(EV_BEXT_ARG_, __WEVFA(__VA_ARGS__))(__VA_ARGS__)

#   define EV_BDIR_ARG_3(_1,_2,_3) _wbasedir_selector(_1,_2,_3)
#   define EV_BDIR_ARG_2(_1,_2) _wbasedir_selector(__wchar_type_id(_1),_1,_2)
#   define EV_BDIR_ARG_1(_1) _wbasedir_selector(__wchar_type_id(_1),_1, 0)
#   define EV_BDIR_ARG_0(...)

#   define _wbasedir_macro(...) \
        __WEV(EV_BDIR_ARG_, __WEVFA(__VA_ARGS__))(__VA_ARGS__)

#define wstocscvt(A,B,D)                                                                                           \
    size_t __WEV(sz,__LINE__); errno = 0;                                                                          \
    if (!(__WEV(sz,__LINE__) = _wcsrtombs(NULL, &(const wchar_t*){B}, 0, 0))) {                                    \
        errno = EILSEQ; return D;                                                                                  \
    }                                                                                                              \
    char __WEV(A,__LINE__)[(__WEV(sz,__LINE__) + 1)], * A = (char*)&__WEV(A,__LINE__);                             \
    if ((__WEV(sz,__LINE__) = _wcsrtombs(__WEV(A,__LINE__), &(const wchar_t*){B}, (__WEV(sz,__LINE__) + 1), 0))) { \
        __WEV(A,__LINE__)[(__WEV(sz,__LINE__))] = '\0';                                                            \
    }

#define wstocsncvt(A,B,C,D)                                                                                         \
    char __WEV(A,__LINE__)[(C + 1 * sizeof(wchar_t))], * A = (char*)&__WEV(A,__LINE__); errno = 0;                  \
    if (!((C) = _wcsrtombs(__WEV(A,__LINE__), &(const wchar_t*){B}, (C * 2 + 1), 0))) {                             \
        errno = EILSEQ; return D;                                                                                   \
    }                                                                                                               \
    __WEV(A,__LINE__)[(C)] = '\0'

#define wstrtocscvt(A,B,D)                                                                                          \
    size_t __WEV(sz,__LINE__); errno = 0;                                                                           \
    char __WEV(A,__LINE__)[(B->sz + 1 * sizeof(wchar_t))], * A = (char*)&__WEV(A,__LINE__);                         \
    if (!(__WEV(sz,__LINE__) = _wcsrtombs(__WEV(A,__LINE__), &(const wchar_t*){B->str}, (B->sz * 2 + 1), 0))) {     \
        errno = EILSEQ; return D;                                                                                   \
    }                                                                                                               \
    __WEV(A,__LINE__)[__WEV(sz,__LINE__)] = '\0'

#if defined(vsnprintf)
#   undef vsnprintf
#endif

#if defined(snprintf)
#   undef snprintf
#endif

#if defined(vsnprintf)
#   undef vsnprintf
#endif

#if defined(snprintf)
#   undef snprintf
#endif

#if defined(WS_FS_REDEFINE)
#      define fputc _fputwc
#      define fputs _fputws
#   if defined(WS_FS_UTF8)
#      define mkdir u8wmkdir
#      define remove u8wremove
#      define rename u8wrename
#      define stat u8wstat
#      define fopen u8wfopen
#      define access u8waccess
#   else
#      define mkdir _wmkdir_macro
#      define remove _wremove_macro
#      define rename _wrename_macro
#      define stat _wstat_macro
#      define access _waccess_macro
#      define fopen _wfopen_macro
#      define access _waccess_macro
#      define basename(A) (__WSTR *) _wbasename_macro(A)
#      define dirname(A)  (__WSTR *) _wbasedir_macro(A)
#      define baseext(A)  (__WSTR *) _wbaseext_macro(A)
#   endif
#endif

#define wmkdir _wmkdir_macro
#define wmkdir_w _wmkdir
#define wmkdir_s _wmkdir_s
#define wmkdir_ws _wmkdir_ws

#define wremove _wremove_macro
#define wremove_w _wremove
#define wremove_s _wremove_s
#define wremove_ws _wremove_ws

#define wrename _wrename_macro
#define wrename_w _wrename
#define wrename_s _wrename_s
#define wrename_ws _wrename_ws

#define wstat _wstat_macro
#define wstat_w _wstat
#define wstat_s _wstat_s
#define wstat_ws _wstat_ws

#define wfopen _wfopen_macro
#define wfopen_w _wfopen
#define wfopen_s _wfopen_s
#define wfopen_ws _wfopen_ws

#define waccess _waccess_macro
#define waccess_w _waccess
#define waccess_s _waccess_s
#define waccess_ws _waccess_ws

#define wbasename _wbasename_macro
#define wbasename_w _wbasename
#define wbasename_ws _wbasename_ws

#define wbaseext _wbaseext_macro
#define wbaseext_w _wbaseext
#define wbaseext_ws _wbaseext_ws

#define wbasedir _wbasedir_macro
#define wbasedir_w _wbasedir
#define wbasedir_ws _wbasedir_ws
#define wpathnormalize _wpathnormalize
#define wpathnormalize_ws _wpathnormalize_ws

#define fputwc _fputwc
#define fputws _fputws
#define vfprintf _vfprintf
#define vsnprintf _vsnprintf
#define fprintf _fprintf
#define snprintf _snprintf
#define vfwprintf _vfwprintf
#define vswprintf _vswprintf
#define fwprintf _fwprintf
#define swprintf _swprintf
#define wprintf _wprintf
#define fprintf _fprintf
#define printf _printf

#define _wcprint wcprint
#define _wcsregexp wcsregexp
#define _wcstocscmp wcstocscmp
#define _u8stowcs u8stowcs
#define _wcstou8s wcstou8s
#define _u8wfopen u8wfopen
#define _u8wmkdir u8wmkdir
#define _u8waccess u8waccess
#define _u8wremove u8wremove
#define _u8wrename u8wrename
#define _u8wstat u8wstat
#define _u8sverify u8sverify

#define wclosedir _wclosedir
#define wopendir _wopendir
#define wreaddir _wreaddir
#define wreaddir_r _wreaddir_r
#define wreaddir_cb _wreaddir_cb
#define wrewinddir _wrewinddir
#define wseekdir _wseekdir
#define wtelldir _wtelldir

#define towupper _towupper
#define towlower _towlower
#define towctrans _towctrans
#define wctype _wctype
#define wctrans _wctrans
#define wcwidth _wcwidth
#define wcswidth _wcswidth

#define iswctype _iswctype
#define iswxdigit _iswxdigit
#define iswupper _iswupper
#define iswspace _iswspace
#define iswpunct _iswpunct
#define iswprint _iswprint
#define iswlower _iswlower
#define iswgraph _iswgraph
#define iswdigit _iswdigit
#define iswcntrl _iswcntrl
#define iswblank _iswblank
#define iswalpha _iswalpha
#define iswalnum _iswalnum

#define wcstod _wcstod
#define wcstof _wcstof
#define wcstold _wcstold
#define wcstol _wcstol
#define wcstoll _wcstoll
#define wcstoul _wcstoul
#define wcstoull _wcstoull
#define wcstoimax _wcstoimax
#define wcstoumax _wcstoumax

#define wcstombs _wcstombs
#define wcstombs_s _wcstombs_s
#define wcsrtombs _wcsrtombs
#define wcrtomb _wcrtomb
#define mbstowcs _mbstowcs
#define mbsrtowcs _mbsrtowcs
#define wcsnrtombs _wcsnrtombs
#define mbsnrtowcs _mbsnrtowcs
#define mbrtowc _mbrtowc
#define mbrlen _mbrlen
#define mblen _mblen
#define mbsinit _mbsinit
#define mbtowc _mbtowc
#define wctomb _wctomb
#define wctob _wctob
#define btowc _btowc
#define wcpcpy _wcpcpy
#define wcpncpy _wcpncpy
#define wcscat _wcscat
#define wcsncat _wcsncat
#define wcsncpy _wcsncpy
#define wcspbrk _wcspbrk
#define wcschr _wcschr
#define wcsrchr _wcsrchr
#define wcsstr _wcsstr
#define wcstok _wcstok
#define wcscmp _wcscmp
#define wcsftime _wcsftime
#define wcsptime _wcsptime
#define wmemchr _wmemchr
#define wmemcpy _wmemcpy
#define wmemmove _wmemmove
#define wmemset _wmemset
#define wcslcat _wcslcat
#define wcslcpy _wcslcpy
#define wcslen _wcslen
#define wcsnlen _wcsnlen
#define wcsspn _wcsspn
#define wcscasecmp _wcscasecmp
#define wcsncasecmp _wcsncasecmp
#define wcsncmp _wcsncmp
#define wmemcmp _wmemcmp

#endif