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