lib/i18n_module/ZW/citrus_zw.c

   1 /* $FreeBSD: head/lib/libiconv_modules/ZW/citrus_zw.c 281550 2015-04-15 09:09:20Z tijl $ */
   2 /* $NetBSD: citrus_zw.c,v 1.4 2008/06/14 16:01:08 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/types.h>
  33
  34 #include <assert.h>
  35 #include <errno.h>
  36 #include <limits.h>
  37 #include <stddef.h>
  38 #include <stdio.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_module.h"
  47 #include "citrus_stdenc.h"
  48 #include "citrus_zw.h"
  49
  50 /* ----------------------------------------------------------------------
  51  * private stuffs used by templates
  52  */
  53
  54 typedef struct {
  55         int      dummy;
  56 } _ZWEncodingInfo;
  57
  58 typedef enum {
  59         NONE, AMBIGIOUS, ASCII, GB2312
  60 } _ZWCharset;
  61
  62 typedef struct {
  63         _ZWCharset       charset;
  64         int              chlen;
  65         char             ch[4];
  66 } _ZWState;
  67
  68 #define _CEI_TO_EI(_cei_)               (&(_cei_)->ei)
  69 #define _CEI_TO_STATE(_cei_, _func_)    (_cei_)->states.s_##_func_
  70
  71 #define _FUNCNAME(m)                    _citrus_ZW_##m
  72 #define _ENCODING_INFO                  _ZWEncodingInfo
  73 #define _ENCODING_STATE                 _ZWState
  74 #define _ENCODING_MB_CUR_MAX(_ei_)      MB_LEN_MAX
  75 #define _ENCODING_IS_STATE_DEPENDENT            1
  76 #define _STATE_NEEDS_EXPLICIT_INIT(_ps_)        ((_ps_)->charset != NONE)
  77
  78 static __inline void
  79 /*ARGSUSED*/
  80 _citrus_ZW_init_state(_ZWEncodingInfo * __restrict ei __unused,
  81     _ZWState * __restrict psenc)
  82 {
  83
  84         psenc->chlen = 0;
  85         psenc->charset = NONE;
  86 }
  87
  88 #if 0
  89 static __inline void
  90 /*ARGSUSED*/
  91 _citrus_ZW_pack_state(_ZWEncodingInfo * __restrict ei __unused,
  92     void *__restrict pspriv, const _ZWState * __restrict psenc)
  93 {
  94
  95         memcpy(pspriv, (const void *)psenc, sizeof(*psenc));
  96 }
  97
  98 static __inline void
  99 /*ARGSUSED*/
 100 _citrus_ZW_unpack_state(_ZWEncodingInfo * __restrict ei __unused,
 101     _ZWState * __restrict psenc, const void * __restrict pspriv)
 102 {
 103
 104         memcpy((void *)psenc, pspriv, sizeof(*psenc));
 105 }
 106 #endif
 107
 108 static int
 109 _citrus_ZW_mbrtowc_priv(_ZWEncodingInfo * __restrict ei,
 110     wchar_t * __restrict pwc, char **__restrict s, size_t n,
 111     _ZWState * __restrict psenc, size_t * __restrict nresult)
 112 {
 113         char *s0;
 114         wchar_t  wc;
 115         int ch, len;
 116
 117         if (*s == NULL) {
 118                 _citrus_ZW_init_state(ei, psenc);
 119                 *nresult = (size_t)_ENCODING_IS_STATE_DEPENDENT;
 120                 return (0);
 121         }
 122         s0 = *s;
 123         len = 0;
 124
 125 #define STORE                           \
 126 do {                                    \
 127         if (n-- < 1) {                  \
 128                 *nresult = (size_t)-2;  \
 129                 *s = s0;                \
 130                 return (0);             \
 131         }                               \
 132         ch = (unsigned char)*s0++;      \
 133         if (len++ > MB_LEN_MAX || ch > 0x7F)\
 134                 goto ilseq;             \
 135         psenc->ch[psenc->chlen++] = ch; \
 136 } while (/*CONSTCOND*/0)
 137
 138 loop:
 139         switch (psenc->charset) {
 140         case ASCII:
 141                 switch (psenc->chlen) {
 142                 case 0:
 143                         STORE;
 144                         switch (psenc->ch[0]) {
 145                         case '\0': case '\n':
 146                                 psenc->charset = NONE;
 147                         }
 148                 /*FALLTHROUGH*/
 149                 case 1:
 150                         break;
 151                 default:
 152                         return (EINVAL);
 153                 }
 154                 ch = (unsigned char)psenc->ch[0];
 155                 if (ch > 0x7F)
 156                         goto ilseq;
 157                 wc = (wchar_t)ch;
 158                 psenc->chlen = 0;
 159                 break;
 160         case NONE:
 161                 if (psenc->chlen != 0)
 162                         return (EINVAL);
 163                 STORE;
 164                 ch = (unsigned char)psenc->ch[0];
 165                 if (ch != 'z') {
 166                         if (ch != '\n' && ch != '\0')
 167                                 psenc->charset = ASCII;
 168                         wc = (wchar_t)ch;
 169                         psenc->chlen = 0;
 170                         break;
 171                 }
 172                 psenc->charset = AMBIGIOUS;
 173                 psenc->chlen = 0;
 174         /* FALLTHROUGH */
 175         case AMBIGIOUS:
 176                 if (psenc->chlen != 0)
 177                         return (EINVAL);
 178                 STORE;
 179                 if (psenc->ch[0] != 'W') {
 180                         psenc->charset = ASCII;
 181                         wc = L'z';
 182                         break;
 183                 }
 184                 psenc->charset = GB2312;
 185                 psenc->chlen = 0;
 186         /* FALLTHROUGH */
 187         case GB2312:
 188                 switch (psenc->chlen) {
 189                 case 0:
 190                         STORE;
 191                         ch = (unsigned char)psenc->ch[0];
 192                         if (ch == '\0') {
 193                                 psenc->charset = NONE;
 194                                 wc = (wchar_t)ch;
 195                                 psenc->chlen = 0;
 196                                 break;
 197                         } else if (ch == '\n') {
 198                                 psenc->charset = NONE;
 199                                 psenc->chlen = 0;
 200                                 goto loop;
 201                         }
 202                 /*FALLTHROUGH*/
 203                 case 1:
 204                         STORE;
 205                         if (psenc->ch[0] == ' ') {
 206                                 ch = (unsigned char)psenc->ch[1];
 207                                 wc = (wchar_t)ch;
 208                                 psenc->chlen = 0;
 209                                 break;
 210                         } else if (psenc->ch[0] == '#') {
 211                                 ch = (unsigned char)psenc->ch[1];
 212                                 if (ch == '\n') {
 213                                         psenc->charset = NONE;
 214                                         wc = (wchar_t)ch;
 215                                         psenc->chlen = 0;
 216                                         break;
 217                                 } else if (ch == ' ') {
 218                                         wc = (wchar_t)ch;
 219                                         psenc->chlen = 0;
 220                                         break;
 221                                 }
 222                         }
 223                         ch = (unsigned char)psenc->ch[0];
 224                         if (ch < 0x21 || ch > 0x7E)
 225                                 goto ilseq;
 226                         wc = (wchar_t)(ch << 8);
 227                         ch = (unsigned char)psenc->ch[1];
 228                         if (ch < 0x21 || ch > 0x7E) {
 229 ilseq:
 230                                 *nresult = (size_t)-1;
 231                                 return (EILSEQ);
 232                         }
 233                         wc |= (wchar_t)ch;
 234                         psenc->chlen = 0;
 235                         break;
 236                 default:
 237                         return (EINVAL);
 238                 }
 239                 break;
 240         default:
 241                 return (EINVAL);
 242         }
 243         if (pwc != NULL)
 244                 *pwc = wc;
 245
 246         *nresult = (size_t)(wc == 0 ? 0 : len);
 247         *s = s0;
 248
 249         return (0);
 250 }
 251
 252 static int
 253 /*ARGSUSED*/
 254 _citrus_ZW_wcrtomb_priv(_ZWEncodingInfo * __restrict ei __unused,
 255     char *__restrict s, size_t n, wchar_t wc,
 256     _ZWState * __restrict psenc, size_t * __restrict nresult)
 257 {
 258         int ch;
 259
 260         if (psenc->chlen != 0)
 261                 return (EINVAL);
 262         if ((uint32_t)wc <= 0x7F) {
 263                 ch = (unsigned char)wc;
 264                 switch (psenc->charset) {
 265                 case NONE:
 266                         if (ch == '\0' || ch == '\n')
 267                                 psenc->ch[psenc->chlen++] = ch;
 268                         else {
 269                                 if (n < 4)
 270                                         return (E2BIG);
 271                                 n -= 4;
 272                                 psenc->ch[psenc->chlen++] = 'z';
 273                                 psenc->ch[psenc->chlen++] = 'W';
 274                                 psenc->ch[psenc->chlen++] = ' ';
 275                                 psenc->ch[psenc->chlen++] = ch;
 276                                 psenc->charset = GB2312;
 277                         }
 278                         break;
 279                 case GB2312:
 280                         if (n < 2)
 281                                 return (E2BIG);
 282                         n -= 2;
 283                         if (ch == '\0') {
 284                                 psenc->ch[psenc->chlen++] = '\n';
 285                                 psenc->ch[psenc->chlen++] = '\0';
 286                                 psenc->charset = NONE;
 287                         } else if (ch == '\n') {
 288                                 psenc->ch[psenc->chlen++] = '#';
 289                                 psenc->ch[psenc->chlen++] = '\n';
 290                                 psenc->charset = NONE;
 291                         } else {
 292                                 psenc->ch[psenc->chlen++] = ' ';
 293                                 psenc->ch[psenc->chlen++] = ch;
 294                         }
 295                         break;
 296                 default:
 297                         return (EINVAL);
 298                 }
 299         } else if ((uint32_t)wc <= 0x7E7E) {
 300                 switch (psenc->charset) {
 301                 case NONE:
 302                         if (n < 2)
 303                                 return (E2BIG);
 304                         n -= 2;
 305                         psenc->ch[psenc->chlen++] = 'z';
 306                         psenc->ch[psenc->chlen++] = 'W';
 307                         psenc->charset = GB2312;
 308                 /* FALLTHROUGH*/
 309                 case GB2312:
 310                         if (n < 2)
 311                                 return (E2BIG);
 312                         n -= 2;
 313                         ch = (wc >> 8) & 0xFF;
 314                         if (ch < 0x21 || ch > 0x7E)
 315                                 goto ilseq;
 316                         psenc->ch[psenc->chlen++] = ch;
 317                         ch = wc & 0xFF;
 318                         if (ch < 0x21 || ch > 0x7E)
 319                                 goto ilseq;
 320                         psenc->ch[psenc->chlen++] = ch;
 321                         break;
 322                 default:
 323                         return (EINVAL);
 324                 }
 325         } else {
 326 ilseq:
 327                 *nresult = (size_t)-1;
 328                 return (EILSEQ);
 329         }
 330         memcpy(s, psenc->ch, psenc->chlen);
 331         *nresult = psenc->chlen;
 332         psenc->chlen = 0;
 333
 334         return (0);
 335 }
 336
 337 static int
 338 /*ARGSUSED*/
 339 _citrus_ZW_put_state_reset(_ZWEncodingInfo * __restrict ei __unused,
 340     char * __restrict s, size_t n, _ZWState * __restrict psenc,
 341     size_t * __restrict nresult)
 342 {
 343
 344         if (psenc->chlen != 0)
 345                 return (EINVAL);
 346         switch (psenc->charset) {
 347         case GB2312:
 348                 if (n-- < 1)
 349                         return (E2BIG);
 350                 psenc->ch[psenc->chlen++] = '\n';
 351                 psenc->charset = NONE;
 352         /*FALLTHROUGH*/
 353         case NONE:
 354                 *nresult = psenc->chlen;
 355                 if (psenc->chlen > 0) {
 356                         memcpy(s, psenc->ch, psenc->chlen);
 357                         psenc->chlen = 0;
 358                 }
 359                 break;
 360         default:
 361                 return (EINVAL);
 362         }
 363
 364         return (0);
 365 }
 366
 367 static __inline int
 368 /*ARGSUSED*/
 369 _citrus_ZW_stdenc_get_state_desc_generic(_ZWEncodingInfo * __restrict ei __unused,
 370     _ZWState * __restrict psenc, int * __restrict rstate)
 371 {
 372
 373         switch (psenc->charset) {
 374         case NONE:
 375                 if (psenc->chlen != 0)
 376                         return (EINVAL);
 377                 *rstate = _STDENC_SDGEN_INITIAL;
 378                 break;
 379         case AMBIGIOUS:
 380                 if (psenc->chlen != 0)
 381                         return (EINVAL);
 382                 *rstate = _STDENC_SDGEN_INCOMPLETE_SHIFT;
 383                 break;
 384         case ASCII:
 385         case GB2312:
 386                 switch (psenc->chlen) {
 387                 case 0:
 388                         *rstate = _STDENC_SDGEN_STABLE;
 389                         break;
 390                 case 1:
 391                         *rstate = (psenc->ch[0] == '#') ?
 392                             _STDENC_SDGEN_INCOMPLETE_SHIFT :
 393                             _STDENC_SDGEN_INCOMPLETE_CHAR;
 394                         break;
 395                 default:
 396                         return (EINVAL);
 397                 }
 398                 break;
 399         default:
 400                 return (EINVAL);
 401         }
 402         return (0);
 403 }
 404
 405 static __inline int
 406 /*ARGSUSED*/
 407 _citrus_ZW_stdenc_wctocs(_ZWEncodingInfo * __restrict ei __unused,
 408     _csid_t * __restrict csid, _index_t * __restrict idx, wchar_t wc)
 409 {
 410
 411         *csid = (_csid_t)(wc <= (wchar_t)0x7FU) ? 0 : 1;
 412         *idx = (_index_t)wc;
 413
 414         return (0);
 415 }
 416
 417 static __inline int
 418 /*ARGSUSED*/
 419 _citrus_ZW_stdenc_cstowc(_ZWEncodingInfo * __restrict ei __unused,
 420     wchar_t * __restrict wc, _csid_t csid, _index_t idx)
 421 {
 422
 423         switch (csid) {
 424         case 0: case 1:
 425                 break;
 426         default:
 427                 return (EINVAL);
 428         }
 429         *wc = (wchar_t)idx;
 430
 431         return (0);
 432 }
 433
 434 static void
 435 /*ARGSUSED*/
 436 _citrus_ZW_encoding_module_uninit(_ZWEncodingInfo *ei __unused)
 437 {
 438
 439 }
 440
 441 static int
 442 /*ARGSUSED*/
 443 _citrus_ZW_encoding_module_init(_ZWEncodingInfo * __restrict ei __unused,
 444     const void *__restrict var __unused, size_t lenvar __unused)
 445 {
 446
 447         return (0);
 448 }
 449
 450 /* ----------------------------------------------------------------------
 451  * public interface for stdenc
 452  */
 453
 454 _CITRUS_STDENC_DECLS(ZW);
 455 _CITRUS_STDENC_DEF_OPS(ZW);
 456
 457 #include "citrus_stdenc_template.h"