1 /*
2 * "streamable kanji code filter and converter"
3 * Copyright (c) 1998-2002 HappySize, Inc. All rights reserved.
4 *
5 * LICENSE NOTICES
6 *
7 * This file is part of "streamable kanji code filter and converter",
8 * which is distributed under the terms of GNU Lesser General Public
9 * License (version 2) as published by the Free Software Foundation.
10 *
11 * This software is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with "streamable kanji code filter and converter";
18 * if not, write to the Free Software Foundation, Inc., 59 Temple Place,
19 * Suite 330, Boston, MA 02111-1307 USA
20 *
21 * The author of this file:
22 *
23 */
24 /*
25 * The source code included in this files was separated from mbfilter_kr.c
26 * by moriyoshi koizumi <moriyoshi@php.net> on 4 dec 2002.
27 *
28 */
29
30 #ifdef HAVE_CONFIG_H
31 #include "config.h"
32 #endif
33
34 #include "mbfilter.h"
35 #include "mbfilter_uhc.h"
36 #define UNICODE_TABLE_UHC_DEF
37 #include "unicode_table_uhc.h"
38
39 static int mbfl_filt_ident_uhc(int c, mbfl_identify_filter *filter);
40
41 static const unsigned char mblen_table_uhc[] = { /* 0x81-0xFE */
42 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
43 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
44 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
45 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
46 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
47 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
48 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
49 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
50 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
51 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
52 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
53 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
54 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
55 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
56 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
57 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1
58 };
59
60 static const char *mbfl_encoding_uhc_aliases[] = {"CP949", NULL};
61
62 const mbfl_encoding mbfl_encoding_uhc = {
63 mbfl_no_encoding_uhc,
64 "UHC",
65 "UHC",
66 (const char *(*)[])&mbfl_encoding_uhc_aliases,
67 mblen_table_uhc,
68 MBFL_ENCTYPE_MBCS,
69 &vtbl_uhc_wchar,
70 &vtbl_wchar_uhc
71 };
72
73 const struct mbfl_identify_vtbl vtbl_identify_uhc = {
74 mbfl_no_encoding_uhc,
75 mbfl_filt_ident_common_ctor,
76 mbfl_filt_ident_common_dtor,
77 mbfl_filt_ident_uhc
78 };
79
80 const struct mbfl_convert_vtbl vtbl_uhc_wchar = {
81 mbfl_no_encoding_uhc,
82 mbfl_no_encoding_wchar,
83 mbfl_filt_conv_common_ctor,
84 mbfl_filt_conv_common_dtor,
85 mbfl_filt_conv_uhc_wchar,
86 mbfl_filt_conv_common_flush
87 };
88
89 const struct mbfl_convert_vtbl vtbl_wchar_uhc = {
90 mbfl_no_encoding_wchar,
91 mbfl_no_encoding_uhc,
92 mbfl_filt_conv_common_ctor,
93 mbfl_filt_conv_common_dtor,
94 mbfl_filt_conv_wchar_uhc,
95 mbfl_filt_conv_common_flush
96 };
97
98 #define CK(statement) do { if ((statement) < 0) return (-1); } while (0)
99
100 /*
101 * UHC => wchar
102 */
103 int
mbfl_filt_conv_uhc_wchar(int c,mbfl_convert_filter * filter)104 mbfl_filt_conv_uhc_wchar(int c, mbfl_convert_filter *filter)
105 {
106 int c1, w = 0, flag = 0;
107
108 switch (filter->status) {
109 case 0:
110 if (c >= 0 && c < 0x80) { /* latin */
111 CK((*filter->output_function)(c, filter->data));
112 } else if (c > 0x80 && c < 0xff && c != 0xc9) { /* dbcs lead byte */
113 filter->status = 1;
114 filter->cache = c;
115 } else {
116 w = c & MBFL_WCSGROUP_MASK;
117 w |= MBFL_WCSGROUP_THROUGH;
118 CK((*filter->output_function)(w, filter->data));
119 }
120 break;
121
122 case 1: /* dbcs second byte */
123 filter->status = 0;
124 c1 = filter->cache;
125
126 if ( c1 >= 0x81 && c1 <= 0xa0){
127 w = (c1 - 0x81)*190 + (c - 0x41);
128 if (w >= 0 && w < uhc1_ucs_table_size) {
129 flag = 1;
130 w = uhc1_ucs_table[w];
131 } else {
132 w = 0;
133 }
134 } else if ( c1 >= 0xa1 && c1 <= 0xc6){
135 w = (c1 - 0xa1)*190 + (c - 0x41);
136 if (w >= 0 && w < uhc2_ucs_table_size) {
137 flag = 2;
138 w = uhc2_ucs_table[w];
139 } else {
140 w = 0;
141 }
142 } else if ( c1 >= 0xc7 && c1 <= 0xfe){
143 w = (c1 - 0xc7)*94 + (c - 0xa1);
144 if (w >= 0 && w < uhc3_ucs_table_size) {
145 flag = 3;
146 w = uhc3_ucs_table[w];
147 } else {
148 w = 0;
149 }
150 }
151 if (flag > 0){
152 if (w <= 0) {
153 w = (c1 << 8) | c;
154 w &= MBFL_WCSPLANE_MASK;
155 w |= MBFL_WCSPLANE_UHC;
156 }
157 CK((*filter->output_function)(w, filter->data));
158 } else {
159 if ((c >= 0 && c < 0x21) || c == 0x7f) { /* CTLs */
160 CK((*filter->output_function)(c, filter->data));
161 } else {
162 w = (c1 << 8) | c;
163 w &= MBFL_WCSGROUP_MASK;
164 w |= MBFL_WCSGROUP_THROUGH;
165 CK((*filter->output_function)(w, filter->data));
166 }
167 }
168 break;
169
170 default:
171 filter->status = 0;
172 break;
173 }
174
175 return c;
176 }
177
178 /*
179 * wchar => UHC
180 */
181 int
mbfl_filt_conv_wchar_uhc(int c,mbfl_convert_filter * filter)182 mbfl_filt_conv_wchar_uhc(int c, mbfl_convert_filter *filter)
183 {
184 int c1, s;
185
186 s = 0;
187 if (c >= ucs_a1_uhc_table_min && c < ucs_a1_uhc_table_max) {
188 s = ucs_a1_uhc_table[c - ucs_a1_uhc_table_min];
189 } else if (c >= ucs_a2_uhc_table_min && c < ucs_a2_uhc_table_max) {
190 s = ucs_a2_uhc_table[c - ucs_a2_uhc_table_min];
191 } else if (c >= ucs_a3_uhc_table_min && c < ucs_a3_uhc_table_max) {
192 s = ucs_a3_uhc_table[c - ucs_a3_uhc_table_min];
193 } else if (c >= ucs_i_uhc_table_min && c < ucs_i_uhc_table_max) {
194 s = ucs_i_uhc_table[c - ucs_i_uhc_table_min];
195 } else if (c >= ucs_s_uhc_table_min && c < ucs_s_uhc_table_max) {
196 s = ucs_s_uhc_table[c - ucs_s_uhc_table_min];
197 } else if (c >= ucs_r1_uhc_table_min && c < ucs_r1_uhc_table_max) {
198 s = ucs_r1_uhc_table[c - ucs_r1_uhc_table_min];
199 } else if (c >= ucs_r2_uhc_table_min && c < ucs_r2_uhc_table_max) {
200 s = ucs_r2_uhc_table[c - ucs_r2_uhc_table_min];
201 }
202 if (s <= 0) {
203 c1 = c & ~MBFL_WCSPLANE_MASK;
204 if (c1 == MBFL_WCSPLANE_UHC) {
205 s = c & MBFL_WCSPLANE_MASK;
206 }
207 if (c == 0) {
208 s = 0;
209 } else if (s <= 0) {
210 s = -1;
211 }
212 }
213 if (s >= 0) {
214 if (s < 0x80) { /* latin */
215 CK((*filter->output_function)(s, filter->data));
216 } else {
217 CK((*filter->output_function)((s >> 8) & 0xff, filter->data));
218 CK((*filter->output_function)(s & 0xff, filter->data));
219 }
220 } else {
221 CK(mbfl_filt_conv_illegal_output(c, filter));
222 }
223
224 return c;
225 }
226
mbfl_filt_ident_uhc(int c,mbfl_identify_filter * filter)227 static int mbfl_filt_ident_uhc(int c, mbfl_identify_filter *filter)
228 {
229 switch (filter->status) {
230 case 0: /* latin */
231 if (c >= 0 && c < 0x80) { /* ok */
232 ;
233 } else if (c >= 0x81 && c <= 0xa0) { /* dbcs first char */
234 filter->status= 1;
235 } else if (c >= 0xa1 && c <= 0xc6) { /* dbcs first char */
236 filter->status= 2;
237 } else if (c >= 0xc7 && c <= 0xfe) { /* dbcs first char */
238 filter->status= 3;
239 } else { /* bad */
240 filter->flag = 1;
241 }
242
243 case 1:
244 case 2:
245 if (c < 0x41 || (c > 0x5a && c < 0x61)
246 || (c > 0x7a && c < 0x81) || c > 0xfe) { /* bad */
247 filter->flag = 1;
248 }
249 filter->status = 0;
250 break;
251
252 case 3:
253 if (c < 0xa1 || c > 0xfe) { /* bad */
254 filter->flag = 1;
255 }
256 filter->status = 0;
257 break;
258
259 default:
260 filter->status = 0;
261 break;
262 }
263
264 return c;
265 }
266
