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
82 typedef struct {
83 unsigned char type;
84 unsigned char final;
85 unsigned char interm;
86 unsigned char vers;
87 } _ISO2022Charset;
88
89 static const _ISO2022Charset ascii = { CS94, 'B', '\0', '\0' };
90 static const _ISO2022Charset iso88591 = { CS96, 'A', '\0', '\0' };
91
92 typedef 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
105 typedef 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
isc0(__uint8_t x)142 static __inline bool isc0(__uint8_t x)
143 {
144
145 return ((x & 0x1f) == x);
146 }
147
isc1(__uint8_t x)148 static __inline bool isc1(__uint8_t x)
149 {
150
151 return (0x80 <= x && x <= 0x9f);
152 }
153
iscntl(__uint8_t x)154 static __inline bool iscntl(__uint8_t x)
155 {
156
157 return (isc0(x) || isc1(x) || x == 0x7f);
158 }
159
is94(__uint8_t x)160 static __inline bool is94(__uint8_t x)
161 {
162
163 return (0x21 <= x && x <= 0x7e);
164 }
165
is96(__uint8_t x)166 static __inline bool is96(__uint8_t x)
167 {
168
169 return (0x20 <= x && x <= 0x7f);
170 }
171
isecma(__uint8_t x)172 static __inline bool isecma(__uint8_t x)
173 {
174
175 return (0x30 <= x && x <= 0x7f);
176 }
177
isinterm(__uint8_t x)178 static __inline bool isinterm(__uint8_t x)
179 {
180
181 return (0x20 <= x && x <= 0x2f);
182 }
183
isthree(__uint8_t x)184 static __inline bool isthree(__uint8_t x)
185 {
186
187 return (0x60 <= x && x <= 0x6f);
188 }
189
190 static __inline int
getcs(const char * __restrict p,_ISO2022Charset * __restrict cs)191 getcs(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
225 static __inline int
get_recommend(_ISO2022EncodingInfo * __restrict ei,const char * __restrict token)226 get_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
282 static __inline int
get_initg(_ISO2022EncodingInfo * __restrict ei,const char * __restrict token)283 get_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
304 static __inline int
get_max(_ISO2022EncodingInfo * __restrict ei,const char * __restrict token)305 get_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
321 static __inline int
get_flags(_ISO2022EncodingInfo * __restrict ei,const char * __restrict token)322 get_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
359 static __inline int
_citrus_ISO2022_parse_variable(_ISO2022EncodingInfo * __restrict ei,const void * __restrict var,size_t lenvar __unused)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
419 parsefail:
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
428 static __inline void
429 /*ARGSUSED*/
_citrus_ISO2022_init_state(_ISO2022EncodingInfo * __restrict ei,_ISO2022State * __restrict s)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
450 static __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
459 static __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
469 static int
470 /*ARGSUSED*/
_citrus_ISO2022_encoding_module_init(_ISO2022EncodingInfo * __restrict ei,const void * __restrict var,size_t lenvar)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
478 static void
479 /*ARGSUSED*/
_citrus_ISO2022_encoding_module_uninit(_ISO2022EncodingInfo * ei __unused)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
489 static 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
531 static int
seqmatch(const char * __restrict s,size_t n,const struct seqtable * __restrict sp)532 seqmatch(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
573 terminate:
574 return (p - sp->chars);
575 }
576
577 static wchar_t
_ISO2022_sgetwchar(_ISO2022EncodingInfo * __restrict ei __unused,char * __restrict string,size_t n,char ** __restrict result,_ISO2022State * __restrict psenc)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
717 eat:
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) {
734 asis:
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
846 static int
_citrus_ISO2022_mbrtowc_priv(_ISO2022EncodingInfo * __restrict ei,wchar_t * __restrict pwc,char ** __restrict s,size_t n,_ISO2022State * __restrict psenc,size_t * __restrict nresult)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
910 emptybuf:
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
937 encoding_error:
938 psenc->chlen = 0;
939 *nresult = (size_t)-1;
940 return (EILSEQ);
941
942 output:
943 *s = s0;
944 if (pwc)
945 *pwc = wchar;
946 *nresult = wchar ? c - chlenbak : 0;
947 return (0);
948
949 restart:
950 *s = s0;
951 *nresult = (size_t)-2;
952
953 return (0);
954 }
955
956 static int
recommendation(_ISO2022EncodingInfo * __restrict ei,_ISO2022Charset * __restrict cs)957 recommendation(_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
1010 static int
_ISO2022_sputwchar(_ISO2022EncodingInfo * __restrict ei,wchar_t wc,char * __restrict string,size_t n,char ** __restrict result,_ISO2022State * __restrict psenc,size_t * __restrict nresult)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
1075 planeok:
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
1128 sideok:
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
1171 ilseq:
1172 *nresult = (size_t)-1;
1173 return (EILSEQ);
1174 }
1175
1176 static int
_citrus_ISO2022_put_state_reset(_ISO2022EncodingInfo * __restrict ei,char * __restrict s,size_t n,_ISO2022State * __restrict psenc,size_t * __restrict nresult)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
1205 static int
_citrus_ISO2022_wcrtomb_priv(_ISO2022EncodingInfo * __restrict ei,char * __restrict s,size_t n,wchar_t wc,_ISO2022State * __restrict psenc,size_t * __restrict nresult)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
1234 static __inline int
1235 /*ARGSUSED*/
_citrus_ISO2022_stdenc_wctocs(_ISO2022EncodingInfo * __restrict ei __unused,_csid_t * __restrict csid,_index_t * __restrict idx,wchar_t wc)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
1260 static __inline int
1261 /*ARGSUSED*/
_citrus_ISO2022_stdenc_cstowc(_ISO2022EncodingInfo * __restrict ei __unused,wchar_t * __restrict wc,_csid_t csid,_index_t idx)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
1271 static __inline int
1272 /*ARGSUSED*/
_citrus_ISO2022_stdenc_get_state_desc_generic(_ISO2022EncodingInfo * __restrict ei __unused,_ISO2022State * __restrict psenc,int * __restrict rstate)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