1 /****************************************************************** 2 3 Copyright 1993 by SunSoft, Inc. 4 Copyright 1999-2000 by Bruno Haible 5 6 Permission to use, copy, modify, distribute, and sell this software 7 and its documentation for any purpose is hereby granted without fee, 8 provided that the above copyright notice appear in all copies and 9 that both that copyright notice and this permission notice appear 10 in supporting documentation, and that the names of SunSoft, Inc. and 11 Bruno Haible not be used in advertising or publicity pertaining to 12 distribution of the software without specific, written prior 13 permission. SunSoft, Inc. and Bruno Haible make no representations 14 about the suitability of this software for any purpose. It is 15 provided "as is" without express or implied warranty. 16 17 SunSoft Inc. AND Bruno Haible DISCLAIM ALL WARRANTIES WITH REGARD 18 TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 19 AND FITNESS, IN NO EVENT SHALL SunSoft, Inc. OR Bruno Haible BE LIABLE 20 FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 21 WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 22 ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT 23 OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 24 25 ******************************************************************/ 26 27 /* 28 * This file contains: 29 * 30 * I. Conversion routines CompoundText/CharSet <--> Unicode/UTF-8. 31 * 32 * Used for three purposes: 33 * 1. The UTF-8 locales, see below. 34 * 2. Unicode aware applications for which the use of 8-bit character 35 * sets is an anachronism. 36 * 3. For conversion from keysym to locale encoding. 37 * 38 * II. Conversion files for an UTF-8 locale loader. 39 * Supports: all locales with codeset UTF-8. 40 * How: Provides converters for UTF-8. 41 * Platforms: all systems. 42 * 43 * The loader itself is located in lcUTF8.c. 44 */ 45 46 /* 47 * The conversion from UTF-8 to CompoundText is realized in a very 48 * conservative way. Recall that CompoundText data is used for inter-client 49 * communication purposes. We distinguish three classes of clients: 50 * - Clients which accept only those pieces of CompoundText which belong to 51 * the character set understood by the current locale. 52 * (Example: clients which are linked to an older X11 library.) 53 * - Clients which accept CompoundText with multiple character sets and parse 54 * it themselves. 55 * (Example: emacs, xemacs.) 56 * - Clients which rely entirely on the X{mb,wc}TextPropertyToTextList 57 * functions for the conversion of CompoundText to their current locale's 58 * multi-byte/wide-character format. 59 * For best interoperation, the UTF-8 to CompoundText conversion proceeds as 60 * follows. For every character, it first tests whether the character is 61 * representable in the current locale's original (non-UTF-8) character set. 62 * If not, it goes through the list of predefined character sets for 63 * CompoundText and tests if the character is representable in that character 64 * set. If so, it encodes the character using its code within that character 65 * set. If not, it uses an UTF-8-in-CompoundText encapsulation. Since 66 * clients of the first and second kind ignore such encapsulated text, 67 * this encapsulation is kept to a minimum and terminated as early as possible. 68 * 69 * In a distant future, when clients of the first and second kind will have 70 * disappeared, we will be able to stuff UTF-8 data directly in CompoundText 71 * without first going through the list of predefined character sets. 72 */ 73 74 #ifdef HAVE_CONFIG_H 75 #include <config.h> 76 #endif 77 #include <stdio.h> 78 #include "Xlibint.h" 79 #include "XlcPubI.h" 80 #include "XlcGeneric.h" 81 82 static XlcConv 83 create_conv( 84 XLCd lcd, 85 XlcConvMethods methods) 86 { 87 XlcConv conv; 88 89 conv = Xmalloc(sizeof(XlcConvRec)); 90 if (conv == (XlcConv) NULL) 91 return (XlcConv) NULL; 92 93 conv->methods = methods; 94 conv->state = NULL; 95 96 return conv; 97 } 98 99 static void 100 close_converter( 101 XlcConv conv) 102 { 103 Xfree(conv); 104 } 105 106 /* Replacement character for invalid multibyte sequence or wide character. */ 107 #define BAD_WCHAR ((ucs4_t) 0xfffd) 108 #define BAD_CHAR '?' 109 110 /***************************************************************************/ 111 /* Part I: Conversion routines CompoundText/CharSet <--> Unicode/UTF-8. 112 * 113 * Note that this code works in any locale. We store Unicode values in 114 * `ucs4_t' variables, but don't pass them to the user. 115 * 116 * This code has to support all character sets that are used for CompoundText, 117 * nothing more, nothing less. See the table in lcCT.c. 118 * Since the conversion _to_ CompoundText is likely to need the tables for all 119 * character sets at once, we don't use dynamic loading (of tables or shared 120 * libraries through iconv()). Use a fixed set of tables instead. 121 * 122 * We use statically computed tables, not dynamically allocated arrays, 123 * because it's more memory efficient: Different processes using the same 124 * libX11 shared library share the "text" and read-only "data" sections. 125 */ 126 127 typedef unsigned int ucs4_t; 128 #define conv_t XlcConv 129 130 typedef struct _Utf8ConvRec { 131 const char *name; 132 XrmQuark xrm_name; 133 int (* cstowc) (XlcConv, ucs4_t *, unsigned char const *, int); 134 int (* wctocs) (XlcConv, unsigned char *, ucs4_t, int); 135 } Utf8ConvRec, *Utf8Conv; 136 137 /* 138 * int xxx_cstowc (XlcConv conv, ucs4_t *pwc, unsigned char const *s, int n) 139 * converts the byte sequence starting at s to a wide character. Up to n bytes 140 * are available at s. n is >= 1. 141 * Result is number of bytes consumed (if a wide character was read), 142 * or 0 if invalid, or -1 if n too small. 143 * 144 * int xxx_wctocs (XlcConv conv, unsigned char *r, ucs4_t wc, int n) 145 * converts the wide character wc to the character set xxx, and stores the 146 * result beginning at r. Up to n bytes may be written at r. n is >= 1. 147 * Result is number of bytes written, or 0 if invalid, or -1 if n too small. 148 */ 149 150 /* Return code if invalid. (xxx_mbtowc, xxx_wctomb) */ 151 #define RET_ILSEQ 0 152 /* Return code if only a shift sequence of n bytes was read. (xxx_mbtowc) */ 153 #define RET_TOOFEW(n) (-1-(n)) 154 /* Return code if output buffer is too small. (xxx_wctomb, xxx_reset) */ 155 #define RET_TOOSMALL -1 156 157 /* 158 * The tables below are bijective. It would be possible to extend the 159 * xxx_wctocs tables to do some transliteration (e.g. U+201C,U+201D -> 0x22) 160 * but *only* with characters not contained in any other table, and *only* 161 * when the current locale is not an UTF-8 locale. 162 */ 163 164 #include "lcUniConv/utf8.h" 165 #include "lcUniConv/ucs2be.h" 166 #ifdef notused 167 #include "lcUniConv/ascii.h" 168 #endif 169 #include "lcUniConv/iso8859_1.h" 170 #include "lcUniConv/iso8859_2.h" 171 #include "lcUniConv/iso8859_3.h" 172 #include "lcUniConv/iso8859_4.h" 173 #include "lcUniConv/iso8859_5.h" 174 #include "lcUniConv/iso8859_6.h" 175 #include "lcUniConv/iso8859_7.h" 176 #include "lcUniConv/iso8859_8.h" 177 #include "lcUniConv/iso8859_9.h" 178 #include "lcUniConv/iso8859_10.h" 179 #include "lcUniConv/iso8859_11.h" 180 #include "lcUniConv/iso8859_13.h" 181 #include "lcUniConv/iso8859_14.h" 182 #include "lcUniConv/iso8859_15.h" 183 #include "lcUniConv/iso8859_16.h" 184 #include "lcUniConv/iso8859_9e.h" 185 #include "lcUniConv/jisx0201.h" 186 #include "lcUniConv/tis620.h" 187 #include "lcUniConv/koi8_r.h" 188 #include "lcUniConv/koi8_u.h" 189 #include "lcUniConv/koi8_c.h" 190 #include "lcUniConv/armscii_8.h" 191 #include "lcUniConv/cp1133.h" 192 #include "lcUniConv/mulelao.h" 193 #include "lcUniConv/viscii.h" 194 #include "lcUniConv/tcvn.h" 195 #include "lcUniConv/georgian_academy.h" 196 #include "lcUniConv/georgian_ps.h" 197 #include "lcUniConv/cp1251.h" 198 #include "lcUniConv/cp1255.h" 199 #include "lcUniConv/cp1256.h" 200 #include "lcUniConv/tatar_cyr.h" 201 202 typedef struct { 203 unsigned short indx; /* index into big table */ 204 unsigned short used; /* bitmask of used entries */ 205 } Summary16; 206 207 #include "lcUniConv/gb2312.h" 208 #include "lcUniConv/jisx0208.h" 209 #include "lcUniConv/jisx0212.h" 210 #include "lcUniConv/ksc5601.h" 211 #include "lcUniConv/big5.h" 212 #include "lcUniConv/big5_emacs.h" 213 #include "lcUniConv/big5hkscs.h" 214 #include "lcUniConv/gbk.h" 215 216 static Utf8ConvRec all_charsets[] = { 217 /* The ISO10646-1/UTF-8 entry occurs twice, once at the beginning 218 (for lookup speed), once at the end (as a fallback). */ 219 { "ISO10646-1", NULLQUARK, 220 utf8_mbtowc, utf8_wctomb 221 }, 222 223 { "ISO8859-1", NULLQUARK, 224 iso8859_1_mbtowc, iso8859_1_wctomb 225 }, 226 { "ISO8859-2", NULLQUARK, 227 iso8859_2_mbtowc, iso8859_2_wctomb 228 }, 229 { "ISO8859-3", NULLQUARK, 230 iso8859_3_mbtowc, iso8859_3_wctomb 231 }, 232 { "ISO8859-4", NULLQUARK, 233 iso8859_4_mbtowc, iso8859_4_wctomb 234 }, 235 { "ISO8859-5", NULLQUARK, 236 iso8859_5_mbtowc, iso8859_5_wctomb 237 }, 238 { "ISO8859-6", NULLQUARK, 239 iso8859_6_mbtowc, iso8859_6_wctomb 240 }, 241 { "ISO8859-7", NULLQUARK, 242 iso8859_7_mbtowc, iso8859_7_wctomb 243 }, 244 { "ISO8859-8", NULLQUARK, 245 iso8859_8_mbtowc, iso8859_8_wctomb 246 }, 247 { "ISO8859-9", NULLQUARK, 248 iso8859_9_mbtowc, iso8859_9_wctomb 249 }, 250 { "ISO8859-10", NULLQUARK, 251 iso8859_10_mbtowc, iso8859_10_wctomb 252 }, 253 { "ISO8859-11", NULLQUARK, 254 iso8859_11_mbtowc, iso8859_11_wctomb 255 }, 256 { "ISO8859-13", NULLQUARK, 257 iso8859_13_mbtowc, iso8859_13_wctomb 258 }, 259 { "ISO8859-14", NULLQUARK, 260 iso8859_14_mbtowc, iso8859_14_wctomb 261 }, 262 { "ISO8859-15", NULLQUARK, 263 iso8859_15_mbtowc, iso8859_15_wctomb 264 }, 265 { "ISO8859-16", NULLQUARK, 266 iso8859_16_mbtowc, iso8859_16_wctomb 267 }, 268 { "JISX0201.1976-0", NULLQUARK, 269 jisx0201_mbtowc, jisx0201_wctomb 270 }, 271 { "TIS620-0", NULLQUARK, 272 tis620_mbtowc, tis620_wctomb 273 }, 274 { "GB2312.1980-0", NULLQUARK, 275 gb2312_mbtowc, gb2312_wctomb 276 }, 277 { "JISX0208.1983-0", NULLQUARK, 278 jisx0208_mbtowc, jisx0208_wctomb 279 }, 280 { "JISX0208.1990-0", NULLQUARK, 281 jisx0208_mbtowc, jisx0208_wctomb 282 }, 283 { "JISX0212.1990-0", NULLQUARK, 284 jisx0212_mbtowc, jisx0212_wctomb 285 }, 286 { "KSC5601.1987-0", NULLQUARK, 287 ksc5601_mbtowc, ksc5601_wctomb 288 }, 289 { "KOI8-R", NULLQUARK, 290 koi8_r_mbtowc, koi8_r_wctomb 291 }, 292 { "KOI8-U", NULLQUARK, 293 koi8_u_mbtowc, koi8_u_wctomb 294 }, 295 { "KOI8-C", NULLQUARK, 296 koi8_c_mbtowc, koi8_c_wctomb 297 }, 298 { "TATAR-CYR", NULLQUARK, 299 tatar_cyr_mbtowc, tatar_cyr_wctomb 300 }, 301 { "ARMSCII-8", NULLQUARK, 302 armscii_8_mbtowc, armscii_8_wctomb 303 }, 304 { "IBM-CP1133", NULLQUARK, 305 cp1133_mbtowc, cp1133_wctomb 306 }, 307 { "MULELAO-1", NULLQUARK, 308 mulelao_mbtowc, mulelao_wctomb 309 }, 310 { "VISCII1.1-1", NULLQUARK, 311 viscii_mbtowc, viscii_wctomb 312 }, 313 { "TCVN-5712", NULLQUARK, 314 tcvn_mbtowc, tcvn_wctomb 315 }, 316 { "GEORGIAN-ACADEMY", NULLQUARK, 317 georgian_academy_mbtowc, georgian_academy_wctomb 318 }, 319 { "GEORGIAN-PS", NULLQUARK, 320 georgian_ps_mbtowc, georgian_ps_wctomb 321 }, 322 { "ISO8859-9E", NULLQUARK, 323 iso8859_9e_mbtowc, iso8859_9e_wctomb 324 }, 325 { "MICROSOFT-CP1251", NULLQUARK, 326 cp1251_mbtowc, cp1251_wctomb 327 }, 328 { "MICROSOFT-CP1255", NULLQUARK, 329 cp1255_mbtowc, cp1255_wctomb 330 }, 331 { "MICROSOFT-CP1256", NULLQUARK, 332 cp1256_mbtowc, cp1256_wctomb 333 }, 334 { "BIG5-0", NULLQUARK, 335 big5_mbtowc, big5_wctomb 336 }, 337 { "BIG5-E0", NULLQUARK, 338 big5_0_mbtowc, big5_0_wctomb 339 }, 340 { "BIG5-E1", NULLQUARK, 341 big5_1_mbtowc, big5_1_wctomb 342 }, 343 { "GBK-0", NULLQUARK, 344 gbk_mbtowc, gbk_wctomb 345 }, 346 { "BIG5HKSCS-0", NULLQUARK, 347 big5hkscs_mbtowc, big5hkscs_wctomb 348 }, 349 350 /* The ISO10646-1/UTF-8 entry occurs twice, once at the beginning 351 (for lookup speed), once at the end (as a fallback). */ 352 { "ISO10646-1", NULLQUARK, 353 utf8_mbtowc, utf8_wctomb 354 }, 355 356 /* Encoding ISO10646-1 for fonts means UCS2-like encoding 357 so for conversion to FontCharSet we need this record */ 358 { "ISO10646-1", NULLQUARK, 359 ucs2be_mbtowc, ucs2be_wctomb 360 } 361 }; 362 363 #define charsets_table_size (sizeof(all_charsets)/sizeof(all_charsets[0])) 364 #define all_charsets_count (charsets_table_size - 1) 365 #define ucs2_conv_index (charsets_table_size - 1) 366 367 static void 368 init_all_charsets (void) 369 { 370 Utf8Conv convptr; 371 int i; 372 373 for (convptr = all_charsets, i = charsets_table_size; i > 0; convptr++, i--) 374 convptr->xrm_name = XrmStringToQuark(convptr->name); 375 } 376 377 #define lazy_init_all_charsets() \ 378 do { \ 379 if (all_charsets[0].xrm_name == NULLQUARK) \ 380 init_all_charsets(); \ 381 } while (0) 382 383 /* from XlcNCharSet to XlcNUtf8String */ 384 385 static int 386 cstoutf8( 387 XlcConv conv, 388 XPointer *from, 389 int *from_left, 390 XPointer *to, 391 int *to_left, 392 XPointer *args, 393 int num_args) 394 { 395 XlcCharSet charset; 396 const char *name; 397 Utf8Conv convptr; 398 int i; 399 unsigned char const *src; 400 unsigned char const *srcend; 401 unsigned char *dst; 402 unsigned char *dstend; 403 int unconv_num; 404 405 if (from == NULL || *from == NULL) 406 return 0; 407 408 if (num_args < 1) 409 return -1; 410 411 charset = (XlcCharSet) args[0]; 412 name = charset->encoding_name; 413 /* not charset->name because the latter has a ":GL"/":GR" suffix */ 414 415 for (convptr = all_charsets, i = all_charsets_count-1; i > 0; convptr++, i--) 416 if (!strcmp(convptr->name, name)) 417 break; 418 if (i == 0) 419 return -1; 420 421 src = (unsigned char const *) *from; 422 srcend = src + *from_left; 423 dst = (unsigned char *) *to; 424 dstend = dst + *to_left; 425 unconv_num = 0; 426 427 while (src < srcend) { 428 ucs4_t wc; 429 int consumed; 430 int count; 431 432 consumed = convptr->cstowc(conv, &wc, src, srcend-src); 433 if (consumed == RET_ILSEQ) 434 return -1; 435 if (consumed == RET_TOOFEW(0)) 436 break; 437 438 count = utf8_wctomb(NULL, dst, wc, dstend-dst); 439 if (count == RET_TOOSMALL) 440 break; 441 if (count == RET_ILSEQ) { 442 count = utf8_wctomb(NULL, dst, BAD_WCHAR, dstend-dst); 443 if (count == RET_TOOSMALL) 444 break; 445 unconv_num++; 446 } 447 src += consumed; 448 dst += count; 449 } 450 451 *from = (XPointer) src; 452 *from_left = srcend - src; 453 *to = (XPointer) dst; 454 *to_left = dstend - dst; 455 456 return unconv_num; 457 } 458 459 static XlcConvMethodsRec methods_cstoutf8 = { 460 close_converter, 461 cstoutf8, 462 NULL 463 }; 464 465 static XlcConv 466 open_cstoutf8( 467 XLCd from_lcd, 468 const char *from_type, 469 XLCd to_lcd, 470 const char *to_type) 471 { 472 lazy_init_all_charsets(); 473 return create_conv(from_lcd, &methods_cstoutf8); 474 } 475 476 /* from XlcNUtf8String to XlcNCharSet */ 477 478 static XlcConv 479 create_tocs_conv( 480 XLCd lcd, 481 XlcConvMethods methods) 482 { 483 XlcConv conv; 484 CodeSet *codeset_list; 485 int codeset_num; 486 int charset_num; 487 int i, j, k; 488 Utf8Conv *preferred; 489 490 lazy_init_all_charsets(); 491 492 codeset_list = XLC_GENERIC(lcd, codeset_list); 493 codeset_num = XLC_GENERIC(lcd, codeset_num); 494 495 charset_num = 0; 496 for (i = 0; i < codeset_num; i++) 497 charset_num += codeset_list[i]->num_charsets; 498 if (charset_num > all_charsets_count-1) 499 charset_num = all_charsets_count-1; 500 501 conv = Xmalloc(sizeof(XlcConvRec) 502 + (charset_num + 1) * sizeof(Utf8Conv)); 503 if (conv == (XlcConv) NULL) 504 return (XlcConv) NULL; 505 preferred = (Utf8Conv *) ((char *) conv + sizeof(XlcConvRec)); 506 507 /* Loop through all codesets mentioned in the locale. */ 508 charset_num = 0; 509 for (i = 0; i < codeset_num; i++) { 510 XlcCharSet *charsets = codeset_list[i]->charset_list; 511 int num_charsets = codeset_list[i]->num_charsets; 512 for (j = 0; j < num_charsets; j++) { 513 const char *name = charsets[j]->encoding_name; 514 /* If it wasn't already encountered... */ 515 for (k = charset_num-1; k >= 0; k--) 516 if (!strcmp(preferred[k]->name, name)) 517 break; 518 if (k < 0) { 519 /* Look it up in all_charsets[]. */ 520 for (k = 0; k < all_charsets_count-1; k++) 521 if (!strcmp(all_charsets[k].name, name)) { 522 /* Add it to the preferred set. */ 523 preferred[charset_num++] = &all_charsets[k]; 524 break; 525 } 526 } 527 } 528 } 529 preferred[charset_num] = (Utf8Conv) NULL; 530 531 conv->methods = methods; 532 conv->state = (XPointer) preferred; 533 534 return conv; 535 } 536 537 static void 538 close_tocs_converter( 539 XlcConv conv) 540 { 541 /* conv->state is allocated together with conv, free both at once. */ 542 Xfree(conv); 543 } 544 545 /* 546 * Converts a Unicode character to an appropriate character set. The NULL 547 * terminated array of preferred character sets is passed as first argument. 548 * If successful, *charsetp is set to the character set that was used, and 549 * *sidep is set to the character set side (XlcGL or XlcGR). 550 */ 551 static int 552 charset_wctocs( 553 Utf8Conv *preferred, 554 Utf8Conv *charsetp, 555 XlcSide *sidep, 556 XlcConv conv, 557 unsigned char *r, 558 ucs4_t wc, 559 int n) 560 { 561 int count; 562 Utf8Conv convptr; 563 int i; 564 565 for (; *preferred != (Utf8Conv) NULL; preferred++) { 566 convptr = *preferred; 567 count = convptr->wctocs(conv, r, wc, n); 568 if (count == RET_TOOSMALL) 569 return RET_TOOSMALL; 570 if (count != RET_ILSEQ) { 571 *charsetp = convptr; 572 *sidep = (*r < 0x80 ? XlcGL : XlcGR); 573 return count; 574 } 575 } 576 for (convptr = all_charsets+1, i = all_charsets_count-1; i > 0; convptr++, i--) { 577 count = convptr->wctocs(conv, r, wc, n); 578 if (count == RET_TOOSMALL) 579 return RET_TOOSMALL; 580 if (count != RET_ILSEQ) { 581 *charsetp = convptr; 582 *sidep = (*r < 0x80 ? XlcGL : XlcGR); 583 return count; 584 } 585 } 586 return RET_ILSEQ; 587 } 588 589 static int 590 utf8tocs( 591 XlcConv conv, 592 XPointer *from, 593 int *from_left, 594 XPointer *to, 595 int *to_left, 596 XPointer *args, 597 int num_args) 598 { 599 Utf8Conv *preferred_charsets; 600 XlcCharSet last_charset = NULL; 601 unsigned char const *src; 602 unsigned char const *srcend; 603 unsigned char *dst; 604 unsigned char *dstend; 605 int unconv_num; 606 607 if (from == NULL || *from == NULL) 608 return 0; 609 610 preferred_charsets = (Utf8Conv *) conv->state; 611 src = (unsigned char const *) *from; 612 srcend = src + *from_left; 613 dst = (unsigned char *) *to; 614 dstend = dst + *to_left; 615 unconv_num = 0; 616 617 while (src < srcend && dst < dstend) { 618 Utf8Conv chosen_charset = NULL; 619 XlcSide chosen_side = XlcNONE; 620 ucs4_t wc; 621 int consumed; 622 int count; 623 624 consumed = utf8_mbtowc(NULL, &wc, src, srcend-src); 625 if (consumed == RET_TOOFEW(0)) 626 break; 627 if (consumed == RET_ILSEQ) { 628 src++; 629 unconv_num++; 630 continue; 631 } 632 633 count = charset_wctocs(preferred_charsets, &chosen_charset, &chosen_side, conv, dst, wc, dstend-dst); 634 if (count == RET_TOOSMALL) 635 break; 636 if (count == RET_ILSEQ) { 637 src += consumed; 638 unconv_num++; 639 continue; 640 } 641 642 if (last_charset == NULL) { 643 last_charset = 644 _XlcGetCharSetWithSide(chosen_charset->name, chosen_side); 645 if (last_charset == NULL) { 646 src += consumed; 647 unconv_num++; 648 continue; 649 } 650 } else { 651 if (!(last_charset->xrm_encoding_name == chosen_charset->xrm_name 652 && (last_charset->side == XlcGLGR 653 || last_charset->side == chosen_side))) 654 break; 655 } 656 src += consumed; 657 dst += count; 658 } 659 660 if (last_charset == NULL) 661 return -1; 662 663 *from = (XPointer) src; 664 *from_left = srcend - src; 665 *to = (XPointer) dst; 666 *to_left = dstend - dst; 667 668 if (num_args >= 1) 669 *((XlcCharSet *)args[0]) = last_charset; 670 671 return unconv_num; 672 } 673 674 static XlcConvMethodsRec methods_utf8tocs = { 675 close_tocs_converter, 676 utf8tocs, 677 NULL 678 }; 679 680 static XlcConv 681 open_utf8tocs( 682 XLCd from_lcd, 683 const char *from_type, 684 XLCd to_lcd, 685 const char *to_type) 686 { 687 return create_tocs_conv(from_lcd, &methods_utf8tocs); 688 } 689 690 /* from XlcNUtf8String to XlcNChar */ 691 692 static int 693 utf8tocs1( 694 XlcConv conv, 695 XPointer *from, 696 int *from_left, 697 XPointer *to, 698 int *to_left, 699 XPointer *args, 700 int num_args) 701 { 702 Utf8Conv *preferred_charsets; 703 XlcCharSet last_charset = NULL; 704 unsigned char const *src; 705 unsigned char const *srcend; 706 unsigned char *dst; 707 unsigned char *dstend; 708 int unconv_num; 709 710 if (from == NULL || *from == NULL) 711 return 0; 712 713 preferred_charsets = (Utf8Conv *) conv->state; 714 src = (unsigned char const *) *from; 715 srcend = src + *from_left; 716 dst = (unsigned char *) *to; 717 dstend = dst + *to_left; 718 unconv_num = 0; 719 720 while (src < srcend && dst < dstend) { 721 Utf8Conv chosen_charset = NULL; 722 XlcSide chosen_side = XlcNONE; 723 ucs4_t wc; 724 int consumed; 725 int count; 726 727 consumed = utf8_mbtowc(NULL, &wc, src, srcend-src); 728 if (consumed == RET_TOOFEW(0)) 729 break; 730 if (consumed == RET_ILSEQ) { 731 src++; 732 unconv_num++; 733 continue; 734 } 735 736 count = charset_wctocs(preferred_charsets, &chosen_charset, &chosen_side, conv, dst, wc, dstend-dst); 737 if (count == RET_TOOSMALL) 738 break; 739 if (count == RET_ILSEQ) { 740 src += consumed; 741 unconv_num++; 742 continue; 743 } 744 745 last_charset = _XlcGetCharSetWithSide(chosen_charset->name, chosen_side); 746 747 if (last_charset == NULL) { 748 src += consumed; 749 unconv_num++; 750 continue; 751 } 752 753 src += consumed; 754 dst += count; 755 break; 756 } 757 758 if (last_charset == NULL) 759 return -1; 760 761 *from = (XPointer) src; 762 *from_left = srcend - src; 763 *to = (XPointer) dst; 764 *to_left = dstend - dst; 765 766 if (num_args >= 1) 767 *((XlcCharSet *)args[0]) = last_charset; 768 769 return unconv_num; 770 } 771 772 static XlcConvMethodsRec methods_utf8tocs1 = { 773 close_tocs_converter, 774 utf8tocs1, 775 NULL 776 }; 777 778 static XlcConv 779 open_utf8tocs1( 780 XLCd from_lcd, 781 const char *from_type, 782 XLCd to_lcd, 783 const char *to_type) 784 { 785 return create_tocs_conv(from_lcd, &methods_utf8tocs1); 786 } 787 788 /* from XlcNUtf8String to XlcNString */ 789 790 static int 791 utf8tostr( 792 XlcConv conv, 793 XPointer *from, 794 int *from_left, 795 XPointer *to, 796 int *to_left, 797 XPointer *args, 798 int num_args) 799 { 800 unsigned char const *src; 801 unsigned char const *srcend; 802 unsigned char *dst; 803 unsigned char *dstend; 804 int unconv_num; 805 806 if (from == NULL || *from == NULL) 807 return 0; 808 809 src = (unsigned char const *) *from; 810 srcend = src + *from_left; 811 dst = (unsigned char *) *to; 812 dstend = dst + *to_left; 813 unconv_num = 0; 814 815 while (src < srcend) { 816 unsigned char c; 817 ucs4_t wc; 818 int consumed; 819 820 consumed = utf8_mbtowc(NULL, &wc, src, srcend-src); 821 if (consumed == RET_TOOFEW(0)) 822 break; 823 if (dst == dstend) 824 break; 825 if (consumed == RET_ILSEQ) { 826 consumed = 1; 827 c = BAD_CHAR; 828 unconv_num++; 829 } else { 830 if ((wc & ~(ucs4_t)0xff) != 0) { 831 c = BAD_CHAR; 832 unconv_num++; 833 } else 834 c = (unsigned char) wc; 835 } 836 *dst++ = c; 837 src += consumed; 838 } 839 840 *from = (XPointer) src; 841 *from_left = srcend - src; 842 *to = (XPointer) dst; 843 *to_left = dstend - dst; 844 845 return unconv_num; 846 } 847 848 static XlcConvMethodsRec methods_utf8tostr = { 849 close_converter, 850 utf8tostr, 851 NULL 852 }; 853 854 static XlcConv 855 open_utf8tostr( 856 XLCd from_lcd, 857 const char *from_type, 858 XLCd to_lcd, 859 const char *to_type) 860 { 861 return create_conv(from_lcd, &methods_utf8tostr); 862 } 863 864 /* from XlcNString to XlcNUtf8String */ 865 866 static int 867 strtoutf8( 868 XlcConv conv, 869 XPointer *from, 870 int *from_left, 871 XPointer *to, 872 int *to_left, 873 XPointer *args, 874 int num_args) 875 { 876 unsigned char const *src; 877 unsigned char const *srcend; 878 unsigned char *dst; 879 unsigned char *dstend; 880 881 if (from == NULL || *from == NULL) 882 return 0; 883 884 src = (unsigned char const *) *from; 885 srcend = src + *from_left; 886 dst = (unsigned char *) *to; 887 dstend = dst + *to_left; 888 889 while (src < srcend) { 890 int count = utf8_wctomb(NULL, dst, *src, dstend-dst); 891 if (count == RET_TOOSMALL) 892 break; 893 dst += count; 894 src++; 895 } 896 897 *from = (XPointer) src; 898 *from_left = srcend - src; 899 *to = (XPointer) dst; 900 *to_left = dstend - dst; 901 902 return 0; 903 } 904 905 static XlcConvMethodsRec methods_strtoutf8 = { 906 close_converter, 907 strtoutf8, 908 NULL 909 }; 910 911 static XlcConv 912 open_strtoutf8( 913 XLCd from_lcd, 914 const char *from_type, 915 XLCd to_lcd, 916 const char *to_type) 917 { 918 return create_conv(from_lcd, &methods_strtoutf8); 919 } 920 921 /* Support for the input methods. */ 922 923 XPointer 924 _Utf8GetConvByName( 925 const char *name) 926 { 927 XrmQuark xrm_name; 928 Utf8Conv convptr; 929 int i; 930 931 if (name == NULL) 932 return (XPointer) NULL; 933 934 lazy_init_all_charsets(); 935 xrm_name = XrmStringToQuark(name); 936 937 for (convptr = all_charsets, i = all_charsets_count-1; i > 0; convptr++, i--) 938 if (convptr->xrm_name == xrm_name) 939 return (XPointer) convptr->wctocs; 940 return (XPointer) NULL; 941 } 942 943 /* from XlcNUcsChar to XlcNChar, needed for input methods */ 944 945 static XlcConv 946 create_ucstocs_conv( 947 XLCd lcd, 948 XlcConvMethods methods) 949 { 950 951 if (XLC_PUBLIC_PART(lcd)->codeset 952 && _XlcCompareISOLatin1(XLC_PUBLIC_PART(lcd)->codeset, "UTF-8") == 0) { 953 XlcConv conv; 954 Utf8Conv *preferred; 955 956 lazy_init_all_charsets(); 957 958 conv = Xmalloc(sizeof(XlcConvRec) + 2 * sizeof(Utf8Conv)); 959 if (conv == (XlcConv) NULL) 960 return (XlcConv) NULL; 961 preferred = (Utf8Conv *) ((char *) conv + sizeof(XlcConvRec)); 962 963 preferred[0] = &all_charsets[0]; /* ISO10646 */ 964 preferred[1] = (Utf8Conv) NULL; 965 966 conv->methods = methods; 967 conv->state = (XPointer) preferred; 968 969 return conv; 970 } else { 971 return create_tocs_conv(lcd, methods); 972 } 973 } 974 975 static int 976 charset_wctocs_exactly( 977 Utf8Conv *preferred, 978 Utf8Conv *charsetp, 979 XlcSide *sidep, 980 XlcConv conv, 981 unsigned char *r, 982 ucs4_t wc, 983 int n) 984 { 985 int count; 986 Utf8Conv convptr; 987 988 for (; *preferred != (Utf8Conv) NULL; preferred++) { 989 convptr = *preferred; 990 count = convptr->wctocs(conv, r, wc, n); 991 if (count == RET_TOOSMALL) 992 return RET_TOOSMALL; 993 if (count != RET_ILSEQ) { 994 *charsetp = convptr; 995 *sidep = (*r < 0x80 ? XlcGL : XlcGR); 996 return count; 997 } 998 } 999 return RET_ILSEQ; 1000 } 1001 1002 static int 1003 ucstocs1( 1004 XlcConv conv, 1005 XPointer *from, 1006 int *from_left, 1007 XPointer *to, 1008 int *to_left, 1009 XPointer *args, 1010 int num_args) 1011 { 1012 ucs4_t const *src; 1013 unsigned char *dst = (unsigned char *) *to; 1014 int unconv_num = 0; 1015 Utf8Conv *preferred_charsets = (Utf8Conv *) conv->state; 1016 Utf8Conv chosen_charset = NULL; 1017 XlcSide chosen_side = XlcNONE; 1018 XlcCharSet charset = NULL; 1019 int count; 1020 1021 if (from == NULL || *from == NULL) 1022 return 0; 1023 1024 src = (ucs4_t const *) *from; 1025 1026 count = charset_wctocs_exactly(preferred_charsets, &chosen_charset, 1027 &chosen_side, conv, dst, *src, *to_left); 1028 if (count < 1) { 1029 unconv_num++; 1030 count = 0; 1031 } else { 1032 charset = _XlcGetCharSetWithSide(chosen_charset->name, chosen_side); 1033 } 1034 if (charset == NULL) 1035 return -1; 1036 1037 *from = (XPointer) ++src; 1038 (*from_left)--; 1039 *to = (XPointer) dst; 1040 *to_left -= count; 1041 1042 if (num_args >= 1) 1043 *((XlcCharSet *)args[0]) = charset; 1044 1045 return unconv_num; 1046 } 1047 1048 static XlcConvMethodsRec methods_ucstocs1 = { 1049 close_tocs_converter, 1050 ucstocs1, 1051 NULL 1052 }; 1053 1054 static XlcConv 1055 open_ucstocs1( 1056 XLCd from_lcd, 1057 const char *from_type, 1058 XLCd to_lcd, 1059 const char *to_type) 1060 { 1061 return create_ucstocs_conv(from_lcd, &methods_ucstocs1); 1062 } 1063 1064 /* from XlcNUcsChar to XlcNUtf8String, needed for input methods */ 1065 1066 static int 1067 ucstoutf8( 1068 XlcConv conv, 1069 XPointer *from, 1070 int *from_left, 1071 XPointer *to, 1072 int *to_left, 1073 XPointer *args, 1074 int num_args) 1075 { 1076 const ucs4_t *src; 1077 const ucs4_t *srcend; 1078 unsigned char *dst; 1079 unsigned char *dstend; 1080 int unconv_num; 1081 1082 if (from == NULL || *from == NULL) 1083 return 0; 1084 1085 src = (const ucs4_t *) *from; 1086 srcend = src + *from_left; 1087 dst = (unsigned char *) *to; 1088 dstend = dst + *to_left; 1089 unconv_num = 0; 1090 1091 while (src < srcend) { 1092 int count = utf8_wctomb(NULL, dst, *src, dstend-dst); 1093 if (count == RET_TOOSMALL) 1094 break; 1095 if (count == RET_ILSEQ) 1096 unconv_num++; 1097 src++; 1098 dst += count; 1099 } 1100 1101 *from = (XPointer) src; 1102 *from_left = srcend - src; 1103 *to = (XPointer) dst; 1104 *to_left = dstend - dst; 1105 1106 return unconv_num; 1107 } 1108 1109 static XlcConvMethodsRec methods_ucstoutf8 = { 1110 close_converter, 1111 ucstoutf8, 1112 NULL 1113 }; 1114 1115 static XlcConv 1116 open_ucstoutf8( 1117 XLCd from_lcd, 1118 const char *from_type, 1119 XLCd to_lcd, 1120 const char *to_type) 1121 { 1122 return create_conv(from_lcd, &methods_ucstoutf8); 1123 } 1124 1125 /* Registers UTF-8 converters for a non-UTF-8 locale. */ 1126 void 1127 _XlcAddUtf8Converters( 1128 XLCd lcd) 1129 { 1130 _XlcSetConverter(lcd, XlcNCharSet, lcd, XlcNUtf8String, open_cstoutf8); 1131 _XlcSetConverter(lcd, XlcNUtf8String, lcd, XlcNCharSet, open_utf8tocs); 1132 _XlcSetConverter(lcd, XlcNUtf8String, lcd, XlcNChar, open_utf8tocs1); 1133 _XlcSetConverter(lcd, XlcNString, lcd, XlcNUtf8String, open_strtoutf8); 1134 _XlcSetConverter(lcd, XlcNUtf8String, lcd, XlcNString, open_utf8tostr); 1135 _XlcSetConverter(lcd, XlcNUcsChar, lcd, XlcNChar, open_ucstocs1); 1136 _XlcSetConverter(lcd, XlcNUcsChar, lcd, XlcNUtf8String, open_ucstoutf8); 1137 } 1138 1139 /***************************************************************************/ 1140 /* Part II: UTF-8 locale loader conversion files 1141 * 1142 * Here we can assume that "multi-byte" is UTF-8 and that `wchar_t' is Unicode. 1143 */ 1144 1145 /* from XlcNMultiByte to XlcNWideChar */ 1146 1147 static int 1148 utf8towcs( 1149 XlcConv conv, 1150 XPointer *from, 1151 int *from_left, 1152 XPointer *to, 1153 int *to_left, 1154 XPointer *args, 1155 int num_args) 1156 { 1157 unsigned char const *src; 1158 unsigned char const *srcend; 1159 wchar_t *dst; 1160 wchar_t *dstend; 1161 int unconv_num; 1162 1163 if (from == NULL || *from == NULL) 1164 return 0; 1165 1166 src = (unsigned char const *) *from; 1167 srcend = src + *from_left; 1168 dst = (wchar_t *) *to; 1169 dstend = dst + *to_left; 1170 unconv_num = 0; 1171 1172 while (src < srcend && dst < dstend) { 1173 ucs4_t wc; 1174 int consumed = utf8_mbtowc(NULL, &wc, src, srcend-src); 1175 if (consumed == RET_TOOFEW(0)) 1176 break; 1177 if (consumed == RET_ILSEQ) { 1178 src++; 1179 *dst = BAD_WCHAR; 1180 unconv_num++; 1181 } else { 1182 src += consumed; 1183 *dst = wc; 1184 } 1185 dst++; 1186 } 1187 1188 *from = (XPointer) src; 1189 *from_left = srcend - src; 1190 *to = (XPointer) dst; 1191 *to_left = dstend - dst; 1192 1193 return unconv_num; 1194 } 1195 1196 static XlcConvMethodsRec methods_utf8towcs = { 1197 close_converter, 1198 utf8towcs, 1199 NULL 1200 }; 1201 1202 static XlcConv 1203 open_utf8towcs( 1204 XLCd from_lcd, 1205 const char *from_type, 1206 XLCd to_lcd, 1207 const char *to_type) 1208 { 1209 return create_conv(from_lcd, &methods_utf8towcs); 1210 } 1211 1212 /* from XlcNWideChar to XlcNMultiByte */ 1213 1214 static int 1215 wcstoutf8( 1216 XlcConv conv, 1217 XPointer *from, 1218 int *from_left, 1219 XPointer *to, 1220 int *to_left, 1221 XPointer *args, 1222 int num_args) 1223 { 1224 wchar_t const *src; 1225 wchar_t const *srcend; 1226 unsigned char *dst; 1227 unsigned char *dstend; 1228 int unconv_num; 1229 1230 if (from == NULL || *from == NULL) 1231 return 0; 1232 1233 src = (wchar_t const *) *from; 1234 srcend = src + *from_left; 1235 dst = (unsigned char *) *to; 1236 dstend = dst + *to_left; 1237 unconv_num = 0; 1238 1239 while (src < srcend) { 1240 int count = utf8_wctomb(NULL, dst, *src, dstend-dst); 1241 if (count == RET_TOOSMALL) 1242 break; 1243 if (count == RET_ILSEQ) { 1244 count = utf8_wctomb(NULL, dst, BAD_WCHAR, dstend-dst); 1245 if (count == RET_TOOSMALL) 1246 break; 1247 unconv_num++; 1248 } 1249 dst += count; 1250 src++; 1251 } 1252 1253 *from = (XPointer) src; 1254 *from_left = srcend - src; 1255 *to = (XPointer) dst; 1256 *to_left = dstend - dst; 1257 1258 return unconv_num; 1259 } 1260 1261 static XlcConvMethodsRec methods_wcstoutf8 = { 1262 close_converter, 1263 wcstoutf8, 1264 NULL 1265 }; 1266 1267 static XlcConv 1268 open_wcstoutf8( 1269 XLCd from_lcd, 1270 const char *from_type, 1271 XLCd to_lcd, 1272 const char *to_type) 1273 { 1274 return create_conv(from_lcd, &methods_wcstoutf8); 1275 } 1276 1277 /* from XlcNString to XlcNWideChar */ 1278 1279 static int 1280 our_strtowcs( 1281 XlcConv conv, 1282 XPointer *from, 1283 int *from_left, 1284 XPointer *to, 1285 int *to_left, 1286 XPointer *args, 1287 int num_args) 1288 { 1289 unsigned char const *src; 1290 unsigned char const *srcend; 1291 wchar_t *dst; 1292 wchar_t *dstend; 1293 1294 if (from == NULL || *from == NULL) 1295 return 0; 1296 1297 src = (unsigned char const *) *from; 1298 srcend = src + *from_left; 1299 dst = (wchar_t *) *to; 1300 dstend = dst + *to_left; 1301 1302 while (src < srcend && dst < dstend) 1303 *dst++ = (wchar_t) *src++; 1304 1305 *from = (XPointer) src; 1306 *from_left = srcend - src; 1307 *to = (XPointer) dst; 1308 *to_left = dstend - dst; 1309 1310 return 0; 1311 } 1312 1313 static XlcConvMethodsRec methods_strtowcs = { 1314 close_converter, 1315 our_strtowcs, 1316 NULL 1317 }; 1318 1319 static XlcConv 1320 open_strtowcs( 1321 XLCd from_lcd, 1322 const char *from_type, 1323 XLCd to_lcd, 1324 const char *to_type) 1325 { 1326 return create_conv(from_lcd, &methods_strtowcs); 1327 } 1328 1329 /* from XlcNWideChar to XlcNString */ 1330 1331 static int 1332 our_wcstostr( 1333 XlcConv conv, 1334 XPointer *from, 1335 int *from_left, 1336 XPointer *to, 1337 int *to_left, 1338 XPointer *args, 1339 int num_args) 1340 { 1341 wchar_t const *src; 1342 wchar_t const *srcend; 1343 unsigned char *dst; 1344 unsigned char *dstend; 1345 int unconv_num; 1346 1347 if (from == NULL || *from == NULL) 1348 return 0; 1349 1350 src = (wchar_t const *) *from; 1351 srcend = src + *from_left; 1352 dst = (unsigned char *) *to; 1353 dstend = dst + *to_left; 1354 unconv_num = 0; 1355 1356 while (src < srcend && dst < dstend) { 1357 unsigned int wc = *src++; 1358 if (wc < 0x80) 1359 *dst = wc; 1360 else { 1361 *dst = BAD_CHAR; 1362 unconv_num++; 1363 } 1364 dst++; 1365 } 1366 1367 *from = (XPointer) src; 1368 *from_left = srcend - src; 1369 *to = (XPointer) dst; 1370 *to_left = dstend - dst; 1371 1372 return unconv_num; 1373 } 1374 1375 static XlcConvMethodsRec methods_wcstostr = { 1376 close_converter, 1377 our_wcstostr, 1378 NULL 1379 }; 1380 1381 static XlcConv 1382 open_wcstostr( 1383 XLCd from_lcd, 1384 const char *from_type, 1385 XLCd to_lcd, 1386 const char *to_type) 1387 { 1388 return create_conv(from_lcd, &methods_wcstostr); 1389 } 1390 1391 /* from XlcNCharSet to XlcNWideChar */ 1392 1393 static int 1394 cstowcs( 1395 XlcConv conv, 1396 XPointer *from, 1397 int *from_left, 1398 XPointer *to, 1399 int *to_left, 1400 XPointer *args, 1401 int num_args) 1402 { 1403 XlcCharSet charset; 1404 const char *name; 1405 Utf8Conv convptr; 1406 int i; 1407 unsigned char const *src; 1408 unsigned char const *srcend; 1409 wchar_t *dst; 1410 wchar_t *dstend; 1411 int unconv_num; 1412 1413 if (from == NULL || *from == NULL) 1414 return 0; 1415 1416 if (num_args < 1) 1417 return -1; 1418 1419 charset = (XlcCharSet) args[0]; 1420 name = charset->encoding_name; 1421 /* not charset->name because the latter has a ":GL"/":GR" suffix */ 1422 1423 for (convptr = all_charsets, i = all_charsets_count-1; i > 0; convptr++, i--) 1424 if (!strcmp(convptr->name, name)) 1425 break; 1426 if (i == 0) 1427 return -1; 1428 1429 src = (unsigned char const *) *from; 1430 srcend = src + *from_left; 1431 dst = (wchar_t *) *to; 1432 dstend = dst + *to_left; 1433 unconv_num = 0; 1434 1435 while (src < srcend && dst < dstend) { 1436 unsigned int wc; 1437 int consumed; 1438 1439 consumed = convptr->cstowc(conv, &wc, src, srcend-src); 1440 if (consumed == RET_ILSEQ) 1441 return -1; 1442 if (consumed == RET_TOOFEW(0)) 1443 break; 1444 1445 *dst++ = wc; 1446 src += consumed; 1447 } 1448 1449 *from = (XPointer) src; 1450 *from_left = srcend - src; 1451 *to = (XPointer) dst; 1452 *to_left = dstend - dst; 1453 1454 return unconv_num; 1455 } 1456 1457 static XlcConvMethodsRec methods_cstowcs = { 1458 close_converter, 1459 cstowcs, 1460 NULL 1461 }; 1462 1463 static XlcConv 1464 open_cstowcs( 1465 XLCd from_lcd, 1466 const char *from_type, 1467 XLCd to_lcd, 1468 const char *to_type) 1469 { 1470 lazy_init_all_charsets(); 1471 return create_conv(from_lcd, &methods_cstowcs); 1472 } 1473 1474 /* from XlcNWideChar to XlcNCharSet */ 1475 1476 static int 1477 wcstocs( 1478 XlcConv conv, 1479 XPointer *from, 1480 int *from_left, 1481 XPointer *to, 1482 int *to_left, 1483 XPointer *args, 1484 int num_args) 1485 { 1486 Utf8Conv *preferred_charsets; 1487 XlcCharSet last_charset = NULL; 1488 wchar_t const *src; 1489 wchar_t const *srcend; 1490 unsigned char *dst; 1491 unsigned char *dstend; 1492 int unconv_num; 1493 1494 if (from == NULL || *from == NULL) 1495 return 0; 1496 1497 preferred_charsets = (Utf8Conv *) conv->state; 1498 src = (wchar_t const *) *from; 1499 srcend = src + *from_left; 1500 dst = (unsigned char *) *to; 1501 dstend = dst + *to_left; 1502 unconv_num = 0; 1503 1504 while (src < srcend && dst < dstend) { 1505 Utf8Conv chosen_charset = NULL; 1506 XlcSide chosen_side = XlcNONE; 1507 wchar_t wc = *src; 1508 int count; 1509 1510 count = charset_wctocs(preferred_charsets, &chosen_charset, &chosen_side, conv, dst, wc, dstend-dst); 1511 if (count == RET_TOOSMALL) 1512 break; 1513 if (count == RET_ILSEQ) { 1514 src++; 1515 unconv_num++; 1516 continue; 1517 } 1518 1519 if (last_charset == NULL) { 1520 last_charset = 1521 _XlcGetCharSetWithSide(chosen_charset->name, chosen_side); 1522 if (last_charset == NULL) { 1523 src++; 1524 unconv_num++; 1525 continue; 1526 } 1527 } else { 1528 if (!(last_charset->xrm_encoding_name == chosen_charset->xrm_name 1529 && (last_charset->side == XlcGLGR 1530 || last_charset->side == chosen_side))) 1531 break; 1532 } 1533 src++; 1534 dst += count; 1535 } 1536 1537 if (last_charset == NULL) 1538 return -1; 1539 1540 *from = (XPointer) src; 1541 *from_left = srcend - src; 1542 *to = (XPointer) dst; 1543 *to_left = dstend - dst; 1544 1545 if (num_args >= 1) 1546 *((XlcCharSet *)args[0]) = last_charset; 1547 1548 return unconv_num; 1549 } 1550 1551 static XlcConvMethodsRec methods_wcstocs = { 1552 close_tocs_converter, 1553 wcstocs, 1554 NULL 1555 }; 1556 1557 static XlcConv 1558 open_wcstocs( 1559 XLCd from_lcd, 1560 const char *from_type, 1561 XLCd to_lcd, 1562 const char *to_type) 1563 { 1564 return create_tocs_conv(from_lcd, &methods_wcstocs); 1565 } 1566 1567 /* from XlcNWideChar to XlcNChar */ 1568 1569 static int 1570 wcstocs1( 1571 XlcConv conv, 1572 XPointer *from, 1573 int *from_left, 1574 XPointer *to, 1575 int *to_left, 1576 XPointer *args, 1577 int num_args) 1578 { 1579 Utf8Conv *preferred_charsets; 1580 XlcCharSet last_charset = NULL; 1581 wchar_t const *src; 1582 wchar_t const *srcend; 1583 unsigned char *dst; 1584 unsigned char *dstend; 1585 int unconv_num; 1586 1587 if (from == NULL || *from == NULL) 1588 return 0; 1589 1590 preferred_charsets = (Utf8Conv *) conv->state; 1591 src = (wchar_t const *) *from; 1592 srcend = src + *from_left; 1593 dst = (unsigned char *) *to; 1594 dstend = dst + *to_left; 1595 unconv_num = 0; 1596 1597 while (src < srcend && dst < dstend) { 1598 Utf8Conv chosen_charset = NULL; 1599 XlcSide chosen_side = XlcNONE; 1600 wchar_t wc = *src; 1601 int count; 1602 1603 count = charset_wctocs(preferred_charsets, &chosen_charset, &chosen_side, conv, dst, wc, dstend-dst); 1604 if (count == RET_TOOSMALL) 1605 break; 1606 if (count == RET_ILSEQ) { 1607 src++; 1608 unconv_num++; 1609 continue; 1610 } 1611 1612 last_charset = _XlcGetCharSetWithSide(chosen_charset->name, chosen_side); 1613 1614 if (last_charset == NULL) { 1615 src++; 1616 unconv_num++; 1617 continue; 1618 } 1619 1620 src++; 1621 dst += count; 1622 break; 1623 } 1624 1625 if (last_charset == NULL) 1626 return -1; 1627 1628 *from = (XPointer) src; 1629 *from_left = srcend - src; 1630 *to = (XPointer) dst; 1631 *to_left = dstend - dst; 1632 1633 if (num_args >= 1) 1634 *((XlcCharSet *)args[0]) = last_charset; 1635 1636 return unconv_num; 1637 } 1638 1639 static XlcConvMethodsRec methods_wcstocs1 = { 1640 close_tocs_converter, 1641 wcstocs1, 1642 NULL 1643 }; 1644 1645 static XlcConv 1646 open_wcstocs1( 1647 XLCd from_lcd, 1648 const char *from_type, 1649 XLCd to_lcd, 1650 const char *to_type) 1651 { 1652 return create_tocs_conv(from_lcd, &methods_wcstocs1); 1653 } 1654 1655 /* trivial, no conversion */ 1656 1657 static int 1658 identity( 1659 XlcConv conv, 1660 XPointer *from, 1661 int *from_left, 1662 XPointer *to, 1663 int *to_left, 1664 XPointer *args, 1665 int num_args) 1666 { 1667 unsigned char const *src; 1668 unsigned char const *srcend; 1669 unsigned char *dst; 1670 unsigned char *dstend; 1671 1672 if (from == NULL || *from == NULL) 1673 return 0; 1674 1675 src = (unsigned char const *) *from; 1676 srcend = src + *from_left; 1677 dst = (unsigned char *) *to; 1678 dstend = dst + *to_left; 1679 1680 while (src < srcend && dst < dstend) 1681 *dst++ = *src++; 1682 1683 *from = (XPointer) src; 1684 *from_left = srcend - src; 1685 *to = (XPointer) dst; 1686 *to_left = dstend - dst; 1687 1688 return 0; 1689 } 1690 1691 static XlcConvMethodsRec methods_identity = { 1692 close_converter, 1693 identity, 1694 NULL 1695 }; 1696 1697 static XlcConv 1698 open_identity( 1699 XLCd from_lcd, 1700 const char *from_type, 1701 XLCd to_lcd, 1702 const char *to_type) 1703 { 1704 return create_conv(from_lcd, &methods_identity); 1705 } 1706 1707 /* from MultiByte/WideChar to FontCharSet. */ 1708 /* They really use converters to CharSet 1709 * but with different create_conv procedure. */ 1710 1711 static XlcConv 1712 create_tofontcs_conv( 1713 XLCd lcd, 1714 XlcConvMethods methods) 1715 { 1716 XlcConv conv; 1717 int i, num, k, count; 1718 char **value, buf[32]; 1719 Utf8Conv *preferred; 1720 1721 lazy_init_all_charsets(); 1722 1723 for (i = 0, num = 0;; i++) { 1724 snprintf(buf, sizeof(buf), "fs%d.charset.name", i); 1725 _XlcGetResource(lcd, "XLC_FONTSET", buf, &value, &count); 1726 if (count < 1) { 1727 snprintf(buf, sizeof(buf), "fs%d.charset", i); 1728 _XlcGetResource(lcd, "XLC_FONTSET", buf, &value, &count); 1729 if (count < 1) 1730 break; 1731 } 1732 num += count; 1733 } 1734 1735 conv = Xmalloc(sizeof(XlcConvRec) + (num + 1) * sizeof(Utf8Conv)); 1736 if (conv == (XlcConv) NULL) 1737 return (XlcConv) NULL; 1738 preferred = (Utf8Conv *) ((char *) conv + sizeof(XlcConvRec)); 1739 1740 /* Loop through all fontsets mentioned in the locale. */ 1741 for (i = 0, num = 0;; i++) { 1742 snprintf(buf, sizeof(buf), "fs%d.charset.name", i); 1743 _XlcGetResource(lcd, "XLC_FONTSET", buf, &value, &count); 1744 if (count < 1) { 1745 snprintf(buf, sizeof(buf), "fs%d.charset", i); 1746 _XlcGetResource(lcd, "XLC_FONTSET", buf, &value, &count); 1747 if (count < 1) 1748 break; 1749 } 1750 while (count-- > 0) { 1751 XlcCharSet charset = _XlcGetCharSet(*value++); 1752 const char *name; 1753 1754 if (charset == (XlcCharSet) NULL) 1755 continue; 1756 1757 name = charset->encoding_name; 1758 /* If it wasn't already encountered... */ 1759 for (k = num - 1; k >= 0; k--) 1760 if (!strcmp(preferred[k]->name, name)) 1761 break; 1762 if (k < 0) { 1763 /* For fonts "ISO10646-1" means ucs2, not utf8.*/ 1764 if (!strcmp("ISO10646-1", name)) { 1765 preferred[num++] = &all_charsets[ucs2_conv_index]; 1766 continue; 1767 } 1768 /* Look it up in all_charsets[]. */ 1769 for (k = 0; k < all_charsets_count-1; k++) 1770 if (!strcmp(all_charsets[k].name, name)) { 1771 /* Add it to the preferred set. */ 1772 preferred[num++] = &all_charsets[k]; 1773 break; 1774 } 1775 } 1776 } 1777 } 1778 preferred[num] = (Utf8Conv) NULL; 1779 1780 conv->methods = methods; 1781 conv->state = (XPointer) preferred; 1782 1783 return conv; 1784 } 1785 1786 static XlcConv 1787 open_wcstofcs( 1788 XLCd from_lcd, 1789 const char *from_type, 1790 XLCd to_lcd, 1791 const char *to_type) 1792 { 1793 return create_tofontcs_conv(from_lcd, &methods_wcstocs); 1794 } 1795 1796 static XlcConv 1797 open_utf8tofcs( 1798 XLCd from_lcd, 1799 const char *from_type, 1800 XLCd to_lcd, 1801 const char *to_type) 1802 { 1803 return create_tofontcs_conv(from_lcd, &methods_utf8tocs); 1804 } 1805 1806 /* ========================== iconv Stuff ================================ */ 1807 1808 /* from XlcNCharSet to XlcNMultiByte */ 1809 1810 static int 1811 iconv_cstombs(XlcConv conv, XPointer *from, int *from_left, 1812 XPointer *to, int *to_left, XPointer *args, int num_args) 1813 { 1814 XlcCharSet charset; 1815 char const *name; 1816 Utf8Conv convptr; 1817 int i; 1818 unsigned char const *src; 1819 unsigned char const *srcend; 1820 unsigned char *dst; 1821 unsigned char *dstend; 1822 int unconv_num; 1823 1824 if (from == NULL || *from == NULL) 1825 return 0; 1826 1827 if (num_args < 1) 1828 return -1; 1829 1830 charset = (XlcCharSet) args[0]; 1831 name = charset->encoding_name; 1832 /* not charset->name because the latter has a ":GL"/":GR" suffix */ 1833 1834 for (convptr = all_charsets, i = all_charsets_count-1; i > 0; convptr++, i--) 1835 if (!strcmp(convptr->name, name)) 1836 break; 1837 if (i == 0) 1838 return -1; 1839 1840 src = (unsigned char const *) *from; 1841 srcend = src + *from_left; 1842 dst = (unsigned char *) *to; 1843 dstend = dst + *to_left; 1844 unconv_num = 0; 1845 1846 while (src < srcend) { 1847 ucs4_t wc; 1848 int consumed; 1849 int count; 1850 1851 consumed = convptr->cstowc(conv, &wc, src, srcend-src); 1852 if (consumed == RET_ILSEQ) 1853 return -1; 1854 if (consumed == RET_TOOFEW(0)) 1855 break; 1856 1857 /* Use stdc iconv to convert widechar -> multibyte */ 1858 1859 count = wctomb((char *)dst, wc); 1860 if (count == 0) 1861 break; 1862 if (count == -1) { 1863 count = wctomb((char *)dst, BAD_WCHAR); 1864 if (count == 0) 1865 break; 1866 unconv_num++; 1867 } 1868 src += consumed; 1869 dst += count; 1870 } 1871 1872 *from = (XPointer) src; 1873 *from_left = srcend - src; 1874 *to = (XPointer) dst; 1875 *to_left = dstend - dst; 1876 1877 return unconv_num; 1878 1879 } 1880 1881 static XlcConvMethodsRec iconv_cstombs_methods = { 1882 close_converter, 1883 iconv_cstombs, 1884 NULL 1885 }; 1886 1887 static XlcConv 1888 open_iconv_cstombs(XLCd from_lcd, const char *from_type, XLCd to_lcd, const char *to_type) 1889 { 1890 lazy_init_all_charsets(); 1891 return create_conv(from_lcd, &iconv_cstombs_methods); 1892 } 1893 1894 static int 1895 iconv_mbstocs(XlcConv conv, XPointer *from, int *from_left, 1896 XPointer *to, int *to_left, XPointer *args, int num_args) 1897 { 1898 Utf8Conv *preferred_charsets; 1899 XlcCharSet last_charset = NULL; 1900 unsigned char const *src; 1901 unsigned char const *srcend; 1902 unsigned char *dst; 1903 unsigned char *dstend; 1904 int unconv_num; 1905 1906 if (from == NULL || *from == NULL) 1907 return 0; 1908 1909 preferred_charsets = (Utf8Conv *) conv->state; 1910 src = (unsigned char const *) *from; 1911 srcend = src + *from_left; 1912 dst = (unsigned char *) *to; 1913 dstend = dst + *to_left; 1914 unconv_num = 0; 1915 1916 while (src < srcend && dst < dstend) { 1917 Utf8Conv chosen_charset = NULL; 1918 XlcSide chosen_side = XlcNONE; 1919 wchar_t wc; 1920 int consumed; 1921 int count; 1922 1923 /* Uses stdc iconv to convert multibyte -> widechar */ 1924 1925 consumed = mbtowc(&wc, (const char *)src, (size_t) (srcend - src)); 1926 if (consumed == 0) 1927 break; 1928 if (consumed == -1) { 1929 src++; 1930 unconv_num++; 1931 continue; 1932 } 1933 1934 count = charset_wctocs(preferred_charsets, &chosen_charset, &chosen_side, conv, dst, wc, dstend-dst); 1935 1936 if (count == RET_TOOSMALL) 1937 break; 1938 if (count == RET_ILSEQ) { 1939 src += consumed; 1940 unconv_num++; 1941 continue; 1942 } 1943 1944 if (last_charset == NULL) { 1945 last_charset = 1946 _XlcGetCharSetWithSide(chosen_charset->name, chosen_side); 1947 if (last_charset == NULL) { 1948 src += consumed; 1949 unconv_num++; 1950 continue; 1951 } 1952 } else { 1953 if (!(last_charset->xrm_encoding_name == chosen_charset->xrm_name 1954 && (last_charset->side == XlcGLGR 1955 || last_charset->side == chosen_side))) 1956 break; 1957 } 1958 src += consumed; 1959 dst += count; 1960 } 1961 1962 if (last_charset == NULL) 1963 return -1; 1964 1965 *from = (XPointer) src; 1966 *from_left = srcend - src; 1967 *to = (XPointer) dst; 1968 *to_left = dstend - dst; 1969 1970 if (num_args >= 1) 1971 *((XlcCharSet *)args[0]) = last_charset; 1972 1973 return unconv_num; 1974 } 1975 1976 static XlcConvMethodsRec iconv_mbstocs_methods = { 1977 close_tocs_converter, 1978 iconv_mbstocs, 1979 NULL 1980 }; 1981 1982 static XlcConv 1983 open_iconv_mbstocs(XLCd from_lcd, const char *from_type, XLCd to_lcd, const char *to_type) 1984 { 1985 return create_tocs_conv(from_lcd, &iconv_mbstocs_methods); 1986 } 1987 1988 /* from XlcNMultiByte to XlcNChar */ 1989 1990 static int 1991 iconv_mbtocs(XlcConv conv, XPointer *from, int *from_left, 1992 XPointer *to, int *to_left, XPointer *args, int num_args) 1993 { 1994 Utf8Conv *preferred_charsets; 1995 XlcCharSet last_charset = NULL; 1996 unsigned char const *src; 1997 unsigned char const *srcend; 1998 unsigned char *dst; 1999 unsigned char *dstend; 2000 int unconv_num; 2001 2002 if (from == NULL || *from == NULL) 2003 return 0; 2004 2005 preferred_charsets = (Utf8Conv *) conv->state; 2006 src = (unsigned char const *) *from; 2007 srcend = src + *from_left; 2008 dst = (unsigned char *) *to; 2009 dstend = dst + *to_left; 2010 unconv_num = 0; 2011 2012 while (src < srcend && dst < dstend) { 2013 Utf8Conv chosen_charset = NULL; 2014 XlcSide chosen_side = XlcNONE; 2015 wchar_t wc; 2016 int consumed; 2017 int count; 2018 2019 /* Uses stdc iconv to convert multibyte -> widechar */ 2020 2021 consumed = mbtowc(&wc, (const char *)src, (size_t) (srcend - src)); 2022 if (consumed == 0) 2023 break; 2024 if (consumed == -1) { 2025 src++; 2026 unconv_num++; 2027 continue; 2028 } 2029 2030 count = charset_wctocs(preferred_charsets, &chosen_charset, &chosen_side, conv, dst, wc, dstend-dst); 2031 if (count == RET_TOOSMALL) 2032 break; 2033 if (count == RET_ILSEQ) { 2034 src += consumed; 2035 unconv_num++; 2036 continue; 2037 } 2038 2039 if (last_charset == NULL) { 2040 last_charset = 2041 _XlcGetCharSetWithSide(chosen_charset->name, chosen_side); 2042 if (last_charset == NULL) { 2043 src += consumed; 2044 unconv_num++; 2045 continue; 2046 } 2047 } else { 2048 if (!(last_charset->xrm_encoding_name == chosen_charset->xrm_name 2049 && (last_charset->side == XlcGLGR 2050 || last_charset->side == chosen_side))) 2051 break; 2052 } 2053 src += consumed; 2054 dst += count; 2055 } 2056 2057 if (last_charset == NULL) 2058 return -1; 2059 2060 *from = (XPointer) src; 2061 *from_left = srcend - src; 2062 *to = (XPointer) dst; 2063 *to_left = dstend - dst; 2064 2065 if (num_args >= 1) 2066 *((XlcCharSet *)args[0]) = last_charset; 2067 2068 return unconv_num; 2069 } 2070 2071 static XlcConvMethodsRec iconv_mbtocs_methods = { 2072 close_tocs_converter, 2073 iconv_mbtocs, 2074 NULL 2075 }; 2076 2077 static XlcConv 2078 open_iconv_mbtocs(XLCd from_lcd, const char *from_type, XLCd to_lcd, const char *to_type) 2079 { 2080 return create_tocs_conv(from_lcd, &iconv_mbtocs_methods ); 2081 } 2082 2083 /* from XlcNMultiByte to XlcNString */ 2084 2085 static int 2086 iconv_mbstostr(XlcConv conv, XPointer *from, int *from_left, 2087 XPointer *to, int *to_left, XPointer *args, int num_args) 2088 { 2089 unsigned char const *src; 2090 unsigned char const *srcend; 2091 unsigned char *dst; 2092 unsigned char *dstend; 2093 int unconv_num; 2094 2095 if (from == NULL || *from == NULL) 2096 return 0; 2097 2098 src = (unsigned char const *) *from; 2099 srcend = src + *from_left; 2100 dst = (unsigned char *) *to; 2101 dstend = dst + *to_left; 2102 unconv_num = 0; 2103 2104 while (src < srcend) { 2105 unsigned char c; 2106 wchar_t wc; 2107 int consumed; 2108 2109 /* Uses stdc iconv to convert multibyte -> widechar */ 2110 2111 consumed = mbtowc(&wc, (const char *)src, (size_t) (srcend - src)); 2112 if (consumed == 0) 2113 break; 2114 if (dst == dstend) 2115 break; 2116 if (consumed == -1) { 2117 consumed = 1; 2118 c = BAD_CHAR; 2119 unconv_num++; 2120 } else { 2121 if ((wc & ~(wchar_t)0xff) != 0) { 2122 c = BAD_CHAR; 2123 unconv_num++; 2124 } else 2125 c = (unsigned char) wc; 2126 } 2127 *dst++ = c; 2128 src += consumed; 2129 } 2130 2131 *from = (XPointer) src; 2132 *from_left = srcend - src; 2133 *to = (XPointer) dst; 2134 *to_left = dstend - dst; 2135 2136 return unconv_num; 2137 } 2138 2139 static XlcConvMethodsRec iconv_mbstostr_methods = { 2140 close_converter, 2141 iconv_mbstostr, 2142 NULL 2143 }; 2144 2145 static XlcConv 2146 open_iconv_mbstostr(XLCd from_lcd, const char *from_type, XLCd to_lcd, const char *to_type) 2147 { 2148 return create_conv(from_lcd, &iconv_mbstostr_methods); 2149 } 2150 2151 /* from XlcNString to XlcNMultiByte */ 2152 static int 2153 iconv_strtombs(XlcConv conv, XPointer *from, int *from_left, 2154 XPointer *to, int *to_left, XPointer *args, int num_args) 2155 { 2156 unsigned char const *src; 2157 unsigned char const *srcend; 2158 unsigned char *dst; 2159 unsigned char *dstend; 2160 2161 if (from == NULL || *from == NULL) 2162 return 0; 2163 2164 src = (unsigned char const *) *from; 2165 srcend = src + *from_left; 2166 dst = (unsigned char *) *to; 2167 dstend = dst + *to_left; 2168 2169 while (src < srcend) { 2170 int count = wctomb((char *)dst, *src); 2171 if (count < 0) 2172 break; 2173 dst += count; 2174 src++; 2175 } 2176 2177 *from = (XPointer) src; 2178 *from_left = srcend - src; 2179 *to = (XPointer) dst; 2180 *to_left = dstend - dst; 2181 2182 return 0; 2183 } 2184 2185 static XlcConvMethodsRec iconv_strtombs_methods= { 2186 close_converter, 2187 iconv_strtombs, 2188 NULL 2189 }; 2190 2191 static XlcConv 2192 open_iconv_strtombs(XLCd from_lcd, const char *from_type, XLCd to_lcd, const char *to_type) 2193 { 2194 return create_conv(from_lcd, &iconv_strtombs_methods); 2195 } 2196 2197 /***************************************************************************/ 2198 /* Part II: An iconv locale loader. 2199 * 2200 *Here we can assume that "multi-byte" is iconv and that `wchar_t' is Unicode. 2201 */ 2202 2203 /* from XlcNMultiByte to XlcNWideChar */ 2204 static int 2205 iconv_mbstowcs(XlcConv conv, XPointer *from, int *from_left, 2206 XPointer *to, int *to_left, XPointer *args, int num_args) 2207 { 2208 char *src = *((char **) from); 2209 wchar_t *dst = *((wchar_t **) to); 2210 int src_left = *from_left; 2211 int dst_left = *to_left; 2212 int length, unconv_num = 0; 2213 2214 while (src_left > 0 && dst_left > 0) { 2215 length = mbtowc(dst, src, (size_t) src_left); 2216 2217 if (length > 0) { 2218 src += length; 2219 src_left -= length; 2220 if (dst) 2221 dst++; 2222 dst_left--; 2223 } else if (length < 0) { 2224 src++; 2225 src_left--; 2226 unconv_num++; 2227 } else { 2228 /* null ? */ 2229 src++; 2230 src_left--; 2231 if (dst) 2232 *dst++ = L'\0'; 2233 dst_left--; 2234 } 2235 } 2236 2237 *from = (XPointer) src; 2238 if (dst) 2239 *to = (XPointer) dst; 2240 *from_left = src_left; 2241 *to_left = dst_left; 2242 2243 return unconv_num; 2244 } 2245 2246 static XlcConvMethodsRec iconv_mbstowcs_methods = { 2247 close_converter, 2248 iconv_mbstowcs, 2249 NULL 2250 } ; 2251 2252 static XlcConv 2253 open_iconv_mbstowcs(XLCd from_lcd, const char *from_type, XLCd to_lcd, const char *to_type) 2254 { 2255 return create_conv(from_lcd, &iconv_mbstowcs_methods); 2256 } 2257 2258 static int 2259 iconv_wcstombs(XlcConv conv, XPointer *from, int *from_left, 2260 XPointer *to, int *to_left, XPointer *args, int num_args) 2261 { 2262 wchar_t *src = *((wchar_t **) from); 2263 char *dst = *((char **) to); 2264 int src_left = *from_left; 2265 int dst_left = *to_left; 2266 int length, unconv_num = 0; 2267 2268 while (src_left > 0 && dst_left >= MB_CUR_MAX) { 2269 length = wctomb(dst, *src); /* XXX */ 2270 2271 if (length > 0) { 2272 src++; 2273 src_left--; 2274 if (dst) 2275 dst += length; 2276 dst_left -= length; 2277 } else if (length < 0) { 2278 src++; 2279 src_left--; 2280 unconv_num++; 2281 } 2282 } 2283 2284 *from = (XPointer) src; 2285 if (dst) 2286 *to = (XPointer) dst; 2287 *from_left = src_left; 2288 *to_left = dst_left; 2289 2290 return unconv_num; 2291 } 2292 2293 static XlcConvMethodsRec iconv_wcstombs_methods = { 2294 close_converter, 2295 iconv_wcstombs, 2296 NULL 2297 } ; 2298 2299 static XlcConv 2300 open_iconv_wcstombs(XLCd from_lcd, const char *from_type, XLCd to_lcd, const char *to_type) 2301 { 2302 return create_conv(from_lcd, &iconv_wcstombs_methods); 2303 } 2304 2305 static XlcConv 2306 open_iconv_mbstofcs( 2307 XLCd from_lcd, 2308 const char *from_type, 2309 XLCd to_lcd, 2310 const char *to_type) 2311 { 2312 return create_tofontcs_conv(from_lcd, &iconv_mbstocs_methods); 2313 } 2314 2315 /* Registers UTF-8 converters for a UTF-8 locale. */ 2316 2317 void 2318 _XlcAddUtf8LocaleConverters( 2319 XLCd lcd) 2320 { 2321 /* Register elementary converters. */ 2322 2323 _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNWideChar, open_utf8towcs); 2324 2325 _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNMultiByte, open_wcstoutf8); 2326 _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNString, open_wcstostr); 2327 2328 _XlcSetConverter(lcd, XlcNString, lcd, XlcNWideChar, open_strtowcs); 2329 2330 /* Register converters for XlcNCharSet. This implicitly provides 2331 * converters from and to XlcNCompoundText. */ 2332 2333 _XlcSetConverter(lcd, XlcNCharSet, lcd, XlcNMultiByte, open_cstoutf8); 2334 _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNCharSet, open_utf8tocs); 2335 _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNChar, open_utf8tocs1); 2336 2337 _XlcSetConverter(lcd, XlcNCharSet, lcd, XlcNWideChar, open_cstowcs); 2338 _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNCharSet, open_wcstocs); 2339 _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNChar, open_wcstocs1); 2340 2341 _XlcSetConverter(lcd, XlcNString, lcd, XlcNMultiByte, open_strtoutf8); 2342 _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNString, open_utf8tostr); 2343 _XlcSetConverter(lcd, XlcNUtf8String, lcd, XlcNMultiByte, open_identity); 2344 _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNUtf8String, open_identity); 2345 2346 /* Register converters for XlcNFontCharSet */ 2347 _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNFontCharSet, open_utf8tofcs); 2348 _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNFontCharSet, open_wcstofcs); 2349 _XlcSetConverter(lcd, XlcNUtf8String, lcd, XlcNFontCharSet, open_utf8tofcs); 2350 } 2351 2352 void 2353 _XlcAddGB18030LocaleConverters( 2354 XLCd lcd) 2355 { 2356 2357 /* Register elementary converters. */ 2358 _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNWideChar, open_iconv_mbstowcs); 2359 _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNMultiByte, open_iconv_wcstombs); 2360 2361 /* Register converters for XlcNCharSet. This implicitly provides 2362 * converters from and to XlcNCompoundText. */ 2363 2364 _XlcSetConverter(lcd, XlcNCharSet, lcd, XlcNMultiByte, open_iconv_cstombs); 2365 _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNCharSet, open_iconv_mbstocs); 2366 _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNChar, open_iconv_mbtocs); 2367 _XlcSetConverter(lcd, XlcNString, lcd, XlcNMultiByte, open_iconv_strtombs); 2368 _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNString, open_iconv_mbstostr); 2369 2370 /* Register converters for XlcNFontCharSet */ 2371 _XlcSetConverter(lcd, XlcNMultiByte, lcd, XlcNFontCharSet, open_iconv_mbstofcs); 2372 2373 _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNString, open_wcstostr); 2374 _XlcSetConverter(lcd, XlcNString, lcd, XlcNWideChar, open_strtowcs); 2375 _XlcSetConverter(lcd, XlcNCharSet, lcd, XlcNWideChar, open_cstowcs); 2376 _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNCharSet, open_wcstocs); 2377 _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNChar, open_wcstocs1); 2378 2379 /* Register converters for XlcNFontCharSet */ 2380 _XlcSetConverter(lcd, XlcNWideChar, lcd, XlcNFontCharSet, open_wcstofcs); 2381 } 2382
Indexes created Thu Aug 20 00:25:57 UTC 2026