2 /* $NetBSD: citrus_iso2022.c,v 1.20 2010/12/07 22:01:45 joerg Exp $ */
5 * SPDX-License-Identifier: BSD-2-Clause
7 * Copyright (c)1999, 2002 Citrus Project,
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
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.
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
31 * $Citrus: xpg4dl/FreeBSD/lib/libc/locale/iso2022.c,v 1.23 2001/06/21 01:51:44 yamt Exp $
34 #include <sys/cdefs.h>
35 #include <sys/types.h>
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"
54 /* ----------------------------------------------------------------------
55 * private stuffs used by templates
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
79 #define CS94MULTI (2U)
80 #define CS96MULTI (3U)
89 static const _ISO2022Charset ascii = { CS94, 'B', '\0', '\0' };
90 static const _ISO2022Charset iso88591 = { CS96, 'A', '\0', '\0' };
94 /* need 3 bits to hold -1, 0, ..., 3 */
99 char ch[7]; /* longest escape sequence (ESC & V ESC $ ( F) */
102 #define _ISO2022STATE_FLAG_INITIALIZED 1
106 _ISO2022Charset *recommend[4];
107 size_t recommendsize[4];
108 _ISO2022Charset initg[4];
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;
128 #define _CEI_TO_EI(_cei_) (&(_cei_)->ei)
129 #define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_
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))
140 #define _ISO2022INVALID (wchar_t)-1
142 static __inline bool isc0(__uint8_t x)
145 return ((x & 0x1f) == x);
148 static __inline bool isc1(__uint8_t x)
151 return (0x80 <= x && x <= 0x9f);
154 static __inline bool iscntl(__uint8_t x)
157 return (isc0(x) || isc1(x) || x == 0x7f);
160 static __inline bool is94(__uint8_t x)
163 return (0x21 <= x && x <= 0x7e);
166 static __inline bool is96(__uint8_t x)
169 return (0x20 <= x && x <= 0x7f);
172 static __inline bool isecma(__uint8_t x)
175 return (0x30 <= x && x <= 0x7f);
178 static __inline bool isinterm(__uint8_t x)
181 return (0x20 <= x && x <= 0x2f);
184 static __inline bool isthree(__uint8_t x)
187 return (0x60 <= x && x <= 0x6f);
191 getcs(const char * __restrict p, _ISO2022Charset * __restrict cs)
194 if (!strncmp(p, "94$", 3) && p[3] && !p[4]) {
195 cs->final = (unsigned char)(p[3] & 0xff);
198 cs->type = CS94MULTI;
199 } else if (!strncmp(p, "96$", 3) && p[3] && !p[4]) {
200 cs->final = (unsigned char)(p[3] & 0xff);
203 cs->type = CS96MULTI;
204 } else if (!strncmp(p, "94", 2) && p[2] && !p[3]) {
205 cs->final = (unsigned char)(p[2] & 0xff);
209 } else if (!strncmp(p, "96", 2) && p[2] && !p[3]) {
210 cs->final = (unsigned char )(p[2] & 0xff);
226 get_recommend(_ISO2022EncodingInfo * __restrict ei,
227 const char * __restrict token)
229 _ISO2022Charset cs, *p;
232 if (!strchr("0123", token[0]) || token[1] != '=')
235 if (getcs(&token[2], &cs) == 0)
237 else if (!strcmp(&token[2], "94")) {
238 cs.final = (unsigned char)(token[4]);
242 } else if (!strcmp(&token[2], "96")) {
243 cs.final = (unsigned char)(token[4]);
247 } else if (!strcmp(&token[2], "94$")) {
248 cs.final = (unsigned char)(token[5]);
252 } else if (!strcmp(&token[2], "96$")) {
253 cs.final = (unsigned char)(token[5]);
261 if (!ei->recommend[i])
262 ei->recommend[i] = malloc(sizeof(_ISO2022Charset));
264 p = reallocarray(ei->recommend[i], ei->recommendsize[i] + 1,
265 sizeof(_ISO2022Charset));
268 ei->recommend[i] = p;
270 if (!ei->recommend[i])
272 ei->recommendsize[i]++;
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;
283 get_initg(_ISO2022EncodingInfo * __restrict ei,
284 const char * __restrict token)
288 if (strncmp("INIT", &token[0], 4) ||
289 !strchr("0123", token[4]) ||
293 if (getcs(&token[6], &cs) != 0)
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;
305 get_max(_ISO2022EncodingInfo * __restrict ei,
306 const char * __restrict token)
308 if (!strcmp(token, "MAX1"))
310 else if (!strcmp(token, "MAX2"))
312 else if (!strcmp(token, "MAX3"))
322 get_flags(_ISO2022EncodingInfo * __restrict ei,
323 const char * __restrict token)
331 { "NOOLD", F_NOOLD },
349 for (i = 0; tags[i].tag; i++)
350 if (!strcmp(token, tags[i].tag)) {
351 ei->flags |= tags[i].flag;
360 _citrus_ISO2022_parse_variable(_ISO2022EncodingInfo * __restrict ei,
361 const void * __restrict var, size_t lenvar __unused)
369 * parse VARIABLE section.
375 v = (const char *) var;
377 /* initialize structure */
379 for (i = 0; i < 4; i++) {
380 ei->recommend[i] = NULL;
381 ei->recommendsize[i] = 0;
386 while (*v == ' ' || *v == '\t')
391 while (*e && *e != ' ' && *e != '\t')
397 if (len >= sizeof(buf))
399 snprintf(buf, sizeof(buf), "%.*s", (int)len, v);
401 if ((ret = get_recommend(ei, buf)) != _NOTMATCH)
403 else if ((ret = get_initg(ei, buf)) != _NOTMATCH)
405 else if ((ret = get_max(ei, buf)) != _NOTMATCH)
407 else if ((ret = get_flags(ei, buf)) != _NOTMATCH)
411 if (ret == _PARSEFAIL)
420 free(ei->recommend[0]);
421 free(ei->recommend[1]);
422 free(ei->recommend[2]);
423 free(ei->recommend[3]);
430 _citrus_ISO2022_init_state(_ISO2022EncodingInfo * __restrict ei,
431 _ISO2022State * __restrict s)
435 memset(s, 0, sizeof(*s));
437 s->gr = (ei->flags & F_8BIT) ? 1 : -1;
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;
445 s->singlegl = s->singlegr = -1;
446 s->flags |= _ISO2022STATE_FLAG_INITIALIZED;
452 _citrus_ISO2022_pack_state(_ISO2022EncodingInfo * __restrict ei __unused,
453 void * __restrict pspriv, const _ISO2022State * __restrict s)
456 memcpy(pspriv, (const void *)s, sizeof(*s));
461 _citrus_ISO2022_unpack_state(_ISO2022EncodingInfo * __restrict ei __unused,
462 _ISO2022State * __restrict s, const void * __restrict pspriv)
465 memcpy((void *)s, pspriv, sizeof(*s));
471 _citrus_ISO2022_encoding_module_init(_ISO2022EncodingInfo * __restrict ei,
472 const void * __restrict var, size_t lenvar)
475 return (_citrus_ISO2022_parse_variable(ei, var, lenvar));
480 _citrus_ISO2022_encoding_module_uninit(_ISO2022EncodingInfo *ei __unused)
489 static const struct 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 }, },
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, }, },
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, }, },
511 { CS94MULTI, 2, 3, -1, -1, 4, { ESC, '$', CS94, ECMA, }, },
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, }, },
517 { -1, -1, -1, -1, -1, 2, { ESC, 'n', }, },
518 { -1, -1, -1, -1, -1, 2, { ESC, 'o', }, },
520 { -1, -1, -1, -1, -1, 2, { ESC, '~', }, },
521 { -1, -1, -1, -1, -1, 2, { ESC, /*{*/ '}', }, },
522 { -1, -1, -1, -1, -1, 2, { ESC, '|', }, },
524 { -1, -1, -1, -1, -1, 2, { ESC, 'N', }, },
525 { -1, -1, -1, -1, -1, 2, { ESC, 'O', }, },
528 { 0, 0, 0, 0, 0, 0, { ESC, 0, }, }
532 seqmatch(const char * __restrict s, size_t n,
533 const struct seqtable * __restrict sp)
538 while ((size_t)(p - sp->chars) < n && p - sp->chars < sp->len) {
545 if (*s && strchr("@AB", *s))
554 if (*s && strchr("()*+", *s))
559 if (*s && strchr(",-./", *s))
574 return (p - sp->chars);
578 _ISO2022_sgetwchar(_ISO2022EncodingInfo * __restrict ei __unused,
579 char * __restrict string, size_t n, char ** __restrict result,
580 _ISO2022State * __restrict psenc)
582 const struct seqtable *sp;
588 if (1 <= n && string[0] == '\017') {
594 if (1 <= n && string[0] == '\016') {
602 if (1 <= n && string[0] && strchr("\217\216", string[0])) {
603 psenc->singlegl = psenc->singlegr =
604 (string[0] - '\216') + 2;
610 /* eat the letter if this is not ESC */
611 if (1 <= n && string[0] != '\033')
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))
624 if (sp->type != -1) {
631 i = string[sp->csoff] - '(';
635 i = string[sp->csoff] - ',';
638 return (_ISO2022INVALID);
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];
659 if (2 <= n && string[0] == '\033' &&
660 string[1] && strchr("no", string[1])) {
661 psenc->gl = string[1] - 'n' + 2;
668 /* XXX: { for vi showmatch */
669 if (2 <= n && string[0] == '\033' &&
670 string[1] && strchr("~}|", string[1])) {
671 psenc->gr = 3 - (string[1] - '|');
678 if (2 <= n && string[0] == '\033' && string[1] &&
679 strchr("NO", string[1])) {
680 psenc->singlegl = (string[1] - 'N') + 2;
688 * if we've got an unknown escape sequence, eat the ESC at the
689 * head. otherwise, wait till full escape sequence comes.
691 for (sp = &seqtable[0]; sp->len; sp++) {
692 nmatch = seqmatch(string, n, sp);
697 * if we are in the middle of escape sequence,
698 * we still need to wait for more characters to come
700 if (n < (size_t)(sp->len)) {
701 if ((size_t)(nmatch) == n) {
704 return (_ISO2022INVALID);
707 if (nmatch == sp->len) {
708 /* this case should not happen */
718 /* no letter to eat */
722 return (_ISO2022INVALID);
725 /* normal chars. always eat C0/C1 as is. */
726 if (iscntl(*string & 0xff))
728 else if (*string & 0x80)
729 cur = (psenc->singlegr == -1) ? psenc->gr : psenc->singlegr;
731 cur = (psenc->singlegl == -1) ? psenc->gl : psenc->singlegl;
735 wchar = *string++ & 0xff;
738 /* reset single shift state */
739 psenc->singlegr = psenc->singlegl = -1;
743 /* length error check */
744 switch (psenc->g[cur].type) {
747 if (!isthree(psenc->g[cur].final)) {
749 (string[0] & 0x80) == (string[1] & 0x80))
753 (string[0] & 0x80) == (string[1] & 0x80) &&
754 (string[0] & 0x80) == (string[2] & 0x80))
758 /* we still need to wait for more characters to come */
761 return (_ISO2022INVALID);
768 /* we still need to wait for more characters to come */
771 return (_ISO2022INVALID);
775 switch (psenc->g[cur].type) {
777 if (!(is94(string[0] & 0x7f)))
781 if (!(is96(string[0] & 0x7f)))
785 if (!(is94(string[0] & 0x7f) && is94(string[1] & 0x7f)))
789 if (!(is96(string[0] & 0x7f) && is96(string[1] & 0x7f)))
794 /* extract the character. */
795 switch (psenc->g[cur].type) {
797 /* special case for ASCII. */
798 if (psenc->g[cur].final == 'B' && !psenc->g[cur].interm) {
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);
810 /* special case for ISO-8859-1. */
811 if (psenc->g[cur].final == 'A' && !psenc->g[cur].interm) {
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);
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)
839 /* reset single shift state */
840 psenc->singlegr = psenc->singlegl = -1;
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)
851 char *p, *result, *s0;
856 _citrus_ISO2022_init_state(ei, psenc);
857 *nresult = _ENCODING_IS_STATE_DEPENDENT;
862 chlenbak = psenc->chlen;
865 * if we have something in buffer, use that.
866 * otherwise, skip here
868 if (psenc->chlen > sizeof(psenc->ch)) {
870 _citrus_ISO2022_init_state(ei, psenc);
873 if (psenc->chlen == 0)
876 /* buffer is not empty */
878 while (psenc->chlen < sizeof(psenc->ch)) {
880 psenc->ch[psenc->chlen++] = *s0++;
884 wchar = _ISO2022_sgetwchar(ei, p, psenc->chlen - (p-psenc->ch),
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)
898 if ((size_t)(result - p) == psenc->chlen)
899 /* complete shift sequence. */
907 /* escape sequence too long? */
911 wchar = _ISO2022_sgetwchar(ei, s0, n, &result, psenc);
912 if (wchar != _ISO2022INVALID) {
924 /* complete shift sequence. */
928 if (n < sizeof(psenc->ch)) {
929 memcpy(psenc->ch, s0 - c, n);
935 /* escape sequence too long? */
939 *nresult = (size_t)-1;
946 *nresult = wchar ? c - chlenbak : 0;
951 *nresult = (size_t)-2;
957 recommendation(_ISO2022EncodingInfo * __restrict ei,
958 _ISO2022Charset * __restrict cs)
960 _ISO2022Charset *recommend;
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)
970 if (cs->final != recommend[j].final)
972 if (cs->interm != recommend[j].interm)
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)
985 if (cs->final && (cs->final != recommend[j].final))
987 if (cs->interm && (cs->interm != recommend[j].interm))
994 /* there's no recommendation. make a guess. */
995 if (ei->maxcharset == 0) {
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)
1017 char tmp[MB_LEN_MAX];
1019 int bit8, i = 0, target;
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)) {
1030 /* special treatment for ISO-8859-1 */
1033 /* special treatment for ASCII */
1037 cs.final = (wc >> 24) & 0x7f;
1038 if ((wc >> 16) & 0x80)
1039 cs.interm = (wc >> 16) & 0x7f;
1043 cs.type = (wc & 0x00007f00) ? CS96MULTI : CS96;
1045 cs.type = (wc & 0x00007f00) ? CS94MULTI : CS94;
1047 target = recommendation(ei, &cs);
1049 bit8 = ei->flags & F_8BIT;
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)
1058 if (cs.type == CS94MULTI || cs.type == CS96MULTI)
1060 if (target == 0 && cs.type == CS94MULTI && strchr("@AB", cs.final) &&
1061 !cs.interm && !(ei->flags & F_NOOLD))
1063 else if (cs.type == CS94 || cs.type == CS94MULTI)
1064 *p++ = "()*+"[target];
1066 *p++ = ",-./"[target];
1071 psenc->g[target].type = cs.type;
1072 psenc->g[target].final = cs.final;
1073 psenc->g[target].interm = cs.interm;
1076 /* invoke the plane onto GL or GR. */
1077 if (psenc->gl == target)
1079 if (bit8 && psenc->gr == target)
1082 if (target == 0 && (ei->flags & F_LS0)) {
1085 } else if (target == 1 && (ei->flags & F_LS1)) {
1088 } else if (target == 2 && (ei->flags & F_LS2)) {
1092 } else if (target == 3 && (ei->flags & F_LS3)) {
1096 } else if (bit8 && target == 1 && (ei->flags & F_LS1R)) {
1100 } else if (bit8 && target == 2 && (ei->flags & F_LS2R)) {
1105 } else if (bit8 && target == 3 && (ei->flags & F_LS3R)) {
1109 } else if (target == 2 && (ei->flags & F_SS2)) {
1112 psenc->singlegl = 2;
1113 } else if (target == 3 && (ei->flags & F_SS3)) {
1116 psenc->singlegl = 3;
1117 } else if (bit8 && target == 2 && (ei->flags & F_SS2R)) {
1120 psenc->singlegl = psenc->singlegr = 2;
1121 } else if (bit8 && target == 3 && (ei->flags & F_SS3R)) {
1124 psenc->singlegl = psenc->singlegr = 3;
1129 if (psenc->singlegl == target)
1131 else if (psenc->singlegr == target)
1133 else if (psenc->gl == target)
1135 else if ((ei->flags & F_8BIT) && psenc->gr == target)
1147 i = !iscntl(wc & 0xff) ?
1148 (isthree(cs.final) ? 3 : 2) : 1;
1152 *p++ = ((wc >> (i << 3)) & 0x7f) | mask;
1154 /* reset single shift state */
1155 psenc->singlegl = psenc->singlegr = -1;
1157 len = (size_t)(p - tmp);
1160 *result = (char *)0;
1161 *nresult = (size_t)-1;
1165 *result = string + len;
1166 memcpy(string, tmp, len);
1172 *nresult = (size_t)-1;
1177 _citrus_ISO2022_put_state_reset(_ISO2022EncodingInfo * __restrict ei,
1178 char * __restrict s, size_t n, _ISO2022State * __restrict psenc,
1179 size_t * __restrict nresult)
1182 char buf[MB_LEN_MAX];
1186 /* XXX state will be modified after this operation... */
1187 ret = _ISO2022_sputwchar(ei, L'\0', buf, sizeof(buf), &result, psenc,
1194 if (sizeof(buf) < len || n < len-1) {
1195 /* XXX should recover state? */
1196 *nresult = (size_t)-1;
1200 memcpy(s, buf, len - 1);
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)
1211 char buf[MB_LEN_MAX];
1215 /* XXX state will be modified after this operation... */
1216 ret = _ISO2022_sputwchar(ei, wc, buf, sizeof(buf), &result, psenc,
1223 if (sizeof(buf) < len || n < len) {
1224 /* XXX should recover state? */
1225 *nresult = (size_t)-1;
1229 memcpy(s, buf, len);
1236 _citrus_ISO2022_stdenc_wctocs(_ISO2022EncodingInfo * __restrict ei __unused,
1237 _csid_t * __restrict csid, _index_t * __restrict idx, wchar_t wc)
1241 m = wc & 0x7FFF8080;
1242 nm = wc & 0x007F7F7F;
1247 if (nm & 0x007F0000) {
1250 } else if (nm & 0x00007F00) {
1255 *idx = (_index_t)nm;
1262 _citrus_ISO2022_stdenc_cstowc(_ISO2022EncodingInfo * __restrict ei __unused,
1263 wchar_t * __restrict wc, _csid_t csid, _index_t idx)
1266 *wc = (wchar_t)(csid & 0x7F808080) | (wchar_t)idx;
1273 _citrus_ISO2022_stdenc_get_state_desc_generic(_ISO2022EncodingInfo * __restrict ei __unused,
1274 _ISO2022State * __restrict psenc, int * __restrict rstate)
1277 if (psenc->chlen == 0) {
1278 /* XXX: it should distinguish initial and stable. */
1279 *rstate = _STDENC_SDGEN_STABLE;
1281 *rstate = (psenc->ch[0] == '\033') ?
1282 _STDENC_SDGEN_INCOMPLETE_SHIFT :
1283 _STDENC_SDGEN_INCOMPLETE_CHAR;
1287 /* ----------------------------------------------------------------------
1288 * public interface for stdenc
1291 _CITRUS_STDENC_DECLS(ISO2022);
1292 _CITRUS_STDENC_DEF_OPS(ISO2022);
1294 #include "citrus_stdenc_template.h"