1/* $FreeBSD$ */
2/*	$NetBSD: citrus_iso2022.c,v 1.20 2010/12/07 22:01:45 joerg Exp $	*/
3
4/*-
5 * SPDX-License-Identifier: BSD-2-Clause
6 *
7 * Copyright (c)1999, 2002 Citrus Project,
8 * All rights reserved.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 *    notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 *    notice, this list of conditions and the following disclaimer in the
17 *    documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 *
31 *	$Citrus: xpg4dl/FreeBSD/lib/libc/locale/iso2022.c,v 1.23 2001/06/21 01:51:44 yamt Exp $
32 */
33
34#include <sys/cdefs.h>
35#include <sys/types.h>
36
37#include <assert.h>
38#include <errno.h>
39#include <limits.h>
40#include <stdbool.h>
41#include <stddef.h>
42#include <stdio.h>
43#include <stdlib.h>
44#include <string.h>
45#include <wchar.h>
46
47#include "citrus_namespace.h"
48#include "citrus_types.h"
49#include "citrus_module.h"
50#include "citrus_stdenc.h"
51#include "citrus_iso2022.h"
52
53
54/* ----------------------------------------------------------------------
55 * private stuffs used by templates
56 */
57
58
59/*
60 * wchar_t mappings:
61 * ASCII (ESC ( B)		00000000 00000000 00000000 0xxxxxxx
62 * iso-8859-1 (ESC , A)		00000000 00000000 00000000 1xxxxxxx
63 * 94 charset (ESC ( F)		0fffffff 00000000 00000000 0xxxxxxx
64 * 94 charset (ESC ( M F)	0fffffff 1mmmmmmm 00000000 0xxxxxxx
65 * 96 charset (ESC , F)		0fffffff 00000000 00000000 1xxxxxxx
66 * 96 charset (ESC , M F)	0fffffff 1mmmmmmm 00000000 1xxxxxxx
67 * 94x94 charset (ESC $ ( F)	0fffffff 00000000 0xxxxxxx 0xxxxxxx
68 * 96x96 charset (ESC $ , F)	0fffffff 00000000 0xxxxxxx 1xxxxxxx
69 * 94x94 charset (ESC & V ESC $ ( F)
70 *				0fffffff 1vvvvvvv 0xxxxxxx 0xxxxxxx
71 * 94x94x94 charset (ESC $ ( F)	0fffffff 0xxxxxxx 0xxxxxxx 0xxxxxxx
72 * 96x96x96 charset (ESC $ , F)	0fffffff 0xxxxxxx 0xxxxxxx 1xxxxxxx
73 * reserved for UCS4 co-existence (UCS4 is 31bit encoding thanks to mohta bit)
74 *				1xxxxxxx xxxxxxxx xxxxxxxx xxxxxxxx
75 */
76
77#define CS94		(0U)
78#define CS96		(1U)
79#define CS94MULTI	(2U)
80#define CS96MULTI	(3U)
81
82typedef struct {
83	unsigned char	 type;
84	unsigned char	 final;
85	unsigned char	 interm;
86	unsigned char	 vers;
87} _ISO2022Charset;
88
89static const _ISO2022Charset ascii    = { CS94, 'B', '\0', '\0' };
90static const _ISO2022Charset iso88591 = { CS96, 'A', '\0', '\0' };
91
92typedef struct {
93	_ISO2022Charset	g[4];
94	/* need 3 bits to hold -1, 0, ..., 3 */
95	int	gl:3,
96		gr:3,
97		singlegl:3,
98		singlegr:3;
99	char ch[7];	/* longest escape sequence (ESC & V ESC $ ( F) */
100	size_t chlen;
101	int flags;
102#define _ISO2022STATE_FLAG_INITIALIZED	1
103} _ISO2022State;
104
105typedef struct {
106	_ISO2022Charset	*recommend[4];
107	size_t	recommendsize[4];
108	_ISO2022Charset	initg[4];
109	int	maxcharset;
110	int	flags;
111#define	F_8BIT	0x0001
112#define	F_NOOLD	0x0002
113#define	F_SI	0x0010	/*0F*/
114#define	F_SO	0x0020	/*0E*/
115#define	F_LS0	0x0010	/*0F*/
116#define	F_LS1	0x0020	/*0E*/
117#define	F_LS2	0x0040	/*ESC n*/
118#define	F_LS3	0x0080	/*ESC o*/
119#define	F_LS1R	0x0100	/*ESC ~*/
120#define	F_LS2R	0x0200	/*ESC }*/
121#define	F_LS3R	0x0400	/*ESC |*/
122#define	F_SS2	0x0800	/*ESC N*/
123#define	F_SS3	0x1000	/*ESC O*/
124#define	F_SS2R	0x2000	/*8E*/
125#define	F_SS3R	0x4000	/*8F*/
126} _ISO2022EncodingInfo;
127
128#define _CEI_TO_EI(_cei_)		(&(_cei_)->ei)
129#define _CEI_TO_STATE(_cei_, _func_)	(_cei_)->states.s_##_func_
130
131#define _FUNCNAME(m)			_citrus_ISO2022_##m
132#define _ENCODING_INFO			_ISO2022EncodingInfo
133#define _ENCODING_STATE			_ISO2022State
134#define _ENCODING_MB_CUR_MAX(_ei_)	MB_LEN_MAX
135#define _ENCODING_IS_STATE_DEPENDENT	1
136#define _STATE_NEEDS_EXPLICIT_INIT(_ps_)	\
137    (!((_ps_)->flags & _ISO2022STATE_FLAG_INITIALIZED))
138
139
140#define _ISO2022INVALID (wchar_t)-1
141
142static __inline bool isc0(__uint8_t x)
143{
144
145	return ((x & 0x1f) == x);
146}
147
148static __inline bool isc1(__uint8_t x)
149{
150
151	return (0x80 <= x && x <= 0x9f);
152}
153
154static __inline bool iscntl(__uint8_t x)
155{
156
157	return (isc0(x) || isc1(x) || x == 0x7f);
158}
159
160static __inline bool is94(__uint8_t x)
161{
162
163	return (0x21 <= x && x <= 0x7e);
164}
165
166static __inline bool is96(__uint8_t x)
167{
168
169	return (0x20 <= x && x <= 0x7f);
170}
171
172static __inline bool isecma(__uint8_t x)
173{
174
175	return (0x30 <= x && x <= 0x7f);
176}
177
178static __inline bool isinterm(__uint8_t x)
179{
180
181	return (0x20 <= x && x <= 0x2f);
182}
183
184static __inline bool isthree(__uint8_t x)
185{
186
187	return (0x60 <= x && x <= 0x6f);
188}
189
190static __inline int
191getcs(const char * __restrict p, _ISO2022Charset * __restrict cs)
192{
193
194	if (!strncmp(p, "94$", 3) && p[3] && !p[4]) {
195		cs->final = (unsigned char)(p[3] & 0xff);
196		cs->interm = '\0';
197		cs->vers = '\0';
198		cs->type = CS94MULTI;
199	} else if (!strncmp(p, "96$", 3) && p[3] && !p[4]) {
200		cs->final = (unsigned char)(p[3] & 0xff);
201		cs->interm = '\0';
202		cs->vers = '\0';
203		cs->type = CS96MULTI;
204	} else if (!strncmp(p, "94", 2) && p[2] && !p[3]) {
205		cs->final = (unsigned char)(p[2] & 0xff);
206		cs->interm = '\0';
207		cs->vers = '\0';
208		cs->type = CS94;
209	} else if (!strncmp(p, "96", 2) && p[2] && !p[3]) {
210		cs->final = (unsigned char )(p[2] & 0xff);
211		cs->interm = '\0';
212		cs->vers = '\0';
213		cs->type = CS96;
214	} else
215		return (1);
216
217	return (0);
218}
219
220
221#define _NOTMATCH	0
222#define _MATCH		1
223#define _PARSEFAIL	2
224
225static __inline int
226get_recommend(_ISO2022EncodingInfo * __restrict ei,
227    const char * __restrict token)
228{
229	_ISO2022Charset cs, *p;
230	int i;
231
232	if (!strchr("0123", token[0]) || token[1] != '=')
233		return (_NOTMATCH);
234
235	if (getcs(&token[2], &cs) == 0)
236		;
237	else if (!strcmp(&token[2], "94")) {
238		cs.final = (unsigned char)(token[4]);
239		cs.interm = '\0';
240		cs.vers = '\0';
241		cs.type = CS94;
242	} else if (!strcmp(&token[2], "96")) {
243		cs.final = (unsigned char)(token[4]);
244		cs.interm = '\0';
245		cs.vers = '\0';
246		cs.type = CS96;
247	} else if (!strcmp(&token[2], "94$")) {
248		cs.final = (unsigned char)(token[5]);
249		cs.interm = '\0';
250		cs.vers = '\0';
251		cs.type = CS94MULTI;
252	} else if (!strcmp(&token[2], "96$")) {
253		cs.final = (unsigned char)(token[5]);
254		cs.interm = '\0';
255		cs.vers = '\0';
256		cs.type = CS96MULTI;
257	} else
258		return (_PARSEFAIL);
259
260	i = token[0] - '0';
261	if (!ei->recommend[i])
262		ei->recommend[i] = malloc(sizeof(_ISO2022Charset));
263	else {
264		p = reallocarray(ei->recommend[i], ei->recommendsize[i] + 1,
265		    sizeof(_ISO2022Charset));
266		if (!p)
267			return (_PARSEFAIL);
268		ei->recommend[i] = p;
269	}
270	if (!ei->recommend[i])
271		return (_PARSEFAIL);
272	ei->recommendsize[i]++;
273
274	(ei->recommend[i] + (ei->recommendsize[i] - 1))->final = cs.final;
275	(ei->recommend[i] + (ei->recommendsize[i] - 1))->interm = cs.interm;
276	(ei->recommend[i] + (ei->recommendsize[i] - 1))->vers = cs.vers;
277	(ei->recommend[i] + (ei->recommendsize[i] - 1))->type = cs.type;
278
279	return (_MATCH);
280}
281
282static __inline int
283get_initg(_ISO2022EncodingInfo * __restrict ei,
284    const char * __restrict token)
285{
286	_ISO2022Charset cs;
287
288	if (strncmp("INIT", &token[0], 4) ||
289	    !strchr("0123", token[4]) ||
290	    token[5] != '=')
291		return (_NOTMATCH);
292
293	if (getcs(&token[6], &cs) != 0)
294		return (_PARSEFAIL);
295
296	ei->initg[token[4] - '0'].type = cs.type;
297	ei->initg[token[4] - '0'].final = cs.final;
298	ei->initg[token[4] - '0'].interm = cs.interm;
299	ei->initg[token[4] - '0'].vers = cs.vers;
300
301	return (_MATCH);
302}
303
304static __inline int
305get_max(_ISO2022EncodingInfo * __restrict ei,
306    const char * __restrict token)
307{
308	if (!strcmp(token, "MAX1"))
309		ei->maxcharset = 1;
310	else if (!strcmp(token, "MAX2"))
311		ei->maxcharset = 2;
312	else if (!strcmp(token, "MAX3"))
313		ei->maxcharset = 3;
314	else
315		return (_NOTMATCH);
316
317	return (_MATCH);
318}
319
320
321static __inline int
322get_flags(_ISO2022EncodingInfo * __restrict ei,
323    const char * __restrict token)
324{
325	static struct {
326		const char	*tag;
327		int		flag;
328	} const tags[] = {
329		{ "DUMMY",	0	},
330		{ "8BIT",	F_8BIT	},
331		{ "NOOLD",	F_NOOLD	},
332		{ "SI",		F_SI	},
333		{ "SO",		F_SO	},
334		{ "LS0",	F_LS0	},
335		{ "LS1",	F_LS1	},
336		{ "LS2",	F_LS2	},
337		{ "LS3",	F_LS3	},
338		{ "LS1R",	F_LS1R	},
339		{ "LS2R",	F_LS2R	},
340		{ "LS3R",	F_LS3R	},
341		{ "SS2",	F_SS2	},
342		{ "SS3",	F_SS3	},
343		{ "SS2R",	F_SS2R	},
344		{ "SS3R",	F_SS3R	},
345		{ NULL,		0 }
346	};
347	int i;
348
349	for (i = 0; tags[i].tag; i++)
350		if (!strcmp(token, tags[i].tag)) {
351			ei->flags |= tags[i].flag;
352			return (_MATCH);
353		}
354
355	return (_NOTMATCH);
356}
357
358
359static __inline int
360_citrus_ISO2022_parse_variable(_ISO2022EncodingInfo * __restrict ei,
361    const void * __restrict var, size_t lenvar __unused)
362{
363	char const *e, *v;
364	char buf[20];
365	size_t len;
366	int i, ret;
367
368	/*
369	 * parse VARIABLE section.
370	 */
371
372	if (!var)
373		return (EFTYPE);
374
375	v = (const char *) var;
376
377	/* initialize structure */
378	ei->maxcharset = 0;
379	for (i = 0; i < 4; i++) {
380		ei->recommend[i] = NULL;
381		ei->recommendsize[i] = 0;
382	}
383	ei->flags = 0;
384
385	while (*v) {
386		while (*v == ' ' || *v == '\t')
387			++v;
388
389		/* find the token */
390		e = v;
391		while (*e && *e != ' ' && *e != '\t')
392			++e;
393
394		len = e - v;
395		if (len == 0)
396			break;
397		if (len >= sizeof(buf))
398			goto parsefail;
399		snprintf(buf, sizeof(buf), "%.*s", (int)len, v);
400
401		if ((ret = get_recommend(ei, buf)) != _NOTMATCH)
402			;
403		else if ((ret = get_initg(ei, buf)) != _NOTMATCH)
404			;
405		else if ((ret = get_max(ei, buf)) != _NOTMATCH)
406			;
407		else if ((ret = get_flags(ei, buf)) != _NOTMATCH)
408			;
409		else
410			ret = _PARSEFAIL;
411		if (ret == _PARSEFAIL)
412			goto parsefail;
413		v = e;
414
415	}
416
417	return (0);
418
419parsefail:
420	free(ei->recommend[0]);
421	free(ei->recommend[1]);
422	free(ei->recommend[2]);
423	free(ei->recommend[3]);
424
425	return (EFTYPE);
426}
427
428static __inline void
429/*ARGSUSED*/
430_citrus_ISO2022_init_state(_ISO2022EncodingInfo * __restrict ei,
431    _ISO2022State * __restrict s)
432{
433	int i;
434
435	memset(s, 0, sizeof(*s));
436	s->gl = 0;
437	s->gr = (ei->flags & F_8BIT) ? 1 : -1;
438
439	for (i = 0; i < 4; i++)
440		if (ei->initg[i].final) {
441			s->g[i].type = ei->initg[i].type;
442			s->g[i].final = ei->initg[i].final;
443			s->g[i].interm = ei->initg[i].interm;
444		}
445	s->singlegl = s->singlegr = -1;
446	s->flags |= _ISO2022STATE_FLAG_INITIALIZED;
447}
448
449#if 0
450static __inline void
451/*ARGSUSED*/
452_citrus_ISO2022_pack_state(_ISO2022EncodingInfo * __restrict ei __unused,
453    void * __restrict pspriv, const _ISO2022State * __restrict s)
454{
455
456	memcpy(pspriv, (const void *)s, sizeof(*s));
457}
458
459static __inline void
460/*ARGSUSED*/
461_citrus_ISO2022_unpack_state(_ISO2022EncodingInfo * __restrict ei __unused,
462    _ISO2022State * __restrict s, const void * __restrict pspriv)
463{
464
465	memcpy((void *)s, pspriv, sizeof(*s));
466}
467#endif
468
469static int
470/*ARGSUSED*/
471_citrus_ISO2022_encoding_module_init(_ISO2022EncodingInfo * __restrict ei,
472    const void * __restrict var, size_t lenvar)
473{
474
475	return (_citrus_ISO2022_parse_variable(ei, var, lenvar));
476}
477
478static void
479/*ARGSUSED*/
480_citrus_ISO2022_encoding_module_uninit(_ISO2022EncodingInfo *ei __unused)
481{
482
483}
484
485#define	ESC	'\033'
486#define	ECMA	-1
487#define	INTERM	-2
488#define	OECMA	-3
489static const struct seqtable {
490	int type;
491	int csoff;
492	int finaloff;
493	int intermoff;
494	int versoff;
495	int len;
496	int chars[10];
497} seqtable[] = {
498	/* G0 94MULTI special */
499	{ CS94MULTI, -1, 2, -1, -1,	3, { ESC, '$', OECMA }, },
500	/* G0 94MULTI special with version identification */
501	{ CS94MULTI, -1, 5, -1, 2,	6, { ESC, '&', ECMA, ESC, '$', OECMA }, },
502	/* G? 94 */
503	{ CS94, 1, 2, -1, -1,		3, { ESC, CS94, ECMA, }, },
504	/* G? 94 with 2nd intermediate char */
505	{ CS94, 1, 3, 2, -1,		4, { ESC, CS94, INTERM, ECMA, }, },
506	/* G? 96 */
507	{ CS96, 1, 2, -1, -1,		3, { ESC, CS96, ECMA, }, },
508	/* G? 96 with 2nd intermediate char */
509	{ CS96, 1, 3, 2, -1,		4, { ESC, CS96, INTERM, ECMA, }, },
510	/* G? 94MULTI */
511	{ CS94MULTI, 2, 3, -1, -1,	4, { ESC, '$', CS94, ECMA, }, },
512	/* G? 96MULTI */
513	{ CS96MULTI, 2, 3, -1, -1,	4, { ESC, '$', CS96, ECMA, }, },
514	/* G? 94MULTI with version specification */
515	{ CS94MULTI, 5, 6, -1, 2,	7, { ESC, '&', ECMA, ESC, '$', CS94, ECMA, }, },
516	/* LS2/3 */
517	{ -1, -1, -1, -1, -1,		2, { ESC, 'n', }, },
518	{ -1, -1, -1, -1, -1,		2, { ESC, 'o', }, },
519	/* LS1/2/3R */
520	{ -1, -1, -1, -1, -1,		2, { ESC, '~', }, },
521	{ -1, -1, -1, -1, -1,		2, { ESC, /*{*/ '}', }, },
522	{ -1, -1, -1, -1, -1,		2, { ESC, '|', }, },
523	/* SS2/3 */
524	{ -1, -1, -1, -1, -1,		2, { ESC, 'N', }, },
525	{ -1, -1, -1, -1, -1,		2, { ESC, 'O', }, },
526	/* end of records */
527//	{ 0, }
528	{  0,  0,  0,  0,  0,		0, { ESC,  0, }, }
529};
530
531static int
532seqmatch(const char * __restrict s, size_t n,
533    const struct seqtable * __restrict sp)
534{
535	const int *p;
536
537	p = sp->chars;
538	while ((size_t)(p - sp->chars) < n && p - sp->chars < sp->len) {
539		switch (*p) {
540		case ECMA:
541			if (!isecma(*s))
542				goto terminate;
543			break;
544		case OECMA:
545			if (*s && strchr("@AB", *s))
546				break;
547			else
548				goto terminate;
549		case INTERM:
550			if (!isinterm(*s))
551				goto terminate;
552			break;
553		case CS94:
554			if (*s && strchr("()*+", *s))
555				break;
556			else
557				goto terminate;
558		case CS96:
559			if (*s && strchr(",-./", *s))
560				break;
561			else
562				goto terminate;
563		default:
564			if (*s != *p)
565				goto terminate;
566			break;
567		}
568
569		p++;
570		s++;
571	}
572
573terminate:
574	return (p - sp->chars);
575}
576
577static wchar_t
578_ISO2022_sgetwchar(_ISO2022EncodingInfo * __restrict ei __unused,
579    char * __restrict string, size_t n, char ** __restrict result,
580    _ISO2022State * __restrict psenc)
581{
582	const struct seqtable *sp;
583	wchar_t wchar = 0;
584	int i, cur, nmatch;
585
586	while (1) {
587		/* SI/SO */
588		if (1 <= n && string[0] == '\017') {
589			psenc->gl = 0;
590			string++;
591			n--;
592			continue;
593		}
594		if (1 <= n && string[0] == '\016') {
595			psenc->gl = 1;
596			string++;
597			n--;
598			continue;
599		}
600
601		/* SS2/3R */
602		if (1 <= n && string[0] && strchr("\217\216", string[0])) {
603			psenc->singlegl = psenc->singlegr =
604			    (string[0] - '\216') + 2;
605			string++;
606			n--;
607			continue;
608		}
609
610		/* eat the letter if this is not ESC */
611		if (1 <= n && string[0] != '\033')
612			break;
613
614		/* look for a perfect match from escape sequences */
615		for (sp = &seqtable[0]; sp->len; sp++) {
616			nmatch = seqmatch(string, n, sp);
617			if (sp->len == nmatch && n >= (size_t)(sp->len))
618				break;
619		}
620
621		if (!sp->len)
622			goto notseq;
623
624		if (sp->type != -1) {
625			if (sp->csoff == -1)
626				i = 0;
627			else {
628				switch (sp->type) {
629				case CS94:
630				case CS94MULTI:
631					i = string[sp->csoff] - '(';
632					break;
633				case CS96:
634				case CS96MULTI:
635					i = string[sp->csoff] - ',';
636					break;
637				default:
638					return (_ISO2022INVALID);
639				}
640			}
641			psenc->g[i].type = sp->type;
642			psenc->g[i].final = '\0';
643			psenc->g[i].interm = '\0';
644			psenc->g[i].vers = '\0';
645			/* sp->finaloff must not be -1 */
646			if (sp->finaloff != -1)
647				psenc->g[i].final = string[sp->finaloff];
648			if (sp->intermoff != -1)
649				psenc->g[i].interm = string[sp->intermoff];
650			if (sp->versoff != -1)
651				psenc->g[i].vers = string[sp->versoff];
652
653			string += sp->len;
654			n -= sp->len;
655			continue;
656		}
657
658		/* LS2/3 */
659		if (2 <= n && string[0] == '\033' &&
660		    string[1] && strchr("no", string[1])) {
661			psenc->gl = string[1] - 'n' + 2;
662			string += 2;
663			n -= 2;
664			continue;
665		}
666
667		/* LS1/2/3R */
668			/* XXX: { for vi showmatch */
669		if (2 <= n && string[0] == '\033' &&
670		    string[1] && strchr("~}|", string[1])) {
671			psenc->gr = 3 - (string[1] - '|');
672			string += 2;
673			n -= 2;
674			continue;
675		}
676
677		/* SS2/3 */
678		if (2 <= n && string[0] == '\033' && string[1] &&
679		    strchr("NO", string[1])) {
680			psenc->singlegl = (string[1] - 'N') + 2;
681			string += 2;
682			n -= 2;
683			continue;
684		}
685
686	notseq:
687		/*
688		 * if we've got an unknown escape sequence, eat the ESC at the
689		 * head.  otherwise, wait till full escape sequence comes.
690		 */
691		for (sp = &seqtable[0]; sp->len; sp++) {
692			nmatch = seqmatch(string, n, sp);
693			if (!nmatch)
694				continue;
695
696			/*
697			 * if we are in the middle of escape sequence,
698			 * we still need to wait for more characters to come
699			 */
700			if (n < (size_t)(sp->len)) {
701				if ((size_t)(nmatch) == n) {
702					if (result)
703						*result = string;
704					return (_ISO2022INVALID);
705				}
706			} else {
707				if (nmatch == sp->len) {
708					/* this case should not happen */
709					goto eat;
710				}
711			}
712		}
713
714		break;
715	}
716
717eat:
718	/* no letter to eat */
719	if (n < 1) {
720		if (result)
721			*result = string;
722		return (_ISO2022INVALID);
723	}
724
725	/* normal chars.  always eat C0/C1 as is. */
726	if (iscntl(*string & 0xff))
727		cur = -1;
728	else if (*string & 0x80)
729		cur = (psenc->singlegr == -1) ? psenc->gr : psenc->singlegr;
730	else
731		cur = (psenc->singlegl == -1) ? psenc->gl : psenc->singlegl;
732
733	if (cur == -1) {
734asis:
735		wchar = *string++ & 0xff;
736		if (result)
737			*result = string;
738		/* reset single shift state */
739		psenc->singlegr = psenc->singlegl = -1;
740		return (wchar);
741	}
742
743	/* length error check */
744	switch (psenc->g[cur].type) {
745	case CS94MULTI:
746	case CS96MULTI:
747		if (!isthree(psenc->g[cur].final)) {
748			if (2 <= n &&
749			    (string[0] & 0x80) == (string[1] & 0x80))
750				break;
751		} else {
752			if (3 <= n &&
753			    (string[0] & 0x80) == (string[1] & 0x80) &&
754			    (string[0] & 0x80) == (string[2] & 0x80))
755				break;
756		}
757
758		/* we still need to wait for more characters to come */
759		if (result)
760			*result = string;
761		return (_ISO2022INVALID);
762
763	case CS94:
764	case CS96:
765		if (1 <= n)
766			break;
767
768		/* we still need to wait for more characters to come */
769		if (result)
770			*result = string;
771		return (_ISO2022INVALID);
772	}
773
774	/* range check */
775	switch (psenc->g[cur].type) {
776	case CS94:
777		if (!(is94(string[0] & 0x7f)))
778			goto asis;
779		break;
780	case CS96:
781		if (!(is96(string[0] & 0x7f)))
782			goto asis;
783		break;
784	case CS94MULTI:
785		if (!(is94(string[0] & 0x7f) && is94(string[1] & 0x7f)))
786			goto asis;
787		break;
788	case CS96MULTI:
789		if (!(is96(string[0] & 0x7f) && is96(string[1] & 0x7f)))
790			goto asis;
791		break;
792	}
793
794	/* extract the character. */
795	switch (psenc->g[cur].type) {
796	case CS94:
797		/* special case for ASCII. */
798		if (psenc->g[cur].final == 'B' && !psenc->g[cur].interm) {
799			wchar = *string++;
800			wchar &= 0x7f;
801			break;
802		}
803		wchar = psenc->g[cur].final;
804		wchar = (wchar << 8);
805		wchar |= (psenc->g[cur].interm ? (0x80 | psenc->g[cur].interm) : 0);
806		wchar = (wchar << 8);
807		wchar = (wchar << 8) | (*string++ & 0x7f);
808		break;
809	case CS96:
810		/* special case for ISO-8859-1. */
811		if (psenc->g[cur].final == 'A' && !psenc->g[cur].interm) {
812			wchar = *string++;
813			wchar &= 0x7f;
814			wchar |= 0x80;
815			break;
816		}
817		wchar = psenc->g[cur].final;
818		wchar = (wchar << 8);
819		wchar |= (psenc->g[cur].interm ? (0x80 | psenc->g[cur].interm) : 0);
820		wchar = (wchar << 8);
821		wchar = (wchar << 8) | (*string++ & 0x7f);
822		wchar |= 0x80;
823		break;
824	case CS94MULTI:
825	case CS96MULTI:
826		wchar = psenc->g[cur].final;
827		wchar = (wchar << 8);
828		if (isthree(psenc->g[cur].final))
829			wchar |= (*string++ & 0x7f);
830		wchar = (wchar << 8) | (*string++ & 0x7f);
831		wchar = (wchar << 8) | (*string++ & 0x7f);
832		if (psenc->g[cur].type == CS96MULTI)
833			wchar |= 0x80;
834		break;
835	}
836
837	if (result)
838		*result = string;
839	/* reset single shift state */
840	psenc->singlegr = psenc->singlegl = -1;
841	return (wchar);
842}
843
844
845
846static int
847_citrus_ISO2022_mbrtowc_priv(_ISO2022EncodingInfo * __restrict ei,
848    wchar_t * __restrict pwc, char ** __restrict s,
849    size_t n, _ISO2022State * __restrict psenc, size_t * __restrict nresult)
850{
851	char *p, *result, *s0;
852	wchar_t wchar;
853	int c, chlenbak;
854
855	if (*s == NULL) {
856		_citrus_ISO2022_init_state(ei, psenc);
857		*nresult = _ENCODING_IS_STATE_DEPENDENT;
858		return (0);
859	}
860	s0 = *s;
861	c = 0;
862	chlenbak = psenc->chlen;
863
864	/*
865	 * if we have something in buffer, use that.
866	 * otherwise, skip here
867	 */
868	if (psenc->chlen > sizeof(psenc->ch)) {
869		/* illgeal state */
870		_citrus_ISO2022_init_state(ei, psenc);
871		goto encoding_error;
872	}
873	if (psenc->chlen == 0)
874		goto emptybuf;
875
876	/* buffer is not empty */
877	p = psenc->ch;
878	while (psenc->chlen < sizeof(psenc->ch)) {
879		if (n > 0) {
880			psenc->ch[psenc->chlen++] = *s0++;
881			n--;
882		}
883
884		wchar = _ISO2022_sgetwchar(ei, p, psenc->chlen - (p-psenc->ch),
885		    &result, psenc);
886		c += result - p;
887		if (wchar != _ISO2022INVALID) {
888			if (psenc->chlen > (size_t)c)
889				memmove(psenc->ch, result, psenc->chlen - c);
890			if (psenc->chlen < (size_t)c)
891				psenc->chlen = 0;
892			else
893				psenc->chlen -= c;
894			goto output;
895		}
896
897		if (n == 0) {
898			if ((size_t)(result - p) == psenc->chlen)
899				/* complete shift sequence. */
900				psenc->chlen = 0;
901			goto restart;
902		}
903
904		p = result;
905	}
906
907	/* escape sequence too long? */
908	goto encoding_error;
909
910emptybuf:
911	wchar = _ISO2022_sgetwchar(ei, s0, n, &result, psenc);
912	if (wchar != _ISO2022INVALID) {
913		c += result - s0;
914		psenc->chlen = 0;
915		s0 = result;
916		goto output;
917	}
918	if (result > s0) {
919		c += (result - s0);
920		n -= (result - s0);
921		s0 = result;
922		if (n > 0)
923			goto emptybuf;
924		/* complete shift sequence. */
925		goto restart;
926	}
927	n += c;
928	if (n < sizeof(psenc->ch)) {
929		memcpy(psenc->ch, s0 - c, n);
930		psenc->chlen = n;
931		s0 = result;
932		goto restart;
933	}
934
935	/* escape sequence too long? */
936
937encoding_error:
938	psenc->chlen = 0;
939	*nresult = (size_t)-1;
940	return (EILSEQ);
941
942output:
943	*s = s0;
944	if (pwc)
945		*pwc = wchar;
946	*nresult = wchar ? c - chlenbak : 0;
947	return (0);
948
949restart:
950	*s = s0;
951	*nresult = (size_t)-2;
952
953	return (0);
954}
955
956static int
957recommendation(_ISO2022EncodingInfo * __restrict ei,
958    _ISO2022Charset * __restrict cs)
959{
960	_ISO2022Charset *recommend;
961	size_t j;
962	int i;
963
964	/* first, try a exact match. */
965	for (i = 0; i < 4; i++) {
966		recommend = ei->recommend[i];
967		for (j = 0; j < ei->recommendsize[i]; j++) {
968			if (cs->type != recommend[j].type)
969				continue;
970			if (cs->final != recommend[j].final)
971				continue;
972			if (cs->interm != recommend[j].interm)
973				continue;
974
975			return (i);
976		}
977	}
978
979	/* then, try a wildcard match over final char. */
980	for (i = 0; i < 4; i++) {
981		recommend = ei->recommend[i];
982		for (j = 0; j < ei->recommendsize[i]; j++) {
983			if (cs->type != recommend[j].type)
984				continue;
985			if (cs->final && (cs->final != recommend[j].final))
986				continue;
987			if (cs->interm && (cs->interm != recommend[j].interm))
988				continue;
989
990			return (i);
991		}
992	}
993
994	/* there's no recommendation. make a guess. */
995	if (ei->maxcharset == 0) {
996		return (0);
997	} else {
998		switch (cs->type) {
999		case CS94:
1000		case CS94MULTI:
1001			return (0);
1002		case CS96:
1003		case CS96MULTI:
1004			return (1);
1005		}
1006	}
1007	return (0);
1008}
1009
1010static int
1011_ISO2022_sputwchar(_ISO2022EncodingInfo * __restrict ei, wchar_t wc,
1012    char * __restrict string, size_t n, char ** __restrict result,
1013    _ISO2022State * __restrict psenc, size_t * __restrict nresult)
1014{
1015	_ISO2022Charset cs;
1016	char *p;
1017	char tmp[MB_LEN_MAX];
1018	size_t len;
1019	int bit8, i = 0, target;
1020	unsigned char mask;
1021
1022	if (isc0(wc & 0xff)) {
1023		/* go back to INIT0 or ASCII on control chars */
1024		cs = ei->initg[0].final ? ei->initg[0] : ascii;
1025	} else if (isc1(wc & 0xff)) {
1026		/* go back to INIT1 or ISO-8859-1 on control chars */
1027		cs = ei->initg[1].final ? ei->initg[1] : iso88591;
1028	} else if (!(wc & ~0xff)) {
1029		if (wc & 0x80) {
1030			/* special treatment for ISO-8859-1 */
1031			cs = iso88591;
1032		} else {
1033			/* special treatment for ASCII */
1034			cs = ascii;
1035		}
1036	} else {
1037		cs.final = (wc >> 24) & 0x7f;
1038		if ((wc >> 16) & 0x80)
1039			cs.interm = (wc >> 16) & 0x7f;
1040		else
1041			cs.interm = '\0';
1042		if (wc & 0x80)
1043			cs.type = (wc & 0x00007f00) ? CS96MULTI : CS96;
1044		else
1045			cs.type = (wc & 0x00007f00) ? CS94MULTI : CS94;
1046	}
1047	target = recommendation(ei, &cs);
1048	p = tmp;
1049	bit8 = ei->flags & F_8BIT;
1050
1051	/* designate the charset onto the target plane(G0/1/2/3). */
1052	if (psenc->g[target].type == cs.type &&
1053	    psenc->g[target].final == cs.final &&
1054	    psenc->g[target].interm == cs.interm)
1055		goto planeok;
1056
1057	*p++ = '\033';
1058	if (cs.type == CS94MULTI || cs.type == CS96MULTI)
1059		*p++ = '$';
1060	if (target == 0 && cs.type == CS94MULTI && strchr("@AB", cs.final) &&
1061	    !cs.interm && !(ei->flags & F_NOOLD))
1062		;
1063	else if (cs.type == CS94 || cs.type == CS94MULTI)
1064		*p++ = "()*+"[target];
1065	else
1066		*p++ = ",-./"[target];
1067	if (cs.interm)
1068		*p++ = cs.interm;
1069	*p++ = cs.final;
1070
1071	psenc->g[target].type = cs.type;
1072	psenc->g[target].final = cs.final;
1073	psenc->g[target].interm = cs.interm;
1074
1075planeok:
1076	/* invoke the plane onto GL or GR. */
1077	if (psenc->gl == target)
1078		goto sideok;
1079	if (bit8 && psenc->gr == target)
1080		goto sideok;
1081
1082	if (target == 0 && (ei->flags & F_LS0)) {
1083		*p++ = '\017';
1084		psenc->gl = 0;
1085	} else if (target == 1 && (ei->flags & F_LS1)) {
1086		*p++ = '\016';
1087		psenc->gl = 1;
1088	} else if (target == 2 && (ei->flags & F_LS2)) {
1089		*p++ = '\033';
1090		*p++ = 'n';
1091		psenc->gl = 2;
1092	} else if (target == 3 && (ei->flags & F_LS3)) {
1093		*p++ = '\033';
1094		*p++ = 'o';
1095		psenc->gl = 3;
1096	} else if (bit8 && target == 1 && (ei->flags & F_LS1R)) {
1097		*p++ = '\033';
1098		*p++ = '~';
1099		psenc->gr = 1;
1100	} else if (bit8 && target == 2 && (ei->flags & F_LS2R)) {
1101		*p++ = '\033';
1102		/*{*/
1103		*p++ = '}';
1104		psenc->gr = 2;
1105	} else if (bit8 && target == 3 && (ei->flags & F_LS3R)) {
1106		*p++ = '\033';
1107		*p++ = '|';
1108		psenc->gr = 3;
1109	} else if (target == 2 && (ei->flags & F_SS2)) {
1110		*p++ = '\033';
1111		*p++ = 'N';
1112		psenc->singlegl = 2;
1113	} else if (target == 3 && (ei->flags & F_SS3)) {
1114		*p++ = '\033';
1115		*p++ = 'O';
1116		psenc->singlegl = 3;
1117	} else if (bit8 && target == 2 && (ei->flags & F_SS2R)) {
1118		*p++ = '\216';
1119		*p++ = 'N';
1120		psenc->singlegl = psenc->singlegr = 2;
1121	} else if (bit8 && target == 3 && (ei->flags & F_SS3R)) {
1122		*p++ = '\217';
1123		*p++ = 'O';
1124		psenc->singlegl = psenc->singlegr = 3;
1125	} else
1126		goto ilseq;
1127
1128sideok:
1129	if (psenc->singlegl == target)
1130		mask = 0x00;
1131	else if (psenc->singlegr == target)
1132		mask = 0x80;
1133	else if (psenc->gl == target)
1134		mask = 0x00;
1135	else if ((ei->flags & F_8BIT) && psenc->gr == target)
1136		mask = 0x80;
1137	else
1138		goto ilseq;
1139
1140	switch (cs.type) {
1141	case CS94:
1142	case CS96:
1143		i = 1;
1144		break;
1145	case CS94MULTI:
1146	case CS96MULTI:
1147		i = !iscntl(wc & 0xff) ?
1148		    (isthree(cs.final) ? 3 : 2) : 1;
1149		break;
1150	}
1151	while (i-- > 0)
1152		*p++ = ((wc >> (i << 3)) & 0x7f) | mask;
1153
1154	/* reset single shift state */
1155	psenc->singlegl = psenc->singlegr = -1;
1156
1157	len = (size_t)(p - tmp);
1158	if (n < len) {
1159		if (result)
1160			*result = (char *)0;
1161		*nresult = (size_t)-1;
1162		return (E2BIG);
1163	}
1164	if (result)
1165		*result = string + len;
1166	memcpy(string, tmp, len);
1167	*nresult = len;
1168
1169	return (0);
1170
1171ilseq:
1172	*nresult = (size_t)-1;
1173	return (EILSEQ);
1174}
1175
1176static int
1177_citrus_ISO2022_put_state_reset(_ISO2022EncodingInfo * __restrict ei,
1178    char * __restrict s, size_t n, _ISO2022State * __restrict psenc,
1179    size_t * __restrict nresult)
1180{
1181	char *result;
1182	char buf[MB_LEN_MAX];
1183	size_t len;
1184	int ret;
1185
1186	/* XXX state will be modified after this operation... */
1187	ret = _ISO2022_sputwchar(ei, L'\0', buf, sizeof(buf), &result, psenc,
1188	    &len);
1189	if (ret) {
1190		*nresult = len;
1191		return (ret);
1192	}
1193
1194	if (sizeof(buf) < len || n < len-1) {
1195		/* XXX should recover state? */
1196		*nresult = (size_t)-1;
1197		return (E2BIG);
1198	}
1199
1200	memcpy(s, buf, len - 1);
1201	*nresult = len - 1;
1202	return (0);
1203}
1204
1205static int
1206_citrus_ISO2022_wcrtomb_priv(_ISO2022EncodingInfo * __restrict ei,
1207    char * __restrict s, size_t n, wchar_t wc,
1208    _ISO2022State * __restrict psenc, size_t * __restrict nresult)
1209{
1210	char *result;
1211	char buf[MB_LEN_MAX];
1212	size_t len;
1213	int ret;
1214
1215	/* XXX state will be modified after this operation... */
1216	ret = _ISO2022_sputwchar(ei, wc, buf, sizeof(buf), &result, psenc,
1217	    &len);
1218	if (ret) {
1219		*nresult = len;
1220		return (ret);
1221	}
1222
1223	if (sizeof(buf) < len || n < len) {
1224		/* XXX should recover state? */
1225		*nresult = (size_t)-1;
1226		return (E2BIG);
1227	}
1228
1229	memcpy(s, buf, len);
1230	*nresult = len;
1231	return (0);
1232}
1233
1234static __inline int
1235/*ARGSUSED*/
1236_citrus_ISO2022_stdenc_wctocs(_ISO2022EncodingInfo * __restrict ei __unused,
1237    _csid_t * __restrict csid, _index_t * __restrict idx, wchar_t wc)
1238{
1239	wchar_t m, nm;
1240
1241	m = wc & 0x7FFF8080;
1242	nm = wc & 0x007F7F7F;
1243	if (m & 0x00800000)
1244		nm &= 0x00007F7F;
1245	else
1246		m &= 0x7F008080;
1247	if (nm & 0x007F0000) {
1248		/* ^3 mark */
1249		m |= 0x007F0000;
1250	} else if (nm & 0x00007F00) {
1251		/* ^2 mark */
1252		m |= 0x00007F00;
1253	}
1254	*csid = (_csid_t)m;
1255	*idx  = (_index_t)nm;
1256
1257	return (0);
1258}
1259
1260static __inline int
1261/*ARGSUSED*/
1262_citrus_ISO2022_stdenc_cstowc(_ISO2022EncodingInfo * __restrict ei __unused,
1263    wchar_t * __restrict wc, _csid_t csid, _index_t idx)
1264{
1265
1266	*wc = (wchar_t)(csid & 0x7F808080) | (wchar_t)idx;
1267
1268	return (0);
1269}
1270
1271static __inline int
1272/*ARGSUSED*/
1273_citrus_ISO2022_stdenc_get_state_desc_generic(_ISO2022EncodingInfo * __restrict ei __unused,
1274    _ISO2022State * __restrict psenc, int * __restrict rstate)
1275{
1276
1277	if (psenc->chlen == 0) {
1278		/* XXX: it should distinguish initial and stable. */
1279		*rstate = _STDENC_SDGEN_STABLE;
1280	} else
1281		*rstate = (psenc->ch[0] == '\033') ?
1282		    _STDENC_SDGEN_INCOMPLETE_SHIFT :
1283		    _STDENC_SDGEN_INCOMPLETE_CHAR;
1284	return (0);
1285}
1286
1287/* ----------------------------------------------------------------------
1288 * public interface for stdenc
1289 */
1290
1291_CITRUS_STDENC_DECLS(ISO2022);
1292_CITRUS_STDENC_DEF_OPS(ISO2022);
1293
1294#include "citrus_stdenc_template.h"
1295