Something went wrong. Try again.
Reactos
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611/****mbrtowc.c - Convert multibyte char to wide char.** Copyright (c) Microsoft Corporation. All rights reserved.**Purpose:* Convert a multibyte character into the equivalent wide character.********************************************************************************/#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 <uchar.h>#include <wchar.h>
using namespace __crt_mbstring;
/****errno_t _mbrtowc_internal() - Helper function to convert multibyte char to wide character.**Purpose:* Convert a multi-byte character into the equivalent wide character,* according to the specified LC_CTYPE category, or the current locale.* [ANSI].** NOTE: Currently, the C libraries support the "C" locale only.* Non-C locale support now available under _INTL switch.*Entry:* wchar_t *dst = pointer to (single) destination wide character* const char *s = pointer to multibyte character* size_t n = maximum length of multibyte character to consider* mbstate_t *pmbst = pointer to state (must be not nullptr)* _locale_t plocinfo = locale info**Exit:* returns, in *pRetValue:* If s = nullptr, 0, indicating we only use state-independent* character encodings.* If s != nullptr: 0 (if *s = null char)* -1 (if the next n or fewer bytes not valid mbc)* number of bytes comprising converted mbc**Exceptions:********************************************************************************/
_Success_(return != 0)_Post_satisfies_(*pRetValue <= _String_length_(s))static errno_t __cdecl _mbrtowc_internal( _Inout_ _Out_range_(<=, 1) int * pRetValue, _Pre_maybenull_ _Out_writes_opt_z_(1) wchar_t * dst, _In_opt_z_ const char * s, _In_ size_t n, _Inout_ mbstate_t * pmbst, _Inout_ __crt_cached_ptd_host& ptd ) throw(){ _ASSERTE(pmbst != nullptr); _ASSIGN_IF_NOT_NULL(dst, 0);
if (!s || n == 0) { /* indicate do not have state-dependent encodings, handle zero length string */ _ASSIGN_IF_NOT_NULL(pRetValue, 0); return 0; }
if (!*s) { /* handle nullptr char */ _ASSIGN_IF_NOT_NULL(pRetValue, 0); return 0; }
const _locale_t locale = ptd.get_locale();
if (locale->locinfo->_public._locale_lc_codepage == CP_UTF8) { const size_t retval = __mbrtowc_utf8(dst, s, n, pmbst, ptd); _ASSIGN_IF_NOT_NULL(pRetValue, static_cast<int>(retval)); return ptd.get_errno().value_or(0); }
const int locale_mb_cur_max = locale->locinfo->_public._locale_mb_cur_max; _ASSERTE(locale_mb_cur_max == 1 || locale_mb_cur_max == 2);
if (locale->locinfo->locale_name[LC_CTYPE] == nullptr) { _ASSIGN_IF_NOT_NULL(dst, (wchar_t) (unsigned char) *s); _ASSIGN_IF_NOT_NULL(pRetValue, 1); return 0; }
if (pmbst->_Wchar != 0) { /* complete two-byte multibyte character */ ((char *) pmbst)[1] = *s; if (locale_mb_cur_max <= 1 || (__acrt_MultiByteToWideChar( locale->locinfo->_public._locale_lc_codepage, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS, (char *) pmbst, 2, dst, (dst != nullptr ? 1 : 0)) == 0)) { /* translation failed */ pmbst->_Wchar = 0; _ASSIGN_IF_NOT_NULL(dst, 0); _ASSIGN_IF_NOT_NULL(pRetValue, -1); return ptd.get_errno().set(EILSEQ); } pmbst->_Wchar = 0; _ASSIGN_IF_NOT_NULL(pRetValue, locale_mb_cur_max); return 0; } else if (_isleadbyte_fast_internal((unsigned char) *s, locale)) { /* multi-byte char */ if (n < (size_t) locale_mb_cur_max) { /* save partial multibyte character */ ((char *) pmbst)[0] = *s; _ASSIGN_IF_NOT_NULL(pRetValue, -2); return 0; } else if (locale_mb_cur_max <= 1 || (__acrt_MultiByteToWideChar(locale->locinfo->_public._locale_lc_codepage, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS, s, static_cast<int>(__min(strlen(s), INT_MAX)), dst, (dst != nullptr ? 1 : 0)) == 0)) { /* validate high byte of mbcs char */ if (!*(s + 1)) { pmbst->_Wchar = 0; _ASSIGN_IF_NOT_NULL(dst, 0); _ASSIGN_IF_NOT_NULL(pRetValue, -1); return ptd.get_errno().set(EILSEQ); } } _ASSIGN_IF_NOT_NULL(pRetValue, locale_mb_cur_max); return 0; } else { /* single byte char */ if (__acrt_MultiByteToWideChar( locale->locinfo->_public._locale_lc_codepage, MB_PRECOMPOSED | MB_ERR_INVALID_CHARS, s, 1, dst, (dst != nullptr ? 1 : 0)) == 0) { _ASSIGN_IF_NOT_NULL(dst, 0); _ASSIGN_IF_NOT_NULL(pRetValue, -1); return ptd.get_errno().set(EILSEQ); }
_ASSIGN_IF_NOT_NULL(pRetValue, sizeof(char) ); return 0; }}
/****wint_t btowc(c) - translate single byte to wide char**Purpose:**Entry:**Exit:**Exceptions:********************************************************************************/
extern "C" wint_t __cdecl btowc( int c ){ if (c == EOF) { return WEOF; } else { /* convert as one-byte string */ char ch = (char) c; mbstate_t mbst = {}; wchar_t wc = 0; int retValue = -1;
__crt_cached_ptd_host ptd; _mbrtowc_internal(&retValue, &wc, &ch, 1, &mbst, ptd); return (retValue < 0 ? WEOF : wc); }}
/****size_t mbrlen(s, n, pst) - determine next multibyte code, restartably**Purpose:**Entry:**Exit:**Exceptions:********************************************************************************/
extern "C" size_t __cdecl mbrlen( const char *s, size_t n, mbstate_t *pst ){ static mbstate_t mbst = {}; int retValue = -1;
__crt_cached_ptd_host ptd; _mbrtowc_internal(&retValue, nullptr, s, n, (pst != nullptr ? pst : &mbst), ptd); return retValue;}
/****size_t mbrtowc(pwc, s, n, pst) - translate multibyte to wchar_t, restartably**Purpose:**Entry:**Exit:**Exceptions:********************************************************************************/
extern "C" size_t __cdecl mbrtowc( wchar_t *dst, const char *s, size_t n, mbstate_t *pst ){ static mbstate_t mbst = {}; int retValue = -1;
__crt_cached_ptd_host ptd;
if (s != nullptr) { _mbrtowc_internal(&retValue, dst, s, n, (pst != nullptr ? pst : &mbst), ptd); } else { _mbrtowc_internal(&retValue, nullptr, "", 1, (pst != nullptr ? pst : &mbst), ptd); } return retValue;}
/****size_t mbsrtowcs(wcs, ps, n, pst) - translate multibyte string to wide,* restartably**Purpose:**Entry:**Exit:**Exceptions:********************************************************************************/
/* Helper function shared by the secure and non-secure versions. */
_Success_(return == 0)static size_t __cdecl _mbsrtowcs_helper( _Out_writes_opt_z_(n) wchar_t * wcs, _Deref_pre_opt_z_ const char ** ps, _In_ size_t n, _Inout_ mbstate_t * pst, _Inout_ __crt_cached_ptd_host& ptd ) throw(){ /* validation section */ _UCRT_VALIDATE_RETURN(ptd, ps != nullptr, EINVAL, (size_t) - 1);
static mbstate_t mbst = {}; const char *s = *ps; int i = 0; size_t nwc = 0;
// Use the static cached state if necessary if (pst == nullptr) { pst = &mbst; }
const _locale_t locale = ptd.get_locale();
if (locale->locinfo->_public._locale_lc_codepage == CP_UTF8) { return __mbsrtowcs_utf8(wcs, ps, n, pst, ptd); }
if (wcs == nullptr) { for (;; ++nwc, s += i) { /* translate but don't store */ wchar_t wc; _mbrtowc_internal(&i, &wc, s, INT_MAX, pst, ptd); if (i < 0) { return (size_t) - 1; } else if (i == 0) { return nwc; } } }
for (; 0 < n; ++nwc, s += i, ++wcs, --n) { /* translate and store */ _mbrtowc_internal(&i, wcs, s, INT_MAX, pst, ptd); if (i < 0) { /* encountered invalid sequence */ nwc = (size_t) - 1; break; } else if (i == 0) { /* encountered terminating null */ s = 0; break; } }
*ps = s; return nwc;}
/****size_t mbsrtowcs() - Convert multibyte char string to wide char string.**Purpose:* Convert a multi-byte char string into the equivalent wide char string,* according to the LC_CTYPE category of the current locale.* Same as mbsrtowcs_s(), but the destination may not be null terminated.* If there's not enough space, we return EINVAL.**Entry:* wchar_t *pwcs = pointer to destination wide character string buffer* const char **s = pointer to source multibyte character string* size_t n = maximum number of wide characters to store (not including the terminating null character)* mbstate_t *pst = pointer to the conversion state**Exit:* The nunber if wide characters written to *wcs, not including any terminating null character)**Exceptions:* Input parameters are validated. Refer to the validation section of the function.********************************************************************************/extern "C" size_t __cdecl mbsrtowcs( wchar_t * wcs, const char ** ps, size_t n, mbstate_t * pst ){ /* Call a non-deprecated helper to do the work. */ __crt_cached_ptd_host ptd; return _mbsrtowcs_helper(wcs, ps, n, pst, ptd);}
/****errno_t mbsrtowcs_s() - Convert multibyte char string to wide char string.**Purpose:* Convert a multi-byte char string into the equivalent wide char string,* according to the LC_CTYPE category of the current locale.* Same as mbsrtowcs(), but the destination is ensured to be null terminated.* If there's not enough space, we return EINVAL.**Entry:* size_t *pRetValue = Number of bytes modified including the terminating nullptr* This pointer can be nullptr.* wchar_t *pwcs = pointer to destination wide character string buffer* size_t sizeInWords = size of the destination buffer* const char **s = pointer to source multibyte character string* size_t n = maximum number of wide characters to store (not including the terminating null character)* mbstate_t *pst = pointer to the conversion state**Exit:* The error code.**Exceptions:* Input parameters are validated. Refer to the validation section of the function.********************************************************************************/
static errno_t __cdecl mbsrtowcs_s_internal( size_t * pRetValue, wchar_t * dst, size_t sizeInWords, const char ** ps, size_t n, mbstate_t * pmbst, __crt_cached_ptd_host& ptd ){ size_t retsize;
/* validation section */ _ASSIGN_IF_NOT_NULL(pRetValue, (size_t) - 1); _UCRT_VALIDATE_RETURN_ERRCODE(ptd, (dst == nullptr && sizeInWords == 0) || (dst != nullptr && sizeInWords > 0), EINVAL); if (dst != nullptr) { _RESET_STRING(dst, sizeInWords); } _UCRT_VALIDATE_RETURN_ERRCODE(ptd, ps != nullptr, EINVAL);
/* Call a non-deprecated helper to do the work. */
retsize = _mbsrtowcs_helper(dst, ps, (n > sizeInWords ? sizeInWords : n), pmbst, ptd);
if (retsize == (size_t) - 1) { if (dst != nullptr) { _RESET_STRING(dst, sizeInWords); } return ptd.get_errno().value_or(0); }
/* count the null terminator */ retsize++;
if (dst != nullptr) { /* return error if the string does not fit */ if (retsize > sizeInWords) { _RESET_STRING(dst, sizeInWords); _UCRT_VALIDATE_RETURN_ERRCODE(ptd, sizeInWords <= retsize, ERANGE); } else { /* ensure the string is null terminated */ dst[retsize - 1] = '\0'; } }
_ASSIGN_IF_NOT_NULL(pRetValue, retsize);
return 0;}
extern "C" errno_t __cdecl mbsrtowcs_s( size_t * pRetValue, wchar_t * dst, size_t sizeInWords, const char ** ps, size_t n, mbstate_t * pmbst ){ __crt_cached_ptd_host ptd; return mbsrtowcs_s_internal(pRetValue, dst, sizeInWords, ps, n, pmbst, ptd);}
size_t __cdecl __crt_mbstring::__mbrtowc_utf8(wchar_t* pwc, const char* s, size_t n, mbstate_t* ps, __crt_cached_ptd_host& ptd){ static_assert(sizeof(wchar_t) == 2, "wchar_t is assumed to be 16 bits"); char32_t c32; const size_t retval = __mbrtoc32_utf8(&c32, s, n, ps, ptd); // If we succesfully consumed a character, write the result after a quick range check if (retval <= 4) { if (c32 > 0xffff) { // A 4-byte UTF-8 character won't fit into a single UTF-16 wchar // So return the "replacement char" c32 = 0xfffd; } _ASSIGN_IF_NOT_NULL(pwc, static_cast<wchar_t>(c32)); } return retval;}
size_t __cdecl __crt_mbstring::__mbsrtowcs_utf8(wchar_t* dst, const char** src, size_t len, mbstate_t* ps, __crt_cached_ptd_host& ptd){ const char* current_src = *src;
auto compute_available = [](const char* s) -> size_t { // We shouldn't just blindly request to read 4 bytes, because there might not be 4 bytes left to read. if (s[0] == '\0') { return 1; } else if (s[1] == '\0') { return 2; } else if (s[2] == '\0') { return 3; } return 4; };
if (dst != nullptr) { wchar_t* current_dest = dst; for (; len > 0; --len) { const size_t avail = compute_available(current_src); char32_t c32; const size_t retval = __mbrtoc32_utf8(&c32, current_src, avail, ps, ptd); if (retval == __crt_mbstring::INVALID) { // Set src to the beginning of the invalid char *src = current_src; ptd.get_errno().set(EILSEQ); return retval; } else if (retval == 0) { current_src = nullptr; *current_dest = L'\0'; break; } else if (c32 > 0xffff) { // This is going to take two output wchars. Make sure we have enough room for this output. if (len > 1) { --len; c32 -= 0x10000; const char16_t high_surrogate = static_cast<char16_t>((c32 >> 10) | 0xd800); const char16_t low_surrogate = static_cast<char16_t>((c32 & 0x03ff) | 0xdc00); *current_dest++ = high_surrogate; *current_dest++ = low_surrogate; } else { break; } } else { *current_dest++ = static_cast<wchar_t>(c32); } current_src += retval; } *src = current_src; return current_dest - dst; } else { size_t total_count = 0; for (;; ++total_count) { const size_t avail = compute_available(current_src);
const size_t retval = __mbrtoc32_utf8(nullptr, current_src, avail, ps, ptd); if (retval == __crt_mbstring::INVALID) { ptd.get_errno().set(EILSEQ); return retval; } else if (retval == 0) { break; } else if (retval == 4) { // SMP characters take two UTF-16 wide chars ++total_count; } else { // This should be impossible. Means we encountered a multibyte char // that extended past the null terminator, or is more than 4 bytes long _ASSERTE(retval != __crt_mbstring::INCOMPLETE); } current_src += retval; } return total_count; }}