1 /* $NetBSD: mbrtoc8.c,v 1.8 2024/08/21 18:36:11 rillig Exp $ */
2
3 /*-
4 * Copyright (c) 2024 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29 /*
30 * mbrtoc8(&c8, s, n, ps)
31 *
32 * Decode a Unicode scalar value from up to n bytes out of the
33 * multibyte string s, using multibyte encoding state ps, and
34 * store the next code unit in the UTF-8 representation of that
35 * scalar value at c8.
36 *
37 * If the UTF-8 representation of that scalar value is multiple
38 * bytes long, mbrtoc8 will yield the leading byte in one call that
39 * consumes input, and will yield the trailing bytes in subsequent
40 * calls without consuming any input and returning (size_t)-3
41 * instead.
42 *
43 * Return the number of bytes consumed on success, or:
44 *
45 * - 0 if the code unit is NUL, or
46 * - (size_t)-3 if a trailing byte was returned without consuming
47 * any additional input, or
48 * - (size_t)-2 if the input is incomplete, or
49 * - (size_t)-1 on error with errno set to EILSEQ.
50 *
51 * In the case of incomplete input, the decoding state so far
52 * after processing s[0], s[1], ..., s[n - 1] is saved in ps, so
53 * subsequent calls to mbrtoc8 will pick up n bytes later into
54 * the input stream.
55 *
56 * References:
57 *
58 * The Unicode Standard, Version 15.0 -- Core Specification, The
59 * Unicode Consortium, Sec. 3.8 `Surrogates', p. 118.
60 * https://www.unicode.org/versions/Unicode15.0.0/UnicodeStandard-15.0.pdf#page=144
61 * https://web.archive.org/web/20240718101254/https://www.unicode.org/versions/Unicode15.0.0/UnicodeStandard-15.0.pdf#page=144
62 *
63 * The Unicode Standard, Version 15.0 -- Core Specification, The
64 * Unicode Consortium, Sec. 3.9 `Unicode Encoding Forms': UTF-8,
65 * p. 124.
66 * https://www.unicode.org/versions/Unicode15.0.0/UnicodeStandard-15.0.pdf#page=150
67 * https://web.archive.org/web/20240718101254/https://www.unicode.org/versions/Unicode15.0.0/UnicodeStandard-15.0.pdf#page=150
68 *
69 * F. Yergeau, `UTF-8, a transformation format of ISO 10646',
70 * RFC 3629, Internet Engineering Task Force, November 2003.
71 * https://datatracker.ietf.org/doc/html/rfc3629
72 */
73
74 #include <sys/cdefs.h>
75 __RCSID("$NetBSD: mbrtoc8.c,v 1.8 2024/08/21 18:36:11 rillig Exp $");
76
77 #include "namespace.h"
78
79 #include <assert.h>
80 #include <errno.h>
81 #include <locale.h>
82 #include <stdalign.h>
83 #include <stddef.h>
84 #include <uchar.h>
85
86 #include "mbrtoc32.h"
87 #include "setlocale_local.h"
88
89 struct mbrtoc8state {
90 char8_t nleft;
91 char8_t buf[3];
92 mbstate_t mbs;
93 };
94 __CTASSERT(offsetof(struct mbrtoc8state, mbs) <= sizeof(mbstate_t));
95 __CTASSERT(sizeof(struct mbrtoc32state) <= sizeof(mbstate_t) -
96 offsetof(struct mbrtoc8state, mbs));
97 __CTASSERT(alignof(struct mbrtoc8state) <= alignof(mbstate_t));
98
99 #ifdef __weak_alias
__weak_alias(mbrtoc8_l,_mbrtoc8_l)100 __weak_alias(mbrtoc8_l,_mbrtoc8_l)
101 #endif
102
103 size_t
104 mbrtoc8(char8_t *restrict pc8, const char *restrict s, size_t n,
105 mbstate_t *restrict ps)
106 {
107
108 return mbrtoc8_l(pc8, s, n, ps, _current_locale());
109 }
110
111 size_t
mbrtoc8_l(char8_t * restrict pc8,const char * restrict s,size_t n,mbstate_t * restrict ps,locale_t restrict loc)112 mbrtoc8_l(char8_t *restrict pc8, const char *restrict s, size_t n,
113 mbstate_t *restrict ps, locale_t restrict loc)
114 {
115 static mbstate_t psbuf;
116 struct mbrtoc8state *S;
117 char32_t c32;
118 size_t len;
119
120 /*
121 * `If ps is a null pointer, each function uses its own
122 * internal mbstate_t object instead, which is initialized at
123 * program startup to the initial conversion state; the
124 * functions are not required to avoid data races with other
125 * calls to the same function in this case. The
126 * implementation behaves as if no library function calls
127 * these functions with a null pointer for ps.'
128 */
129 if (ps == NULL)
130 ps = &psbuf;
131
132 /*
133 * `If s is a null pointer, the mbrtoc8 function is equivalent
134 * to the call:
135 *
136 * mbrtoc8(NULL, "", 1, ps)
137 *
138 * In this case, the values of the parameters pc8 and n are
139 * ignored.'
140 */
141 if (s == NULL) {
142 pc8 = NULL;
143 s = "";
144 n = 1;
145 }
146
147 /*
148 * Get the private conversion state.
149 */
150 S = (struct mbrtoc8state *)(void *)ps;
151
152 /*
153 * If there are pending trailing bytes, yield them and return
154 * (size_t)-3 to indicate that no bytes of input were consumed.
155 */
156 if (S->nleft) {
157 if (pc8)
158 *pc8 = S->buf[sizeof(S->buf) - S->nleft];
159 S->buf[sizeof(S->buf) - S->nleft] = 0; /* paranoia */
160 S->nleft--;
161 return (size_t)-3;
162 }
163
164 /*
165 * Consume the next scalar value. If no full scalar value can
166 * be obtained, stop here.
167 */
168 len = mbrtoc32_l(&c32, s, n, &S->mbs, loc);
169 switch (len) {
170 case 0: /* NUL */
171 if (pc8)
172 *pc8 = 0;
173 return 0;
174 case (size_t)-2: /* still incomplete after n bytes */
175 case (size_t)-1: /* error */
176 return len;
177 default: /* consumed len bytes of input */
178 break;
179 }
180
181 /*
182 * We consumed a scalar value from the input.
183 *
184 * Encode it as UTF-8, yield the leading byte, and buffer the
185 * trailing bytes to yield later.
186 *
187 * Table 3-6: UTF-8 Bit Distribution
188 * Table 3-7: Well-Formed UTF-8 Byte Sequences
189 */
190 switch (c32) {
191 case 0x00 ... 0x7f:
192 if (pc8)
193 *pc8 = c32;
194 _DIAGASSERT(S->nleft == 0);
195 break;
196 case 0x0080 ... 0x07ff:
197 if (pc8)
198 *pc8 = 0xc0 | __SHIFTOUT(c32, __BITS(10,6));
199 S->buf[2] = 0x80 | __SHIFTOUT(c32, __BITS(5,0));
200 S->nleft = 1;
201 break;
202 case 0x0800 ... 0xffff:
203 if (pc8)
204 *pc8 = 0xe0 | __SHIFTOUT(c32, __BITS(15,12));
205 S->buf[1] = 0x80 | __SHIFTOUT(c32, __BITS(11,6));
206 S->buf[2] = 0x80 | __SHIFTOUT(c32, __BITS(5,0));
207 S->nleft = 2;
208 break;
209 case 0x10000 ... 0x10ffff:
210 if (pc8)
211 *pc8 = 0xf0 | __SHIFTOUT(c32, __BITS(20,18));
212 S->buf[0] = 0x80 | __SHIFTOUT(c32, __BITS(17,12));
213 S->buf[1] = 0x80 | __SHIFTOUT(c32, __BITS(11,6));
214 S->buf[2] = 0x80 | __SHIFTOUT(c32, __BITS(5,0));
215 S->nleft = 3;
216 break;
217 default:
218 errno = EILSEQ;
219 return (size_t)-1;
220 }
221
222 /*
223 * Return the number of bytes consumed from the input.
224 */
225 return len;
226 }
227