lib/libc/citrus/modules/citrus_ues.c

   1 /* $NetBSD: citrus_ues.c,v 1.1 2006/11/13 15:16:31 tnozaki Exp $ */
   2
   3 /*-
   4  * Copyright (c)2006 Citrus Project,
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <assert.h>
  30 #include <errno.h>
  31 #include <string.h>
  32 #include <stdio.h>
  33 #include <stdint.h>
  34 #include <stdlib.h>
  35 #include <limits.h>
  36 #include <wchar.h>
  37
  38 #include "citrus_namespace.h"
  39 #include "citrus_types.h"
  40 #include "citrus_bcs.h"
  41 #include "citrus_module.h"
  42 #include "citrus_ctype.h"
  43 #include "citrus_stdenc.h"
  44 #include "citrus_ues.h"
  45
  46 typedef struct {
  47         int mode;
  48 #define MODE_C99        1
  49         size_t mb_cur_max;
  50 } _UESEncodingInfo;
  51
  52 typedef struct {
  53         int chlen;
  54         char ch[12];
  55 } _UESState;
  56
  57 typedef struct {
  58         _UESEncodingInfo        ei;
  59         struct {
  60                 /* for future multi-locale facility */
  61                 _UESState       s_mblen;
  62                 _UESState       s_mbrlen;
  63                 _UESState       s_mbrtowc;
  64                 _UESState       s_mbtowc;
  65                 _UESState       s_mbsrtowcs;
  66                 _UESState       s_wcrtomb;
  67                 _UESState       s_wcsrtombs;
  68                 _UESState       s_wctomb;
  69         } states;
  70 } _UESCTypeInfo;
  71
  72 #define _CEI_TO_EI(_cei_)               (&(_cei_)->ei)
  73 #define _CEI_TO_STATE(_cei_, _func_)    (_cei_)->states.s_##_func_
  74
  75 #define _FUNCNAME(m)                    _citrus_UES_##m
  76 #define _ENCODING_INFO                  _UESEncodingInfo
  77 #define _CTYPE_INFO                     _UESCTypeInfo
  78 #define _ENCODING_STATE                 _UESState
  79 #define _ENCODING_MB_CUR_MAX(_ei_)      (_ei_)->mb_cur_max
  80 #define _ENCODING_IS_STATE_DEPENDENT            0
  81 #define _STATE_NEEDS_EXPLICIT_INIT(_ps_)        0
  82
  83 static __inline void
  84 /*ARGSUSED*/
  85 _citrus_UES_init_state(_UESEncodingInfo * __restrict ei,
  86         _UESState * __restrict psenc)
  87 {
  88         psenc->chlen = 0;
  89 }
  90
  91 static __inline void
  92 /*ARGSUSED*/
  93 _citrus_UES_pack_state(_UESEncodingInfo * __restrict ei,
  94         void *__restrict pspriv, const _UESState * __restrict psenc)
  95 {
  96         /* ei seem to be unused */
  97         _DIAGASSERT(pspriv != NULL);
  98         _DIAGASSERT(psenc != NULL);
  99
 100         memcpy(pspriv, (const void *)psenc, sizeof(*psenc));
 101 }
 102
 103 static __inline void
 104 /*ARGSUSED*/
 105 _citrus_UES_unpack_state(_UESEncodingInfo * __restrict ei,
 106         _UESState * __restrict psenc, const void * __restrict pspriv)
 107 {
 108         /* ei seem to be unused */
 109         _DIAGASSERT(psenc != NULL);
 110         _DIAGASSERT(pspriv != NULL);
 111
 112         memcpy((void *)psenc, pspriv, sizeof(*psenc));
 113 }
 114
 115 static __inline int
 116 to_int(int ch)
 117 {
 118         if (ch >= '0' && ch <= '9')
 119                 return ch - '0';
 120         else if (ch >= 'A' && ch <= 'F')
 121                 return (ch - 'A') + 10;
 122         else if (ch >= 'a' && ch <= 'f')
 123                 return (ch - 'a') + 10;
 124         return -1;
 125 }
 126
 127 #define ESCAPE          '\\'
 128 #define UCS2_ESC        'u'
 129 #define UCS4_ESC        'U'
 130
 131 #define UCS2_BIT        16
 132 #define UCS4_BIT        32
 133 #define BMP_MAX         UINT32_C(0xFFFF)
 134 #define UCS2_MAX        UINT32_C(0x10FFFF)
 135 #define UCS4_MAX        UINT32_C(0x7FFFFFFF)
 136
 137 static const char *xdig = "0123456789abcdef";
 138
 139 static __inline int
 140 to_str(char *s, wchar_t wc, int bit)
 141 {
 142         char *p;
 143
 144         p = s;
 145         *p++ = ESCAPE;
 146         switch (bit) {
 147         case UCS2_BIT:
 148                 *p++ = UCS2_ESC;
 149                 break;
 150         case UCS4_BIT:
 151                 *p++ = UCS4_ESC;
 152                 break;
 153         default:
 154                 abort();
 155         }
 156         do {
 157                 *p++ = xdig[(wc >> (bit -= 4)) & 0xF];
 158         } while (bit > 0);
 159         return p - s;
 160 }
 161
 162 static __inline int
 163 is_hi_surrogate(wchar_t wc)
 164 {
 165         return wc >= 0xD800 && wc <= 0xDBFF;
 166 }
 167
 168 static __inline int
 169 is_lo_surrogate(wchar_t wc)
 170 {
 171         return wc >= 0xDC00 && wc <= 0xDFFF;
 172 }
 173
 174 static __inline wchar_t
 175 surrogate_to_ucs(wchar_t hi, wchar_t lo)
 176 {
 177         _DIAGASSERT(is_hi_surrogate(hi));
 178         _DIAGASSERT(is_lo_surrogate(lo));
 179
 180         hi -= 0xD800;
 181         lo -= 0xDC00;
 182         return (hi << 10 | lo) + 0x10000;
 183 }
 184
 185 static __inline void
 186 ucs_to_surrogate(wchar_t wc, wchar_t * __restrict hi, wchar_t * __restrict lo)
 187 {
 188         _DIAGASSERT(hi != NULL);
 189         _DIAGASSERT(lo != NULL);
 190         _DIAGASSERT(wc >= 0x10000);
 191
 192         wc -= 0x10000;
 193         *hi = (wc >> 10) + 0xD800;
 194         *lo = (wc & 0x3FF) + 0xDC00;
 195 }
 196
 197 static __inline int
 198 is_basic(wchar_t wc)
 199 {
 200         return (uint32_t)wc <= 0x9F &&
 201             wc != 0x24 && wc != 0x40 && wc != 0x60;
 202 }
 203
 204 static int
 205 _citrus_UES_mbrtowc_priv(_UESEncodingInfo * __restrict ei,
 206         wchar_t * __restrict pwc, const char ** __restrict s, size_t n,
 207         _UESState * __restrict psenc, size_t * __restrict nresult)
 208 {
 209         const char *s0;
 210         int ch, head, tail, i, num;
 211         wchar_t hi, wc;
 212
 213         _DIAGASSERT(ei != NULL);
 214         /* pwc may be null */
 215         _DIAGASSERT(s != NULL);
 216         _DIAGASSERT(psenc != NULL);
 217         _DIAGASSERT(nresult != NULL);
 218
 219         if (*s == NULL) {
 220                 _citrus_UES_init_state(ei, psenc);
 221                 *nresult = 0;
 222                 return 0;
 223         }
 224         s0 = *s;
 225
 226         hi = (wchar_t)0;
 227         tail = 0;
 228
 229 surrogate:
 230         wc = (wchar_t)0;
 231         head = tail;
 232         if (psenc->chlen == head) {
 233                 if (n-- < 1)
 234                         goto restart;
 235                 psenc->ch[psenc->chlen++] = *s0++;
 236         }
 237         ch = (unsigned char)psenc->ch[head++];
 238         if (ch == ESCAPE) {
 239                 if (psenc->chlen == head) {
 240                         if (n-- < 1)
 241                                 goto restart;
 242                         psenc->ch[psenc->chlen++] = *s0++;
 243                 }
 244                 switch (psenc->ch[head]) {
 245                 case UCS2_ESC:
 246                         tail += 6;
 247                         break;
 248                 case UCS4_ESC:
 249                         if (ei->mode & MODE_C99) {
 250                                 tail = 10;
 251                                 break;
 252                         }
 253                 /*FALLTHROUGH*/
 254                 default:
 255                         tail = 0;
 256                 }
 257                 ++head;
 258         }
 259         for (; head < tail; ++head) {
 260                 if (psenc->chlen == head) {
 261                         if (n-- < 1) {
 262 restart:
 263                                 *s = s0;
 264                                 *nresult = (size_t)-2;
 265                                 return 0;
 266                         }
 267                         psenc->ch[psenc->chlen++] = *s0++;
 268                 }
 269                 num = to_int((int)(unsigned char)psenc->ch[head]);
 270                 if (num < 0) {
 271                         tail = 0;
 272                         break;
 273                 }
 274                 wc = (wc << 4) | num;
 275         }
 276         head = 0;
 277         switch (tail) {
 278         case 0:
 279                 break;
 280         case 6:
 281                 if (hi != (wchar_t)0)
 282                         break;
 283                 if ((ei->mode & MODE_C99) == 0) {
 284                         if (is_hi_surrogate(wc) != 0) {
 285                                 hi = wc;
 286                                 goto surrogate;
 287                         }
 288                         if ((uint32_t)wc <= 0x7F /* XXX */ ||
 289                             is_lo_surrogate(wc) != 0)
 290                                 break;
 291                         goto done;
 292                 }
 293         /*FALLTHROUGH*/
 294         case 10:
 295                 if (is_basic(wc) == 0 && (uint32_t)wc <= UCS4_MAX &&
 296                     is_hi_surrogate(wc) == 0 && is_lo_surrogate(wc) == 0)
 297                         goto done;
 298                 *nresult = (size_t)-1;
 299                 return EILSEQ;
 300         case 12:
 301                 if (is_lo_surrogate(wc) == 0)
 302                         break;
 303                 wc = surrogate_to_ucs(hi, wc);
 304                 goto done;
 305         }
 306         ch = (unsigned char)psenc->ch[0];
 307         head = psenc->chlen;
 308         if (--head > 0)
 309                 memmove(&psenc->ch[0], &psenc->ch[1], head);
 310         wc = (wchar_t)ch;
 311 done:
 312         psenc->chlen = head;
 313         if (pwc != NULL)
 314                 *pwc = wc;
 315         *nresult = (size_t)((wc == 0) ? 0 : (s0 - *s));
 316         *s = s0;
 317
 318         return 0;
 319 }
 320
 321 static int
 322 _citrus_UES_wcrtomb_priv(_UESEncodingInfo * __restrict ei,
 323         char * __restrict s, size_t n, wchar_t wc,
 324         _UESState * __restrict psenc, size_t * __restrict nresult)
 325 {
 326         wchar_t hi, lo;
 327
 328         if (psenc->chlen != 0)
 329                 return EINVAL;
 330
 331         if ((ei->mode & MODE_C99) ? is_basic(wc) : (uint32_t)wc <= 0x7F) {
 332                 if (n-- < 1)
 333                         goto e2big;
 334                 psenc->ch[psenc->chlen++] = (char)wc;
 335         } else if ((uint32_t)wc <= BMP_MAX) {
 336                 if (n < 6)
 337                         goto e2big;
 338                 psenc->chlen = to_str(&psenc->ch[0], wc, UCS2_BIT);
 339         } else if ((ei->mode & MODE_C99) == 0 && (uint32_t)wc <= UCS2_MAX) {
 340                 if (n < 12)
 341                         goto e2big;
 342                 ucs_to_surrogate(wc, &hi, &lo);
 343                 psenc->chlen += to_str(&psenc->ch[0], hi, UCS2_BIT);
 344                 psenc->chlen += to_str(&psenc->ch[6], lo, UCS2_BIT);
 345         } else if ((ei->mode & MODE_C99) && (uint32_t)wc <= UCS4_MAX) {
 346                 if (n < 10)
 347                         goto e2big;
 348                 psenc->chlen = to_str(&psenc->ch[0], wc, UCS4_BIT);
 349         } else {
 350                 *nresult = (size_t)-1;
 351                 return EILSEQ;
 352         }
 353         memcpy(s, psenc->ch, psenc->chlen);
 354         *nresult = psenc->chlen;
 355         psenc->chlen = 0;
 356
 357         return 0;
 358
 359 e2big:
 360         *nresult = (size_t)-1;
 361         return E2BIG;
 362 }
 363
 364 static __inline int
 365 /*ARGSUSED*/
 366 _citrus_UES_stdenc_wctocs(_UESEncodingInfo * __restrict ei,
 367         _csid_t * __restrict csid, _index_t * __restrict idx, wchar_t wc)
 368 {
 369         /* ei seem to be unused */
 370         _DIAGASSERT(csid != NULL);
 371         _DIAGASSERT(idx != NULL);
 372
 373         *csid = 0;
 374         *idx = (_index_t)wc;
 375
 376         return 0;
 377 }
 378
 379 static __inline int
 380 /*ARGSUSED*/
 381 _citrus_UES_stdenc_cstowc(_UESEncodingInfo * __restrict ei,
 382         wchar_t * __restrict wc, _csid_t csid, _index_t idx)
 383 {
 384         /* ei seem to be unused */
 385         _DIAGASSERT(wc != NULL);
 386
 387         if (csid != 0)
 388                 return EILSEQ;
 389         *wc = (wchar_t)idx;
 390
 391         return 0;
 392 }
 393
 394 static __inline int
 395 /*ARGSUSED*/
 396 _citrus_UES_stdenc_get_state_desc_generic(_UESEncodingInfo * __restrict ei,
 397         _UESState * __restrict psenc, int * __restrict rstate)
 398 {
 399         _DIAGASSERT(psenc != NULL);
 400         _DIAGASSERT(rstate != NULL);
 401
 402         if (psenc->chlen == 0)
 403                 *rstate = _STDENC_SDGEN_INITIAL;
 404         else
 405                 *rstate = _STDENC_SDGEN_INCOMPLETE_CHAR; /* XXX */
 406
 407         return 0;
 408 }
 409
 410 static void
 411 /*ARGSUSED*/
 412 _citrus_UES_encoding_module_uninit(_UESEncodingInfo *ei)
 413 {
 414         /* ei seems to be unused */
 415 }
 416
 417 static int
 418 /*ARGSUSED*/
 419 _citrus_UES_encoding_module_init(_UESEncodingInfo * __restrict ei,
 420         const void * __restrict var, size_t lenvar)
 421 {
 422         const char *p;
 423
 424         _DIAGASSERT(ei != NULL);
 425
 426         p = var;
 427 #define MATCH(x, act)                                           \
 428 do {                                                            \
 429         if (lenvar >= (sizeof(#x)-1) &&                         \
 430             _bcs_strncasecmp(p, #x, sizeof(#x)-1) == 0) {       \
 431                 act;                                            \
 432                 lenvar -= sizeof(#x)-1;                         \
 433                 p += sizeof(#x)-1;                              \
 434         }                                                       \
 435 } while (/*CONSTCOND*/0)
 436         memset((void *)ei, 0, sizeof(*ei));
 437         while (lenvar > 0) {
 438                 switch (_bcs_toupper(*p)) {
 439                 case 'C':
 440                         MATCH(C99, ei->mode |= MODE_C99);
 441                         break;
 442                 }
 443                 ++p;
 444                 --lenvar;
 445         }
 446         ei->mb_cur_max = (ei->mode & MODE_C99) ? 10 : 12;
 447
 448         return 0;
 449 }
 450
 451 /* ----------------------------------------------------------------------
 452  * public interface for ctype
 453  */
 454
 455 _CITRUS_CTYPE_DECLS(UES);
 456 _CITRUS_CTYPE_DEF_OPS(UES);
 457
 458 #include "citrus_ctype_template.h"
 459
 460 /* ----------------------------------------------------------------------
 461  * public interface for stdenc
 462  */
 463
 464 _CITRUS_STDENC_DECLS(UES);
 465 _CITRUS_STDENC_DEF_OPS(UES);
 466
 467 #include "citrus_stdenc_template.h"