lib/i18n_module/HZ/citrus_hz.c

   1 /* $FreeBSD: head/lib/libiconv_modules/HZ/citrus_hz.c 252583 2013-07-03 18:27:45Z peter $ */
   2 /* $NetBSD: citrus_hz.c,v 1.2 2008/06/14 16:01:07 tnozaki Exp $ */
   3
   4 /*-
   5  * Copyright (c)2004, 2006 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  */
  30
  31 #include <sys/cdefs.h>
  32 #include <sys/queue.h>
  33 #include <sys/types.h>
  34
  35 #include <assert.h>
  36 #include <errno.h>
  37 #include <limits.h>
  38 #include <stddef.h>
  39 #include <stdint.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <wchar.h>
  43
  44 #include "citrus_namespace.h"
  45 #include "citrus_types.h"
  46 #include "citrus_bcs.h"
  47 #include "citrus_module.h"
  48 #include "citrus_stdenc.h"
  49
  50 #include "citrus_hz.h"
  51 #include "citrus_prop.h"
  52
  53 /*
  54  * wchar_t mapping:
  55  *
  56  * CTRL/ASCII   00000000 00000000 00000000 gxxxxxxx
  57  * GB2312       00000000 00000000 0xxxxxxx gxxxxxxx
  58  * 94/96*n (~M) 0mmmmmmm 0xxxxxxx 0xxxxxxx gxxxxxxx
  59  */
  60
  61 #define ESCAPE_CHAR     '~'
  62
  63 typedef enum {
  64         CTRL = 0, ASCII = 1, GB2312 = 2, CS94 = 3, CS96 = 4
  65 } charset_t;
  66
  67 typedef struct {
  68         int      end;
  69         int      start;
  70         int      width;
  71 } range_t;
  72
  73 static const range_t ranges[] = {
  74 #define RANGE(start, end) { start, end, (end - start) + 1 }
  75 /* CTRL   */ RANGE(0x00, 0x1F),
  76 /* ASCII  */ RANGE(0x20, 0x7F),
  77 /* GB2312 */ RANGE(0x21, 0x7E),
  78 /* CS94   */ RANGE(0x21, 0x7E),
  79 /* CS96   */ RANGE(0x20, 0x7F),
  80 #undef RANGE
  81 };
  82
  83 typedef struct escape_t escape_t;
  84 typedef struct {
  85         charset_t        charset;
  86         escape_t        *escape;
  87         ssize_t          length;
  88 #define ROWCOL_MAX      3
  89 } graphic_t;
  90
  91 typedef TAILQ_HEAD(escape_list, escape_t) escape_list;
  92 struct escape_t {
  93         TAILQ_ENTRY(escape_t)    entry;
  94         escape_list             *set;
  95         graphic_t               *left;
  96         graphic_t               *right;
  97         int                      ch;
  98 };
  99
 100 #define GL(escape)      ((escape)->left)
 101 #define GR(escape)      ((escape)->right)
 102 #define SET(escape)     ((escape)->set)
 103 #define ESC(escape)     ((escape)->ch)
 104 #define INIT(escape)    (TAILQ_FIRST(SET(escape)))
 105
 106 static __inline escape_t *
 107 find_escape(escape_list *set, int ch)
 108 {
 109         escape_t *escape;
 110
 111         TAILQ_FOREACH(escape, set, entry) {
 112                 if (ESC(escape) == ch)
 113                         break;
 114         }
 115
 116         return (escape);
 117 }
 118
 119 typedef struct {
 120         escape_list      e0;
 121         escape_list      e1;
 122         graphic_t       *ascii;
 123         graphic_t       *gb2312;
 124 } _HZEncodingInfo;
 125
 126 #define E0SET(ei)       (&(ei)->e0)
 127 #define E1SET(ei)       (&(ei)->e1)
 128 #define INIT0(ei)       (TAILQ_FIRST(E0SET(ei)))
 129 #define INIT1(ei)       (TAILQ_FIRST(E1SET(ei)))
 130
 131 typedef struct {
 132         escape_t        *inuse;
 133         int              chlen;
 134         char             ch[ROWCOL_MAX];
 135 } _HZState;
 136
 137 #define _CEI_TO_EI(_cei_)               (&(_cei_)->ei)
 138 #define _CEI_TO_STATE(_cei_, _func_)    (_cei_)->states.s_##_func_
 139
 140 #define _FUNCNAME(m)                    _citrus_HZ_##m
 141 #define _ENCODING_INFO                  _HZEncodingInfo
 142 #define _ENCODING_STATE                 _HZState
 143 #define _ENCODING_MB_CUR_MAX(_ei_)      MB_LEN_MAX
 144 #define _ENCODING_IS_STATE_DEPENDENT            1
 145 #define _STATE_NEEDS_EXPLICIT_INIT(_ps_)        ((_ps_)->inuse == NULL)
 146
 147 static __inline void
 148 _citrus_HZ_init_state(_HZEncodingInfo * __restrict ei,
 149     _HZState * __restrict psenc)
 150 {
 151
 152         psenc->chlen = 0;
 153         psenc->inuse = INIT0(ei);
 154 }
 155
 156 static __inline void
 157 /*ARGSUSED*/
 158 _citrus_HZ_pack_state(_HZEncodingInfo * __restrict ei __unused,
 159     void *__restrict pspriv, const _HZState * __restrict psenc)
 160 {
 161
 162         memcpy(pspriv, (const void *)psenc, sizeof(*psenc));
 163 }
 164
 165 static __inline void
 166 /*ARGSUSED*/
 167 _citrus_HZ_unpack_state(_HZEncodingInfo * __restrict ei __unused,
 168     _HZState * __restrict psenc, const void * __restrict pspriv)
 169 {
 170
 171         memcpy((void *)psenc, pspriv, sizeof(*psenc));
 172 }
 173
 174 static int
 175 _citrus_HZ_mbrtowc_priv(_HZEncodingInfo * __restrict ei,
 176     wchar_t * __restrict pwc, const char ** __restrict s, size_t n,
 177     _HZState * __restrict psenc, size_t * __restrict nresult)
 178 {
 179         escape_t *candidate, *init;
 180         graphic_t *graphic;
 181         const range_t *range;
 182         const char *s0;
 183         wchar_t wc;
 184         int bit, ch, head, len, tail;
 185
 186         if (*s == NULL) {
 187                 _citrus_HZ_init_state(ei, psenc);
 188                 *nresult = 1;
 189                 return (0);
 190         }
 191         s0 = *s;
 192         if (psenc->chlen < 0 || psenc->inuse == NULL)
 193                 return (EINVAL);
 194
 195         wc = (wchar_t)0;
 196         bit = head = tail = 0;
 197         graphic = NULL;
 198         for (len = 0; len <= MB_LEN_MAX;) {
 199                 if (psenc->chlen == tail) {
 200                         if (n-- < 1) {
 201                                 *s = s0;
 202                                 *nresult = (size_t)-2;
 203                                 return (0);
 204                         }
 205                         psenc->ch[psenc->chlen++] = *s0++;
 206                         ++len;
 207                 }
 208                 ch = (unsigned char)psenc->ch[tail++];
 209                 if (tail == 1) {
 210                         if ((ch & ~0x80) <= 0x1F) {
 211                                 if (psenc->inuse != INIT0(ei))
 212                                         break;
 213                                 wc = (wchar_t)ch;
 214                                 goto done;
 215                         }
 216                         if (ch & 0x80) {
 217                                 graphic = GR(psenc->inuse);
 218                                 bit = 0x80;
 219                                 ch &= ~0x80;
 220                         } else {
 221                                 graphic = GL(psenc->inuse);
 222                                 if (ch == ESCAPE_CHAR)
 223                                         continue;
 224                                 bit = 0x0;
 225                         }
 226                         if (graphic == NULL)
 227                                 break;
 228                 } else if (tail == 2 && psenc->ch[0] == ESCAPE_CHAR) {
 229                         if (tail < psenc->chlen)
 230                                 return (EINVAL);
 231                         if (ch == ESCAPE_CHAR) {
 232                                 ++head;
 233                         } else if (ch == '\n') {
 234                                 if (psenc->inuse != INIT0(ei))
 235                                         break;
 236                                 tail = psenc->chlen = 0;
 237                                 continue;
 238                         } else {
 239                                 candidate = NULL;
 240                                 init = INIT0(ei);
 241                                 if (psenc->inuse == init) {
 242                                         init = INIT1(ei);
 243                                 } else if (INIT(psenc->inuse) == init) {
 244                                         if (ESC(init) != ch)
 245                                                 break;
 246                                         candidate = init;
 247                                 }
 248                                 if (candidate == NULL) {
 249                                         candidate = find_escape(
 250                                             SET(psenc->inuse), ch);
 251                                         if (candidate == NULL) {
 252                                                 if (init == NULL ||
 253                                                     ESC(init) != ch)
 254                                                         break;
 255                                                 candidate = init;
 256                                         }
 257                                 }
 258                                 psenc->inuse = candidate;
 259                                 tail = psenc->chlen = 0;
 260                                 continue;
 261                         }
 262                 } else if (ch & 0x80) {
 263                         if (graphic != GR(psenc->inuse))
 264                                 break;
 265                         ch &= ~0x80;
 266                 } else {
 267                         if (graphic != GL(psenc->inuse))
 268                                 break;
 269                 }
 270                 range = &ranges[(size_t)graphic->charset];
 271                 if (range->start > ch || range->end < ch)
 272                         break;
 273                 wc <<= 8;
 274                 wc |= ch;
 275                 if (graphic->length == (tail - head)) {
 276                         if (graphic->charset > GB2312)
 277                                 bit |= ESC(psenc->inuse) << 24;
 278                         wc |= bit;
 279                         goto done;
 280                 }
 281         }
 282         *nresult = (size_t)-1;
 283         return (EILSEQ);
 284 done:
 285         if (tail < psenc->chlen)
 286                 return (EINVAL);
 287         *s = s0;
 288         if (pwc != NULL)
 289                 *pwc = wc;
 290         psenc->chlen = 0;
 291         *nresult = (wc == 0) ? 0 : len;
 292
 293         return (0);
 294 }
 295
 296 static int
 297 _citrus_HZ_wcrtomb_priv(_HZEncodingInfo * __restrict ei,
 298     char * __restrict s, size_t n, wchar_t wc,
 299     _HZState * __restrict psenc, size_t * __restrict nresult)
 300 {
 301         escape_t *candidate, *init;
 302         graphic_t *graphic;
 303         const range_t *range;
 304         size_t len;
 305         int bit, ch;
 306
 307         if (psenc->chlen != 0 || psenc->inuse == NULL)
 308                 return (EINVAL);
 309         if (wc & 0x80) {
 310                 bit = 0x80;
 311                 wc &= ~0x80;
 312         } else {
 313                 bit = 0x0;
 314         }
 315         if ((uint32_t)wc <= 0x1F) {
 316                 candidate = INIT0(ei);
 317                 graphic = (bit == 0) ? candidate->left : candidate->right;
 318                 if (graphic == NULL)
 319                         goto ilseq;
 320                 range = &ranges[(size_t)CTRL];
 321                 len = 1;
 322         } else if ((uint32_t)wc <= 0x7F) {
 323                 graphic = ei->ascii;
 324                 if (graphic == NULL)
 325                         goto ilseq;
 326                 candidate = graphic->escape;
 327                 range = &ranges[(size_t)graphic->charset];
 328                 len = graphic->length;
 329         } else if ((uint32_t)wc <= 0x7F7F) {
 330                 graphic = ei->gb2312;
 331                 if (graphic == NULL)
 332                         goto ilseq;
 333                 candidate = graphic->escape;
 334                 range = &ranges[(size_t)graphic->charset];
 335                 len = graphic->length;
 336         } else {
 337                 ch = (wc >> 24) & 0xFF;
 338                 candidate = find_escape(E0SET(ei), ch);
 339                 if (candidate == NULL) {
 340                         candidate = find_escape(E1SET(ei), ch);
 341                         if (candidate == NULL)
 342                                 goto ilseq;
 343                 }
 344                 wc &= ~0xFF000000;
 345                 graphic = (bit == 0) ? candidate->left : candidate->right;
 346                 if (graphic == NULL)
 347                         goto ilseq;
 348                 range = &ranges[(size_t)graphic->charset];
 349                 len = graphic->length;
 350         }
 351         if (psenc->inuse != candidate) {
 352                 init = INIT0(ei);
 353                 if (SET(psenc->inuse) == SET(candidate)) {
 354                         if (INIT(psenc->inuse) != init ||
 355                             psenc->inuse == init || candidate == init)
 356                                 init = NULL;
 357                 } else if (candidate == (init = INIT(candidate))) {
 358                         init = NULL;
 359                 }
 360                 if (init != NULL) {
 361                         if (n < 2)
 362                                 return (E2BIG);
 363                         n -= 2;
 364                         psenc->ch[psenc->chlen++] = ESCAPE_CHAR;
 365                         psenc->ch[psenc->chlen++] = ESC(init);
 366                 }
 367                 if (n < 2)
 368                         return (E2BIG);
 369                 n -= 2;
 370                 psenc->ch[psenc->chlen++] = ESCAPE_CHAR;
 371                 psenc->ch[psenc->chlen++] = ESC(candidate);
 372                 psenc->inuse = candidate;
 373         }
 374         if (n < len)
 375                 return (E2BIG);
 376         while (len-- > 0) {
 377                 ch = (wc >> (len * 8)) & 0xFF;
 378                 if (range->start > ch || range->end < ch)
 379                         goto ilseq;
 380                 psenc->ch[psenc->chlen++] = ch | bit;
 381         }
 382         memcpy(s, psenc->ch, psenc->chlen);
 383         *nresult = psenc->chlen;
 384         psenc->chlen = 0;
 385
 386         return (0);
 387
 388 ilseq:
 389         *nresult = (size_t)-1;
 390         return (EILSEQ);
 391 }
 392
 393 static __inline int
 394 _citrus_HZ_put_state_reset(_HZEncodingInfo * __restrict ei,
 395     char * __restrict s, size_t n, _HZState * __restrict psenc,
 396     size_t * __restrict nresult)
 397 {
 398         escape_t *candidate;
 399
 400         if (psenc->chlen != 0 || psenc->inuse == NULL)
 401                 return (EINVAL);
 402         candidate = INIT0(ei);
 403         if (psenc->inuse != candidate) {
 404                 if (n < 2)
 405                         return (E2BIG);
 406                 n -= 2;
 407                 psenc->ch[psenc->chlen++] = ESCAPE_CHAR;
 408                 psenc->ch[psenc->chlen++] = ESC(candidate);
 409         }
 410         if (n < 1)
 411                 return (E2BIG);
 412         if (psenc->chlen > 0)
 413                 memcpy(s, psenc->ch, psenc->chlen);
 414         *nresult = psenc->chlen;
 415         _citrus_HZ_init_state(ei, psenc);
 416
 417         return (0);
 418 }
 419
 420 static __inline int
 421 _citrus_HZ_stdenc_get_state_desc_generic(_HZEncodingInfo * __restrict ei,
 422     _HZState * __restrict psenc, int * __restrict rstate)
 423 {
 424
 425         if (psenc->chlen < 0 || psenc->inuse == NULL)
 426                 return (EINVAL);
 427         *rstate = (psenc->chlen == 0)
 428             ? ((psenc->inuse == INIT0(ei))
 429                 ? _STDENC_SDGEN_INITIAL
 430                 : _STDENC_SDGEN_STABLE)
 431             : ((psenc->ch[0] == ESCAPE_CHAR)
 432                 ? _STDENC_SDGEN_INCOMPLETE_SHIFT
 433                 : _STDENC_SDGEN_INCOMPLETE_CHAR);
 434
 435         return (0);
 436 }
 437
 438 static __inline int
 439 /*ARGSUSED*/
 440 _citrus_HZ_stdenc_wctocs(_HZEncodingInfo * __restrict ei __unused,
 441     _csid_t * __restrict csid, _index_t * __restrict idx, wchar_t wc)
 442 {
 443         int bit;
 444
 445         if (wc & 0x80) {
 446                 bit = 0x80;
 447                 wc &= ~0x80;
 448         } else
 449                 bit = 0x0;
 450         if ((uint32_t)wc <= 0x7F) {
 451                 *csid = (_csid_t)bit;
 452                 *idx = (_index_t)wc;
 453         } else if ((uint32_t)wc <= 0x7F7F) {
 454                 *csid = (_csid_t)(bit | 0x8000);
 455                 *idx = (_index_t)wc;
 456         } else {
 457                 *csid = (_index_t)(wc & ~0x00FFFF7F);
 458                 *idx = (_csid_t)(wc & 0x00FFFF7F);
 459         }
 460
 461         return (0);
 462 }
 463
 464 static __inline int
 465 /*ARGSUSED*/
 466 _citrus_HZ_stdenc_cstowc(_HZEncodingInfo * __restrict ei __unused,
 467     wchar_t * __restrict wc, _csid_t csid, _index_t idx)
 468 {
 469
 470         *wc = (wchar_t)idx;
 471         switch (csid) {
 472         case 0x80:
 473         case 0x8080:
 474                 *wc |= (wchar_t)0x80;
 475                 /*FALLTHROUGH*/
 476         case 0x0:
 477         case 0x8000:
 478                 break;
 479         default:
 480                 *wc |= (wchar_t)csid;
 481         }
 482
 483         return (0);
 484 }
 485
 486 static void
 487 _citrus_HZ_encoding_module_uninit(_HZEncodingInfo *ei)
 488 {
 489         escape_t *escape;
 490
 491         while ((escape = TAILQ_FIRST(E0SET(ei))) != NULL) {
 492                 TAILQ_REMOVE(E0SET(ei), escape, entry);
 493                 free(GL(escape));
 494                 free(GR(escape));
 495                 free(escape);
 496         }
 497         while ((escape = TAILQ_FIRST(E1SET(ei))) != NULL) {
 498                 TAILQ_REMOVE(E1SET(ei), escape, entry);
 499                 free(GL(escape));
 500                 free(GR(escape));
 501                 free(escape);
 502         }
 503 }
 504
 505 static int
 506 _citrus_HZ_parse_char(void **context, const char *name __unused, const char *s)
 507 {
 508         escape_t *escape;
 509         void **p;
 510
 511         p = (void **)*context;
 512         escape = (escape_t *)p[0];
 513         if (escape->ch != '\0')
 514                 return (EINVAL);
 515         escape->ch = *s++;
 516         if (escape->ch == ESCAPE_CHAR || *s != '\0')
 517                 return (EINVAL);
 518
 519         return (0);
 520 }
 521
 522 static int
 523 _citrus_HZ_parse_graphic(void **context, const char *name, const char *s)
 524 {
 525         _HZEncodingInfo *ei;
 526         escape_t *escape;
 527         graphic_t *graphic;
 528         void **p;
 529
 530         p = (void **)*context;
 531         escape = (escape_t *)p[0];
 532         ei = (_HZEncodingInfo *)p[1];
 533         graphic = malloc(sizeof(*graphic));
 534         if (graphic == NULL)
 535                 return (ENOMEM);
 536         memset(graphic, 0, sizeof(*graphic));
 537         if (strcmp("GL", name) == 0) {
 538                 if (GL(escape) != NULL)
 539                         goto release;
 540                 GL(escape) = graphic;
 541         } else if (strcmp("GR", name) == 0) {
 542                 if (GR(escape) != NULL)
 543                         goto release;
 544                 GR(escape) = graphic;
 545         } else {
 546 release:
 547                 free(graphic);
 548                 return (EINVAL);
 549         }
 550         graphic->escape = escape;
 551         if (_bcs_strncasecmp("ASCII", s, 5) == 0) {
 552                 if (s[5] != '\0')
 553                         return (EINVAL);
 554                 graphic->charset = ASCII;
 555                 graphic->length = 1;
 556                 ei->ascii = graphic;
 557                 return (0);
 558         } else if (_bcs_strncasecmp("GB2312", s, 6) == 0) {
 559                 if (s[6] != '\0')
 560                         return (EINVAL);
 561                 graphic->charset = GB2312;
 562                 graphic->length = 2;
 563                 ei->gb2312 = graphic;
 564                 return (0);
 565         } else if (strncmp("94*", s, 3) == 0)
 566                 graphic->charset = CS94;
 567         else if (strncmp("96*", s, 3) == 0)
 568                 graphic->charset = CS96;
 569         else
 570                 return (EINVAL);
 571         s += 3;
 572         switch(*s) {
 573         case '1': case '2': case '3':
 574                 graphic->length = (size_t)(*s - '0');
 575                 if (*++s == '\0')
 576                         break;
 577         /*FALLTHROUGH*/
 578         default:
 579                 return (EINVAL);
 580         }
 581         return (0);
 582 }
 583
 584 static const _citrus_prop_hint_t escape_hints[] = {
 585 _CITRUS_PROP_HINT_STR("CH", &_citrus_HZ_parse_char),
 586 _CITRUS_PROP_HINT_STR("GL", &_citrus_HZ_parse_graphic),
 587 _CITRUS_PROP_HINT_STR("GR", &_citrus_HZ_parse_graphic),
 588 _CITRUS_PROP_HINT_END
 589 };
 590
 591 static int
 592 _citrus_HZ_parse_escape(void **context, const char *name, const char *s)
 593 {
 594         _HZEncodingInfo *ei;
 595         escape_t *escape;
 596         void *p[2];
 597
 598         ei = (_HZEncodingInfo *)*context;
 599         escape = malloc(sizeof(*escape));
 600         if (escape == NULL)
 601                 return (EINVAL);
 602         memset(escape, 0, sizeof(*escape));
 603         if (strcmp("0", name) == 0) {
 604                 escape->set = E0SET(ei);
 605                 TAILQ_INSERT_TAIL(E0SET(ei), escape, entry);
 606         } else if (strcmp("1", name) == 0) {
 607                 escape->set = E1SET(ei);
 608                 TAILQ_INSERT_TAIL(E1SET(ei), escape, entry);
 609         } else {
 610                 free(escape);
 611                 return (EINVAL);
 612         }
 613         p[0] = (void *)escape;
 614         p[1] = (void *)ei;
 615         return (_citrus_prop_parse_variable(
 616             escape_hints, (void *)&p[0], s, strlen(s)));
 617 }
 618
 619 static const _citrus_prop_hint_t root_hints[] = {
 620 _CITRUS_PROP_HINT_STR("0", &_citrus_HZ_parse_escape),
 621 _CITRUS_PROP_HINT_STR("1", &_citrus_HZ_parse_escape),
 622 _CITRUS_PROP_HINT_END
 623 };
 624
 625 static int
 626 _citrus_HZ_encoding_module_init(_HZEncodingInfo * __restrict ei,
 627     const void * __restrict var, size_t lenvar)
 628 {
 629         int errnum;
 630
 631         memset(ei, 0, sizeof(*ei));
 632         TAILQ_INIT(E0SET(ei));
 633         TAILQ_INIT(E1SET(ei));
 634         errnum = _citrus_prop_parse_variable(
 635             root_hints, (void *)ei, var, lenvar);
 636         if (errnum != 0)
 637                 _citrus_HZ_encoding_module_uninit(ei);
 638         return (errnum);
 639 }
 640
 641 /* ----------------------------------------------------------------------
 642  * public interface for stdenc
 643  */
 644
 645 _CITRUS_STDENC_DECLS(HZ);
 646 _CITRUS_STDENC_DEF_OPS(HZ);
 647
 648 #include "citrus_stdenc_template.h"