lib/i18n_module/ISO2022/citrus_iso2022.c

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