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
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
|
#include "mb_wc_common.h"
#include <wchar.h>
#include <stdlib.h>
#include <errno.h>
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
static int __MINGW_ATTRIB_NONNULL(1) __MINGW_ATTRIB_NONNULL(4)
__mbrtowc_cp (wchar_t * __restrict__ pwc, const char * __restrict__ s,
size_t n, mbstate_t* __restrict__ ps,
const unsigned int cp, const unsigned int mb_max)
{
union {
mbstate_t val;
char mbcs[4];
} shift_state;
/* Do the prelim checks */
if (s == NULL)
return 0;
if (n == 0)
/* The standard doesn't mention this case explicitly. Tell
caller that the conversion from a non-null s is incomplete. */
return -2;
/* Save the current shift state, in case we need it in DBCS case. */
shift_state.val = *ps;
*ps = 0;
if (!*s)
{
*pwc = 0;
return 0;
}
if (mb_max > 1)
{
if (shift_state.mbcs[0] != 0)
{
/* Complete the mb char with the trailing byte. */
shift_state.mbcs[1] = *s; /* the second byte */
if (MultiByteToWideChar(cp, MB_ERR_INVALID_CHARS,
shift_state.mbcs, 2, pwc, 1)
== 0)
{
/* An invalid trailing byte */
errno = EILSEQ;
return -1;
}
return 2;
}
else if (IsDBCSLeadByteEx (cp, *s))
{
/* If told to translate one byte, just save the leadbyte
in *ps. */
if (n < 2)
{
((char*) ps)[0] = *s;
return -2;
}
/* Else translate the first two bytes */
else if (MultiByteToWideChar (cp, MB_ERR_INVALID_CHARS,
s, 2, pwc, 1)
== 0)
{
errno = EILSEQ;
return -1;
}
return 2;
}
}
/* Fall through to single byte char */
if (cp == 0)
*pwc = (wchar_t)(unsigned char)*s;
else if (MultiByteToWideChar (cp, MB_ERR_INVALID_CHARS, s, 1, pwc, 1)
== 0)
{
errno = EILSEQ;
return -1;
}
return 1;
}
size_t
mbrtowc (wchar_t * __restrict__ pwc, const char * __restrict__ s,
size_t n, mbstate_t* __restrict__ ps)
{
static mbstate_t internal_mbstate = 0;
wchar_t byte_bucket = 0;
wchar_t* dst = pwc ? pwc : &byte_bucket;
return (size_t) __mbrtowc_cp (dst, s, n, ps ? ps : &internal_mbstate,
get_cp_from_locale(), MB_CUR_MAX);
}
size_t
mbsrtowcs (wchar_t* __restrict__ dst, const char ** __restrict__ src,
size_t len, mbstate_t* __restrict__ ps)
{
int ret =0 ;
size_t n = 0;
static mbstate_t internal_mbstate = 0;
mbstate_t* internal_ps = ps ? ps : &internal_mbstate;
const unsigned int cp = get_cp_from_locale();;
const unsigned int mb_max = MB_CUR_MAX;
if ( src == NULL || *src == NULL ) /* undefined behavior */
return 0;
if (dst != NULL)
{
while (n < len
&& (ret = __mbrtowc_cp(dst, *src, len - n,
internal_ps, cp, mb_max))
> 0)
{
++dst;
*src += ret;
n += ret;
}
if (n < len && ret == 0)
*src = (char *)NULL;
}
else
{
wchar_t byte_bucket = 0;
while (n < len
&& (ret = __mbrtowc_cp (&byte_bucket, *src, mb_max,
internal_ps, cp, mb_max))
> 0)
{
*src += ret;
n += ret;
}
}
return n;
}
size_t
mbrlen (const char * __restrict__ s, size_t n,
mbstate_t * __restrict__ ps)
{
static mbstate_t s_mbstate = 0;
wchar_t byte_bucket = 0;
return __mbrtowc_cp (&byte_bucket, s, n, (ps) ? ps : &s_mbstate,
get_cp_from_locale(), MB_CUR_MAX);
}
|
