1 /* Conversion from and to CP1255.
2 Copyright (C) 1998, 2001, 2002 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998,
5 and Bruno Haible <haible@clisp.cons.org>, 2001.
7 The GNU C Library is free software; you can redistribute it and/or
8 modify it under the terms of the GNU Lesser General Public
9 License as published by the Free Software Foundation; either
10 version 2.1 of the License, or (at your option) any later version.
12 The GNU C Library is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public
18 License along with the GNU C Library; if not, write to the Free
19 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
26 #define NELEMS(arr) (sizeof (arr) / sizeof (arr[0]))
28 /* Definitions used in the body of the `gconv' function. */
29 #define CHARSET_NAME "CP1255//"
30 #define FROM_LOOP from_cp1255
31 #define TO_LOOP to_cp1255
34 #define FROM_LOOP_MIN_NEEDED_FROM 1
35 #define FROM_LOOP_MAX_NEEDED_FROM 1
36 #define FROM_LOOP_MIN_NEEDED_TO 4
37 #define FROM_LOOP_MAX_NEEDED_TO 4
38 #define TO_LOOP_MIN_NEEDED_FROM 4
39 #define TO_LOOP_MAX_NEEDED_FROM 4
40 #define TO_LOOP_MIN_NEEDED_TO 1
41 #define TO_LOOP_MAX_NEEDED_TO 3
42 #define PREPARE_LOOP \
44 int *statep = &data->__statep->__count;
45 #define EXTRA_LOOP_ARGS , statep
48 /* Since we might have to reset input pointer we must be able to save
49 and restore the state. */
50 #define SAVE_RESET_STATE(Save) \
52 saved_state = *statep; \
57 /* During CP1255 to UCS4 conversion, the COUNT element of the state
58 contains the last UCS4 character, shifted by 3 bits. */
61 /* Since this is a stateful encoding we have to provide code which resets
62 the output state to the initial state. This has to be done during the
64 #define EMIT_SHIFT_TO_INIT \
65 if (data->__statep->__count != 0) \
69 if (__builtin_expect (outbuf + 4 <= outend, 1)) \
71 /* Write out the last character. */ \
72 *((uint32_t *) outbuf)++ = data->__statep->__count >> 3; \
73 data->__statep->__count = 0; \
76 /* We don't have enough room in the output buffer. */ \
77 status = __GCONV_FULL_OUTPUT; \
80 /* We don't use shift states in the TO_DIRECTION. */ \
81 data->__statep->__count = 0; \
85 /* First define the conversion function from CP1255 to UCS4. */
87 static const uint16_t to_ucs4
[128] = {
89 0x20AC, 0, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
90 0x02C6, 0x2030, 0, 0x2039, 0, 0, 0, 0,
92 0, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
93 0x02DC, 0x2122, 0, 0x203A, 0, 0, 0, 0,
95 0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x20AA, 0x00A5, 0x00A6, 0x00A7,
96 0x00A8, 0x00A9, 0x00D7, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
98 0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
99 0x00B8, 0x00B9, 0x00F7, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
101 0x05B0, 0x05B1, 0x05B2, 0x05B3, 0x05B4, 0x05B5, 0x05B6, 0x05B7,
102 0x05B8, 0x05B9, 0, 0x05BB, 0x05BC, 0x05BD, 0x05BE, 0x05BF,
104 0x05C0, 0x05C1, 0x05C2, 0x05C3, 0x05F0, 0x05F1, 0x05F2, 0x05F3,
105 0x05F4, 0, 0, 0, 0, 0, 0, 0,
107 0x05D0, 0x05D1, 0x05D2, 0x05D3, 0x05D4, 0x05D5, 0x05D6, 0x05D7,
108 0x05D8, 0x05D9, 0x05DA, 0x05DB, 0x05DC, 0x05DD, 0x05DE, 0x05DF,
110 0x05E0, 0x05E1, 0x05E2, 0x05E3, 0x05E4, 0x05E5, 0x05E6, 0x05E7,
111 0x05E8, 0x05E9, 0x05EA, 0, 0, 0x200E, 0x200F, 0,
114 /* CP1255 contains eight combining characters:
115 0x05b4, 0x05b7, 0x05b8, 0x05b9, 0x05bc, 0x05bf, 0x05c1, 0x05c2. */
117 /* Composition tables for each of the relevant combining characters. */
118 static const struct {
121 } comp_table_data
[] = {
122 #define COMP_TABLE_IDX_05B4 0
123 #define COMP_TABLE_LEN_05B4 1
125 #define COMP_TABLE_IDX_05B7 (COMP_TABLE_IDX_05B4 + COMP_TABLE_LEN_05B4)
126 #define COMP_TABLE_LEN_05B7 2
129 #define COMP_TABLE_IDX_05B8 (COMP_TABLE_IDX_05B7 + COMP_TABLE_LEN_05B7)
130 #define COMP_TABLE_LEN_05B8 1
132 #define COMP_TABLE_IDX_05B9 (COMP_TABLE_IDX_05B8 + COMP_TABLE_LEN_05B8)
133 #define COMP_TABLE_LEN_05B9 1
135 #define COMP_TABLE_IDX_05BC (COMP_TABLE_IDX_05B9 + COMP_TABLE_LEN_05B9)
136 #define COMP_TABLE_LEN_05BC 24
161 #define COMP_TABLE_IDX_05BF (COMP_TABLE_IDX_05BC + COMP_TABLE_LEN_05BC)
162 #define COMP_TABLE_LEN_05BF 3
166 #define COMP_TABLE_IDX_05C1 (COMP_TABLE_IDX_05BF + COMP_TABLE_LEN_05BF)
167 #define COMP_TABLE_LEN_05C1 2
170 #define COMP_TABLE_IDX_05C2 (COMP_TABLE_IDX_05C1 + COMP_TABLE_LEN_05C1)
171 #define COMP_TABLE_LEN_05C2 2
174 #define COMP_TABLE_IDX_END (COMP_TABLE_IDX_05C2 + COMP_TABLE_LEN_05C2)
176 /* Compile-time verification of table size. */
177 typedef int verify1
[(NELEMS (comp_table_data
) == COMP_TABLE_IDX_END
) - 1];
179 static const struct { unsigned int idx
; unsigned int len
; } comp_table
[8] = {
180 { COMP_TABLE_IDX_05B4
, COMP_TABLE_LEN_05B4
},
181 { COMP_TABLE_IDX_05B7
, COMP_TABLE_LEN_05B7
},
182 { COMP_TABLE_IDX_05B8
, COMP_TABLE_LEN_05B8
},
183 { COMP_TABLE_IDX_05B9
, COMP_TABLE_LEN_05B9
},
184 { COMP_TABLE_IDX_05BC
, COMP_TABLE_LEN_05BC
},
185 { COMP_TABLE_IDX_05BF
, COMP_TABLE_LEN_05BF
},
186 { COMP_TABLE_IDX_05C1
, COMP_TABLE_LEN_05C1
},
187 { COMP_TABLE_IDX_05C2
, COMP_TABLE_LEN_05C2
},
190 #define MIN_NEEDED_INPUT FROM_LOOP_MIN_NEEDED_FROM
191 #define MAX_NEEDED_INPUT FROM_LOOP_MAX_NEEDED_FROM
192 #define MIN_NEEDED_OUTPUT FROM_LOOP_MIN_NEEDED_TO
193 #define MAX_NEEDED_OUTPUT FROM_LOOP_MAX_NEEDED_TO
194 #define LOOPFCT FROM_LOOP
197 uint32_t ch = *inptr; \
199 int must_buffer_ch; \
203 ch = to_ucs4[ch - 0x80]; \
204 if (__builtin_expect (ch == L'\0', 0)) \
206 /* This is an illegal character. */ \
207 STANDARD_FROM_LOOP_ERR_HANDLER (1); \
211 /* Determine whether there is a buffered character pending. */ \
212 last_ch = *statep >> 3; \
214 /* We have to buffer ch if it is a possible match in comp_table_data. */ \
215 must_buffer_ch = (ch >= 0x05d0 && ch <= 0x05f2); \
219 if (ch >= 0x05b0 && ch < 0x05c5) \
221 /* See whether last_ch and ch can be combined. */ \
222 unsigned int i, i1, i2; \
251 goto not_combining; \
254 i1 = comp_table[i].idx; \
255 i2 = i1 + comp_table[i].len - 1; \
257 if (last_ch >= comp_table_data[i1].base \
258 && last_ch <= comp_table_data[i2].base) \
262 i = (i1 + i2) >> 1; \
263 if (last_ch == comp_table_data[i].base) \
265 if (last_ch < comp_table_data[i].base) \
268 goto not_combining; \
278 if (last_ch == comp_table_data[i].base) \
280 goto not_combining; \
284 last_ch = comp_table_data[i].composed; \
285 if (last_ch == 0xfb2a || last_ch == 0xfb2b \
286 || last_ch == 0xfb49) \
287 /* Buffer the combined character. */ \
288 *statep = last_ch << 3; \
291 /* Output the combined character. */ \
292 put32 (outptr, last_ch); \
302 /* Output the buffered character. */ \
303 put32 (outptr, last_ch); \
307 /* If we don't have enough room to output ch as well, then deal \
308 with it in another round. */ \
309 if (!must_buffer_ch && __builtin_expect (outptr + 4 > outend, 0)) \
313 if (must_buffer_ch) \
317 put32 (outptr, ch); \
322 #define LOOP_NEED_FLAGS
323 #define EXTRA_LOOP_DECLS , int *statep
324 #include <iconv/loop.c>
327 /* Next, define the conversion function from UCS4 to CP1255. */
329 static const unsigned char from_ucs4
[] = {
330 #define FROM_IDX_00 0
331 0xa0, 0xa1, 0xa2, 0xa3, 0x00, 0xa5, 0xa6, 0xa7, /* 0x00a0-0x00a7 */
332 0xa8, 0xa9, 0x00, 0xab, 0xac, 0xad, 0xae, 0xaf, /* 0x00a8-0x00af */
333 0xb0, 0xb1, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6, 0xb7, /* 0x00b0-0x00b7 */
334 0xb8, 0xb9, 0x00, 0xbb, 0xbc, 0xbd, 0xbe, 0xbf, /* 0x00b8-0x00bf */
335 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00c0-0x00c7 */
336 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00c8-0x00cf */
337 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xaa, /* 0x00d0-0x00d7 */
338 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00d8-0x00df */
339 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00e0-0x00e7 */
340 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x00e8-0x00ef */
341 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xba, /* 0x00f0-0x00f7 */
342 #define FROM_IDX_02 (FROM_IDX_00 + 88)
343 0x88, 0x00, /* 0x02c6-0x02c7 */
344 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x02c8-0x02cf */
345 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x02d0-0x02d7 */
346 0x00, 0x00, 0x00, 0x00, 0x98, /* 0x02d8-0x02dc */
347 #define FROM_IDX_05 (FROM_IDX_02 + 23)
348 0xc0, 0xc1, 0xc2, 0xc3, 0xc4, 0xc5, 0xc6, 0xc7, /* 0x05b0-0x05b7 */
349 0xc8, 0xc9, 0x00, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, /* 0x05b8-0x05bf */
350 0xd0, 0xd1, 0xd2, 0xd3, 0x00, 0x00, 0x00, 0x00, /* 0x05c0-0x05c7 */
351 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x05c8-0x05cf */
352 0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, /* 0x05d0-0x05d7 */
353 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, /* 0x05d8-0x05df */
354 0xf0, 0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, /* 0x05e0-0x05e7 */
355 0xf8, 0xf9, 0xfa, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x05e8-0x05ef */
356 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, /* 0x05f0-0x05f4 */
357 #define FROM_IDX_20 (FROM_IDX_05 + 69)
358 0xfd, 0xfe, /* 0x200e-0x200f */
359 0x00, 0x00, 0x00, 0x96, 0x97, 0x00, 0x00, 0x00, /* 0x2010-0x2017 */
360 0x91, 0x92, 0x82, 0x00, 0x93, 0x94, 0x84, 0x00, /* 0x2018-0x201f */
361 0x86, 0x87, 0x95, 0x00, 0x00, 0x00, 0x85, 0x00, /* 0x2020-0x2027 */
362 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x2028-0x202f */
363 0x89, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, /* 0x2030-0x2037 */
364 0x00, 0x8b, 0x9b, /* 0x2038-0x203a */
365 #define FROM_IDX_FF (FROM_IDX_20 + 45)
367 /* Compile-time verification of table size. */
368 typedef int verify2
[(NELEMS (from_ucs4
) == FROM_IDX_FF
) - 1];
370 static const unsigned char comb_table
[8] = {
371 0xc4, 0xc7, 0xc8, 0xc9, 0xcc, 0xcf, 0xd1, 0xd2,
374 /* Decomposition table for the relevant Unicode characters. */
375 static const struct {
381 { 0xFB1D, 0x05D9, 0, -1 },
382 { 0xFB1F, 0x05F2, 1, -1 },
383 { 0xFB2A, 0x05E9, 6, -1 },
384 { 0xFB2B, 0x05E9, 7, -1 },
385 { 0xFB2C, 0x05E9, 4, 6 },
386 { 0xFB2D, 0x05E9, 4, 7 },
387 { 0xFB2E, 0x05D0, 1, -1 },
388 { 0xFB2F, 0x05D0, 2, -1 },
389 { 0xFB30, 0x05D0, 4, -1 },
390 { 0xFB31, 0x05D1, 4, -1 },
391 { 0xFB32, 0x05D2, 4, -1 },
392 { 0xFB33, 0x05D3, 4, -1 },
393 { 0xFB34, 0x05D4, 4, -1 },
394 { 0xFB35, 0x05D5, 4, -1 },
395 { 0xFB36, 0x05D6, 4, -1 },
396 { 0xFB38, 0x05D8, 4, -1 },
397 { 0xFB39, 0x05D9, 4, -1 },
398 { 0xFB3A, 0x05DA, 4, -1 },
399 { 0xFB3B, 0x05DB, 4, -1 },
400 { 0xFB3C, 0x05DC, 4, -1 },
401 { 0xFB3E, 0x05DE, 4, -1 },
402 { 0xFB40, 0x05E0, 4, -1 },
403 { 0xFB41, 0x05E1, 4, -1 },
404 { 0xFB43, 0x05E3, 4, -1 },
405 { 0xFB44, 0x05E4, 4, -1 },
406 { 0xFB46, 0x05E6, 4, -1 },
407 { 0xFB47, 0x05E7, 4, -1 },
408 { 0xFB48, 0x05E8, 4, -1 },
409 { 0xFB49, 0x05E9, 4, -1 },
410 { 0xFB4A, 0x05EA, 4, -1 },
411 { 0xFB4B, 0x05D5, 3, -1 },
412 { 0xFB4C, 0x05D1, 5, -1 },
413 { 0xFB4D, 0x05DB, 5, -1 },
414 { 0xFB4E, 0x05E4, 5, -1 },
417 #define MIN_NEEDED_INPUT TO_LOOP_MIN_NEEDED_FROM
418 #define MAX_NEEDED_INPUT TO_LOOP_MAX_NEEDED_FROM
419 #define MIN_NEEDED_OUTPUT TO_LOOP_MIN_NEEDED_TO
420 #define MAX_NEEDED_OUTPUT TO_LOOP_MAX_NEEDED_TO
421 #define LOOPFCT TO_LOOP
424 uint32_t ch = get32 (inptr); \
435 if (ch >= 0x00a0 && ch < 0x00f8) \
436 res = from_ucs4[ch - 0x00a0 + FROM_IDX_00]; \
437 else if (ch == 0x0192) \
439 else if (ch >= 0x02c6 && ch < 0x02dd) \
440 res = from_ucs4[ch - 0x02c6 + FROM_IDX_02]; \
441 else if (ch >= 0x05b0 && ch < 0x05f5) \
442 res = from_ucs4[ch - 0x05b0 + FROM_IDX_05]; \
443 else if (ch >= 0x200e && ch < 0x203b) \
444 res = from_ucs4[ch - 0x200e + FROM_IDX_20]; \
445 else if (ch == 0x20aa) \
447 else if (ch == 0x20ac) \
449 else if (ch == 0x2122) \
453 UNICODE_TAG_HANDLER (ch, 4); \
457 if (__builtin_expect (res != 0, 1)) \
464 /* Try canonical decomposition. */ \
465 unsigned int i1, i2; \
468 i2 = sizeof (decomp_table) / sizeof (decomp_table[0]) - 1; \
469 if (ch >= decomp_table[i1].composed \
470 && ch <= decomp_table[i2].composed) \
476 i = (i1 + i2) >> 1; \
477 if (ch == decomp_table[i].composed) \
479 if (ch < decomp_table[i].composed) \
492 if (ch == decomp_table[i].composed) \
499 /* Found a canonical decomposition. */ \
500 ch = decomp_table[i].base; \
501 /* ch is one of 0x05d0..0x05d6, 0x05d8..0x05dc, 0x05de, \
502 0x05e0..0x05e1, 0x05e3..0x05e4, 0x05e6..0x05ea, 0x05f2. */ \
503 ch = from_ucs4[ch - 0x05b0 + FROM_IDX_05]; \
506 if (decomp_table[i].comb2 < 0) \
508 /* See whether we have room for two bytes. */ \
509 if (__builtin_expect (outptr + 1 >= outend, 0)) \
511 result = __GCONV_FULL_OUTPUT; \
515 *outptr++ = (unsigned char) ch; \
516 *outptr++ = comb_table[decomp_table[i].comb1]; \
520 /* See whether we have room for three bytes. */ \
521 if (__builtin_expect (outptr + 2 >= outend, 0)) \
523 result = __GCONV_FULL_OUTPUT; \
527 *outptr++ = (unsigned char) ch; \
528 *outptr++ = comb_table[decomp_table[i].comb1]; \
529 *outptr++ = comb_table[decomp_table[i].comb2]; \
537 /* This is an illegal character. */ \
538 STANDARD_TO_LOOP_ERR_HANDLER (4); \
542 #define LOOP_NEED_FLAGS
543 #define EXTRA_LOOP_DECLS , int *statep
544 #include <iconv/loop.c>
547 /* Now define the toplevel functions. */
548 #include <iconv/skeleton.c>