1 /* $FreeBSD: head/lib/libiconv_modules/UES/citrus_ues.c 252583 2013-07-03 18:27:45Z peter $ */ 2 /* $NetBSD: citrus_ues.c,v 1.1 2006/11/13 15:16:31 tnozaki Exp $ */ 3 4 /*- 5 * Copyright (c)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 #include <sys/cdefs.h> 31 32 #include <assert.h> 33 #include <errno.h> 34 #include <limits.h> 35 #include <stdio.h> 36 #include <stdint.h> 37 #include <stdlib.h> 38 #include <string.h> 39 #include <wchar.h> 40 41 #include "citrus_namespace.h" 42 #include "citrus_types.h" 43 #include "citrus_bcs.h" 44 #include "citrus_module.h" 45 #include "citrus_stdenc.h" 46 #include "citrus_ues.h" 47 48 typedef struct { 49 size_t mb_cur_max; 50 int mode; 51 #define MODE_C99 1 52 } _UESEncodingInfo; 53 54 typedef struct { 55 int chlen; 56 char ch[12]; 57 } _UESState; 58 59 #define _CEI_TO_EI(_cei_) (&(_cei_)->ei) 60 #define _CEI_TO_STATE(_cei_, _func_) (_cei_)->states.s_##_func_ 61 62 #define _FUNCNAME(m) _citrus_UES_##m 63 #define _ENCODING_INFO _UESEncodingInfo 64 #define _ENCODING_STATE _UESState 65 #define _ENCODING_MB_CUR_MAX(_ei_) (_ei_)->mb_cur_max 66 #define _ENCODING_IS_STATE_DEPENDENT 0 67 #define _STATE_NEEDS_EXPLICIT_INIT(_ps_) 0 68 69 static __inline void 70 /*ARGSUSED*/ 71 _citrus_UES_init_state(_UESEncodingInfo * __restrict ei __unused, 72 _UESState * __restrict psenc) 73 { 74 75 psenc->chlen = 0; 76 } 77 78 static __inline void 79 /*ARGSUSED*/ 80 _citrus_UES_pack_state(_UESEncodingInfo * __restrict ei __unused, 81 void *__restrict pspriv, const _UESState * __restrict psenc) 82 { 83 84 memcpy(pspriv, (const void *)psenc, sizeof(*psenc)); 85 } 86 87 static __inline void 88 /*ARGSUSED*/ 89 _citrus_UES_unpack_state(_UESEncodingInfo * __restrict ei __unused, 90 _UESState * __restrict psenc, const void * __restrict pspriv) 91 { 92 93 memcpy((void *)psenc, pspriv, sizeof(*psenc)); 94 } 95 96 static __inline int 97 to_int(int ch) 98 { 99 100 if (ch >= '0' && ch <= '9') 101 return (ch - '0'); 102 else if (ch >= 'A' && ch <= 'F') 103 return ((ch - 'A') + 10); 104 else if (ch >= 'a' && ch <= 'f') 105 return ((ch - 'a') + 10); 106 return (-1); 107 } 108 109 #define ESCAPE '\\' 110 #define UCS2_ESC 'u' 111 #define UCS4_ESC 'U' 112 113 #define UCS2_BIT 16 114 #define UCS4_BIT 32 115 #define BMP_MAX UINT32_C(0xFFFF) 116 #define UCS2_MAX UINT32_C(0x10FFFF) 117 #define UCS4_MAX UINT32_C(0x7FFFFFFF) 118 119 static const char *xdig = "0123456789abcdef"; 120 121 static __inline int 122 to_str(char *s, wchar_t wc, int bit) 123 { 124 char *p; 125 126 p = s; 127 *p++ = ESCAPE; 128 switch (bit) { 129 case UCS2_BIT: 130 *p++ = UCS2_ESC; 131 break; 132 case UCS4_BIT: 133 *p++ = UCS4_ESC; 134 break; 135 default: 136 abort(); 137 } 138 do { 139 *p++ = xdig[(wc >> (bit -= 4)) & 0xF]; 140 } while (bit > 0); 141 return (p - s); 142 } 143 144 static __inline bool 145 is_hi_surrogate(wchar_t wc) 146 { 147 148 return (wc >= 0xD800 && wc <= 0xDBFF); 149 } 150 151 static __inline bool 152 is_lo_surrogate(wchar_t wc) 153 { 154 155 return (wc >= 0xDC00 && wc <= 0xDFFF); 156 } 157 158 static __inline wchar_t 159 surrogate_to_ucs(wchar_t hi, wchar_t lo) 160 { 161 162 hi -= 0xD800; 163 lo -= 0xDC00; 164 return ((hi << 10 | lo) + 0x10000); 165 } 166 167 static __inline void 168 ucs_to_surrogate(wchar_t wc, wchar_t * __restrict hi, wchar_t * __restrict lo) 169 { 170 171 wc -= 0x10000; 172 *hi = (wc >> 10) + 0xD800; 173 *lo = (wc & 0x3FF) + 0xDC00; 174 } 175 176 static __inline bool 177 is_basic(wchar_t wc) 178 { 179 180 return ((uint32_t)wc <= 0x9F && wc != 0x24 && wc != 0x40 && 181 wc != 0x60); 182 } 183 184 static int 185 _citrus_UES_mbrtowc_priv(_UESEncodingInfo * __restrict ei, 186 wchar_t * __restrict pwc, const char ** __restrict s, size_t n, 187 _UESState * __restrict psenc, size_t * __restrict nresult) 188 { 189 const char *s0; 190 int ch, head, num, tail; 191 wchar_t hi, wc; 192 193 if (*s == NULL) { 194 _citrus_UES_init_state(ei, psenc); 195 *nresult = 0; 196 return (0); 197 } 198 s0 = *s; 199 200 hi = (wchar_t)0; 201 tail = 0; 202 203 surrogate: 204 wc = (wchar_t)0; 205 head = tail; 206 if (psenc->chlen == head) { 207 if (n-- < 1) 208 goto restart; 209 psenc->ch[psenc->chlen++] = *s0++; 210 } 211 ch = (unsigned char)psenc->ch[head++]; 212 if (ch == ESCAPE) { 213 if (psenc->chlen == head) { 214 if (n-- < 1) 215 goto restart; 216 psenc->ch[psenc->chlen++] = *s0++; 217 } 218 switch (psenc->ch[head]) { 219 case UCS2_ESC: 220 tail += 6; 221 break; 222 case UCS4_ESC: 223 if (ei->mode & MODE_C99) { 224 tail = 10; 225 break; 226 } 227 /*FALLTHROUGH*/ 228 default: 229 tail = 0; 230 } 231 ++head; 232 } 233 for (; head < tail; ++head) { 234 if (psenc->chlen == head) { 235 if (n-- < 1) { 236 restart: 237 *s = s0; 238 *nresult = (size_t)-2; 239 return (0); 240 } 241 psenc->ch[psenc->chlen++] = *s0++; 242 } 243 num = to_int((int)(unsigned char)psenc->ch[head]); 244 if (num < 0) { 245 tail = 0; 246 break; 247 } 248 wc = (wc << 4) | num; 249 } 250 head = 0; 251 switch (tail) { 252 case 0: 253 break; 254 case 6: 255 if (hi != (wchar_t)0) 256 break; 257 if ((ei->mode & MODE_C99) == 0) { 258 if (is_hi_surrogate(wc) != 0) { 259 hi = wc; 260 goto surrogate; 261 } 262 if ((uint32_t)wc <= 0x7F /* XXX */ || 263 is_lo_surrogate(wc) != 0) 264 break; 265 goto done; 266 } 267 /*FALLTHROUGH*/ 268 case 10: 269 if (is_basic(wc) == 0 && (uint32_t)wc <= UCS4_MAX && 270 is_hi_surrogate(wc) == 0 && is_lo_surrogate(wc) == 0) 271 goto done; 272 *nresult = (size_t)-1; 273 return (EILSEQ); 274 case 12: 275 if (is_lo_surrogate(wc) == 0) 276 break; 277 wc = surrogate_to_ucs(hi, wc); 278 goto done; 279 } 280 ch = (unsigned char)psenc->ch[0]; 281 head = psenc->chlen; 282 if (--head > 0) 283 memmove(&psenc->ch[0], &psenc->ch[1], head); 284 wc = (wchar_t)ch; 285 done: 286 psenc->chlen = head; 287 if (pwc != NULL) 288 *pwc = wc; 289 *nresult = (size_t)((wc == 0) ? 0 : (s0 - *s)); 290 *s = s0; 291 292 return (0); 293 } 294 295 static int 296 _citrus_UES_wcrtomb_priv(_UESEncodingInfo * __restrict ei, 297 char * __restrict s, size_t n, wchar_t wc, 298 _UESState * __restrict psenc, size_t * __restrict nresult) 299 { 300 wchar_t hi, lo; 301 302 if (psenc->chlen != 0) 303 return (EINVAL); 304 305 if ((ei->mode & MODE_C99) ? is_basic(wc) : (uint32_t)wc <= 0x7F) { 306 if (n-- < 1) 307 goto e2big; 308 psenc->ch[psenc->chlen++] = (char)wc; 309 } else if ((uint32_t)wc <= BMP_MAX) { 310 if (n < 6) 311 goto e2big; 312 psenc->chlen = to_str(&psenc->ch[0], wc, UCS2_BIT); 313 } else if ((ei->mode & MODE_C99) == 0 && (uint32_t)wc <= UCS2_MAX) { 314 if (n < 12) 315 goto e2big; 316 ucs_to_surrogate(wc, &hi, &lo); 317 psenc->chlen += to_str(&psenc->ch[0], hi, UCS2_BIT); 318 psenc->chlen += to_str(&psenc->ch[6], lo, UCS2_BIT); 319 } else if ((ei->mode & MODE_C99) && (uint32_t)wc <= UCS4_MAX) { 320 if (n < 10) 321 goto e2big; 322 psenc->chlen = to_str(&psenc->ch[0], wc, UCS4_BIT); 323 } else { 324 *nresult = (size_t)-1; 325 return (EILSEQ); 326 } 327 memcpy(s, psenc->ch, psenc->chlen); 328 *nresult = psenc->chlen; 329 psenc->chlen = 0; 330 331 return (0); 332 333 e2big: 334 *nresult = (size_t)-1; 335 return (E2BIG); 336 } 337 338 /*ARGSUSED*/ 339 static int 340 _citrus_UES_stdenc_wctocs(_UESEncodingInfo * __restrict ei __unused, 341 _csid_t * __restrict csid, _index_t * __restrict idx, wchar_t wc) 342 { 343 344 *csid = 0; 345 *idx = (_index_t)wc; 346 347 return (0); 348 } 349 350 static __inline int 351 /*ARGSUSED*/ 352 _citrus_UES_stdenc_cstowc(_UESEncodingInfo * __restrict ei __unused, 353 wchar_t * __restrict wc, _csid_t csid, _index_t idx) 354 { 355 356 if (csid != 0) 357 return (EILSEQ); 358 *wc = (wchar_t)idx; 359 360 return (0); 361 } 362 363 static __inline int 364 /*ARGSUSED*/ 365 _citrus_UES_stdenc_get_state_desc_generic(_UESEncodingInfo * __restrict ei __unused, 366 _UESState * __restrict psenc, int * __restrict rstate) 367 { 368 369 *rstate = (psenc->chlen == 0) ? _STDENC_SDGEN_INITIAL : 370 _STDENC_SDGEN_INCOMPLETE_CHAR; 371 return (0); 372 } 373 374 static void 375 /*ARGSUSED*/ 376 _citrus_UES_encoding_module_uninit(_UESEncodingInfo *ei __unused) 377 { 378 379 /* ei seems to be unused */ 380 } 381 382 static int 383 /*ARGSUSED*/ 384 _citrus_UES_encoding_module_init(_UESEncodingInfo * __restrict ei, 385 const void * __restrict var, size_t lenvar) 386 { 387 const char *p; 388 389 p = var; 390 memset((void *)ei, 0, sizeof(*ei)); 391 while (lenvar > 0) { 392 switch (_bcs_toupper(*p)) { 393 case 'C': 394 MATCH(C99, ei->mode |= MODE_C99); 395 break; 396 } 397 ++p; 398 --lenvar; 399 } 400 ei->mb_cur_max = (ei->mode & MODE_C99) ? 10 : 12; 401 402 return (0); 403 } 404 405 /* ---------------------------------------------------------------------- 406 * public interface for stdenc 407 */ 408 409 _CITRUS_STDENC_DECLS(UES); 410 _CITRUS_STDENC_DEF_OPS(UES); 411 412 #include "citrus_stdenc_template.h" 413