lib/libiconv_modules/ISO2022/citrus_iso2022.c

   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
 142 static __inline bool isc0(__uint8_t x)
 143 {
 144
 145         return ((x & 0x1f) == x);
 146 }
 147
 148 static __inline bool isc1(__uint8_t x)
 149 {
 150
 151         return (0x80 <= x && x <= 0x9f);
 152 }
 153
 154 static __inline bool iscntl(__uint8_t x)
 155 {
 156
 157         return (isc0(x) || isc1(x) || x == 0x7f);
 158 }
 159
 160 static __inline bool is94(__uint8_t x)
 161 {
 162
 163         return (0x21 <= x && x <= 0x7e);
 164 }
 165
 166 static __inline bool is96(__uint8_t x)
 167 {
 168
 169         return (0x20 <= x && x <= 0x7f);
 170 }
 171
 172 static __inline bool isecma(__uint8_t x)
 173 {
 174
 175         return (0x30 <= x && x <= 0x7f);
 176 }
 177
 178 static __inline bool isinterm(__uint8_t x)
 179 {
 180
 181         return (0x20 <= x && x <= 0x2f);
 182 }
 183
 184 static __inline bool isthree(__uint8_t x)
 185 {
 186
 187         return (0x60 <= x && x <= 0x6f);
 188 }
 189
 190 static __inline int
 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
 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
 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
 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
 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
 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*/
 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*/
 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*/
 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
 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
 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
 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
 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
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
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
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*/
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*/
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*/
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"