1 /* 2 * Copyright (C) 1999-2007 Free Software Foundation, Inc. 3 * This file is part of the GNU LIBICONV Library. 4 * 5 * The GNU LIBICONV Library is free software; you can redistribute it 6 * and/or modify it under the terms of the GNU Library General Public 7 * License as published by the Free Software Foundation; either version 2 8 * of the License, or (at your option) any later version. 9 * 10 * The GNU LIBICONV Library is distributed in the hope that it will be 11 * useful, but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * Library General Public License for more details. 14 * 15 * You should have received a copy of the GNU Library General Public 16 * License along with the GNU LIBICONV Library; see the file COPYING.LIB. 17 * If not, write to the Free Software Foundation, Inc., 51 Franklin Street, 18 * Fifth Floor, Boston, MA 02110-1301, USA. 19 */ 20 21 #include "iconv.h" 22 23 #include <stdlib.h> 24 #include <string.h> 25 #include "config.h" 26 #include "localcharset.h" 27 28 #if ENABLE_EXTRA 29 /* 30 * Consider all system dependent encodings, for any system, 31 * and the extra encodings. 32 */ 33 #define USE_AIX 34 #define USE_OSF1 35 #define USE_DOS 36 #define USE_EXTRA 37 #else 38 /* 39 * Consider those system dependent encodings that are needed for the 40 * current system. 41 */ 42 #ifdef _AIX 43 #define USE_AIX 44 #endif 45 #if defined(__osf__) || defined(VMS) 46 #define USE_OSF1 47 #endif 48 #if defined(__DJGPP__) || (defined(_WIN32) && (defined(_MSC_VER) || defined(__MINGW32__))) 49 #define USE_DOS 50 #endif 51 #endif 52 53 /* 54 * Data type for general conversion loop. 55 */ 56 struct loop_funcs { 57 size_t (*loop_convert) (iconv_t icd, 58 const char* * inbuf, size_t *inbytesleft, 59 char* * outbuf, size_t *outbytesleft); 60 size_t (*loop_reset) (iconv_t icd, 61 char* * outbuf, size_t *outbytesleft); 62 }; 63 64 /* 65 * Converters. 66 */ 67 #include "converters.h" 68 69 /* 70 * Transliteration tables. 71 */ 72 #include "cjk_variants.h" 73 #include "translit.h" 74 75 /* 76 * Table of all supported encodings. 77 */ 78 struct encoding { 79 struct mbtowc_funcs ifuncs; /* conversion multibyte -> unicode */ 80 struct wctomb_funcs ofuncs; /* conversion unicode -> multibyte */ 81 int oflags; /* flags for unicode -> multibyte conversion */ 82 }; 83 enum { 84 #define DEFENCODING(xxx_names,xxx,xxx_ifuncs1,xxx_ifuncs2,xxx_ofuncs1,xxx_ofuncs2) \ 85 ei_##xxx , 86 #include "encodings.def" 87 #ifdef USE_AIX 88 #include "encodings_aix.def" 89 #endif 90 #ifdef USE_OSF1 91 #include "encodings_osf1.def" 92 #endif 93 #ifdef USE_DOS 94 #include "encodings_dos.def" 95 #endif 96 #ifdef USE_EXTRA 97 #include "encodings_extra.def" 98 #endif 99 #include "encodings_local.def" 100 #undef DEFENCODING 101 ei_for_broken_compilers_that_dont_like_trailing_commas 102 }; 103 #include "flags.h" 104 static struct encoding const all_encodings[] = { 105 #define DEFENCODING(xxx_names,xxx,xxx_ifuncs1,xxx_ifuncs2,xxx_ofuncs1,xxx_ofuncs2) \ 106 { xxx_ifuncs1,xxx_ifuncs2, xxx_ofuncs1,xxx_ofuncs2, ei_##xxx##_oflags }, 107 #include "encodings.def" 108 #ifdef USE_AIX 109 #include "encodings_aix.def" 110 #endif 111 #ifdef USE_OSF1 112 #include "encodings_osf1.def" 113 #endif 114 #ifdef USE_DOS 115 #include "encodings_dos.def" 116 #endif 117 #ifdef USE_EXTRA 118 #include "encodings_extra.def" 119 #endif 120 #undef DEFENCODING 121 #define DEFENCODING(xxx_names,xxx,xxx_ifuncs1,xxx_ifuncs2,xxx_ofuncs1,xxx_ofuncs2) \ 122 { xxx_ifuncs1,xxx_ifuncs2, xxx_ofuncs1,xxx_ofuncs2, 0 }, 123 #include "encodings_local.def" 124 #undef DEFENCODING 125 }; 126 127 /* 128 * Conversion loops. 129 */ 130 #include "loops.h" 131 132 /* 133 * Alias lookup function. 134 * Defines 135 * struct alias { int name; unsigned int encoding_index; }; 136 * const struct alias * aliases_lookup (const char *str, unsigned int len); 137 * #define MAX_WORD_LENGTH ... 138 */ 139 #include "aliases.h" 140 141 /* 142 * System dependent alias lookup function. 143 * Defines 144 * const struct alias * aliases2_lookup (const char *str); 145 */ 146 #if defined(USE_AIX) || defined(USE_OSF1) || defined(USE_DOS) || defined(USE_EXTRA) /* || ... */ 147 struct stringpool2_t { 148 #define S(tag,name,encoding_index) char stringpool_##tag[sizeof(name)]; 149 #include "aliases2.h" 150 #undef S 151 }; 152 static const struct stringpool2_t stringpool2_contents = { 153 #define S(tag,name,encoding_index) name, 154 #include "aliases2.h" 155 #undef S 156 }; 157 #define stringpool2 ((const char *) &stringpool2_contents) 158 static const struct alias sysdep_aliases[] = { 159 #define S(tag,name,encoding_index) { (int)(long)&((struct stringpool2_t *)0)->stringpool_##tag, encoding_index }, 160 #include "aliases2.h" 161 #undef S 162 }; 163 #ifdef __GNUC__ 164 __inline 165 #endif 166 const struct alias * 167 aliases2_lookup (register const char *str) 168 { 169 const struct alias * ptr; 170 unsigned int count; 171 for (ptr = sysdep_aliases, count = sizeof(sysdep_aliases)/sizeof(sysdep_aliases[0]); count > 0; ptr++, count--) 172 if (!strcmp(str, stringpool2 + ptr->name)) 173 return ptr; 174 return NULL; 175 } 176 #else 177 #define aliases2_lookup(str) NULL 178 #define stringpool2 NULL 179 #endif 180 181 #if 0 182 /* Like !strcasecmp, except that the both strings can be assumed to be ASCII 183 and the first string can be assumed to be in uppercase. */ 184 static int strequal (const char* str1, const char* str2) 185 { 186 unsigned char c1; 187 unsigned char c2; 188 for (;;) { 189 c1 = * (unsigned char *) str1++; 190 c2 = * (unsigned char *) str2++; 191 if (c1 == 0) 192 break; 193 if (c2 >= 'a' && c2 <= 'z') 194 c2 -= 'a'-'A'; 195 if (c1 != c2) 196 break; 197 } 198 return (c1 == c2); 199 } 200 #endif 201 202 iconv_t iconv_open (const char* tocode, const char* fromcode) 203 { 204 struct conv_struct * cd; 205 char buf[MAX_WORD_LENGTH+10+1]; 206 const char* cp; 207 char* bp; 208 const struct alias * ap; 209 unsigned int count; 210 unsigned int from_index; 211 int from_wchar; 212 unsigned int to_index; 213 int to_wchar; 214 int transliterate = 0; 215 int discard_ilseq = 0; 216 217 /* Before calling aliases_lookup, convert the input string to upper case, 218 * and check whether it's entirely ASCII (we call gperf with option "-7" 219 * to achieve a smaller table) and non-empty. If it's not entirely ASCII, 220 * or if it's too long, it is not a valid encoding name. 221 */ 222 for (to_wchar = 0;;) { 223 /* Search tocode in the table. */ 224 for (cp = tocode, bp = buf, count = MAX_WORD_LENGTH+10+1; ; cp++, bp++) { 225 unsigned char c = * (unsigned char *) cp; 226 if (c >= 0x80) 227 goto invalid; 228 if (c >= 'a' && c <= 'z') 229 c -= 'a'-'A'; 230 *bp = c; 231 if (c == '\0') 232 break; 233 if (--count == 0) 234 goto invalid; 235 } 236 for (;;) { 237 if (bp-buf >= 10 && memcmp(bp-10,"//TRANSLIT",10)==0) { 238 bp -= 10; 239 *bp = '\0'; 240 transliterate = 1; 241 continue; 242 } 243 if (bp-buf >= 8 && memcmp(bp-8,"//IGNORE",8)==0) { 244 bp -= 8; 245 *bp = '\0'; 246 discard_ilseq = 1; 247 continue; 248 } 249 break; 250 } 251 if (buf[0] == '\0') { 252 tocode = locale_charset(); 253 /* Avoid an endless loop that could occur when using an older version 254 of localcharset.c. */ 255 if (tocode[0] == '\0') 256 goto invalid; 257 continue; 258 } 259 ap = aliases_lookup(buf,bp-buf); 260 if (ap == NULL) { 261 ap = aliases2_lookup(buf); 262 if (ap == NULL) 263 goto invalid; 264 } 265 if (ap->encoding_index == ei_local_char) { 266 tocode = locale_charset(); 267 /* Avoid an endless loop that could occur when using an older version 268 of localcharset.c. */ 269 if (tocode[0] == '\0') 270 goto invalid; 271 continue; 272 } 273 if (ap->encoding_index == ei_local_wchar_t) { 274 /* On systems which define __STDC_ISO_10646__, wchar_t is Unicode. 275 This is also the case on native Woe32 systems. */ 276 #if __STDC_ISO_10646__ || ((defined _WIN32 || defined __WIN32__) && !defined __CYGWIN__) 277 if (sizeof(wchar_t) == 4) { 278 to_index = ei_ucs4internal; 279 break; 280 } 281 if (sizeof(wchar_t) == 2) { 282 to_index = ei_ucs2internal; 283 break; 284 } 285 if (sizeof(wchar_t) == 1) { 286 to_index = ei_iso8859_1; 287 break; 288 } 289 #endif 290 #if HAVE_MBRTOWC 291 to_wchar = 1; 292 tocode = locale_charset(); 293 continue; 294 #endif 295 goto invalid; 296 } 297 to_index = ap->encoding_index; 298 break; 299 } 300 for (from_wchar = 0;;) { 301 /* Search fromcode in the table. */ 302 for (cp = fromcode, bp = buf, count = MAX_WORD_LENGTH+10+1; ; cp++, bp++) { 303 unsigned char c = * (unsigned char *) cp; 304 if (c >= 0x80) 305 goto invalid; 306 if (c >= 'a' && c <= 'z') 307 c -= 'a'-'A'; 308 *bp = c; 309 if (c == '\0') 310 break; 311 if (--count == 0) 312 goto invalid; 313 } 314 for (;;) { 315 if (bp-buf >= 10 && memcmp(bp-10,"//TRANSLIT",10)==0) { 316 bp -= 10; 317 *bp = '\0'; 318 continue; 319 } 320 if (bp-buf >= 8 && memcmp(bp-8,"//IGNORE",8)==0) { 321 bp -= 8; 322 *bp = '\0'; 323 continue; 324 } 325 break; 326 } 327 if (buf[0] == '\0') { 328 fromcode = locale_charset(); 329 /* Avoid an endless loop that could occur when using an older version 330 of localcharset.c. */ 331 if (fromcode[0] == '\0') 332 goto invalid; 333 continue; 334 } 335 ap = aliases_lookup(buf,bp-buf); 336 if (ap == NULL) { 337 ap = aliases2_lookup(buf); 338 if (ap == NULL) 339 goto invalid; 340 } 341 if (ap->encoding_index == ei_local_char) { 342 fromcode = locale_charset(); 343 /* Avoid an endless loop that could occur when using an older version 344 of localcharset.c. */ 345 if (fromcode[0] == '\0') 346 goto invalid; 347 continue; 348 } 349 if (ap->encoding_index == ei_local_wchar_t) { 350 /* On systems which define __STDC_ISO_10646__, wchar_t is Unicode. 351 This is also the case on native Woe32 systems. */ 352 #if __STDC_ISO_10646__ || ((defined _WIN32 || defined __WIN32__) && !defined __CYGWIN__) 353 if (sizeof(wchar_t) == 4) { 354 from_index = ei_ucs4internal; 355 break; 356 } 357 if (sizeof(wchar_t) == 2) { 358 from_index = ei_ucs2internal; 359 break; 360 } 361 if (sizeof(wchar_t) == 1) { 362 from_index = ei_iso8859_1; 363 break; 364 } 365 #endif 366 #if HAVE_WCRTOMB 367 from_wchar = 1; 368 fromcode = locale_charset(); 369 continue; 370 #endif 371 goto invalid; 372 } 373 from_index = ap->encoding_index; 374 break; 375 } 376 cd = (struct conv_struct *) malloc(from_wchar != to_wchar 377 ? sizeof(struct wchar_conv_struct) 378 : sizeof(struct conv_struct)); 379 if (cd == NULL) { 380 errno = ENOMEM; 381 return (iconv_t)(-1); 382 } 383 cd->iindex = from_index; 384 cd->ifuncs = all_encodings[from_index].ifuncs; 385 cd->oindex = to_index; 386 cd->ofuncs = all_encodings[to_index].ofuncs; 387 cd->oflags = all_encodings[to_index].oflags; 388 /* Initialize the loop functions. */ 389 #if HAVE_MBRTOWC 390 if (to_wchar) { 391 #if HAVE_WCRTOMB 392 if (from_wchar) { 393 cd->lfuncs.loop_convert = wchar_id_loop_convert; 394 cd->lfuncs.loop_reset = wchar_id_loop_reset; 395 } else 396 #endif 397 { 398 cd->lfuncs.loop_convert = wchar_to_loop_convert; 399 cd->lfuncs.loop_reset = wchar_to_loop_reset; 400 } 401 } else 402 #endif 403 { 404 #if HAVE_WCRTOMB 405 if (from_wchar) { 406 cd->lfuncs.loop_convert = wchar_from_loop_convert; 407 cd->lfuncs.loop_reset = wchar_from_loop_reset; 408 } else 409 #endif 410 { 411 cd->lfuncs.loop_convert = unicode_loop_convert; 412 cd->lfuncs.loop_reset = unicode_loop_reset; 413 } 414 } 415 /* Initialize the states. */ 416 memset(&cd->istate,'\0',sizeof(state_t)); 417 memset(&cd->ostate,'\0',sizeof(state_t)); 418 /* Initialize the operation flags. */ 419 cd->transliterate = transliterate; 420 cd->discard_ilseq = discard_ilseq; 421 #ifndef LIBICONV_PLUG 422 cd->fallbacks.mb_to_uc_fallback = NULL; 423 cd->fallbacks.uc_to_mb_fallback = NULL; 424 cd->fallbacks.mb_to_wc_fallback = NULL; 425 cd->fallbacks.wc_to_mb_fallback = NULL; 426 cd->fallbacks.data = NULL; 427 cd->hooks.uc_hook = NULL; 428 cd->hooks.wc_hook = NULL; 429 cd->hooks.data = NULL; 430 #endif 431 /* Initialize additional fields. */ 432 if (from_wchar != to_wchar) { 433 struct wchar_conv_struct * wcd = (struct wchar_conv_struct *) cd; 434 memset(&wcd->state,'\0',sizeof(mbstate_t)); 435 } 436 /* Done. */ 437 return (iconv_t)cd; 438 invalid: 439 errno = EINVAL; 440 return (iconv_t)(-1); 441 } 442 443 size_t iconv (iconv_t icd, 444 ICONV_CONST char* * inbuf, size_t *inbytesleft, 445 char* * outbuf, size_t *outbytesleft) 446 { 447 conv_t cd = (conv_t) icd; 448 if (inbuf == NULL || *inbuf == NULL) 449 return cd->lfuncs.loop_reset(icd,outbuf,outbytesleft); 450 else 451 return cd->lfuncs.loop_convert(icd, 452 (const char* *)inbuf,inbytesleft, 453 outbuf,outbytesleft); 454 } 455 456 int iconv_close (iconv_t icd) 457 { 458 conv_t cd = (conv_t) icd; 459 free(cd); 460 return 0; 461 } 462 463 #ifndef LIBICONV_PLUG 464 465 int iconvctl (iconv_t icd, int request, void* argument) 466 { 467 conv_t cd = (conv_t) icd; 468 switch (request) { 469 case ICONV_TRIVIALP: 470 *(int *)argument = 471 ((cd->lfuncs.loop_convert == unicode_loop_convert 472 && cd->iindex == cd->oindex) 473 || cd->lfuncs.loop_convert == wchar_id_loop_convert 474 ? 1 : 0); 475 return 0; 476 case ICONV_GET_TRANSLITERATE: 477 *(int *)argument = cd->transliterate; 478 return 0; 479 case ICONV_SET_TRANSLITERATE: 480 cd->transliterate = (*(const int *)argument ? 1 : 0); 481 return 0; 482 case ICONV_GET_DISCARD_ILSEQ: 483 *(int *)argument = cd->discard_ilseq; 484 return 0; 485 case ICONV_SET_DISCARD_ILSEQ: 486 cd->discard_ilseq = (*(const int *)argument ? 1 : 0); 487 return 0; 488 case ICONV_SET_HOOKS: 489 if (argument != NULL) { 490 cd->hooks = *(const struct iconv_hooks *)argument; 491 } else { 492 cd->hooks.uc_hook = NULL; 493 cd->hooks.wc_hook = NULL; 494 cd->hooks.data = NULL; 495 } 496 return 0; 497 case ICONV_SET_FALLBACKS: 498 if (argument != NULL) { 499 cd->fallbacks = *(const struct iconv_fallbacks *)argument; 500 } else { 501 cd->fallbacks.mb_to_uc_fallback = NULL; 502 cd->fallbacks.uc_to_mb_fallback = NULL; 503 cd->fallbacks.mb_to_wc_fallback = NULL; 504 cd->fallbacks.wc_to_mb_fallback = NULL; 505 cd->fallbacks.data = NULL; 506 } 507 return 0; 508 default: 509 errno = EINVAL; 510 return -1; 511 } 512 } 513 514 /* An alias after its name has been converted from 'int' to 'const char*'. */ 515 struct nalias { const char* name; unsigned int encoding_index; }; 516 517 static int compare_by_index (const void * arg1, const void * arg2) 518 { 519 const struct nalias * alias1 = (const struct nalias *) arg1; 520 const struct nalias * alias2 = (const struct nalias *) arg2; 521 return (int)alias1->encoding_index - (int)alias2->encoding_index; 522 } 523 524 static int compare_by_name (const void * arg1, const void * arg2) 525 { 526 const char * name1 = *(const char **)arg1; 527 const char * name2 = *(const char **)arg2; 528 /* Compare alphabetically, but put "CS" names at the end. */ 529 int sign = strcmp(name1,name2); 530 if (sign != 0) { 531 sign = ((name1[0]=='C' && name1[1]=='S') - (name2[0]=='C' && name2[1]=='S')) 532 * 4 + (sign >= 0 ? 1 : -1); 533 } 534 return sign; 535 } 536 537 void iconvlist (int (*do_one) (unsigned int namescount, 538 const char * const * names, 539 void* data), 540 void* data) 541 { 542 #define aliascount1 sizeof(aliases)/sizeof(aliases[0]) 543 #ifndef aliases2_lookup 544 #define aliascount2 sizeof(sysdep_aliases)/sizeof(sysdep_aliases[0]) 545 #else 546 #define aliascount2 0 547 #endif 548 #define aliascount (aliascount1+aliascount2) 549 struct nalias aliasbuf[aliascount]; 550 const char * namesbuf[aliascount]; 551 size_t num_aliases; 552 { 553 /* Put all existing aliases into a buffer. */ 554 size_t i; 555 size_t j; 556 j = 0; 557 for (i = 0; i < aliascount1; i++) { 558 const struct alias * p = &aliases[i]; 559 if (p->name >= 0 560 && p->encoding_index != ei_local_char 561 && p->encoding_index != ei_local_wchar_t) { 562 aliasbuf[j].name = stringpool + p->name; 563 aliasbuf[j].encoding_index = p->encoding_index; 564 j++; 565 } 566 } 567 #ifndef aliases2_lookup 568 for (i = 0; i < aliascount2; i++) { 569 aliasbuf[j].name = stringpool2 + sysdep_aliases[i].name; 570 aliasbuf[j].encoding_index = sysdep_aliases[i].encoding_index; 571 j++; 572 } 573 #endif 574 num_aliases = j; 575 } 576 /* Sort by encoding_index. */ 577 if (num_aliases > 1) 578 qsort(aliasbuf, num_aliases, sizeof(struct nalias), compare_by_index); 579 { 580 /* Process all aliases with the same encoding_index together. */ 581 size_t j; 582 j = 0; 583 while (j < num_aliases) { 584 unsigned int ei = aliasbuf[j].encoding_index; 585 size_t i = 0; 586 do 587 namesbuf[i++] = aliasbuf[j++].name; 588 while (j < num_aliases && aliasbuf[j].encoding_index == ei); 589 if (i > 1) 590 qsort(namesbuf, i, sizeof(const char *), compare_by_name); 591 /* Call the callback. */ 592 if (do_one(i,namesbuf,data)) 593 break; 594 } 595 } 596 #undef aliascount 597 #undef aliascount2 598 #undef aliascount1 599 } 600 601 /* 602 * Table of canonical names of encodings. 603 * Instead of strings, it contains offsets into stringpool and stringpool2. 604 */ 605 static const unsigned short all_canonical[] = { 606 #include "canonical.h" 607 #ifdef USE_AIX 608 #include "canonical_aix.h" 609 #endif 610 #ifdef USE_OSF1 611 #include "canonical_osf1.h" 612 #endif 613 #ifdef USE_DOS 614 #include "canonical_dos.h" 615 #endif 616 #ifdef USE_EXTRA 617 #include "canonical_extra.h" 618 #endif 619 #include "canonical_local.h" 620 }; 621 622 const char * iconv_canonicalize (const char * name) 623 { 624 const char* code; 625 char buf[MAX_WORD_LENGTH+10+1]; 626 const char* cp; 627 char* bp; 628 const struct alias * ap; 629 unsigned int count; 630 unsigned int index; 631 const char* pool; 632 633 /* Before calling aliases_lookup, convert the input string to upper case, 634 * and check whether it's entirely ASCII (we call gperf with option "-7" 635 * to achieve a smaller table) and non-empty. If it's not entirely ASCII, 636 * or if it's too long, it is not a valid encoding name. 637 */ 638 for (code = name;;) { 639 /* Search code in the table. */ 640 for (cp = code, bp = buf, count = MAX_WORD_LENGTH+10+1; ; cp++, bp++) { 641 unsigned char c = * (unsigned char *) cp; 642 if (c >= 0x80) 643 goto invalid; 644 if (c >= 'a' && c <= 'z') 645 c -= 'a'-'A'; 646 *bp = c; 647 if (c == '\0') 648 break; 649 if (--count == 0) 650 goto invalid; 651 } 652 for (;;) { 653 if (bp-buf >= 10 && memcmp(bp-10,"//TRANSLIT",10)==0) { 654 bp -= 10; 655 *bp = '\0'; 656 continue; 657 } 658 if (bp-buf >= 8 && memcmp(bp-8,"//IGNORE",8)==0) { 659 bp -= 8; 660 *bp = '\0'; 661 continue; 662 } 663 break; 664 } 665 if (buf[0] == '\0') { 666 code = locale_charset(); 667 /* Avoid an endless loop that could occur when using an older version 668 of localcharset.c. */ 669 if (code[0] == '\0') 670 goto invalid; 671 continue; 672 } 673 pool = stringpool; 674 ap = aliases_lookup(buf,bp-buf); 675 if (ap == NULL) { 676 pool = stringpool2; 677 ap = aliases2_lookup(buf); 678 if (ap == NULL) 679 goto invalid; 680 } 681 if (ap->encoding_index == ei_local_char) { 682 code = locale_charset(); 683 /* Avoid an endless loop that could occur when using an older version 684 of localcharset.c. */ 685 if (code[0] == '\0') 686 goto invalid; 687 continue; 688 } 689 if (ap->encoding_index == ei_local_wchar_t) { 690 /* On systems which define __STDC_ISO_10646__, wchar_t is Unicode. 691 This is also the case on native Woe32 systems. */ 692 #if __STDC_ISO_10646__ || ((defined _WIN32 || defined __WIN32__) && !defined __CYGWIN__) 693 if (sizeof(wchar_t) == 4) { 694 index = ei_ucs4internal; 695 break; 696 } 697 if (sizeof(wchar_t) == 2) { 698 index = ei_ucs2internal; 699 break; 700 } 701 if (sizeof(wchar_t) == 1) { 702 index = ei_iso8859_1; 703 break; 704 } 705 #endif 706 } 707 index = ap->encoding_index; 708 break; 709 } 710 return all_canonical[index] + pool; 711 invalid: 712 return name; 713 } 714 715 int _libiconv_version = _LIBICONV_VERSION; 716 717 #if defined __FreeBSD__ && !defined __gnu_freebsd__ 718 /* GNU libiconv is the native FreeBSD iconv implementation since 2002. 719 It wants to define the symbols 'iconv_open', 'iconv', 'iconv_close'. */ 720 #define strong_alias(name, aliasname) _strong_alias(name, aliasname) 721 #define _strong_alias(name, aliasname) \ 722 extern __typeof (name) aliasname __attribute__ ((alias (#name))); 723 #undef iconv_open 724 #undef iconv 725 #undef iconv_close 726 strong_alias (libiconv_open, iconv_open) 727 strong_alias (libiconv, iconv) 728 strong_alias (libiconv_close, iconv_close) 729 #endif 730 731 #endif 732