/*- * Copyright (c) 1999, 2000 * Konstantin Chuguev. All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * iconv (Charset Conversion Library) v2.0 */ #include #include #include #include #include #include #include #include #include "local.h" static __uint16_t __inline _DEFUN(betohs, (s), __uint16_t s) { #if (BYTE_ORDER == LITTLE_ENDIAN) return ((s << 8) & 0xFF00) | ((s >> 8) & 0x00FF); #elif (BYTE_ORDER == BIG_ENDIAN) return s; #else #error "Unknown byte order." #endif } static __uint32_t __inline _DEFUN(betohl, (l), __uint32_t l) { #if (BYTE_ORDER == LITTLE_ENDIAN) return (((l << 24) & 0xFF000000) | ((l << 8) & 0x00FF0000) | ((l >> 8) & 0x0000FF00) | ((l >> 24) & 0x000000FF)); #elif (BYTE_ORDER == BIG_ENDIAN) return l; #else #error "Unknown byte order." #endif } static __uint16_t __inline _DEFUN(letohs, (s), __uint16_t s) { #if (BYTE_ORDER == LITTLE_ENDIAN) return s; #elif (BYTE_ORDER == BIG_ENDIAN) return ((s << 8) & 0xFF00) | ((s >> 8) & 0x00FF); #else #error "Unknown byte order." #endif } static __uint32_t __inline _DEFUN(letohl, (s), __uint32_t l) { #if (BYTE_ORDER == LITTLE_ENDIAN) return l; #elif (BYTE_ORDER == BIG_ENDIAN) return (((l << 24) & 0xFF000000) | ((l << 8) & 0x00FF0000) | ((l >> 8) & 0x0000FF00) | ((l >> 24) & 0x000000FF)); #else #error "Unknown byte order." #endif } /* Generic coded character set conversion table */ typedef struct { unsigned char label[8]; /* CSconvT; N=[0-3] */ __uint32_t tables[2]; /* offsets to 2 unidirectional tables */ } iconv_ccs_convtable_t; #define ICONV_TBL_LABEL "\003CSCT" #define ICONV_TBL_LABEL_SIZE 5 #define ICONV_TBL_BYTE_ORDER(table) (((table)->label[5]) & 1) #define ICONV_TBL_NBITS(table) ((table)->label[6]) #define ICONV_TBL_VERSION(table) ((table)->label[7]) /* Indices for unidirectional conversion tables */ enum { _iconv_ccs_to_ucs = 0, _iconv_ccs_from_ucs = 1 }; /* Unidirectional conversion table types */ /* one-level tables */ typedef struct { ucs2_t data[128]; } iconv_ccs_table_7bit_t; /* 7-bit charset to Unicode */ typedef struct { ucs2_t data[256]; } iconv_ccs_table_8bit_t; /* 8-bit charset to Unicode */ /* two-level tables */ typedef struct { __uint32_t data[128]; } iconv_ccs_table_14bit_t; /* 14-bit charset to Unicode */ typedef struct { __uint32_t data[256]; } iconv_ccs_table_16bit_t; /* 16-bit charset to Unicode; * Unicode to any charset */ /* abstract table */ typedef union { iconv_ccs_table_7bit_t _7bit; iconv_ccs_table_8bit_t _8bit; iconv_ccs_table_14bit_t _14bit; iconv_ccs_table_16bit_t _16bit; } iconv_ccs_table_abstract_t; /* host and network byte order array element macros */ #define iconv_table_elt_le(base, i, type) \ ((type *)(((char *)(base)) + letohl(((__uint32_t *)(base))[(i)]))) #define iconv_table_elt_be(base, i, type) \ ((type *)(((char *)(base)) + betohl(((__int32_t *)(base))[(i)]))) #define abstable ((_CONST iconv_ccs_table_abstract_t *)table) /* Functions for little endian byte order tables */ static ucs2_t _DEFUN(cvt_7bit_le, (table, ch), _CONST _VOID_PTR table _AND ucs2_t ch) { return ch & 0x80 ? UCS_CHAR_INVALID : letohs(abstable->_7bit.data[ch]); } static ucs2_t _DEFUN(cvt_8bit_le, (table, ch), _CONST _VOID_PTR table _AND ucs2_t ch) { return letohs(abstable->_8bit.data[ch]); } static ucs2_t _DEFUN(cvt_14bit_le, (table, ch), _CONST _VOID_PTR table _AND ucs2_t ch) { _CONST iconv_ccs_table_7bit_t *sub_table; if (ch & 0x8080) return UCS_CHAR_INVALID; sub_table = iconv_table_elt_le(table, ch >> 8, iconv_ccs_table_7bit_t); return sub_table == &(abstable->_7bit) ? UCS_CHAR_INVALID : letohs(sub_table->data[ch & 0x7F]); } static ucs2_t _DEFUN(cvt_16bit_le, (table, ch), _CONST _VOID_PTR table _AND ucs2_t ch) { _CONST iconv_ccs_table_8bit_t *sub_table = iconv_table_elt_le(table, ch >> 8, iconv_ccs_table_8bit_t); return sub_table == &(abstable->_8bit) ? UCS_CHAR_INVALID : letohs(sub_table->data[ch & 0xFF]); } static iconv_ccs_convert_t * _CONST converters_le[] = { cvt_7bit_le, cvt_8bit_le, cvt_14bit_le, cvt_16bit_le }; /* Functions for network byte order tables */ static ucs2_t _DEFUN(cvt_7bit_be, (table, ch), _CONST _VOID_PTR table _AND ucs2_t ch) { return ch & 0x80 ? UCS_CHAR_INVALID : betohs(abstable->_7bit.data[ch]); } static ucs2_t _DEFUN(cvt_8bit_be, (table, ch), _CONST _VOID_PTR table _AND ucs2_t ch) { return betohs(abstable->_8bit.data[ch]); } static ucs2_t _DEFUN(cvt_14bit_be, (table, ch), _CONST _VOID_PTR table _AND ucs2_t ch) { _CONST iconv_ccs_table_7bit_t *sub_table; if (ch & 0x8080) return UCS_CHAR_INVALID; sub_table = iconv_table_elt_be(table, ch >> 8, iconv_ccs_table_7bit_t); return sub_table == &(abstable->_7bit) ? UCS_CHAR_INVALID : betohs(sub_table->data[ch & 0x7F]); } static ucs2_t _DEFUN(cvt_16bit_be, (table, ch), _CONST _VOID_PTR table _AND ucs2_t ch) { _CONST iconv_ccs_table_8bit_t *sub_table = iconv_table_elt_be(table, ch >> 8, iconv_ccs_table_8bit_t); return sub_table == &(abstable->_8bit) ? UCS_CHAR_INVALID : betohs(sub_table->data[ch & 0xFF]); } static iconv_ccs_convert_t * _CONST converters_be[] = { cvt_7bit_be, cvt_8bit_be, cvt_14bit_be, cvt_16bit_be }; #undef abstable /* Generic coded character set initialisation function */ static int _DEFUN(ccs_init, (ccs, table), struct iconv_ccs *ccs _AND _CONST iconv_ccs_convtable_t *table) { if (strncmp(table->label, ICONV_TBL_LABEL, ICONV_TBL_LABEL_SIZE)) return EINVAL; if (ICONV_TBL_VERSION(table) > 3) return EINVAL; ccs->nbits = ICONV_TBL_NBITS(table); if (ICONV_TBL_BYTE_ORDER(table) == ICONV_CCT_LE) { /* Little Endian */ ccs->from_ucs = iconv_table_elt_le(table->tables, _iconv_ccs_from_ucs, _CONST iconv_ccs_convtable_t); ccs->to_ucs = iconv_table_elt_le(table->tables, _iconv_ccs_to_ucs, _CONST iconv_ccs_convtable_t); ccs->convert_from_ucs = cvt_16bit_le; ccs->convert_to_ucs = converters_le[ICONV_TBL_VERSION(table)]; } else { /* Big Endian (Network Byte Order) */ ccs->from_ucs = iconv_table_elt_be(table->tables, _iconv_ccs_from_ucs, _CONST iconv_ccs_convtable_t); ccs->to_ucs = iconv_table_elt_be(table->tables, _iconv_ccs_to_ucs, _CONST iconv_ccs_convtable_t); ccs->convert_from_ucs = cvt_16bit_be; ccs->convert_to_ucs = converters_be[ICONV_TBL_VERSION(table)]; } return 0; } static int _DEFUN(close_builtin, (rptr, desc), struct _reent *rptr _AND struct iconv_ccs *desc) { return 0; } static int _DEFUN(iconv_ccs_init_builtin, (ccs, name), struct iconv_ccs *ccs _AND _CONST char *name) { _CONST iconv_builtin_table_t *ccs_ptr; for (ccs_ptr = _iconv_builtin_ccs; ccs_ptr->key != NULL; ccs_ptr ++) { if (strcmp(ccs_ptr->key, name) == 0) { int res = ccs_init(ccs, (_CONST iconv_ccs_convtable_t *) (ccs_ptr->value)); if (res == 0) ccs->close = close_builtin; return res; } } return EINVAL; } /* External CCS initialisation */ struct external_extra { _CONST iconv_ccs_convtable_t *ptr; off_t size; }; static int _DEFUN(close_external, (rptr, desc), struct _reent *rptr _AND struct iconv_ccs *desc) { _iconv_unload_file(rptr, (_iconv_fd_t *)desc->extra); _free_r(rptr, desc->extra); return 0; } static int _DEFUN(iconv_ccs_init_external, (rptr, ccs, name), struct _reent *rptr _AND struct iconv_ccs *ccs _AND _CONST char *name) { char *file; _CONST iconv_ccs_convtable_t *ccs_ptr; _CONST char *datapath; _iconv_fd_t *extra; if ((datapath = _getenv_r(rptr, NLS_ENVVAR_NAME)) == NULL || *datapath == '\0') datapath = NLS_DEFAULT_NLSPATH; if ((file = _malloc_r(rptr, strlen(name) + sizeof(ICONV_DATA_EXT) + 1)) == NULL) return EINVAL; _sprintf_r(rptr, file, "%s"ICONV_DATA_EXT, name); name = (_CONST char *)_iconv_construct_filename(rptr, datapath, file); _free_r(rptr, (_VOID_PTR)file); if (name == NULL) return EINVAL; if ((extra = (_iconv_fd_t *)_malloc_r(rptr, sizeof(_iconv_fd_t))) == NULL) { _free_r(rptr, (_VOID_PTR)name); return EINVAL; } if (_iconv_load_file(rptr, name, extra) != 0) { _free_r(rptr, (_VOID_PTR)name); return EINVAL; } _free_r(rptr, (_VOID_PTR)name); ccs_ptr = (_CONST iconv_ccs_convtable_t *)extra->mem; if (ccs_init(ccs, ccs_ptr) != 0) { _iconv_unload_file(rptr, extra); _free_r(rptr, (_VOID_PTR)extra); return __errno_r(rptr); } ccs->extra = (_VOID_PTR)extra; ccs->close = close_external; return 0; } int _DEFUN(_iconv_ccs_init, (rptr, ccs, name), struct _reent *rptr _AND struct iconv_ccs *ccs _AND _CONST char *name) { int res = iconv_ccs_init_builtin(ccs, name); if (res) res = iconv_ccs_init_external(rptr, ccs, name); if (res) __errno_r(rptr) = res; return res; }