wcrtomb.cpp File Reference

#include <corecrt_internal_mbstring.h>
#include <corecrt_internal_ptd_propagation.h>
#include <corecrt_internal_securecrt.h>
#include <limits.h>
#include <locale.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wchar.h>

Include dependency graph for wcrtomb.cpp:

Go to the source code of this file.

Functions
	_Success_ (return==0) static errno_t __cdecl _wcrtomb_internal(int *const return_value
	__out_bcount_z_opt (destination_count) char *const destination
	_ASSERTE (locale->locinfo->_public._locale_mb_cur_max==1||locale->locinfo->_public._locale_mb_cur_max==2||locale->locinfo->_public._locale_lc_codepage==CP_UTF8)
	if (state)
	if (locale->locinfo->_public._locale_lc_codepage==CP_UTF8)
	if (!locale->locinfo->locale_name[LC_CTYPE])
	if (size==0||default_used)
	if (return_value)
static errno_t __cdecl	wcrtomb_s_internal (size_t *const return_value, char *const destination, size_t const destination_count, wchar_t const wchar, mbstate_t *const state, __crt_cached_ptd_host &ptd)
errno_t __cdecl	wcrtomb_s (size_t *const return_value, char *const destination, size_t const destination_count, wchar_t const wchar, mbstate_t *const state)
size_t __cdecl	wcrtomb (char *const destination, wchar_t const wchar, mbstate_t *const state)
static size_t __cdecl	_wcsrtombs_internal (_Pre_maybenull_ _Post_z_ char *destination, _Inout_ _Deref_prepost_z_ wchar_t const **const source, _In_ size_t n, _Out_opt_ mbstate_t *const state, _Inout_ __crt_cached_ptd_host &ptd) throw ()
size_t __cdecl	wcsrtombs (char *const destination, wchar_t const **const source, size_t const n, mbstate_t *const state)
errno_t __cdecl	wcsrtombs_s (size_t *const return_value, char *const destination, size_t const destination_count, wchar_t const **const source, size_t const n, mbstate_t *const state)
int __cdecl	wctob (wint_t const wchar)

Variables
size_t const	destination_count
size_t const wchar_t const	wchar
size_t const wchar_t const mbstate_t *const	state
size_t const wchar_t const mbstate_t *const _Inout_ __crt_cached_ptd_host &	ptd
_locale_t const	locale = ptd.get_locale()
BOOL	default_used {}
int const	size
	return

Function Documentation

__out_bcount_z_opt()

__out_bcount_z_opt

(

destination_count

)

const

_ASSERTE()

_ASSERTE

(

locale->locinfo->_public.

_locale_mb_cur_max = =1||locale->locinfo->_public._locale_mb_cur_max==2||locale->locinfo->_public._locale_lc_codepage==CP_UTF8

)

_Success_()

_Success_

(

return

= = 0

)

const

_wcsrtombs_internal()

static size_t __cdecl _wcsrtombs_internal ( _Pre_maybenull_ _Post_z_ char *  destination, _Inout_ _Deref_prepost_z_ wchar_t const **const  source, _In_ size_t  n, _Out_opt_ mbstate_t *const  state, _Inout_ __crt_cached_ptd_host &  ptd  ) throw ( )

static

Definition at line 227 of file wcrtomb.cpp.

{
    /* validation section */
    _UCRT_VALIDATE_RETURN(ptd, source != nullptr, EINVAL, (size_t)-1);
 
    _locale_t const locale = ptd.get_locale();
 
    if (locale->locinfo->_public._locale_lc_codepage == CP_UTF8)
    {
        return __wcsrtombs_utf8(destination, source, n, state, ptd);
    }
 
    char buf[MB_LEN_MAX];
    int i = 0;
    size_t nc = 0;
    wchar_t const* wcs = *source;
 
    if (!destination)
    {
        for (; ; nc += i, ++wcs)
        {
            /* translate but don't store */
            _wcrtomb_internal(&i, buf, MB_LEN_MAX, *wcs, state, ptd);
            if (i <= 0)
            {
                return static_cast<size_t>(-1);
            }
            else if (buf[i - 1] == '\0')
            {
                return nc + i - 1;
            }
        }
    }
 
    for (; 0 < n; nc += i, ++wcs, destination += i, n -= i)
    {
        /* translate and store */
        char *t = nullptr;
 
        if (n < (size_t)locale->locinfo->_public._locale_mb_cur_max)
        {
            t = buf;
        }
        else
        {
            t = destination;
        }
 
        _wcrtomb_internal(&i, t, MB_LEN_MAX, *wcs, state, ptd);
        if (i <= 0)
        {
            /* encountered invalid sequence */
            nc = (size_t)-1;
            break;
        }
 
        if (destination == t)
        {
            /* do nothing */
        }
        else if (n < static_cast<size_t>(i))
        {
            break;  // Won't all fit
        }
        else
        {
            memcpy_s(destination, n, buf, i);
        }
 
        if (destination[i - 1] == '\0')
        {
            // Encountered terminating null
            *source = 0;
            return nc + i - 1;
        }
    }
 
    *source = wcs;
    return nc;
}

Referenced by wcsrtombs(), and wcsrtombs_s().

if() [1/5]

if

(

!locale->locinfo->

locale_name[LC_CTYPE]

)

Definition at line 93 of file wcrtomb.cpp.

    {
        if (wchar > 255) // Validate high byte
        {
            if (return_value)
                *return_value = -1;
 
            return ptd.get_errno().set(EILSEQ);
        }
 
        *destination = static_cast<char>(wchar);
        if (return_value)
        {
            *return_value = 1;
        }
 
        return 0;
    }

if() [2/5]

if

(

locale->locinfo->_public.

_locale_lc_codepage = = CP_UTF8

)

Definition at line 72 of file wcrtomb.cpp.

    {
        // Unlike c16rtomb. wctomb/wcrtomb have no ability to process a partial code point.
        // So, we could call c16rtomb and check for a lone surrogate or other error, or for simplicity
        // We can instead just call c32rtomb and check for any error. I choose the latter.
        static mbstate_t local_state{};
        int result = static_cast<int>(__crt_mbstring::__c32rtomb_utf8(destination, static_cast<char32_t>(wchar), (state != nullptr ? state : &local_state), ptd));
        if (return_value != nullptr)
        {
            *return_value = result;
        }
        if (result <= 4)
        {
            return 0;
        }
        else
        {
            return ptd.get_errno().value_or(0);
        }
    }

if() [3/5]

if

(

return_value

)

Definition at line 133 of file wcrtomb.cpp.

    {
        *return_value = size;
    }

if() [4/5]

if

(

size

= = 0 || default_used

)

Definition at line 123 of file wcrtomb.cpp.

    {
        if (return_value)
        {
            *return_value = -1;
        }
 
        return ptd.get_errno().set(EILSEQ);
    }

if() [5/5]

if

(

state

)

Definition at line 67 of file wcrtomb.cpp.

    {
        state->_Wchar = 0;
    }

wcrtomb()

size_t __cdecl wcrtomb	(	char *const	destination,
		wchar_t const	wchar,
		mbstate_t *const	state
	)

Definition at line 200 of file wcrtomb.cpp.

{
    size_t return_value = static_cast<size_t>(-1);
    wcrtomb_s(&return_value, destination, (destination == nullptr ? 0 : MB_LEN_MAX), wchar, state);
    return return_value;
}

wcrtomb_s()

errno_t __cdecl wcrtomb_s	(	size_t *const	return_value,
		char *const	destination,
		size_t const	destination_count,
		wchar_t const	wchar,
		mbstate_t *const	state
	)

Definition at line 188 of file wcrtomb.cpp.

{
    __crt_cached_ptd_host ptd;
    return wcrtomb_s_internal(return_value, destination, destination_count, wchar, state, ptd);
}

Referenced by wcrtomb().

wcrtomb_s_internal()

static errno_t __cdecl wcrtomb_s_internal ( size_t *const  return_value, char *const  destination, size_t const  destination_count, wchar_t const  wchar, mbstate_t *const  state, __crt_cached_ptd_host &  ptd  )

static

Definition at line 154 of file wcrtomb.cpp.

{
    // Note that we do not force destination_count > 0 in the destination !=
    // nullptr case because we do not need to add a null terminator, due to
    // the fact that the destination will receive a character and not a string.
    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, (destination == nullptr && destination_count == 0) || (destination != nullptr), EINVAL);
 
    errno_t e = 0;
    int     int_return_value = -1;
    if (destination == nullptr)
    {
        char buf[MB_LEN_MAX];
        e = _wcrtomb_internal(&int_return_value, buf, MB_LEN_MAX, wchar, state, ptd);
    }
    else
    {
        e = _wcrtomb_internal(&int_return_value, destination, destination_count, wchar, state, ptd);
    }
 
    if (return_value != nullptr)
    {
        *return_value = static_cast<size_t>(int_return_value);
    }
 
    return e;
}

Referenced by wcrtomb_s().

wcsrtombs()

size_t __cdecl wcsrtombs	(	char *const	destination,
		wchar_t const **const	source,
		size_t const	n,
		mbstate_t *const	state
	)

Definition at line 314 of file wcrtomb.cpp.

{
    __crt_cached_ptd_host ptd;
    return _wcsrtombs_internal(destination, source, n, state, ptd);
}

wcsrtombs_s()

errno_t __cdecl wcsrtombs_s	(	size_t *const	return_value,
		char *const	destination,
		size_t const	destination_count,
		wchar_t const **const	source,
		size_t const	n,
		mbstate_t *const	state
	)

Definition at line 351 of file wcrtomb.cpp.

{
    __crt_cached_ptd_host ptd;
 
    if (return_value != nullptr)
    {
        *return_value = static_cast<size_t>(-1);
    }
 
    _UCRT_VALIDATE_RETURN_ERRCODE(
        ptd,
        (destination == nullptr && destination_count == 0) ||
        (destination != nullptr && destination_count >  0),
    EINVAL);
 
    if (destination != nullptr)
    {
        _RESET_STRING(destination, destination_count);
    }
 
    _UCRT_VALIDATE_RETURN_ERRCODE(ptd, source != nullptr, EINVAL);
 
    size_t retsize = _wcsrtombs_internal(destination, source, (n > destination_count ? destination_count : n), state, ptd);
    if (retsize == static_cast<size_t>(-1))
    {
        if (destination != nullptr)
        {
            _RESET_STRING(destination, destination_count);
        }
 
        return ptd.get_errno().value_or(0);
    }
 
    ++retsize; // Account for the null terminator
 
    if (destination != nullptr)
    {
        // Return error if the string does not fit:
        if (retsize > destination_count)
        {
            _RESET_STRING(destination, destination_count);
            _UCRT_VALIDATE_RETURN_ERRCODE(ptd, retsize <= destination_count, ERANGE);
        }
 
        // Ensure the string is null terminated:
        destination[retsize - 1] = '\0';
    }
 
    if (return_value != nullptr)
    {
        *return_value = retsize;
    }
 
    return 0;
}

wctob()

int __cdecl wctob

(

wint_t const

wchar

)

Definition at line 417 of file wcrtomb.cpp.

{
    __crt_cached_ptd_host ptd;
 
    if (wchar == WEOF)
    {
        return EOF;
    }
 
    int  return_value = -1;
    char local_buffer[MB_LEN_MAX];
 
    mbstate_t state{};
    errno_t const e = _wcrtomb_internal(&return_value, local_buffer, MB_LEN_MAX, wchar, &state, ptd);
    if (e == 0 && return_value == 1)
    {
        return local_buffer[0];
    }
 
    return EOF;
}

Variable Documentation

default_used

BOOL default_used {}

Definition at line 112 of file wcrtomb.cpp.

Referenced by _wctomb_internal().

destination_count

size_t const destination_count

Definition at line 52 of file wcrtomb.cpp.

Referenced by __acrt_LCMapStringEx(), __acrt_LCMapStringW(), _wctomb_internal(), _wctomb_s_l(), wcrtomb_s(), wcrtomb_s_internal(), wcsrtombs_s(), and wctomb_s().

locale

_locale_t const locale = ptd.get_locale()

Definition at line 60 of file wcrtomb.cpp.

ptd

size_t const wchar_t const mbstate_t* const _Inout_ __crt_cached_ptd_host& ptd

Initial value:

{
    _ASSERTE(destination != nullptr && destination_count > 0)

Definition at line 55 of file wcrtomb.cpp.

Referenced by __crt_mbstring::__wcsrtombs_utf8(), _wcsrtombs_internal(), if(), wcrtomb_s(), wcrtomb_s_internal(), wcsrtombs(), wcsrtombs_s(), and wctob().

return

return

Definition at line 138 of file wcrtomb.cpp.

size

int const size

Initial value:

= __acrt_WideCharToMultiByte(
        locale->locinfo->_public._locale_lc_codepage,
        0,
        &wchar,
        1,
        destination,
        static_cast<int>(destination_count),
        nullptr,
        &default_used)

Definition at line 113 of file wcrtomb.cpp.

Referenced by if().

state

size_t const wchar_t const mbstate_t* const state

Definition at line 54 of file wcrtomb.cpp.

Referenced by _wcsrtombs_internal(), if(), wcrtomb(), wcrtomb_s(), wcrtomb_s_internal(), wcsrtombs(), wcsrtombs_s(), and wctob().

wchar

size_t const wchar_t const wchar

Definition at line 53 of file wcrtomb.cpp.

Referenced by __pragma(), _putch_nolock_internal(), _wctomb_internal(), _wctomb_l(), _wctomb_s_l(), if(), KmtWcToMb(), mbtowc(), wcrtomb(), wcrtomb_s(), wcrtomb_s_internal(), wctob(), wctomb(), and wctomb_s().