1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
|
//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include <cwchar> // mbstate_t
#include <limits.h> // MB_LEN_MAX
#include <stdlib.h> // MB_CUR_MAX, size_t
#include <string.h> // memcpy
// Converts `max_source_chars` from the wide character buffer pointer to by *`src`,
// into the multi byte character sequence buffer stored at `dst`, which must be
// `dst_size_bytes` bytes in size. Returns the number of bytes in the sequence
// converted from *src, excluding the null terminator.
// Returns (size_t) -1 if an error occurs and sets errno.
// If `dst` is NULL, `dst_size_bytes` is ignored and no bytes are copied to `dst`.
_LIBCPP_EXPORTED_FROM_ABI size_t wcsnrtombs(
char* __restrict dst,
const wchar_t** __restrict src,
size_t max_source_chars,
size_t dst_size_bytes,
mbstate_t* __restrict ps) {
const size_t invalid_wchar = static_cast<size_t>(-1);
size_t source_converted;
size_t dest_converted;
size_t result = 0;
// If `dst` is null then `dst_size_bytes` should be ignored according to the
// standard. Setting dst_size_bytes to a large value has this effect.
if (dst == nullptr)
dst_size_bytes = static_cast<size_t>(-1);
for (dest_converted = source_converted = 0;
source_converted < max_source_chars && (!dst || dest_converted < dst_size_bytes);
++source_converted, dest_converted += result) {
wchar_t c = (*src)[source_converted];
size_t dest_remaining = dst_size_bytes - dest_converted;
if (dst == nullptr) {
result = wcrtomb(NULL, c, ps);
} else if (dest_remaining >= static_cast<size_t>(MB_CUR_MAX)) {
// dst has enough space to translate in-place.
result = wcrtomb(dst + dest_converted, c, ps);
} else {
/*
* dst may not have enough space, so use a temporary buffer.
*
* We need to save a copy of the conversion state
* here so we can restore it if the multibyte
* character is too long for the buffer.
*/
char buff[MB_LEN_MAX];
mbstate_t mbstate_tmp;
if (ps != nullptr)
mbstate_tmp = *ps;
result = wcrtomb(buff, c, ps);
if (result > dest_remaining) {
// Multi-byte sequence for character won't fit.
if (ps != nullptr)
*ps = mbstate_tmp;
if (result != invalid_wchar)
break;
} else {
// The buffer was used, so we need copy the translation to dst.
memcpy(dst, buff, result);
}
}
// result (char_size) contains the size of the multi-byte-sequence converted.
// Otherwise, result (char_size) is (size_t) -1 and wcrtomb() sets the errno.
if (result == invalid_wchar) {
if (dst)
*src = *src + source_converted;
return invalid_wchar;
}
if (c == L'\0') {
if (dst)
*src = NULL;
return dest_converted;
}
}
if (dst)
*src = *src + source_converted;
return dest_converted;
}
|
