wchar.h File Reference

#include <corecrt_wctype.h>
#include <corecrt_wdirect.h>
#include <corecrt_wio.h>
#include <corecrt_wprocess.h>
#include <corecrt_wstdio.h>
#include <corecrt_wstdlib.h>
#include <corecrt_wstring.h>
#include <corecrt_wtime.h>
#include <sys/stat.h>

Include dependency graph for wchar.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	WCHAR_MIN   0U
#define	WCHAR_MAX   0xffffU
#define	_WLOCALE_DEFINED

Typedefs
typedef int	mbstate_t

Functions
_ACRTIMP wchar_t *__cdecl	_wsetlocale (int, const wchar_t *)
wchar_t __cdecl	btowc (int)
size_t __cdecl	mbrlen (const char *, size_t, mbstate_t *)
size_t __cdecl	mbrtowc (wchar_t *, const char *, size_t, mbstate_t *)
size_t __cdecl	mbsrtowcs (wchar_t *, const char **, size_t, mbstate_t *)
size_t __cdecl	wcrtomb (char *, wchar_t, mbstate_t *)
int __cdecl	wcrtomb_s (size_t *, char *, size_t, wchar_t, mbstate_t *)
size_t __cdecl	wcsrtombs (char *, const wchar_t **, size_t, mbstate_t *)
int __cdecl	wctob (wint_t)
_ACRTIMP errno_t __cdecl	wmemcpy_s (wchar_t *, size_t, const wchar_t *, size_t)
static wchar_t *	wmemchr (const wchar_t *s, wchar_t c, size_t n)
static int	wmemcmp (const wchar_t *s1, const wchar_t *s2, size_t n)
static wchar_t *__cdecl	wmemcpy (wchar_t *dst, const wchar_t *src, size_t n)
static wchar_t *__cdecl	wmemmove (wchar_t *dst, const wchar_t *src, size_t n)
static wchar_t *__cdecl	wmemset (wchar_t *s, wchar_t c, size_t n)

Macro Definition Documentation

_WLOCALE_DEFINED

#define _WLOCALE_DEFINED

Definition at line 33 of file wchar.h.

WCHAR_MAX

#define WCHAR_MAX   0xffffU

Definition at line 27 of file wchar.h.

WCHAR_MIN

#define WCHAR_MIN   0U

Definition at line 26 of file wchar.h.

Typedef Documentation

mbstate_t

typedef int mbstate_t

Definition at line 30 of file wchar.h.

Function Documentation

_wsetlocale()

_ACRTIMP wchar_t *__cdecl _wsetlocale	(	int	category,
		const wchar_t *	wlocale
	)

Definition at line 2097 of file locale.c.

{
    static wchar_t current_lc_all[MAX_LOCALE_LENGTH];
 
    char *locale = NULL;
    const char *ret;
    size_t len;
 
    if(wlocale) {
        len = wcstombs(NULL, wlocale, 0);
        if(len == -1)
            return NULL;
 
        locale = malloc(++len);
        if(!locale)
            return NULL;
 
        wcstombs(locale, wlocale, len);
    }
 
    _lock_locales();
    ret = setlocale(category, locale);
    free(locale);
 
    if(ret && mbstowcs(current_lc_all, ret, MAX_LOCALE_LENGTH)==-1)
        ret = NULL;
 
    _unlock_locales();
    return ret ? current_lc_all : NULL;
}

btowc()

wchar_t __cdecl btowc

(

int

c

)

Definition at line 3211 of file mbcs.c.

{
    unsigned char letter = c;
    wchar_t ret;
 
    if(c == EOF)
        return WEOF;
    if(!get_locinfo()->lc_codepage)
        return c & 255;
    if(!MultiByteToWideChar(get_locinfo()->lc_codepage,
                MB_ERR_INVALID_CHARS, (LPCSTR)&letter, 1, &ret, 1))
        return WEOF;
 
    return ret;
}

mbrlen()

size_t __cdecl mbrlen	(	const char *	str,
		size_t	len,
		mbstate_t *	state
	)

Definition at line 3100 of file mbcs.c.

{
    mbstate_t s = (state ? *state : 0);
    size_t ret;
 
    if(!len || !str || !*str)
        return 0;
 
    if(get_locinfo()->mb_cur_max == 1) {
        return 1;
    }else if(!s && isleadbyte((unsigned char)*str)) {
        if(len == 1) {
            s = (unsigned char)*str;
            ret = -2;
        }else {
            ret = 2;
        }
    }else if(!s) {
        ret = 1;
    }else {
        s = 0;
        ret = 2;
    }
 
    if(state)
        *state = s;
    return ret;
}

mbrtowc()

size_t __cdecl mbrtowc	(	wchar_t *	dst,
		const char *	str,
		size_t	n,
		mbstate_t *	state
	)

Definition at line 3230 of file mbcs.c.

{
    pthreadlocinfo locinfo = get_locinfo();
    mbstate_t s = (state ? *state : 0);
    char tmpstr[2];
    int len = 0;
 
    if(dst)
        *dst = 0;
 
    if(!n || !str || !*str)
        return 0;
 
    if(locinfo->mb_cur_max == 1) {
        tmpstr[len++] = *str;
    }else if(!s && isleadbyte((unsigned char)*str)) {
        if(n == 1) {
            s = (unsigned char)*str;
            len = -2;
        }else {
            tmpstr[0] = str[0];
            tmpstr[1] = str[1];
            len = 2;
        }
    }else if(!s) {
        tmpstr[len++] = *str;
    }else {
        tmpstr[0] = s;
        tmpstr[1] = *str;
        len = 2;
        s = 0;
    }
 
    if(len > 0) {
        if(!MultiByteToWideChar(locinfo->lc_codepage, 0, tmpstr, len, dst, dst ? 1 : 0))
            len = -1;
    }
 
    if(state)
        *state = s;
    return len;
}

mbsrtowcs()

size_t __cdecl mbsrtowcs	(	wchar_t *	wcstr,
		const char **	pmbstr,
		size_t	count,
		mbstate_t *	state
	)

Definition at line 3430 of file mbcs.c.

{
    mbstate_t s = (state ? *state : 0);
    wchar_t tmpdst;
    size_t ret = 0;
    const char *p;
 
    if(!MSVCRT_CHECK_PMT(pmbstr != NULL))
        return -1;
 
    p = *pmbstr;
    while(!wcstr || count>ret) {
        int ch_len = mbrtowc(&tmpdst, p, 2, &s);
        if(wcstr)
            wcstr[ret] = tmpdst;
 
        if(ch_len < 0) {
            return -1;
        }else if(ch_len == 0) {
            if(wcstr) *pmbstr = NULL;
            return ret;
        }
 
        p += ch_len;
        ret++;
    }
 
    if(wcstr) *pmbstr = p;
    return ret;
}

Referenced by mbsrtowcs_s().

wcrtomb()

size_t __cdecl wcrtomb	(	char *	dst,
		wchar_t	ch,
		mbstate_t *	s
	)

Definition at line 2211 of file wcs.c.

{
    if(s)
        *s = 0;
    return wctomb(dst, ch);
}

wcrtomb_s()

int __cdecl wcrtomb_s	(	size_t *	len,
		char *	mbchar,
		size_t	size,
		wchar_t	wch,
		mbstate_t *	s
	)

Definition at line 2197 of file wcs.c.

{
    int ilen, ret;
 
    if (s) *s = 0;
    ret = wctomb_s(&ilen, mbchar, size, wch);
    if (len) *len = ilen;
    return ret;
}

Referenced by wcrtomb().

wcsrtombs()

size_t __cdecl wcsrtombs	(	char *	mbstr,
		const wchar_t **	wcstr,
		size_t	count,
		mbstate_t *	mbstate
	)

Definition at line 701 of file wcs.c.

{
    if(mbstate)
        *mbstate = 0;
 
    return wcsrtombs_l(mbstr, wcstr, count, NULL);
}

wctob()

int __cdecl wctob

(

wint_t

wchar

)

Definition at line 2175 of file wcs.c.

{
    char out;
    BOOL error = FALSE;
    BOOL *perror;
    UINT codepage = get_locinfo()->lc_codepage;
 
    perror = (codepage != CP_UTF8 ? &error : NULL);
 
    if(!codepage) {
        if (wchar < 0xff)
            return (signed char)wchar;
        else
            return EOF;
    } else if(WideCharToMultiByte( codepage, 0, &wchar, 1, &out, 1, NULL, perror ) && !error)
        return (INT)out;
    return EOF;
}

wmemchr()

static wchar_t * wmemchr ( const wchar_t *  s, wchar_t  c, size_t  n  )

inlinestatic

Definition at line 48 of file wchar.h.

{
    const wchar_t *end;
    for (end = s + n; s < end; s++)
        if (*s == c) return (wchar_t*)s;
    return NULL;
}

Referenced by add_local_oid_text_to_control(), get_slash_dir(), get_token(), InternetCrackUrlW(), is_domain_legal_for_cookie(), merge_paths(), and set_cookie().

wmemcmp()

static int wmemcmp ( const wchar_t *  s1, const wchar_t *  s2, size_t  n  )

inlinestatic

Definition at line 56 of file wchar.h.

{
    size_t i;
    for (i = 0; i < n; i++)
    {
        if (s1[i] > s2[i]) return 1;
        if (s1[i] < s2[i]) return -1;
    }
    return 0;
}

wmemcpy()

static wchar_t *__cdecl wmemcpy ( wchar_t *  dst, const wchar_t *  src, size_t  n  )

inlinestatic

Definition at line 67 of file wchar.h.

{
    return (wchar_t*)memcpy(dst, src, n * sizeof(wchar_t));
}

Referenced by ATL::ChTraitsCRT< _CharType >::ConvertToBaseType(), and wmemcpy_s().

wmemcpy_s()

_ACRTIMP errno_t __cdecl wmemcpy_s	(	wchar_t *	destination,
		size_t	size_in_elements,
		const wchar_t *	source,
		size_t	count
	)

Definition at line 18 of file wmemcpy_s.cpp.

{
    if (count == 0)
        return 0;
 
    _VALIDATE_RETURN_ERRCODE(destination != nullptr, EINVAL);
 
    if (source == nullptr || size_in_elements < count)
    {
        // Zero the destination buffer:
        wmemset(destination, 0, size_in_elements);
 
        _VALIDATE_RETURN_ERRCODE(source != nullptr, EINVAL);
        _VALIDATE_RETURN_ERRCODE(size_in_elements >= count, ERANGE);
        
        // Useless, but prefast is confused:
        return EINVAL;
    }
 
#pragma warning(suppress:__WARNING_BANNED_API_USAGEL2) /* 28726 */
    wmemcpy(destination, source, count);
    return 0;
}

wmemmove()

static wchar_t *__cdecl wmemmove ( wchar_t *  dst, const wchar_t *  src, size_t  n  )

inlinestatic

Definition at line 72 of file wchar.h.

{
    return (wchar_t*)memmove(dst, src, n * sizeof(wchar_t));
}

Referenced by wmemmove_s().

wmemset()

static wchar_t *__cdecl wmemset ( wchar_t *  s, wchar_t  c, size_t  n  )

inlinestatic

Definition at line 77 of file wchar.h.

{
    size_t i;
    for (i = 0; i < n; i++)
        s[i] = c;
    return s;
}

Referenced by START_TEST(), test_Sid_Null(), and wmemcpy_s().