__crt_mbstring Namespace Reference

Functions
size_t	return_illegal_sequence (mbstate_t *ps, __crt_cached_ptd_host &ptd)
size_t	reset_and_return (size_t retval, mbstate_t *ps)
size_t __cdecl	__c16rtomb_utf8 (char *s, char16_t c16, mbstate_t *ps, __crt_cached_ptd_host &ptd)
size_t __cdecl	__c32rtomb_utf8 (char *s, char32_t c32, mbstate_t *ps, __crt_cached_ptd_host &ptd)
size_t __cdecl	__mbrtoc16_utf8 (char16_t *pc32, const char *s, size_t n, mbstate_t *ps, __crt_cached_ptd_host &ptd)
size_t __cdecl	__mbrtoc32_utf8 (char32_t *pc32, const char *s, size_t n, mbstate_t *ps, __crt_cached_ptd_host &ptd)
size_t __cdecl	__mbrtowc_utf8 (wchar_t *pwc, const char *s, size_t n, mbstate_t *ps, __crt_cached_ptd_host &ptd)
size_t __cdecl	__mbsrtowcs_utf8 (wchar_t *dst, const char **src, size_t len, mbstate_t *ps, __crt_cached_ptd_host &ptd)
size_t __cdecl	__wcsrtombs_utf8 (char *dst, const wchar_t **src, size_t len, mbstate_t *ps, __crt_cached_ptd_host &ptd)

Variables
constexpr size_t	INVALID = static_cast<size_t>(-1)
constexpr size_t	INCOMPLETE = static_cast<size_t>(-2)

Function Documentation

__c16rtomb_utf8()

size_t __cdecl __crt_mbstring::__c16rtomb_utf8	(	char *	s,
		char16_t	c16,
		mbstate_t *	ps,
		__crt_cached_ptd_host &	ptd
	)

Definition at line 54 of file c16rtomb.cpp.

{
    static mbstate_t internal_pst{};
    if (ps == nullptr)
    {
        ps = &internal_pst;
    }
 
    if (!has_surrogate(ps))
    {
        if (is_second_surrogate(c16))
        {
            return return_illegal_sequence(ps, ptd);
        }
        else if (is_first_surrogate(c16))
        {
            store_first_surrogate(c16, ps);
            return 0;
        }
        else
        {
            return __c32rtomb_utf8(s, static_cast<char32_t>(c16), ps, ptd);
        }
    }
    else
    {
        // We've already seen the first (high) surrogate, so we're
        // expecting to complete this code point with its other half
        // in the second (low) surrogate
        if (!is_second_surrogate(c16))
        {
            return return_illegal_sequence(ps, ptd);
        }
        const char32_t c32 = combine_second_surrogate(c16, ps);
 
        mbstate_t temp{};
        const size_t retval = __c32rtomb_utf8(s, c32, &temp, ptd);
        return reset_and_return(retval, ps);
    }
}

Referenced by __wcsrtombs_utf8(), and c16rtomb().

__c32rtomb_utf8()

size_t __cdecl __crt_mbstring::__c32rtomb_utf8	(	char *	s,
		char32_t	c32,
		mbstate_t *	ps,
		__crt_cached_ptd_host &	ptd
	)

Definition at line 21 of file c32rtomb.cpp.

{
    if (!s)
    {
        // Equivalent to c32rtomb(buf, U'\0', ps) for some internal buffer buf
        *ps = {};
        return 1;
    }
 
    if (c32 == U'\0')
    {
        *s = '\0';
        *ps = {};
        return 1;
    }
 
    // Fast path for ASCII
    if ((c32 & ~0x7f) == 0)
    {
        *s = static_cast<char>(c32);
        return 1;
    }
 
    // Figure out how many trail bytes we need
    size_t trail_bytes;
    uint8_t lead_byte;
    if ((c32 & ~0x7ff) == 0)
    {
        trail_bytes = 1;
        lead_byte = 0xc0;
    }
    else if ((c32 & ~0xffff) == 0)
    {
        // high/low surrogates are only valid in UTF-16 encoded data
        if (0xd800 <= c32 && c32 <= 0xdfff)
        {
            return return_illegal_sequence(ps, ptd);
        }
        trail_bytes = 2;
        lead_byte = 0xe0;
    }
    else if ((c32 & ~0x001fffff) == 0)
    {
        // Unicode's max code point is 0x10ffff
        if (0x10ffff < c32)
        {
            return return_illegal_sequence(ps, ptd);
        }
        trail_bytes = 3;
        lead_byte = 0xf0;
    }
    else
    {
        return return_illegal_sequence(ps, ptd);
    }
    _ASSERTE(1 <= trail_bytes && trail_bytes <= 3);
 
    // Put six bits into each of the trail bytes
    // Lowest bits are in the last UTF-8 byte.
    // Filling back to front.
    for (size_t i = trail_bytes; i > 0; --i)
    {
        s[i] = (c32 & 0x3f) | 0x80;
        c32 >>= 6;
    }
 
    // The first byte needs the upper (trail_bytes + 1) bits to store the length
    // And the lower (7 - trail_bytes) to store the upper bits of the code point
    _ASSERTE(c32 < (1u << (7 - trail_bytes)));
    s[0] = static_cast<uint8_t>(c32) | lead_byte;
 
    return reset_and_return(trail_bytes + 1, ps);
}

Referenced by __c16rtomb_utf8(), _wctomb_internal(), c32rtomb(), and if().

__mbrtoc16_utf8()

size_t __cdecl __crt_mbstring::__mbrtoc16_utf8	(	char16_t *	pc32,
		const char *	s,
		size_t	n,
		mbstate_t *	ps,
		__crt_cached_ptd_host &	ptd
	)

Definition at line 50 of file mbrtoc16.cpp.

{
    static mbstate_t internal_pst{};
    if (ps == nullptr)
    {
        ps = &internal_pst;
    }
 
    if (is_surrogate_state(ps))
    {
        return end_surrogate_state(pc16, ps);
    }
 
    char32_t c32;
    const size_t retval = __mbrtoc32_utf8(&c32, s, n, ps, ptd);
    if (!s || retval == INVALID || retval == INCOMPLETE)
    {
        return retval;
    }
    else if (c32 > 0x10ffff)
    {
        // Input is out of range for UTF-16
        return return_illegal_sequence(ps, ptd);
    }
 
    // Got a valid character
    if (c32 <= 0xffff)
    {
        if (pc16)
        {
            *pc16 = static_cast<char16_t>(c32);
        }
        return reset_and_return(retval, ps);
    }
    else
    {
        return begin_surrogate_state(pc16, c32, retval, ps);
    }
}

Referenced by mbrtoc16().

__mbrtoc32_utf8()

size_t __cdecl __crt_mbstring::__mbrtoc32_utf8	(	char32_t *	pc32,
		const char *	s,
		size_t	n,
		mbstate_t *	ps,
		__crt_cached_ptd_host &	ptd
	)

Definition at line 22 of file mbrtoc32.cpp.

{
    const char* begin = s;
    static mbstate_t internal_pst{};
    if (ps == nullptr)
    {
        ps = &internal_pst;
    }
 
    if (!s)
    {
        s = "";
        n = 1;
        pc32 = nullptr;
    }
 
    if (n == 0)
    {
        return INCOMPLETE;
    }
 
    // Retrieve the first byte from the string, or from the previous state
    uint8_t length;
    uint8_t bytes_needed;
    char32_t c32;
    const bool init_state = (ps->_State == 0);
    if (init_state)
    {
        const uint8_t first_byte = static_cast<uint8_t>(*s++);
 
        // Optimize for ASCII if in initial state
        if ((first_byte & 0x80) == 0)
        {
            if (pc32 != nullptr)
            {
                *pc32 = first_byte;
            }
            return first_byte != '\0' ? 1 : 0;
        }
 
        if ((first_byte & 0xe0) == 0xc0)
        {
            length = 2;
        }
        else if ((first_byte & 0xf0) == 0xe0)
        {
            length = 3;
        }
        else if ((first_byte & 0xf8) == 0xf0)
        {
            length = 4;
        }
        else
        {
            return return_illegal_sequence(ps, ptd);
        }
        bytes_needed = length;
        // Mask out the length bits
        c32 = first_byte & ((1 << (7 - length)) - 1);
    }
    else
    {
        c32 = ps->_Wchar;
        length = static_cast<uint8_t>(ps->_Byte);
        bytes_needed = static_cast<uint8_t>(ps->_State);
 
        // Make sure we don't have some sort of invalid/corrupted state.
        // Any input that left behind state would have been more than one byte long
        // and the first byte should have been processed already.
        if (length < 2 || length > 4 || bytes_needed < 1 || bytes_needed >= length)
        {
            return return_illegal_sequence(ps, ptd);
        }
    }
 
    // Don't read more bytes than we're allowed
    if (bytes_needed < n)
    {
        n = bytes_needed;
    }
 
    // We've already read the first byte.
    // All remaining bytes should be continuation bytes
    while (static_cast<size_t>(s - begin) < n)
    {
        uint8_t current_byte = static_cast<uint8_t>(*s++);
        if ((current_byte & 0xc0) != 0x80)
        {
            // Not a continuation character
            return return_illegal_sequence(ps, ptd);
        }
        c32 = (c32 << 6) | (current_byte & 0x3f);
    }
 
    if (n < bytes_needed)
    {
        // Store state and return incomplete
        auto bytes_remaining = static_cast<uint8_t>(bytes_needed - n);
        static_assert(sizeof(mbstate_t::_Wchar) >= sizeof(char32_t), "mbstate_t has broken mbrtoc32");
        ps->_Wchar = c32;
        ps->_Byte = length;
        ps->_State = bytes_remaining;
        return INCOMPLETE;
    }
 
    if ((0xd800 <= c32 && c32 <= 0xdfff) || (0x10ffff < c32))
    {
        // Invalid code point (surrogate or out of range)
        return return_illegal_sequence(ps, ptd);
    }
 
    constexpr char32_t min_legal[3]{ 0x80, 0x800, 0x10000 };
    if (c32 < min_legal[length - 2])
    {
        // Overlong encoding
        return return_illegal_sequence(ps, ptd);
    }
 
    // Success! Store results
    if (pc32 != nullptr)
    {
        *pc32 = c32;
    }
 
    return reset_and_return(c32 == U'\0' ? 0 : bytes_needed, ps);
}

Referenced by __mbrtoc16_utf8(), and mbrtoc32().

__mbrtowc_utf8()

size_t __cdecl __crt_mbstring::__mbrtowc_utf8	(	wchar_t *	pwc,
		const char *	s,
		size_t	n,
		mbstate_t *	ps,
		__crt_cached_ptd_host &	ptd
	)

Referenced by __mbrtowc_utf8(), _mblen_internal(), and _mbtowc_internal().

__mbsrtowcs_utf8()

size_t __cdecl __crt_mbstring::__mbsrtowcs_utf8	(	wchar_t *	dst,
		const char **	src,
		size_t	len,
		mbstate_t *	ps,
		__crt_cached_ptd_host &	ptd
	)

Referenced by __mbsrtowcs_utf8(), _mbstowcs_l_helper(), and write_double_translated_ansi_nolock().

__wcsrtombs_utf8()

size_t __cdecl __crt_mbstring::__wcsrtombs_utf8	(	char *	dst,
		const wchar_t **	src,
		size_t	len,
		mbstate_t *	ps,
		__crt_cached_ptd_host &	ptd
	)

Definition at line 439 of file wcrtomb.cpp.

{
    const wchar_t* current_src = *src;
    char buf[MB_LEN_MAX];
 
    if (dst != nullptr)
    {
        char* current_dest = dst;
 
        // Wide chars are actually UTF-16, so a code point might take 2 input units (a surrogate pair)
        // In case of a failure, keep track of where the current code point began, which might be the previous
        // wchar for a surrogate pair
        const wchar_t* start_of_code_point = current_src;
        for (;;)
        {
            // If we don't have at least 4 MB_CUR_LEN bytes available in the buffer
            // the next char isn't guaranteed to fit, so put it into a temp buffer
            char* temp;
            if (len < 4)
            {
                temp = buf;
            }
            else
            {
                temp = current_dest;
            }
            const size_t retval = __c16rtomb_utf8(temp, *current_src, ps, ptd);
 
            if (retval == __crt_mbstring::INVALID)
            {
                // Set src to the beginning of the invalid char
                // If this was the second half of a surrogate pair, return the beginning of the surrogate pair
                *src = start_of_code_point;
                return retval;
            }
 
            if (temp == current_dest)
            {
                // We wrote in-place. Nothing to do.
            }
            else if (len < retval)
            {
                // Won't fit, so bail out
                // If this was the second half of a surrogate pair, make sure we return that location
                current_src = start_of_code_point;
                break;
            }
            else
            {
                // Will fit in remaining buffer, so let's copy it over
                memcpy(current_dest, temp, retval);
            }
 
            if (retval > 0 && current_dest[retval - 1] == '\0')
            {
                // Reached null terminator, so break out, but don't count that last terminating byte
                current_src = nullptr;
                current_dest += retval - 1;
                break;
            }
 
            ++current_src;
            if (retval > 0)
            {
                start_of_code_point = current_src;
            }
 
            len -= retval;
            current_dest += retval;
        }
        *src = current_src;
        return current_dest - dst;
    }
    else
    {
        size_t total_count = 0;
        for (;;)
        {
            const size_t retval = __c16rtomb_utf8(buf, *current_src, ps, ptd);
            if (retval == __crt_mbstring::INVALID)
            {
                return retval;
            }
            else if (retval > 0 && buf[retval - 1] == '\0')
            {
                // Hit null terminator. Don't count it in the return value.
                total_count += retval - 1;
                break;
            }
            total_count += retval;
            ++current_src;
        }
        return total_count;
    }
}

Referenced by __mbsrtowcs_utf8(), _wcsrtombs_internal(), and if().

reset_and_return()

size_t __crt_mbstring::reset_and_return	(	size_t	retval,
		mbstate_t *	ps
	)

Definition at line 22 of file common_utf8.cpp.

    {
        *ps = {};
        return retval;
    }

Referenced by __c16rtomb_utf8(), __c32rtomb_utf8(), __mbrtoc16_utf8(), __mbrtoc32_utf8(), and anonymous_namespace{mbrtoc16.cpp}::end_surrogate_state().

return_illegal_sequence()

size_t __crt_mbstring::return_illegal_sequence	(	mbstate_t *	ps,
		__crt_cached_ptd_host &	ptd
	)

Definition at line 15 of file common_utf8.cpp.

    {
        *ps = {};
        ptd.get_errno().set(EILSEQ);
        return INVALID;
    }

Referenced by __c16rtomb_utf8(), __c32rtomb_utf8(), __mbrtoc16_utf8(), and __mbrtoc32_utf8().

Variable Documentation

INCOMPLETE

constexpr size_t __crt_mbstring::INCOMPLETE = static_cast<size_t>(-2)

constexpr

Definition at line 148 of file corecrt_internal_mbstring.h.

Referenced by __mbrtoc16_utf8(), and __mbrtoc32_utf8().

INVALID

constexpr size_t __crt_mbstring::INVALID = static_cast<size_t>(-1)

constexpr

Definition at line 147 of file corecrt_internal_mbstring.h.

Referenced by __mbrtoc16_utf8(), __wcsrtombs_utf8(), and return_illegal_sequence().