Report SRU diagnostic 12 (too many chars in query) when rendering the
[yaz-moved-to-github.git] / src / siconv.c
1 /*
2  * Copyright (C) 1995-2005, Index Data ApS
3  * See the file LICENSE for details.
4  *
5  * $Id: siconv.c,v 1.18 2006-03-25 14:41:53 adam Exp $
6  */
7 /**
8  * \file siconv.c
9  * \brief Implements simple ICONV
10  *
11  * This implements an interface similar to that of iconv and
12  * is used by YAZ to interface with iconv (if present).
13  * For systems where iconv is not present, this layer
14  * provides a few important conversion: UTF-8, MARC-8, Latin-1.
15  */
16
17 #if HAVE_CONFIG_H
18 #include <config.h>
19 #endif
20
21 #include <errno.h>
22 #include <string.h>
23 #include <ctype.h>
24 #if HAVE_WCHAR_H
25 #include <wchar.h>
26 #endif
27
28 #if HAVE_ICONV_H
29 #include <iconv.h>
30 #endif
31
32 #include <yaz/yaz-util.h>
33
34 unsigned long yaz_marc8_1_conv (unsigned char *inp, size_t inbytesleft,
35                               size_t *no_read, int *combining);
36 unsigned long yaz_marc8_2_conv (unsigned char *inp, size_t inbytesleft,
37                                 size_t *no_read, int *combining);
38 unsigned long yaz_marc8_3_conv (unsigned char *inp, size_t inbytesleft,
39                                 size_t *no_read, int *combining);
40 unsigned long yaz_marc8_4_conv (unsigned char *inp, size_t inbytesleft,
41                                 size_t *no_read, int *combining);
42 unsigned long yaz_marc8_5_conv (unsigned char *inp, size_t inbytesleft,
43                                 size_t *no_read, int *combining);
44 unsigned long yaz_marc8_6_conv (unsigned char *inp, size_t inbytesleft,
45                                 size_t *no_read, int *combining);
46 unsigned long yaz_marc8_7_conv (unsigned char *inp, size_t inbytesleft,
47                                 size_t *no_read, int *combining);
48 unsigned long yaz_marc8_8_conv (unsigned char *inp, size_t inbytesleft,
49                                 size_t *no_read, int *combining);
50 unsigned long yaz_marc8_9_conv (unsigned char *inp, size_t inbytesleft,
51                                 size_t *no_read, int *combining);
52     
53 struct yaz_iconv_struct {
54     int my_errno;
55     int init_flag;
56     size_t (*init_handle)(yaz_iconv_t cd, unsigned char *inbuf,
57                           size_t inbytesleft, size_t *no_read);
58     unsigned long (*read_handle)(yaz_iconv_t cd, unsigned char *inbuf,
59                                  size_t inbytesleft, size_t *no_read);
60     size_t (*write_handle)(yaz_iconv_t cd, unsigned long x,
61                            char **outbuf, size_t *outbytesleft,
62                            int last);
63     int marc8_esc_mode;
64
65     int comb_offset;
66     int comb_size;
67     unsigned long comb_x[8];
68     size_t comb_no_read[8];
69     size_t no_read_x;
70     unsigned long unget_x;
71 #if HAVE_ICONV_H
72     iconv_t iconv_cd;
73 #endif
74     unsigned long compose_char;
75 };
76
77 static unsigned long yaz_read_ISO8859_1 (yaz_iconv_t cd, unsigned char *inp,
78                                          size_t inbytesleft, size_t *no_read)
79 {
80     unsigned long x = inp[0];
81     *no_read = 1;
82     return x;
83 }
84
85 static size_t yaz_init_UTF8 (yaz_iconv_t cd, unsigned char *inp,
86                              size_t inbytesleft, size_t *no_read)
87 {
88     if (inp[0] != 0xef)
89     {
90         *no_read = 0;
91         return 0;
92     }
93     if (inbytesleft < 3)
94     {
95         cd->my_errno = YAZ_ICONV_EINVAL;
96         return (size_t) -1;
97     }
98     if (inp[1] != 0xbb || inp[2] != 0xbf)
99     {
100         cd->my_errno = YAZ_ICONV_EILSEQ;
101         return (size_t) -1;
102     }
103     *no_read = 3;
104     return 0;
105 }
106
107 static unsigned long yaz_read_UTF8 (yaz_iconv_t cd, unsigned char *inp,
108                                     size_t inbytesleft, size_t *no_read)
109 {
110     unsigned long x = 0;
111
112     if (inp[0] <= 0x7f)
113     {
114         x = inp[0];
115         *no_read = 1;
116     }
117     else if (inp[0] <= 0xbf || inp[0] >= 0xfe)
118     {
119         *no_read = 0;
120         cd->my_errno = YAZ_ICONV_EILSEQ;
121     }
122     else if (inp[0] <= 0xdf && inbytesleft >= 2)
123     {
124         x = ((inp[0] & 0x1f) << 6) | (inp[1] & 0x3f);
125         if (x >= 0x80)
126             *no_read = 2;
127         else
128         {
129             *no_read = 0;
130             cd->my_errno = YAZ_ICONV_EILSEQ;
131         }
132     }
133     else if (inp[0] <= 0xef && inbytesleft >= 3)
134     {
135         x = ((inp[0] & 0x0f) << 12) | ((inp[1] & 0x3f) << 6) |
136             (inp[2] & 0x3f);
137         if (x >= 0x800)
138             *no_read = 3;
139         else
140         {
141             *no_read = 0;
142             cd->my_errno = YAZ_ICONV_EILSEQ;
143         }
144     }
145     else if (inp[0] <= 0xf7 && inbytesleft >= 4)
146     {
147         x =  ((inp[0] & 0x07) << 18) | ((inp[1] & 0x3f) << 12) |
148             ((inp[2] & 0x3f) << 6) | (inp[3] & 0x3f);
149         if (x >= 0x10000)
150             *no_read = 4;
151         else
152         {
153             *no_read = 0;
154             cd->my_errno = YAZ_ICONV_EILSEQ;
155         }
156     }
157     else if (inp[0] <= 0xfb && inbytesleft >= 5)
158     {
159         x =  ((inp[0] & 0x03) << 24) | ((inp[1] & 0x3f) << 18) |
160             ((inp[2] & 0x3f) << 12) | ((inp[3] & 0x3f) << 6) |
161             (inp[4] & 0x3f);
162         if (x >= 0x200000)
163             *no_read = 5;
164         else
165         {
166             *no_read = 0;
167             cd->my_errno = YAZ_ICONV_EILSEQ;
168         }
169     }
170     else if (inp[0] <= 0xfd && inbytesleft >= 6)
171     {
172         x =  ((inp[0] & 0x01) << 30) | ((inp[1] & 0x3f) << 24) |
173             ((inp[2] & 0x3f) << 18) | ((inp[3] & 0x3f) << 12) |
174             ((inp[4] & 0x3f) << 6) | (inp[5] & 0x3f);
175         if (x >= 0x4000000)
176             *no_read = 6;
177         else
178         {
179             *no_read = 0;
180             cd->my_errno = YAZ_ICONV_EILSEQ;
181         }
182     }
183     else
184     {
185         *no_read = 0;
186         cd->my_errno = YAZ_ICONV_EINVAL;
187     }
188     return x;
189 }
190
191 static unsigned long yaz_read_UCS4 (yaz_iconv_t cd, unsigned char *inp,
192                                     size_t inbytesleft, size_t *no_read)
193 {
194     unsigned long x = 0;
195     
196     if (inbytesleft < 4)
197     {
198         cd->my_errno = YAZ_ICONV_EINVAL; /* incomplete input */
199         *no_read = 0;
200     }
201     else
202     {
203         x = (inp[0]<<24) | (inp[1]<<16) | (inp[2]<<8) | inp[3];
204         *no_read = 4;
205     }
206     return x;
207 }
208
209 static unsigned long yaz_read_UCS4LE (yaz_iconv_t cd, unsigned char *inp,
210                                       size_t inbytesleft, size_t *no_read)
211 {
212     unsigned long x = 0;
213     
214     if (inbytesleft < 4)
215     {
216         cd->my_errno = YAZ_ICONV_EINVAL; /* incomplete input */
217         *no_read = 0;
218     }
219     else
220     {
221         x = (inp[3]<<24) | (inp[2]<<16) | (inp[1]<<8) | inp[0];
222         *no_read = 4;
223     }
224     return x;
225 }
226
227 #if HAVE_WCHAR_H
228 static unsigned long yaz_read_wchar_t (yaz_iconv_t cd, unsigned char *inp,
229                                        size_t inbytesleft, size_t *no_read)
230 {
231     unsigned long x = 0;
232     
233     if (inbytesleft < sizeof(wchar_t))
234     {
235         cd->my_errno = YAZ_ICONV_EINVAL; /* incomplete input */
236         *no_read = 0;
237     }
238     else
239     {
240         wchar_t wch;
241         memcpy (&wch, inp, sizeof(wch));
242         x = wch;
243         *no_read = sizeof(wch);
244     }
245     return x;
246 }
247 #endif
248
249
250 static unsigned long yaz_read_marc8_comb (yaz_iconv_t cd, unsigned char *inp,
251                                           size_t inbytesleft, size_t *no_read,
252                                           int *comb);
253
254 static unsigned long yaz_read_marc8 (yaz_iconv_t cd, unsigned char *inp,
255                                      size_t inbytesleft, size_t *no_read)
256 {
257     unsigned long x;
258     if (cd->comb_offset < cd->comb_size)
259     {
260         *no_read = cd->comb_no_read[cd->comb_offset];
261         x = cd->comb_x[cd->comb_offset];
262
263         /* special case for double-diacritic combining characters, 
264            INVERTED BREVE and DOUBLE TILDE.
265            We'll increment the no_read counter by 1, since we want to skip over
266            the processing of the closing ligature character
267         */
268         /* this code is no longer necessary.. our handlers code in
269            yaz_marc8_?_conv (generated by charconv.tcl) now returns
270            0 and no_read=1 when a sequence does not match the input.
271            The SECOND HALFs in codetables.xml produces a non-existant
272            entry in the conversion trie.. Hence when met, the input byte is
273            skipped as it should (in yaz_iconv)
274         */
275 #if 0
276         if (x == 0x0361 || x == 0x0360)
277             *no_read += 1;
278 #endif
279         cd->comb_offset++;
280         return x;
281     }
282
283     cd->comb_offset = 0;
284     for (cd->comb_size = 0; cd->comb_size < 8; cd->comb_size++)
285     {
286         int comb = 0;
287         x = yaz_read_marc8_comb(cd, inp, inbytesleft, no_read, &comb);
288         if (!comb || !x)
289             break;
290         cd->comb_x[cd->comb_size] = x;
291         cd->comb_no_read[cd->comb_size] = *no_read;
292         inp += *no_read;
293         inbytesleft = inbytesleft - *no_read;
294     }
295     return x;
296 }
297
298 static unsigned long yaz_read_marc8_comb (yaz_iconv_t cd, unsigned char *inp,
299                                           size_t inbytesleft, size_t *no_read,
300                                           int *comb)
301 {
302     *no_read = 0;
303     while(inbytesleft >= 1 && inp[0] == 27)
304     {
305         size_t inbytesleft0 = inbytesleft;
306         inp++;
307         inbytesleft--;
308         while(inbytesleft > 0 && strchr("(,$!", *inp))
309         {
310             inbytesleft--;
311             inp++;
312         }
313         if (inbytesleft <= 0)
314         {
315             *no_read = 0;
316             cd->my_errno = YAZ_ICONV_EINVAL;
317             return 0;
318         }
319         cd->marc8_esc_mode = *inp++;
320         inbytesleft--;
321         (*no_read) += inbytesleft0 - inbytesleft;
322     }
323     if (inbytesleft <= 0)
324         return 0;
325     else
326     {
327         unsigned long x;
328         size_t no_read_sub = 0;
329         *comb = 0;
330
331         switch(cd->marc8_esc_mode)
332         {
333         case 'B':  /* Basic ASCII */
334         case 'E':  /* ANSEL */
335         case 's':  /* ASCII */
336             x = yaz_marc8_1_conv(inp, inbytesleft, &no_read_sub, comb);
337             break;
338         case 'g':  /* Greek */
339             x = yaz_marc8_2_conv(inp, inbytesleft, &no_read_sub, comb);
340             break;
341         case 'b':  /* Subscripts */
342             x = yaz_marc8_3_conv(inp, inbytesleft, &no_read_sub, comb);
343             break;
344         case 'p':  /* Superscripts */
345             x = yaz_marc8_4_conv(inp, inbytesleft, &no_read_sub, comb);
346             break;
347         case '2':  /* Basic Hebrew */
348             x = yaz_marc8_5_conv(inp, inbytesleft, &no_read_sub, comb);
349             break;
350         case 'N':  /* Basic Cyrillic */
351         case 'Q':  /* Extended Cyrillic */
352             x = yaz_marc8_6_conv(inp, inbytesleft, &no_read_sub, comb);
353             break;
354         case '3':  /* Basic Arabic */
355         case '4':  /* Extended Arabic */
356             x = yaz_marc8_7_conv(inp, inbytesleft, &no_read_sub, comb);
357             break;
358         case 'S':  /* Greek */
359             x = yaz_marc8_8_conv(inp, inbytesleft, &no_read_sub, comb);
360             break;
361         case '1':  /* Chinese, Japanese, Korean (EACC) */
362             x = yaz_marc8_9_conv(inp, inbytesleft, &no_read_sub, comb);
363             break;
364         default:
365             *no_read = 0;
366             cd->my_errno = YAZ_ICONV_EILSEQ;
367             return 0;
368         }
369         *no_read += no_read_sub;
370         return x;
371     }
372 }
373
374 static size_t yaz_write_UTF8 (yaz_iconv_t cd, unsigned long x,
375                               char **outbuf, size_t *outbytesleft,
376                               int last)
377 {
378     unsigned char *outp = (unsigned char *) *outbuf;
379
380     if (x <= 0x7f && *outbytesleft >= 1)
381     {
382         *outp++ = (unsigned char) x;
383         (*outbytesleft)--;
384     } 
385     else if (x <= 0x7ff && *outbytesleft >= 2)
386     {
387         *outp++ = (unsigned char) ((x >> 6) | 0xc0);
388         *outp++ = (unsigned char) ((x & 0x3f) | 0x80);
389         (*outbytesleft) -= 2;
390     }
391     else if (x <= 0xffff && *outbytesleft >= 3)
392     {
393         *outp++ = (unsigned char) ((x >> 12) | 0xe0);
394         *outp++ = (unsigned char) (((x >> 6) & 0x3f) | 0x80);
395         *outp++ = (unsigned char) ((x & 0x3f) | 0x80);
396         (*outbytesleft) -= 3;
397     }
398     else if (x <= 0x1fffff && *outbytesleft >= 4)
399     {
400         *outp++ = (unsigned char) ((x >> 18) | 0xf0);
401         *outp++ = (unsigned char) (((x >> 12) & 0x3f) | 0x80);
402         *outp++ = (unsigned char) (((x >> 6)  & 0x3f) | 0x80);
403         *outp++ = (unsigned char) ((x & 0x3f) | 0x80);
404         (*outbytesleft) -= 4;
405     }
406     else if (x <= 0x3ffffff && *outbytesleft >= 5)
407     {
408         *outp++ = (unsigned char) ((x >> 24) | 0xf8);
409         *outp++ = (unsigned char) (((x >> 18) & 0x3f) | 0x80);
410         *outp++ = (unsigned char) (((x >> 12) & 0x3f) | 0x80);
411         *outp++ = (unsigned char) (((x >> 6)  & 0x3f) | 0x80);
412         *outp++ = (unsigned char) ((x & 0x3f) | 0x80);
413         (*outbytesleft) -= 5;
414     }
415     else if (*outbytesleft >= 6)
416     {
417         *outp++ = (unsigned char) ((x >> 30) | 0xfc);
418         *outp++ = (unsigned char) (((x >> 24) & 0x3f) | 0x80);
419         *outp++ = (unsigned char) (((x >> 18) & 0x3f) | 0x80);
420         *outp++ = (unsigned char) (((x >> 12) & 0x3f) | 0x80);
421         *outp++ = (unsigned char) (((x >> 6)  & 0x3f) | 0x80);
422         *outp++ = (unsigned char) ((x & 0x3f) | 0x80);
423         (*outbytesleft) -= 6;
424     }
425     else 
426     {
427         cd->my_errno = YAZ_ICONV_E2BIG;  /* not room for output */
428         return (size_t)(-1);
429     }
430     *outbuf = (char *) outp;
431     return 0;
432 }
433
434
435 static size_t yaz_write_ISO8859_1 (yaz_iconv_t cd, unsigned long x,
436                                    char **outbuf, size_t *outbytesleft,
437                                    int last)
438 {
439     /* list of two char unicode sequence that, when combined, are
440        equivalent to single unicode chars that can be represented in
441        ISO-8859-1/Latin-1.
442        Regular iconv on Linux at least does not seem to convert these,
443        but since MARC-8 to UTF-8 generates these composed sequence
444        we get a better chance of a successful MARC-8 -> ISO-8859-1
445        conversion */
446     static struct {
447         unsigned long x1, x2;
448         unsigned y;
449     } comb[] = {
450         { 'A', 0x0300, 0xc0}, /* LATIN CAPITAL LETTER A WITH GRAVE */
451         { 'A', 0x0301, 0xc1}, /* LATIN CAPITAL LETTER A WITH ACUTE */
452         { 'A', 0x0302, 0xc2}, /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
453         { 'A', 0x0303, 0xc3}, /* LATIN CAPITAL LETTER A WITH TILDE */
454         { 'A', 0x0308, 0xc4}, /* LATIN CAPITAL LETTER A WITH DIAERESIS */
455         { 'A', 0x030a, 0xc5}, /* LATIN CAPITAL LETTER A WITH RING ABOVE */
456         /* no need for 0xc6      LATIN CAPITAL LETTER AE */
457         { 'C', 0x0327, 0xc7}, /* LATIN CAPITAL LETTER C WITH CEDILLA */
458         { 'E', 0x0300, 0xc8}, /* LATIN CAPITAL LETTER E WITH GRAVE */
459         { 'E', 0x0301, 0xc9}, /* LATIN CAPITAL LETTER E WITH ACUTE */
460         { 'E', 0x0302, 0xca}, /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
461         { 'E', 0x0308, 0xcb}, /* LATIN CAPITAL LETTER E WITH DIAERESIS */
462         { 'I', 0x0300, 0xcc}, /* LATIN CAPITAL LETTER I WITH GRAVE */
463         { 'I', 0x0301, 0xcd}, /* LATIN CAPITAL LETTER I WITH ACUTE */
464         { 'I', 0x0302, 0xce}, /* LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
465         { 'I', 0x0308, 0xcf}, /* LATIN CAPITAL LETTER I WITH DIAERESIS */
466         { 'N', 0x0303, 0xd1}, /* LATIN CAPITAL LETTER N WITH TILDE */
467         { 'O', 0x0300, 0xd2}, /* LATIN CAPITAL LETTER O WITH GRAVE */
468         { 'O', 0x0301, 0xd3}, /* LATIN CAPITAL LETTER O WITH ACUTE */
469         { 'O', 0x0302, 0xd4}, /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
470         { 'O', 0x0303, 0xd5}, /* LATIN CAPITAL LETTER O WITH TILDE */
471         { 'O', 0x0308, 0xd6}, /* LATIN CAPITAL LETTER O WITH DIAERESIS */
472         /* omitted:    0xd7      MULTIPLICATION SIGN */
473         /* omitted:    0xd8      LATIN CAPITAL LETTER O WITH STROKE */
474         { 'U', 0x0300, 0xd9}, /* LATIN CAPITAL LETTER U WITH GRAVE */
475         { 'U', 0x0301, 0xda}, /* LATIN CAPITAL LETTER U WITH ACUTE */
476         { 'U', 0x0302, 0xdb}, /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
477         { 'U', 0x0308, 0xdc}, /* LATIN CAPITAL LETTER U WITH DIAERESIS */
478         { 'Y', 0x0301, 0xdd}, /* LATIN CAPITAL LETTER Y WITH ACUTE */
479         /* omitted:    0xde      LATIN CAPITAL LETTER THORN */
480         /* omitted:    0xdf      LATIN SMALL LETTER SHARP S */
481         { 'a', 0x0300, 0xe0}, /* LATIN SMALL LETTER A WITH GRAVE */
482         { 'a', 0x0301, 0xe1}, /* LATIN SMALL LETTER A WITH ACUTE */
483         { 'a', 0x0302, 0xe2}, /* LATIN SMALL LETTER A WITH CIRCUMFLEX */
484         { 'a', 0x0303, 0xe3}, /* LATIN SMALL LETTER A WITH TILDE */
485         { 'a', 0x0308, 0xe4}, /* LATIN SMALL LETTER A WITH DIAERESIS */
486         { 'a', 0x030a, 0xe5}, /* LATIN SMALL LETTER A WITH RING ABOVE */
487         /* omitted:    0xe6      LATIN SMALL LETTER AE */
488         { 'c', 0x0327, 0xe7}, /* LATIN SMALL LETTER C WITH CEDILLA */
489         { 'e', 0x0300, 0xe8}, /* LATIN SMALL LETTER E WITH GRAVE */
490         { 'e', 0x0301, 0xe9}, /* LATIN SMALL LETTER E WITH ACUTE */
491         { 'e', 0x0302, 0xea}, /* LATIN SMALL LETTER E WITH CIRCUMFLEX */
492         { 'e', 0x0308, 0xeb}, /* LATIN SMALL LETTER E WITH DIAERESIS */
493         { 'i', 0x0300, 0xec}, /* LATIN SMALL LETTER I WITH GRAVE */
494         { 'i', 0x0301, 0xed}, /* LATIN SMALL LETTER I WITH ACUTE */
495         { 'i', 0x0302, 0xee}, /* LATIN SMALL LETTER I WITH CIRCUMFLEX */
496         { 'i', 0x0308, 0xef}, /* LATIN SMALL LETTER I WITH DIAERESIS */
497         /* omitted:    0xf0      LATIN SMALL LETTER ETH */
498         { 'n', 0x0303, 0xf1}, /* LATIN SMALL LETTER N WITH TILDE */
499         { 'o', 0x0300, 0xf2}, /* LATIN SMALL LETTER O WITH GRAVE */
500         { 'o', 0x0301, 0xf3}, /* LATIN SMALL LETTER O WITH ACUTE */
501         { 'o', 0x0302, 0xf4}, /* LATIN SMALL LETTER O WITH CIRCUMFLEX */
502         { 'o', 0x0303, 0xf5}, /* LATIN SMALL LETTER O WITH TILDE */
503         { 'o', 0x0308, 0xf6}, /* LATIN SMALL LETTER O WITH DIAERESIS */
504         /* omitted:    0xf7      DIVISION SIGN */
505         /* omitted:    0xf8      LATIN SMALL LETTER O WITH STROKE */
506         { 'u', 0x0300, 0xf9}, /* LATIN SMALL LETTER U WITH GRAVE */
507         { 'u', 0x0301, 0xfa}, /* LATIN SMALL LETTER U WITH ACUTE */
508         { 'u', 0x0302, 0xfb}, /* LATIN SMALL LETTER U WITH CIRCUMFLEX */
509         { 'u', 0x0308, 0xfc}, /* LATIN SMALL LETTER U WITH DIAERESIS */
510         { 'y', 0x0301, 0xfd}, /* LATIN SMALL LETTER Y WITH ACUTE */
511         /* omitted:    0xfe      LATIN SMALL LETTER THORN */
512         { 'y', 0x0308, 0xff}, /* LATIN SMALL LETTER Y WITH DIAERESIS */
513         
514         { 0, 0, 0}
515     };
516     unsigned char *outp = (unsigned char *) *outbuf;
517
518     if (cd->compose_char)
519     {
520         int i;
521         for (i = 0; comb[i].x1; i++)
522             if (cd->compose_char == comb[i].x1 && x == comb[i].x2)
523             {
524                 x = comb[i].y;
525                 break;
526             }
527         if (*outbytesleft < 1)
528         {  /* no room. Retain compose_char and bail out */
529             cd->my_errno = YAZ_ICONV_E2BIG;
530             return (size_t)(-1);
531         }
532         if (!comb[i].x1) 
533         {   /* not found. Just write compose_char */
534             *outp++ = (unsigned char) cd->compose_char;
535             (*outbytesleft)--;
536             *outbuf = (char *) outp;
537         }
538         /* compose_char used so reset it. x now holds current char */
539         cd->compose_char = 0;
540     }
541
542     if (!last && x > 32 && x < 127 && cd->compose_char == 0)
543     {
544         cd->compose_char = x;
545         return 0;
546     }
547     else if (x > 255 || x < 1)
548     {
549         cd->my_errno = YAZ_ICONV_EILSEQ;
550         return (size_t) -1;
551     }
552     else if (*outbytesleft < 1)
553     {
554         cd->my_errno = YAZ_ICONV_E2BIG;
555         return (size_t)(-1);
556     }
557     *outp++ = (unsigned char) x;
558     (*outbytesleft)--;
559     *outbuf = (char *) outp;
560     return 0;
561 }
562
563
564 static size_t yaz_write_UCS4 (yaz_iconv_t cd, unsigned long x,
565                               char **outbuf, size_t *outbytesleft,
566                               int last)
567 {
568     unsigned char *outp = (unsigned char *) *outbuf;
569     if (*outbytesleft >= 4)
570     {
571         *outp++ = (unsigned char) (x>>24);
572         *outp++ = (unsigned char) (x>>16);
573         *outp++ = (unsigned char) (x>>8);
574         *outp++ = (unsigned char) x;
575         (*outbytesleft) -= 4;
576     }
577     else
578     {
579         cd->my_errno = YAZ_ICONV_E2BIG;
580         return (size_t)(-1);
581     }
582     *outbuf = (char *) outp;
583     return 0;
584 }
585
586 static size_t yaz_write_UCS4LE (yaz_iconv_t cd, unsigned long x,
587                                 char **outbuf, size_t *outbytesleft,
588                                 int last)
589 {
590     unsigned char *outp = (unsigned char *) *outbuf;
591     if (*outbytesleft >= 4)
592     {
593         *outp++ = (unsigned char) x;
594         *outp++ = (unsigned char) (x>>8);
595         *outp++ = (unsigned char) (x>>16);
596         *outp++ = (unsigned char) (x>>24);
597         (*outbytesleft) -= 4;
598     }
599     else
600     {
601         cd->my_errno = YAZ_ICONV_E2BIG;
602         return (size_t)(-1);
603     }
604     *outbuf = (char *) outp;
605     return 0;
606 }
607
608 #if HAVE_WCHAR_H
609 static size_t yaz_write_wchar_t (yaz_iconv_t cd, unsigned long x,
610                                  char **outbuf, size_t *outbytesleft,
611                                  int last)
612 {
613     unsigned char *outp = (unsigned char *) *outbuf;
614
615     if (*outbytesleft >= sizeof(wchar_t))
616     {
617         wchar_t wch = x;
618         memcpy(outp, &wch, sizeof(wch));
619         outp += sizeof(wch);
620         (*outbytesleft) -= sizeof(wch);
621     }
622     else
623     {
624         cd->my_errno = YAZ_ICONV_E2BIG;
625         return (size_t)(-1);
626     }
627     *outbuf = (char *) outp;
628     return 0;
629 }
630 #endif
631
632 int yaz_iconv_isbuiltin(yaz_iconv_t cd)
633 {
634     return cd->read_handle && cd->write_handle;
635 }
636
637 yaz_iconv_t yaz_iconv_open (const char *tocode, const char *fromcode)
638 {
639     yaz_iconv_t cd = (yaz_iconv_t) xmalloc (sizeof(*cd));
640
641     cd->write_handle = 0;
642     cd->read_handle = 0;
643     cd->init_handle = 0;
644     cd->my_errno = YAZ_ICONV_UNKNOWN;
645     cd->marc8_esc_mode = 'B';
646     cd->comb_offset = cd->comb_size = 0;
647     cd->compose_char = 0;
648
649     /* a useful hack: if fromcode has leading @,
650        the library not use YAZ's own conversions .. */
651     if (fromcode[0] == '@')
652         fromcode++;
653     else
654     {
655         if (!yaz_matchstr(fromcode, "UTF8"))
656         {
657             cd->read_handle = yaz_read_UTF8;
658             cd->init_handle = yaz_init_UTF8;
659         }
660         else if (!yaz_matchstr(fromcode, "ISO88591"))
661             cd->read_handle = yaz_read_ISO8859_1;
662         else if (!yaz_matchstr(fromcode, "UCS4"))
663             cd->read_handle = yaz_read_UCS4;
664         else if (!yaz_matchstr(fromcode, "UCS4LE"))
665             cd->read_handle = yaz_read_UCS4LE;
666         else if (!yaz_matchstr(fromcode, "MARC8"))
667             cd->read_handle = yaz_read_marc8;
668 #if HAVE_WCHAR_H
669         else if (!yaz_matchstr(fromcode, "WCHAR_T"))
670             cd->read_handle = yaz_read_wchar_t;
671 #endif
672         
673         if (!yaz_matchstr(tocode, "UTF8"))
674             cd->write_handle = yaz_write_UTF8;
675         else if (!yaz_matchstr(tocode, "ISO88591"))
676             cd->write_handle = yaz_write_ISO8859_1;
677         else if (!yaz_matchstr (tocode, "UCS4"))
678             cd->write_handle = yaz_write_UCS4;
679         else if (!yaz_matchstr(tocode, "UCS4LE"))
680             cd->write_handle = yaz_write_UCS4LE;
681 #if HAVE_WCHAR_H
682         else if (!yaz_matchstr(tocode, "WCHAR_T"))
683             cd->write_handle = yaz_write_wchar_t;
684 #endif
685     }
686 #if HAVE_ICONV_H
687     cd->iconv_cd = 0;
688     if (!cd->read_handle || !cd->write_handle)
689     {
690         cd->iconv_cd = iconv_open (tocode, fromcode);
691         if (cd->iconv_cd == (iconv_t) (-1))
692         {
693             xfree (cd);
694             return 0;
695         }
696     }
697 #else
698     if (!cd->read_handle || !cd->write_handle)
699     {
700         xfree (cd);
701         return 0;
702     }
703 #endif
704     cd->init_flag = 1;
705     return cd;
706 }
707
708 size_t yaz_iconv(yaz_iconv_t cd, char **inbuf, size_t *inbytesleft,
709                  char **outbuf, size_t *outbytesleft)
710 {
711     char *inbuf0;
712     size_t r = 0;
713
714 #if HAVE_ICONV_H
715     if (cd->iconv_cd)
716     {
717         size_t r =
718             iconv(cd->iconv_cd, inbuf, inbytesleft, outbuf, outbytesleft);
719         if (r == (size_t)(-1))
720         {
721             switch (yaz_errno())
722             {
723             case E2BIG:
724                 cd->my_errno = YAZ_ICONV_E2BIG;
725                 break;
726             case EINVAL:
727                 cd->my_errno = YAZ_ICONV_EINVAL;
728                 break;
729             case EILSEQ:
730                 cd->my_errno = YAZ_ICONV_EILSEQ;
731                 break;
732             default:
733                 cd->my_errno = YAZ_ICONV_UNKNOWN;
734             }
735         }
736         return r;
737     }
738 #endif
739     if (inbuf == 0 || *inbuf == 0)
740     {
741         cd->init_flag = 1;
742         cd->my_errno = YAZ_ICONV_UNKNOWN;
743         return 0;
744     }
745     inbuf0 = *inbuf;
746
747     if (cd->init_flag)
748     {
749         if (cd->init_handle)
750         {
751             size_t no_read;
752             size_t r = (cd->init_handle)(cd, (unsigned char *) *inbuf,
753                                          *inbytesleft, &no_read);
754             if (r)
755             {
756                 if (cd->my_errno == YAZ_ICONV_EINVAL)
757                     return r;
758                 cd->init_flag = 0;
759                 return r;
760             }
761             *inbytesleft -= no_read;
762             *inbuf += no_read;
763         }
764         cd->init_flag = 0;
765         cd->unget_x = 0;
766         cd->no_read_x = 0;
767     }
768     while (1)
769     {
770         unsigned long x;
771         size_t no_read;
772
773         if (*inbytesleft == 0)
774         {
775             r = *inbuf - inbuf0;
776             break;
777         }
778         if (!cd->unget_x)
779         {
780             x = (cd->read_handle)(cd, (unsigned char *) *inbuf, *inbytesleft,
781                                   &no_read);
782             if (no_read == 0)
783             {
784                 r = (size_t)(-1);
785                 break;
786             }
787         }
788         else
789         {
790             x = cd->unget_x;
791             no_read = cd->no_read_x;
792         }
793         if (x)
794         {
795             r = (cd->write_handle)(cd, x, outbuf, outbytesleft,
796                                    (*inbytesleft - no_read) == 0 ? 1 : 0);
797             if (r)
798             {
799                 /* unable to write it. save it because read_handle cannot
800                    rewind .. */
801                 if (cd->my_errno == YAZ_ICONV_E2BIG)
802                 {
803                     cd->unget_x = x;
804                     cd->no_read_x = no_read;
805                     break;
806                 }
807             }
808             cd->unget_x = 0;
809         }
810         *inbytesleft -= no_read;
811         (*inbuf) += no_read;
812     }
813     return r;
814 }
815
816 int yaz_iconv_error (yaz_iconv_t cd)
817 {
818     return cd->my_errno;
819 }
820
821 int yaz_iconv_close (yaz_iconv_t cd)
822 {
823 #if HAVE_ICONV_H
824     if (cd->iconv_cd)
825         iconv_close (cd->iconv_cd);
826 #endif
827     xfree (cd);
828     return 0;
829 }
830
831     
832 /*
833  * Local variables:
834  * c-basic-offset: 4
835  * indent-tabs-mode: nil
836  * End:
837  * vim: shiftwidth=4 tabstop=8 expandtab
838  */
839