1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 1997, by Sun Microsystems, Inc. 24 * All rights reserved. 25 */ 26 27 #include <stdio.h> 28 #include <stdlib.h> 29 #include <errno.h> 30 #include <sys/types.h> 31 32 #include "tab_lookup.h" /* table lookup data types */ 33 34 #define MSB 0x80 /* most significant bit */ 35 #define MBYTE 0x8e /* multi-byte (4 byte character) */ 36 #define PMASK 0xa0 /* plane number mask */ 37 #define ONEBYTE 0xff /* right most byte */ 38 39 /* non-identified character */ 40 #define UTF8_NON_ID_CHAR1 0xEF 41 #define UTF8_NON_ID_CHAR2 0xBF 42 #define UTF8_NON_ID_CHAR3 0xBD 43 44 enum _USTATE { C0, C1 }; 45 46 47 48 49 /* 50 * Actual conversion; called from iconv() 51 * Input is UTF-8 data. 52 * first convert to UCS2 53 */ 54 size_t 55 _icv_iconv(_icv_state *st, char **inbuf, size_t *inbytesleft, 56 char **outbuf, size_t *outbytesleft) 57 { 58 /* 59 * Actual conversion; called from iconv() 60 */ 61 62 char c1, c2; 63 int n, unidx; 64 unsigned long ibm_code; 65 66 #ifdef DEBUG 67 fprintf(stderr, "========== iconv(): IBM --> UTF8 ==========\n"); 68 #endif 69 70 if (st == NULL) { 71 errno = EBADF; 72 return ((size_t) -1); 73 } 74 75 if (inbuf == NULL || *inbuf == NULL) { /* Reset request. */ 76 st->ustate = C0; 77 st->_errno = 0; 78 return ((size_t) 0); 79 } 80 81 st->_errno = 0; /* reset internal errno */ 82 errno = 0; /* reset external errno */ 83 84 /* a state machine for interpreting UTF8 code */ 85 while (*inbytesleft > 0 && *outbytesleft > 0) { 86 switch (st->ustate) { 87 case C0 : 88 st->keepc[0] = (**inbuf); 89 st->ustate = C1; 90 break; 91 92 case C1 : 93 st->keepc[1] = (**inbuf); 94 n = ibm_to_utf8(st, *outbuf, *outbytesleft); 95 if (n > 0) { 96 (*outbuf) += n; 97 (*outbytesleft) -= n; 98 } else { 99 st->_errno = errno; 100 return((size_t)-1); 101 } 102 st->ustate = C0; 103 st->_errno = 0; 104 break; 105 106 default: /* should never come here */ 107 st->_errno = errno = EILSEQ; 108 st->ustate = C0; /* reset state */ 109 break; 110 } 111 112 113 (*inbuf)++; 114 (*inbytesleft)--; 115 116 if (st->_errno) { 117 #ifdef DEBUG 118 fprintf(stderr, "!!!!!\tst->_errno = %d\tst->ustate = %d\n", 119 st->_errno, st->ustate); 120 #endif 121 break; 122 } 123 124 if (errno) 125 return((size_t)-1); 126 } 127 128 if (*outbytesleft == 0) { 129 errno = E2BIG; 130 return((size_t)-1); 131 } 132 return (*inbytesleft); 133 } 134 135 /* 136 * IBM code --> (Unicode) 137 * Unicode --> UTF8 (FSS-UTF) 138 * (File System Safe Universal Character Set Transformation Format) 139 * Return: > 0 - converted with enough space in output buffer 140 * = 0 - no space in outbuf 141 */ 142 int ibm_to_utf8(st, buf, buflen) 143 _icv_state *st; 144 char *buf; 145 size_t buflen; 146 { 147 unsigned long ibm_val; /* Big-5 value */ 148 int unidx; /* Unicode index */ 149 unsigned long uni_val; /* Unicode */ 150 151 ibm_val = ((st->keepc[0]&ONEBYTE) << 8) + (st->keepc[1]&ONEBYTE); 152 #ifdef DEBUG 153 fprintf(stderr, "%x\t", ibm_val); 154 #endif 155 156 157 unidx = bisearch(ibm_val, st, st->table_size); 158 159 if (unidx >= 0) 160 { 161 if ( st->left_to_right ) 162 uni_val = st->table[unidx].right_code; 163 else 164 uni_val = st->table[unidx].left_code; 165 } 166 167 #ifdef DEBUG 168 fprintf(stderr, "unidx = %d, unicode = %x\t", unidx, uni_val); 169 #endif 170 171 if (unidx >= 0) { /* do Unicode to UTF8 conversion */ 172 if (uni_val > 0x0000 && uni_val <= 0x07ff) { 173 if (buflen < 2) { 174 #ifdef DEBUG 175 fprintf(stderr, "outbuf overflow in ibm_to_utf8()!!\n"); 176 #endif 177 errno = E2BIG; 178 return(0); 179 } 180 *buf = (char)((uni_val >> 6) & 0x1f) | 0xc0; 181 *(buf+1) = (char)(uni_val & 0x3f) | 0x80; 182 #ifdef DEBUG 183 fprintf(stderr, "%x %x\n", *buf&ONEBYTE, *(buf+1)&ONEBYTE); 184 #endif 185 return(2); 186 } 187 if (uni_val > 0x0800 && uni_val <= 0xffff) { 188 if (buflen < 3) { 189 #ifdef DEBUG 190 fprintf(stderr, "outbuf overflow in ibm_to_utf8()!!\n"); 191 #endif 192 errno = E2BIG; 193 return(0); 194 } 195 *buf = (char)((uni_val >> 12) & 0xf) | 0xe0; 196 *(buf+1) = (char)((uni_val >>6) & 0x3f) | 0x80; 197 *(buf+2) = (char)(uni_val & 0x3f) | 0x80; 198 #ifdef DEBUG 199 fprintf(stderr, "%x %x %x\n", *buf&ONEBYTE, *(buf+1)&ONEBYTE, *(buf+2)&ONEBYTE); 200 #endif 201 return(3); 202 } 203 } 204 205 /* can't find a match in IBM --> UTF8 table or illegal UTF8 code */ 206 if (buflen < 3) { 207 #ifdef DEBUG 208 fprintf(stderr, "outbuf overflow in ibm_to_utf8()!!\n"); 209 #endif 210 errno = E2BIG; 211 return(0); 212 } 213 214 *buf = (char)UTF8_NON_ID_CHAR1; 215 *(buf+1) = (char)UTF8_NON_ID_CHAR2; 216 *(buf+2) = (char)UTF8_NON_ID_CHAR3; 217 218 #ifdef DEBUG 219 fprintf(stderr, "%c %c %c\n", *buf, *(buf+1), *(buf+2)); 220 #endif 221 return(3); 222 } 223