citrus_utf1632.c revision 331722 
1/* $FreeBSD: stable/11/lib/libiconv_modules/UTF1632/citrus_utf1632.c 331722 2018-03-29 02:50:57Z eadler $ */
2/*	$NetBSD: citrus_utf1632.c,v 1.9 2008/06/14 16:01:08 tnozaki Exp $	*/
3
4/*-
5 * Copyright (c)2003 Citrus Project,
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 *    notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 *    notice, this list of conditions and the following disclaimer in the
15 *    documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27 * SUCH DAMAGE.
28 */
29
30#include <sys/cdefs.h>
31#include <sys/endian.h>
32#include <sys/types.h>
33
34#include <assert.h>
35#include <errno.h>
36#include <limits.h>
37#include <stddef.h>
38#include <stdio.h>
39#include <stdlib.h>
40#include <string.h>
41#include <wchar.h>
42
43#include "citrus_namespace.h"
44#include "citrus_types.h"
45#include "citrus_module.h"
46#include "citrus_stdenc.h"
47#include "citrus_bcs.h"
48
49#include "citrus_utf1632.h"
50
51
52/* ----------------------------------------------------------------------
53 * private stuffs used by templates
54 */
55
56typedef struct {
57	int		 chlen;
58	int		 current_endian;
59	uint8_t		 ch[4];
60} _UTF1632State;
61
62#define _ENDIAN_UNKNOWN		0
63#define _ENDIAN_BIG		1
64#define _ENDIAN_LITTLE		2
65#if BYTE_ORDER == BIG_ENDIAN
66#define _ENDIAN_INTERNAL	_ENDIAN_BIG
67#define _ENDIAN_SWAPPED		_ENDIAN_LITTLE
68#else
69#define _ENDIAN_INTERNAL	_ENDIAN_LITTLE
70#define _ENDIAN_SWAPPED	_ENDIAN_BIG
71#endif
72#define _MODE_UTF32		0x00000001U
73#define _MODE_FORCE_ENDIAN	0x00000002U
74
75typedef struct {
76	int		 preffered_endian;
77	unsigned int	 cur_max;
78	uint32_t	 mode;
79} _UTF1632EncodingInfo;
80
81#define _FUNCNAME(m)			_citrus_UTF1632_##m
82#define _ENCODING_INFO			_UTF1632EncodingInfo
83#define _ENCODING_STATE			_UTF1632State
84#define _ENCODING_MB_CUR_MAX(_ei_)	((_ei_)->cur_max)
85#define _ENCODING_IS_STATE_DEPENDENT	0
86#define _STATE_NEEDS_EXPLICIT_INIT(_ps_)	0
87
88
89static __inline void
90/*ARGSUSED*/
91_citrus_UTF1632_init_state(_UTF1632EncodingInfo *ei __unused,
92    _UTF1632State *s)
93{
94
95	memset(s, 0, sizeof(*s));
96}
97
98static int
99_citrus_UTF1632_mbrtowc_priv(_UTF1632EncodingInfo *ei, wchar_t *pwc,
100    char **s, size_t n, _UTF1632State *psenc, size_t *nresult)
101{
102	char *s0;
103	size_t result;
104	wchar_t wc = L'\0';
105	int chlenbak, endian, needlen;
106
107	s0 = *s;
108
109	if (s0 == NULL) {
110		_citrus_UTF1632_init_state(ei, psenc);
111		*nresult = 0; /* state independent */
112		return (0);
113	}
114
115	result = 0;
116	chlenbak = psenc->chlen;
117
118refetch:
119	needlen = ((ei->mode & _MODE_UTF32) != 0 || chlenbak >= 2) ? 4 : 2;
120
121	while (chlenbak < needlen) {
122		if (n == 0)
123			goto restart;
124		psenc->ch[chlenbak++] = *s0++;
125		n--;
126		result++;
127	}
128
129	/* judge endian marker */
130	if ((ei->mode & _MODE_UTF32) == 0) {
131		/* UTF16 */
132		if (psenc->ch[0] == 0xFE && psenc->ch[1] == 0xFF) {
133			psenc->current_endian = _ENDIAN_BIG;
134			chlenbak = 0;
135			goto refetch;
136		} else if (psenc->ch[0] == 0xFF && psenc->ch[1] == 0xFE) {
137			psenc->current_endian = _ENDIAN_LITTLE;
138			chlenbak = 0;
139			goto refetch;
140		}
141	} else {
142		/* UTF32 */
143		if (psenc->ch[0] == 0x00 && psenc->ch[1] == 0x00 &&
144		    psenc->ch[2] == 0xFE && psenc->ch[3] == 0xFF) {
145			psenc->current_endian = _ENDIAN_BIG;
146			chlenbak = 0;
147			goto refetch;
148		} else if (psenc->ch[0] == 0xFF && psenc->ch[1] == 0xFE &&
149			   psenc->ch[2] == 0x00 && psenc->ch[3] == 0x00) {
150			psenc->current_endian = _ENDIAN_LITTLE;
151			chlenbak = 0;
152			goto refetch;
153		}
154	}
155	endian = ((ei->mode & _MODE_FORCE_ENDIAN) != 0 ||
156	    psenc->current_endian == _ENDIAN_UNKNOWN) ? ei->preffered_endian :
157	    psenc->current_endian;
158
159	/* get wc */
160	if ((ei->mode & _MODE_UTF32) == 0) {
161		/* UTF16 */
162		if (needlen == 2) {
163			switch (endian) {
164			case _ENDIAN_LITTLE:
165				wc = (psenc->ch[0] |
166				    ((wchar_t)psenc->ch[1] << 8));
167				break;
168			case _ENDIAN_BIG:
169				wc = (psenc->ch[1] |
170				    ((wchar_t)psenc->ch[0] << 8));
171				break;
172			default:
173				goto ilseq;
174			}
175			if (wc >= 0xD800 && wc <= 0xDBFF) {
176				/* surrogate high */
177				needlen = 4;
178				goto refetch;
179			}
180		} else {
181			/* surrogate low */
182			wc -= 0xD800; /* wc : surrogate high (see above) */
183			wc <<= 10;
184			switch (endian) {
185			case _ENDIAN_LITTLE:
186				if (psenc->ch[3] < 0xDC || psenc->ch[3] > 0xDF)
187					goto ilseq;
188				wc |= psenc->ch[2];
189				wc |= (wchar_t)(psenc->ch[3] & 3) << 8;
190				break;
191			case _ENDIAN_BIG:
192				if (psenc->ch[2]<0xDC || psenc->ch[2]>0xDF)
193					goto ilseq;
194				wc |= psenc->ch[3];
195				wc |= (wchar_t)(psenc->ch[2] & 3) << 8;
196				break;
197			default:
198				goto ilseq;
199			}
200			wc += 0x10000;
201		}
202	} else {
203		/* UTF32 */
204		switch (endian) {
205		case _ENDIAN_LITTLE:
206			wc = (psenc->ch[0] |
207			    ((wchar_t)psenc->ch[1] << 8) |
208			    ((wchar_t)psenc->ch[2] << 16) |
209			    ((wchar_t)psenc->ch[3] << 24));
210			break;
211		case _ENDIAN_BIG:
212			wc = (psenc->ch[3] |
213			    ((wchar_t)psenc->ch[2] << 8) |
214			    ((wchar_t)psenc->ch[1] << 16) |
215			    ((wchar_t)psenc->ch[0] << 24));
216			break;
217		default:
218			goto ilseq;
219		}
220		if (wc >= 0xD800 && wc <= 0xDFFF)
221			goto ilseq;
222	}
223
224
225	*pwc = wc;
226	psenc->chlen = 0;
227	*nresult = result;
228	*s = s0;
229
230	return (0);
231
232ilseq:
233	*nresult = (size_t)-1;
234	psenc->chlen = 0;
235	return (EILSEQ);
236
237restart:
238	*nresult = (size_t)-2;
239	psenc->chlen = chlenbak;
240	*s = s0;
241	return (0);
242}
243
244static int
245_citrus_UTF1632_wcrtomb_priv(_UTF1632EncodingInfo *ei, char *s, size_t n,
246    wchar_t wc, _UTF1632State *psenc, size_t *nresult)
247{
248	wchar_t wc2;
249	static const char _bom[4] = {
250	    0x00, 0x00, 0xFE, 0xFF,
251	};
252	const char *bom = &_bom[0];
253	size_t cnt;
254
255	cnt = (size_t)0;
256	if (psenc->current_endian == _ENDIAN_UNKNOWN) {
257		if ((ei->mode & _MODE_FORCE_ENDIAN) == 0) {
258			if (ei->mode & _MODE_UTF32)
259				cnt = 4;
260			else {
261				cnt = 2;
262				bom += 2;
263			}
264			if (n < cnt)
265				goto e2big;
266			memcpy(s, bom, cnt);
267			s += cnt, n -= cnt;
268		}
269		psenc->current_endian = ei->preffered_endian;
270	}
271
272	wc2 = 0;
273	if ((ei->mode & _MODE_UTF32)==0) {
274		/* UTF16 */
275		if (wc > 0xFFFF) {
276			/* surrogate */
277			if (wc > 0x10FFFF)
278				goto ilseq;
279			if (n < 4)
280				goto e2big;
281			cnt += 4;
282			wc -= 0x10000;
283			wc2 = (wc & 0x3FF) | 0xDC00;
284			wc = (wc>>10) | 0xD800;
285		} else {
286			if (n < 2)
287				goto e2big;
288			cnt += 2;
289		}
290
291surrogate:
292		switch (psenc->current_endian) {
293		case _ENDIAN_BIG:
294			s[1] = wc;
295			s[0] = (wc >>= 8);
296			break;
297		case _ENDIAN_LITTLE:
298			s[0] = wc;
299			s[1] = (wc >>= 8);
300			break;
301		}
302		if (wc2 != 0) {
303			wc = wc2;
304			wc2 = 0;
305			s += 2;
306			goto surrogate;
307		}
308	} else {
309		/* UTF32 */
310		if (wc >= 0xD800 && wc <= 0xDFFF)
311			goto ilseq;
312		if (n < 4)
313			goto e2big;
314		cnt += 4;
315		switch (psenc->current_endian) {
316		case _ENDIAN_BIG:
317			s[3] = wc;
318			s[2] = (wc >>= 8);
319			s[1] = (wc >>= 8);
320			s[0] = (wc >>= 8);
321			break;
322		case _ENDIAN_LITTLE:
323			s[0] = wc;
324			s[1] = (wc >>= 8);
325			s[2] = (wc >>= 8);
326			s[3] = (wc >>= 8);
327			break;
328		}
329	}
330	*nresult = cnt;
331
332	return (0);
333
334ilseq:
335	*nresult = (size_t)-1;
336	return (EILSEQ);
337e2big:
338	*nresult = (size_t)-1;
339	return (E2BIG);
340}
341
342static void
343parse_variable(_UTF1632EncodingInfo * __restrict ei,
344    const void * __restrict var, size_t lenvar)
345{
346	const char *p;
347
348	p = var;
349	while (lenvar > 0) {
350		switch (*p) {
351		case 'B':
352		case 'b':
353			MATCH(big, ei->preffered_endian = _ENDIAN_BIG);
354			break;
355		case 'L':
356		case 'l':
357			MATCH(little, ei->preffered_endian = _ENDIAN_LITTLE);
358			break;
359		case 'i':
360		case 'I':
361			MATCH(internal, ei->preffered_endian = _ENDIAN_INTERNAL);
362			break;
363		case 's':
364		case 'S':
365			MATCH(swapped, ei->preffered_endian = _ENDIAN_SWAPPED);
366			break;
367		case 'F':
368		case 'f':
369			MATCH(force, ei->mode |= _MODE_FORCE_ENDIAN);
370			break;
371		case 'U':
372		case 'u':
373			MATCH(utf32, ei->mode |= _MODE_UTF32);
374			break;
375		}
376		p++;
377		lenvar--;
378	}
379}
380
381static int
382/*ARGSUSED*/
383_citrus_UTF1632_encoding_module_init(_UTF1632EncodingInfo * __restrict ei,
384    const void * __restrict var, size_t lenvar)
385{
386
387	memset((void *)ei, 0, sizeof(*ei));
388
389	parse_variable(ei, var, lenvar);
390
391	ei->cur_max = ((ei->mode&_MODE_UTF32) == 0) ? 6 : 8;
392	/* 6: endian + surrogate */
393	/* 8: endian + normal */
394
395	if (ei->preffered_endian == _ENDIAN_UNKNOWN) {
396		ei->preffered_endian = _ENDIAN_BIG;
397	}
398
399	return (0);
400}
401
402static void
403/*ARGSUSED*/
404_citrus_UTF1632_encoding_module_uninit(_UTF1632EncodingInfo *ei __unused)
405{
406
407}
408
409static __inline int
410/*ARGSUSED*/
411_citrus_UTF1632_stdenc_wctocs(_UTF1632EncodingInfo * __restrict ei __unused,
412     _csid_t * __restrict csid, _index_t * __restrict idx, _wc_t wc)
413{
414
415	*csid = 0;
416	*idx = (_index_t)wc;
417
418	return (0);
419}
420
421static __inline int
422/*ARGSUSED*/
423_citrus_UTF1632_stdenc_cstowc(_UTF1632EncodingInfo * __restrict ei __unused,
424    _wc_t * __restrict wc, _csid_t csid, _index_t idx)
425{
426
427	if (csid != 0)
428		return (EILSEQ);
429
430	*wc = (_wc_t)idx;
431
432	return (0);
433}
434
435static __inline int
436/*ARGSUSED*/
437_citrus_UTF1632_stdenc_get_state_desc_generic(_UTF1632EncodingInfo * __restrict ei __unused,
438    _UTF1632State * __restrict psenc, int * __restrict rstate)
439{
440
441	*rstate = (psenc->chlen == 0) ? _STDENC_SDGEN_INITIAL :
442	    _STDENC_SDGEN_INCOMPLETE_CHAR;
443	return (0);
444}
445
446/* ----------------------------------------------------------------------
447 * public interface for stdenc
448 */
449
450_CITRUS_STDENC_DECLS(UTF1632);
451_CITRUS_STDENC_DEF_OPS(UTF1632);
452
453#include "citrus_stdenc_template.h"
454