src/siconv.c

   1 /*
   2  * Copyright (C) 1995-2007, Index Data ApS
   3  * See the file LICENSE for details.
   4  *
   5  * $Id: siconv.c,v 1.43 2007-09-17 19:18:27 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 conversions: UTF-8, MARC-8, Latin-1.
  15  *
  16  * MARC-8 reference:
  17  *  http://www.loc.gov/marc/specifications/speccharmarc8.html
  18  */
  19
  20 #if HAVE_CONFIG_H
  21 #include <config.h>
  22 #endif
  23
  24 #include <assert.h>
  25 #include <errno.h>
  26 #include <string.h>
  27 #include <ctype.h>
  28 #if HAVE_WCHAR_H
  29 #include <wchar.h>
  30 #endif
  31
  32 #if HAVE_ICONV_H
  33 #include <iconv.h>
  34 #endif
  35
  36
  37 #include <yaz/yaz-util.h>
  38
  39 unsigned long yaz_marc8_42_conv(unsigned char *inp, size_t inbytesleft,
  40                                size_t *no_read, int *combining);
  41 unsigned long yaz_marc8_45_conv(unsigned char *inp, size_t inbytesleft,
  42                                size_t *no_read, int *combining);
  43 unsigned long yaz_marc8_67_conv(unsigned char *inp, size_t inbytesleft,
  44                                size_t *no_read, int *combining);
  45 unsigned long yaz_marc8_62_conv(unsigned char *inp, size_t inbytesleft,
  46                                size_t *no_read, int *combining);
  47 unsigned long yaz_marc8_70_conv(unsigned char *inp, size_t inbytesleft,
  48                                size_t *no_read, int *combining);
  49 unsigned long yaz_marc8_32_conv(unsigned char *inp, size_t inbytesleft,
  50                                size_t *no_read, int *combining);
  51 unsigned long yaz_marc8_4E_conv(unsigned char *inp, size_t inbytesleft,
  52                                size_t *no_read, int *combining);
  53 unsigned long yaz_marc8_51_conv(unsigned char *inp, size_t inbytesleft,
  54                                size_t *no_read, int *combining);
  55 unsigned long yaz_marc8_33_conv(unsigned char *inp, size_t inbytesleft,
  56                                size_t *no_read, int *combining);
  57 unsigned long yaz_marc8_34_conv(unsigned char *inp, size_t inbytesleft,
  58                                size_t *no_read, int *combining);
  59 unsigned long yaz_marc8_53_conv(unsigned char *inp, size_t inbytesleft,
  60                                size_t *no_read, int *combining);
  61 unsigned long yaz_marc8_31_conv(unsigned char *inp, size_t inbytesleft,
  62                                size_t *no_read, int *combining);
  63
  64
  65 unsigned long yaz_marc8r_42_conv(unsigned char *inp, size_t inbytesleft,
  66                                  size_t *no_read, int *combining);
  67 unsigned long yaz_marc8r_45_conv(unsigned char *inp, size_t inbytesleft,
  68                                  size_t *no_read, int *combining);
  69 unsigned long yaz_marc8r_67_conv(unsigned char *inp, size_t inbytesleft,
  70                                  size_t *no_read, int *combining);
  71 unsigned long yaz_marc8r_62_conv(unsigned char *inp, size_t inbytesleft,
  72                                  size_t *no_read, int *combining);
  73 unsigned long yaz_marc8r_70_conv(unsigned char *inp, size_t inbytesleft,
  74                                  size_t *no_read, int *combining);
  75 unsigned long yaz_marc8r_32_conv(unsigned char *inp, size_t inbytesleft,
  76                                  size_t *no_read, int *combining);
  77 unsigned long yaz_marc8r_4E_conv(unsigned char *inp, size_t inbytesleft,
  78                                  size_t *no_read, int *combining);
  79 unsigned long yaz_marc8r_51_conv(unsigned char *inp, size_t inbytesleft,
  80                                  size_t *no_read, int *combining);
  81 unsigned long yaz_marc8r_33_conv(unsigned char *inp, size_t inbytesleft,
  82                                  size_t *no_read, int *combining);
  83 unsigned long yaz_marc8r_34_conv(unsigned char *inp, size_t inbytesleft,
  84                                  size_t *no_read, int *combining);
  85 unsigned long yaz_marc8r_53_conv(unsigned char *inp, size_t inbytesleft,
  86                                  size_t *no_read, int *combining);
  87 unsigned long yaz_marc8r_31_conv(unsigned char *inp, size_t inbytesleft,
  88                                  size_t *no_read, int *combining);
  89
  90 struct yaz_iconv_struct {
  91     int my_errno;
  92     int init_flag;
  93     size_t (*init_handle)(yaz_iconv_t cd, unsigned char *inbuf,
  94                           size_t inbytesleft, size_t *no_read);
  95     unsigned long (*read_handle)(yaz_iconv_t cd, unsigned char *inbuf,
  96                                  size_t inbytesleft, size_t *no_read);
  97     size_t (*write_handle)(yaz_iconv_t cd, unsigned long x,
  98                            char **outbuf, size_t *outbytesleft);
  99     size_t (*flush_handle)(yaz_iconv_t cd,
 100                            char **outbuf, size_t *outbytesleft);
 101     int marc8_esc_mode;
 102
 103     int comb_offset;
 104     int comb_size;
 105     unsigned long comb_x[8];
 106     size_t comb_no_read[8];
 107     size_t no_read_x;
 108     unsigned long unget_x;
 109 #if HAVE_ICONV_H
 110     iconv_t iconv_cd;
 111 #endif
 112     unsigned long compose_char;
 113
 114     unsigned long write_marc8_comb_ch[8];
 115     size_t write_marc8_comb_no;
 116     unsigned write_marc8_second_half_char;
 117     unsigned long write_marc8_last;
 118     const char *write_marc8_page_chr;
 119 };
 120
 121 static struct {
 122     unsigned long x1, x2;
 123     unsigned y;
 124 } latin1_comb[] = {
 125     { 'A', 0x0300, 0xc0}, /* LATIN CAPITAL LETTER A WITH GRAVE */
 126     { 'A', 0x0301, 0xc1}, /* LATIN CAPITAL LETTER A WITH ACUTE */
 127     { 'A', 0x0302, 0xc2}, /* LATIN CAPITAL LETTER A WITH CIRCUMFLEX */
 128     { 'A', 0x0303, 0xc3}, /* LATIN CAPITAL LETTER A WITH TILDE */
 129     { 'A', 0x0308, 0xc4}, /* LATIN CAPITAL LETTER A WITH DIAERESIS */
 130     { 'A', 0x030a, 0xc5}, /* LATIN CAPITAL LETTER A WITH RING ABOVE */
 131     /* no need for 0xc6      LATIN CAPITAL LETTER AE */
 132     { 'C', 0x0327, 0xc7}, /* LATIN CAPITAL LETTER C WITH CEDILLA */
 133     { 'E', 0x0300, 0xc8}, /* LATIN CAPITAL LETTER E WITH GRAVE */
 134     { 'E', 0x0301, 0xc9}, /* LATIN CAPITAL LETTER E WITH ACUTE */
 135     { 'E', 0x0302, 0xca}, /* LATIN CAPITAL LETTER E WITH CIRCUMFLEX */
 136     { 'E', 0x0308, 0xcb}, /* LATIN CAPITAL LETTER E WITH DIAERESIS */
 137     { 'I', 0x0300, 0xcc}, /* LATIN CAPITAL LETTER I WITH GRAVE */
 138     { 'I', 0x0301, 0xcd}, /* LATIN CAPITAL LETTER I WITH ACUTE */
 139     { 'I', 0x0302, 0xce}, /* LATIN CAPITAL LETTER I WITH CIRCUMFLEX */
 140     { 'I', 0x0308, 0xcf}, /* LATIN CAPITAL LETTER I WITH DIAERESIS */
 141     { 'N', 0x0303, 0xd1}, /* LATIN CAPITAL LETTER N WITH TILDE */
 142     { 'O', 0x0300, 0xd2}, /* LATIN CAPITAL LETTER O WITH GRAVE */
 143     { 'O', 0x0301, 0xd3}, /* LATIN CAPITAL LETTER O WITH ACUTE */
 144     { 'O', 0x0302, 0xd4}, /* LATIN CAPITAL LETTER O WITH CIRCUMFLEX */
 145     { 'O', 0x0303, 0xd5}, /* LATIN CAPITAL LETTER O WITH TILDE */
 146     { 'O', 0x0308, 0xd6}, /* LATIN CAPITAL LETTER O WITH DIAERESIS */
 147     /* omitted:    0xd7      MULTIPLICATION SIGN */
 148     /* omitted:    0xd8      LATIN CAPITAL LETTER O WITH STROKE */
 149     { 'U', 0x0300, 0xd9}, /* LATIN CAPITAL LETTER U WITH GRAVE */
 150     { 'U', 0x0301, 0xda}, /* LATIN CAPITAL LETTER U WITH ACUTE */
 151     { 'U', 0x0302, 0xdb}, /* LATIN CAPITAL LETTER U WITH CIRCUMFLEX */
 152     { 'U', 0x0308, 0xdc}, /* LATIN CAPITAL LETTER U WITH DIAERESIS */
 153     { 'Y', 0x0301, 0xdd}, /* LATIN CAPITAL LETTER Y WITH ACUTE */
 154     /* omitted:    0xde      LATIN CAPITAL LETTER THORN */
 155     /* omitted:    0xdf      LATIN SMALL LETTER SHARP S */
 156     { 'a', 0x0300, 0xe0}, /* LATIN SMALL LETTER A WITH GRAVE */
 157     { 'a', 0x0301, 0xe1}, /* LATIN SMALL LETTER A WITH ACUTE */
 158     { 'a', 0x0302, 0xe2}, /* LATIN SMALL LETTER A WITH CIRCUMFLEX */
 159     { 'a', 0x0303, 0xe3}, /* LATIN SMALL LETTER A WITH TILDE */
 160     { 'a', 0x0308, 0xe4}, /* LATIN SMALL LETTER A WITH DIAERESIS */
 161     { 'a', 0x030a, 0xe5}, /* LATIN SMALL LETTER A WITH RING ABOVE */
 162     /* omitted:    0xe6      LATIN SMALL LETTER AE */
 163     { 'c', 0x0327, 0xe7}, /* LATIN SMALL LETTER C WITH CEDILLA */
 164     { 'e', 0x0300, 0xe8}, /* LATIN SMALL LETTER E WITH GRAVE */
 165     { 'e', 0x0301, 0xe9}, /* LATIN SMALL LETTER E WITH ACUTE */
 166     { 'e', 0x0302, 0xea}, /* LATIN SMALL LETTER E WITH CIRCUMFLEX */
 167     { 'e', 0x0308, 0xeb}, /* LATIN SMALL LETTER E WITH DIAERESIS */
 168     { 'i', 0x0300, 0xec}, /* LATIN SMALL LETTER I WITH GRAVE */
 169     { 'i', 0x0301, 0xed}, /* LATIN SMALL LETTER I WITH ACUTE */
 170     { 'i', 0x0302, 0xee}, /* LATIN SMALL LETTER I WITH CIRCUMFLEX */
 171     { 'i', 0x0308, 0xef}, /* LATIN SMALL LETTER I WITH DIAERESIS */
 172     /* omitted:    0xf0      LATIN SMALL LETTER ETH */
 173     { 'n', 0x0303, 0xf1}, /* LATIN SMALL LETTER N WITH TILDE */
 174     { 'o', 0x0300, 0xf2}, /* LATIN SMALL LETTER O WITH GRAVE */
 175     { 'o', 0x0301, 0xf3}, /* LATIN SMALL LETTER O WITH ACUTE */
 176     { 'o', 0x0302, 0xf4}, /* LATIN SMALL LETTER O WITH CIRCUMFLEX */
 177     { 'o', 0x0303, 0xf5}, /* LATIN SMALL LETTER O WITH TILDE */
 178     { 'o', 0x0308, 0xf6}, /* LATIN SMALL LETTER O WITH DIAERESIS */
 179     /* omitted:    0xf7      DIVISION SIGN */
 180     /* omitted:    0xf8      LATIN SMALL LETTER O WITH STROKE */
 181     { 'u', 0x0300, 0xf9}, /* LATIN SMALL LETTER U WITH GRAVE */
 182     { 'u', 0x0301, 0xfa}, /* LATIN SMALL LETTER U WITH ACUTE */
 183     { 'u', 0x0302, 0xfb}, /* LATIN SMALL LETTER U WITH CIRCUMFLEX */
 184     { 'u', 0x0308, 0xfc}, /* LATIN SMALL LETTER U WITH DIAERESIS */
 185     { 'y', 0x0301, 0xfd}, /* LATIN SMALL LETTER Y WITH ACUTE */
 186     /* omitted:    0xfe      LATIN SMALL LETTER THORN */
 187     { 'y', 0x0308, 0xff}, /* LATIN SMALL LETTER Y WITH DIAERESIS */
 188
 189     { 0, 0, 0}
 190 };
 191
 192 static unsigned long yaz_read_ISO8859_1 (yaz_iconv_t cd, unsigned char *inp,
 193                                          size_t inbytesleft, size_t *no_read)
 194 {
 195     unsigned long x = inp[0];
 196     *no_read = 1;
 197     return x;
 198 }
 199
 200
 201 static size_t yaz_init_UTF8 (yaz_iconv_t cd, unsigned char *inp,
 202                              size_t inbytesleft, size_t *no_read)
 203 {
 204     if (inp[0] != 0xef)
 205     {
 206         *no_read = 0;
 207         return 0;
 208     }
 209     if (inbytesleft < 3)
 210     {
 211         cd->my_errno = YAZ_ICONV_EINVAL;
 212         return (size_t) -1;
 213     }
 214     if (inp[1] != 0xbb && inp[2] == 0xbf)
 215         *no_read = 3;
 216     else
 217         *no_read = 0;
 218     return 0;
 219 }
 220
 221 unsigned long yaz_read_UTF8_char(unsigned char *inp,
 222                                  size_t inbytesleft, size_t *no_read,
 223                                  int *error)
 224 {
 225     unsigned long x = 0;
 226
 227     *no_read = 0; /* by default */
 228     if (inp[0] <= 0x7f)
 229     {
 230         x = inp[0];
 231         *no_read = 1;
 232     }
 233     else if (inp[0] <= 0xbf || inp[0] >= 0xfe)
 234     {
 235         *error = YAZ_ICONV_EILSEQ;
 236     }
 237     else if (inp[0] <= 0xdf && inbytesleft >= 2)
 238     {
 239         if ((inp[1] & 0xc0) == 0x80)
 240         {
 241             x = ((inp[0] & 0x1f) << 6) | (inp[1] & 0x3f);
 242             if (x >= 0x80)
 243                 *no_read = 2;
 244             else
 245                 *error = YAZ_ICONV_EILSEQ;
 246         }
 247         else
 248             *error = YAZ_ICONV_EILSEQ;
 249     }
 250     else if (inp[0] <= 0xef && inbytesleft >= 3)
 251     {
 252         if ((inp[1] & 0xc0) == 0x80 && (inp[2] & 0xc0) == 0x80)
 253         {
 254             x = ((inp[0] & 0x0f) << 12) | ((inp[1] & 0x3f) << 6) |
 255                 (inp[2] & 0x3f);
 256             if (x >= 0x800)
 257                 *no_read = 3;
 258             else
 259                 *error = YAZ_ICONV_EILSEQ;
 260         }
 261         else
 262             *error = YAZ_ICONV_EILSEQ;
 263     }
 264     else if (inp[0] <= 0xf7 && inbytesleft >= 4)
 265     {
 266         if ((inp[1] & 0xc0) == 0x80 && (inp[2] & 0xc0) == 0x80
 267             && (inp[3] & 0xc0) == 0x80)
 268         {
 269             x = ((inp[0] & 0x07) << 18) | ((inp[1] & 0x3f) << 12) |
 270                 ((inp[2] & 0x3f) << 6) | (inp[3] & 0x3f);
 271             if (x >= 0x10000)
 272                 *no_read = 4;
 273             else
 274                 *error = YAZ_ICONV_EILSEQ;
 275         }
 276         else
 277             *error = YAZ_ICONV_EILSEQ;
 278     }
 279     else if (inp[0] <= 0xfb && inbytesleft >= 5)
 280     {
 281         if ((inp[1] & 0xc0) == 0x80 && (inp[2] & 0xc0) == 0x80
 282             && (inp[3] & 0xc0) == 0x80 && (inp[4] & 0xc0) == 0x80)
 283         {
 284             x = ((inp[0] & 0x03) << 24) | ((inp[1] & 0x3f) << 18) |
 285                 ((inp[2] & 0x3f) << 12) | ((inp[3] & 0x3f) << 6) |
 286                 (inp[4] & 0x3f);
 287             if (x >= 0x200000)
 288                 *no_read = 5;
 289             else
 290                 *error = YAZ_ICONV_EILSEQ;
 291         }
 292         else
 293             *error = YAZ_ICONV_EILSEQ;
 294     }
 295     else if (inp[0] <= 0xfd && inbytesleft >= 6)
 296     {
 297         if ((inp[1] & 0xc0) == 0x80 && (inp[2] & 0xc0) == 0x80
 298             && (inp[3] & 0xc0) == 0x80 && (inp[4] & 0xc0) == 0x80
 299             && (inp[5] & 0xc0) == 0x80)
 300         {
 301             x = ((inp[0] & 0x01) << 30) | ((inp[1] & 0x3f) << 24) |
 302                 ((inp[2] & 0x3f) << 18) | ((inp[3] & 0x3f) << 12) |
 303                 ((inp[4] & 0x3f) << 6) | (inp[5] & 0x3f);
 304             if (x >= 0x4000000)
 305                 *no_read = 6;
 306             else
 307                 *error = YAZ_ICONV_EILSEQ;
 308         }
 309         else
 310             *error = YAZ_ICONV_EILSEQ;
 311     }
 312     else
 313         *error = YAZ_ICONV_EINVAL;  /* incomplete sentence */
 314
 315     return x;
 316 }
 317
 318 static unsigned long yaz_read_UTF8 (yaz_iconv_t cd, unsigned char *inp,
 319                                     size_t inbytesleft, size_t *no_read)
 320 {
 321     return yaz_read_UTF8_char(inp, inbytesleft, no_read, &cd->my_errno);
 322 }
 323
 324 static unsigned long yaz_read_UCS4 (yaz_iconv_t cd, unsigned char *inp,
 325                                     size_t inbytesleft, size_t *no_read)
 326 {
 327     unsigned long x = 0;
 328
 329     if (inbytesleft < 4)
 330     {
 331         cd->my_errno = YAZ_ICONV_EINVAL; /* incomplete input */
 332         *no_read = 0;
 333     }
 334     else
 335     {
 336         x = (inp[0]<<24) | (inp[1]<<16) | (inp[2]<<8) | inp[3];
 337         *no_read = 4;
 338     }
 339     return x;
 340 }
 341
 342 static unsigned long yaz_read_UCS4LE (yaz_iconv_t cd, unsigned char *inp,
 343                                       size_t inbytesleft, size_t *no_read)
 344 {
 345     unsigned long x = 0;
 346
 347     if (inbytesleft < 4)
 348     {
 349         cd->my_errno = YAZ_ICONV_EINVAL; /* incomplete input */
 350         *no_read = 0;
 351     }
 352     else
 353     {
 354         x = (inp[3]<<24) | (inp[2]<<16) | (inp[1]<<8) | inp[0];
 355         *no_read = 4;
 356     }
 357     return x;
 358 }
 359
 360 #if HAVE_WCHAR_H
 361 static unsigned long yaz_read_wchar_t (yaz_iconv_t cd, unsigned char *inp,
 362                                        size_t inbytesleft, size_t *no_read)
 363 {
 364     unsigned long x = 0;
 365
 366     if (inbytesleft < sizeof(wchar_t))
 367     {
 368         cd->my_errno = YAZ_ICONV_EINVAL; /* incomplete input */
 369         *no_read = 0;
 370     }
 371     else
 372     {
 373         wchar_t wch;
 374         memcpy (&wch, inp, sizeof(wch));
 375         x = wch;
 376         *no_read = sizeof(wch);
 377     }
 378     return x;
 379 }
 380 #endif
 381
 382 static unsigned long yaz_read_iso5428_1984(yaz_iconv_t cd, unsigned char *inp,
 383                                            size_t inbytesleft, size_t *no_read)
 384 {
 385     unsigned long x = 0;
 386     int tonos = 0;
 387     int dialitika = 0;
 388
 389     *no_read = 0;
 390     while (inbytesleft > 0)
 391     {
 392         if (*inp == 0xa2)
 393         {
 394             tonos = 1;
 395         }
 396         else if (*inp == 0xa3)
 397         {
 398             dialitika = 1;
 399         }
 400         else
 401             break;
 402         inp++;
 403         --inbytesleft;
 404         (*no_read)++;
 405     }
 406     if (inbytesleft == 0)
 407     {
 408         cd->my_errno = YAZ_ICONV_EINVAL; /* incomplete input */
 409         *no_read = 0;
 410         return 0;
 411     }
 412     switch (*inp) {
 413     case 0xe1: /*  alpha small */
 414             if (tonos)
 415                 x = 0x03ac;
 416             else
 417                 x = 0x03b1;
 418             break;
 419     case 0xc1: /*  alpha capital */
 420             if (tonos)
 421                 x = 0x0386;
 422             else
 423                 x = 0x0391;
 424             break;
 425
 426     case 0xe2: /*  Beta small */
 427             x = 0x03b2;
 428             break;
 429     case 0xc2: /*  Beta capital */
 430             x = 0x0392;
 431             break;
 432
 433     case 0xe4: /*  Gamma small */
 434             x = 0x03b3;
 435             break;
 436     case 0xc4: /*  Gamma capital */
 437             x = 0x0393;
 438             break;
 439
 440     case 0xe5: /*  Delta small */
 441             x = 0x03b4;
 442             break;
 443     case 0xc5: /*  Delta capital */
 444             x = 0x0394;
 445             break;
 446     case 0xe6: /*  epsilon small */
 447             if (tonos)
 448                 x = 0x03ad;
 449             else
 450                 x = 0x03b5;
 451             break;
 452     case 0xc6: /*  epsilon capital */
 453             if (tonos)
 454                 x = 0x0388;
 455             else
 456                 x = 0x0395;
 457             break;
 458     case 0xe9: /*  Zeta small */
 459             x = 0x03b6;
 460             break;
 461     case 0xc9: /*  Zeta capital */
 462             x = 0x0396;
 463             break;
 464     case 0xea: /*  Eta small */
 465             if (tonos)
 466                 x = 0x03ae;
 467             else
 468                 x = 0x03b7;
 469             break;
 470     case 0xca: /*  Eta capital */
 471             if (tonos)
 472                 x = 0x0389;
 473             else
 474                 x = 0x0397;
 475             break;
 476     case 0xeb: /*  Theta small */
 477             x = 0x03b8;
 478             break;
 479     case 0xcb: /*  Theta capital */
 480             x = 0x0398;
 481             break;
 482     case 0xec: /*  Iota small */
 483             if (tonos)
 484                 if (dialitika)
 485                     x = 0x0390;
 486                 else
 487                     x = 0x03af;
 488             else
 489                 if (dialitika)
 490                     x = 0x03ca;
 491                 else
 492                     x = 0x03b9;
 493             break;
 494     case 0xcc: /*  Iota capital */
 495             if (tonos)
 496                 x = 0x038a;
 497             else
 498                 if (dialitika)
 499                     x = 0x03aa;
 500                 else
 501                     x = 0x0399;
 502             break;
 503     case 0xed: /*  Kappa small */
 504             x = 0x03ba;
 505             break;
 506     case 0xcd: /*  Kappa capital */
 507             x = 0x039a;
 508             break;
 509     case 0xee: /*  Lambda small */
 510             x = 0x03bb;
 511             break;
 512     case 0xce: /*  Lambda capital */
 513             x = 0x039b;
 514             break;
 515     case 0xef: /*  Mu small */
 516             x = 0x03bc;
 517             break;
 518     case 0xcf: /*  Mu capital */
 519             x = 0x039c;
 520             break;
 521     case 0xf0: /*  Nu small */
 522             x = 0x03bd;
 523             break;
 524     case 0xd0: /*  Nu capital */
 525             x = 0x039d;
 526             break;
 527     case 0xf1: /*  Xi small */
 528             x = 0x03be;
 529             break;
 530     case 0xd1: /*  Xi capital */
 531             x = 0x039e;
 532             break;
 533     case 0xf2: /*  Omicron small */
 534             if (tonos)
 535                 x = 0x03cc;
 536             else
 537                 x = 0x03bf;
 538             break;
 539     case 0xd2: /*  Omicron capital */
 540             if (tonos)
 541                 x = 0x038c;
 542             else
 543                 x = 0x039f;
 544             break;
 545     case 0xf3: /*  Pi small */
 546             x = 0x03c0;
 547             break;
 548     case 0xd3: /*  Pi capital */
 549             x = 0x03a0;
 550             break;
 551     case 0xf5: /*  Rho small */
 552             x = 0x03c1;
 553             break;
 554     case 0xd5: /*  Rho capital */
 555             x = 0x03a1;
 556             break;
 557     case 0xf7: /*  Sigma small (end of words) */
 558             x = 0x03c2;
 559             break;
 560     case 0xf6: /*  Sigma small */
 561             x = 0x03c3;
 562             break;
 563     case 0xd6: /*  Sigma capital */
 564             x = 0x03a3;
 565             break;
 566     case 0xf8: /*  Tau small */
 567             x = 0x03c4;
 568             break;
 569     case 0xd8: /*  Tau capital */
 570             x = 0x03a4;
 571             break;
 572     case 0xf9: /*  Upsilon small */
 573             if (tonos)
 574                 if (dialitika)
 575                     x = 0x03b0;
 576                 else
 577                     x = 0x03cd;
 578             else
 579                 if (dialitika)
 580                     x = 0x03cb;
 581                 else
 582                     x = 0x03c5;
 583             break;
 584     case 0xd9: /*  Upsilon capital */
 585             if (tonos)
 586                 x = 0x038e;
 587             else
 588                 if (dialitika)
 589                     x = 0x03ab;
 590                 else
 591                     x = 0x03a5;
 592             break;
 593     case 0xfa: /*  Phi small */
 594             x = 0x03c6;
 595             break;
 596     case 0xda: /*  Phi capital */
 597             x = 0x03a6;
 598             break;
 599     case 0xfb: /*  Chi small */
 600             x = 0x03c7;
 601             break;
 602     case 0xdb: /*  Chi capital */
 603             x = 0x03a7;
 604             break;
 605     case 0xfc: /*  Psi small */
 606             x = 0x03c8;
 607             break;
 608     case 0xdc: /*  Psi capital */
 609             x = 0x03a8;
 610             break;
 611     case 0xfd: /*  Omega small */
 612             if (tonos)
 613                 x = 0x03ce;
 614             else
 615                 x = 0x03c9;
 616             break;
 617     case 0xdd: /*  Omega capital */
 618             if (tonos)
 619                 x = 0x038f;
 620             else
 621                 x = 0x03a9;
 622             break;
 623     default:
 624         x = *inp;
 625         break;
 626     }
 627     (*no_read)++;
 628
 629     return x;
 630 }
 631
 632 static size_t yaz_write_iso5428_1984(yaz_iconv_t cd, unsigned long x,
 633                                      char **outbuf, size_t *outbytesleft)
 634 {
 635     size_t k = 0;
 636     unsigned char *out = (unsigned char*) *outbuf;
 637     if (*outbytesleft < 3)
 638     {
 639         cd->my_errno = YAZ_ICONV_E2BIG;  /* not room for output */
 640         return (size_t)(-1);
 641     }
 642     switch (x)
 643     {
 644     case 0x03ac : out[k++]=0xa2; out[k++]=0xe1; break;
 645     case 0x03b1 : out[k++]=0xe1; break;
 646     case 0x0386 : out[k++]=0xa2; out[k++]=0xc1; break;
 647     case 0x0391 : out[k++]=0xc1; break;
 648     case 0x03b2 : out[k++]=0xe2; break;
 649     case 0x0392 : out[k++]=0xc2; break;
 650     case 0x03b3 : out[k++]=0xe4; break;
 651     case 0x0393 : out[k++]=0xc4; break;
 652     case 0x03b4 : out[k++]=0xe5; break;
 653     case 0x0394 : out[k++]=0xc5; break;
 654     case 0x03ad : out[k++]=0xa2; out[k++]=0xe6; break;
 655     case 0x03b5 : out[k++]=0xe6; break;
 656     case 0x0388 : out[k++]=0xa2; out[k++]=0xc6; break;
 657     case 0x0395 : out[k++]=0xc6; break;
 658     case 0x03b6 : out[k++]=0xe9; break;
 659     case 0x0396 : out[k++]=0xc9; break;
 660     case 0x03ae : out[k++]=0xa2; out[k++]=0xea; break;
 661     case 0x03b7 : out[k++]=0xea; break;
 662     case 0x0389 : out[k++]=0xa2; out[k++]=0xca; break;
 663     case 0x0397 : out[k++]=0xca; break;
 664     case 0x03b8 : out[k++]=0xeb; break;
 665     case 0x0398 : out[k++]=0xcb; break;
 666     case 0x0390 : out[k++]=0xa2; out[k++]=0xa3; out[k++]=0xec; break;
 667     case 0x03af : out[k++]=0xa2; out[k++]=0xec; break;
 668     case 0x03ca : out[k++]=0xa3; out[k++]=0xec; break;
 669     case 0x03b9 : out[k++]=0xec; break;
 670     case 0x038a : out[k++]=0xa2; out[k++]=0xcc; break;
 671     case 0x03aa : out[k++]=0xa3; out[k++]=0xcc; break;
 672     case 0x0399 : out[k++]=0xcc; break;
 673     case 0x03ba : out[k++]=0xed; break;
 674     case 0x039a : out[k++]=0xcd; break;
 675     case 0x03bb : out[k++]=0xee; break;
 676     case 0x039b : out[k++]=0xce; break;
 677     case 0x03bc : out[k++]=0xef; break;
 678     case 0x039c : out[k++]=0xcf; break;
 679     case 0x03bd : out[k++]=0xf0; break;
 680     case 0x039d : out[k++]=0xd0; break;
 681     case 0x03be : out[k++]=0xf1; break;
 682     case 0x039e : out[k++]=0xd1; break;
 683     case 0x03cc : out[k++]=0xa2; out[k++]=0xf2; break;
 684     case 0x03bf : out[k++]=0xf2; break;
 685     case 0x038c : out[k++]=0xa2; out[k++]=0xd2; break;
 686     case 0x039f : out[k++]=0xd2; break;
 687     case 0x03c0 : out[k++]=0xf3; break;
 688     case 0x03a0 : out[k++]=0xd3; break;
 689     case 0x03c1 : out[k++]=0xf5; break;
 690     case 0x03a1 : out[k++]=0xd5; break;
 691     case 0x03c2 : out[k++]=0xf7; break;
 692     case 0x03c3 : out[k++]=0xf6; break;
 693     case 0x03a3 : out[k++]=0xd6; break;
 694     case 0x03c4 : out[k++]=0xf8; break;
 695     case 0x03a4 : out[k++]=0xd8; break;
 696     case 0x03b0 : out[k++]=0xa2; out[k++]=0xa3; out[k++]=0xf9; break;
 697     case 0x03cd : out[k++]=0xa2; out[k++]=0xf9; break;
 698     case 0x03cb : out[k++]=0xa3; out[k++]=0xf9; break;
 699     case 0x03c5 : out[k++]=0xf9; break;
 700     case 0x038e : out[k++]=0xa2; out[k++]=0xd9; break;
 701     case 0x03ab : out[k++]=0xa3; out[k++]=0xd9; break;
 702     case 0x03a5 : out[k++]=0xd9; break;
 703     case 0x03c6 : out[k++]=0xfa; break;
 704     case 0x03a6 : out[k++]=0xda; break;
 705     case 0x03c7 : out[k++]=0xfb; break;
 706     case 0x03a7 : out[k++]=0xdb; break;
 707     case 0x03c8 : out[k++]=0xfc; break;
 708     case 0x03a8 : out[k++]=0xdc; break;
 709     case 0x03ce : out[k++]=0xa2; out[k++]=0xfd; break;
 710     case 0x03c9 : out[k++]=0xfd; break;
 711     case 0x038f : out[k++]=0xa2; out[k++]=0xdd; break;
 712     case 0x03a9 : out[k++]=0xdd; break;
 713     default:
 714         if (x > 255)
 715         {
 716             cd->my_errno = YAZ_ICONV_EILSEQ;
 717             return (size_t) -1;
 718         }
 719         out[k++] = x;
 720         break;
 721     }
 722     *outbytesleft -= k;
 723     (*outbuf) += k;
 724     return 0;
 725 }
 726
 727 static unsigned long yaz_read_advancegreek(yaz_iconv_t cd, unsigned char *inp,
 728                                            size_t inbytesleft, size_t *no_read)
 729 {
 730     unsigned long x = 0;
 731     int shift = 0;
 732     int tonos = 0;
 733     int dialitika = 0;
 734
 735     *no_read = 0;
 736     while (inbytesleft > 0)
 737     {
 738         if (*inp == 0x9d)
 739         {
 740             tonos = 1;
 741         }
 742         else if (*inp == 0x9e)
 743         {
 744             dialitika = 1;
 745         }
 746         else if (*inp == 0x9f)
 747         {
 748             shift = 1;
 749         }
 750         else
 751             break;
 752         inp++;
 753         --inbytesleft;
 754         (*no_read)++;
 755     }
 756     if (inbytesleft == 0)
 757     {
 758         cd->my_errno = YAZ_ICONV_EINVAL; /* incomplete input */
 759         *no_read = 0;
 760         return 0;
 761     }
 762     switch (*inp) {
 763     case 0x81:
 764         if (shift)
 765             if (tonos)
 766                 x = 0x0386;
 767             else
 768                 x = 0x0391;
 769         else
 770             if (tonos)
 771                 x = 0x03ac;
 772             else
 773                 x = 0x03b1;
 774         break;
 775     case 0x82:
 776         if (shift)
 777             x = 0x0392;
 778         else
 779             x = 0x03b2;
 780
 781         break;
 782     case 0x83:
 783         if (shift)
 784             x = 0x0393;
 785         else
 786             x = 0x03b3;
 787         break;
 788     case 0x84:
 789         if (shift)
 790             x = 0x0394;
 791         else
 792             x = 0x03b4;
 793         break;
 794     case 0x85:
 795         if (shift)
 796             if (tonos)
 797                 x = 0x0388;
 798             else
 799                 x = 0x0395;
 800         else
 801             if (tonos)
 802                 x = 0x03ad;
 803             else
 804                 x = 0x03b5;
 805         break;
 806     case 0x86:
 807         if (shift)
 808             x = 0x0396;
 809         else
 810             x = 0x03b6;
 811         break;
 812     case 0x87:
 813         if (shift)
 814             if (tonos)
 815                 x = 0x0389;
 816             else
 817                 x = 0x0397;
 818         else
 819             if (tonos)
 820                 x = 0x03ae;
 821             else
 822                 x = 0x03b7;
 823         break;
 824     case 0x88:
 825         if (shift)
 826             x = 0x0398;
 827         else
 828             x = 0x03b8;
 829         break;
 830     case 0x89:
 831         if (shift)
 832             if (tonos)
 833                 x = 0x038a;
 834             else
 835                 if (dialitika)
 836                     x = 0x03aa;
 837                 else
 838                     x = 0x0399;
 839         else
 840             if (tonos)
 841                 if (dialitika)
 842                     x = 0x0390;
 843                 else
 844                     x = 0x03af;
 845
 846             else
 847                 if (dialitika)
 848                     x = 0x03ca;
 849                 else
 850                     x = 0x03b9;
 851         break;
 852     case 0x8a:
 853         if (shift)
 854             x = 0x039a;
 855         else
 856             x = 0x03ba;
 857
 858         break;
 859     case 0x8b:
 860         if (shift)
 861             x = 0x039b;
 862         else
 863             x = 0x03bb;
 864         break;
 865     case 0x8c:
 866         if (shift)
 867             x = 0x039c;
 868         else
 869             x = 0x03bc;
 870
 871         break;
 872     case 0x8d:
 873         if (shift)
 874             x = 0x039d;
 875         else
 876             x = 0x03bd;
 877         break;
 878     case 0x8e:
 879         if (shift)
 880             x = 0x039e;
 881         else
 882             x = 0x03be;
 883         break;
 884     case 0x8f:
 885         if (shift)
 886             if (tonos)
 887                 x = 0x038c;
 888             else
 889                 x = 0x039f;
 890         else
 891             if (tonos)
 892                 x = 0x03cc;
 893             else
 894                 x = 0x03bf;
 895         break;
 896     case 0x90:
 897         if (shift)
 898             x = 0x03a0;
 899         else
 900             x = 0x03c0;
 901         break;
 902     case 0x91:
 903         if (shift)
 904             x = 0x03a1;
 905         else
 906             x = 0x03c1;
 907         break;
 908     case 0x92:
 909         x = 0x03c2;
 910         break;
 911     case 0x93:
 912         if (shift)
 913             x = 0x03a3;
 914         else
 915             x = 0x03c3;
 916         break;
 917     case 0x94:
 918         if (shift)
 919             x = 0x03a4;
 920         else
 921             x = 0x03c4;
 922         break;
 923     case 0x95:
 924         if (shift)
 925             if (tonos)
 926                 x = 0x038e;
 927             else
 928                 if (dialitika)
 929                     x = 0x03ab;
 930                 else
 931                     x = 0x03a5;
 932         else
 933             if (tonos)
 934                 if (dialitika)
 935                     x = 0x03b0;
 936                 else
 937                     x = 0x03cd;
 938
 939             else
 940                 if (dialitika)
 941                     x = 0x03cb;
 942                 else
 943                     x = 0x03c5;
 944         break;
 945     case 0x96:
 946         if (shift)
 947             x = 0x03a6;
 948         else
 949             x = 0x03c6;
 950         break;
 951     case 0x97:
 952         if (shift)
 953             x = 0x03a7;
 954         else
 955             x = 0x03c7;
 956         break;
 957     case 0x98:
 958         if (shift)
 959             x = 0x03a8;
 960         else
 961             x = 0x03c8;
 962
 963         break;
 964
 965     case 0x99:
 966         if (shift)
 967             if (tonos)
 968                 x = 0x038f;
 969             else
 970                 x = 0x03a9;
 971         else
 972             if (tonos)
 973                 x = 0x03ce;
 974             else
 975                 x = 0x03c9;
 976         break;
 977     default:
 978         x = *inp;
 979         break;
 980     }
 981     (*no_read)++;
 982
 983     return x;
 984 }
 985
 986 static size_t yaz_write_advancegreek(yaz_iconv_t cd, unsigned long x,
 987                                      char **outbuf, size_t *outbytesleft)
 988 {
 989     size_t k = 0;
 990     unsigned char *out = (unsigned char*) *outbuf;
 991     if (*outbytesleft < 3)
 992     {
 993         cd->my_errno = YAZ_ICONV_E2BIG;  /* not room for output */
 994         return (size_t)(-1);
 995     }
 996     switch (x)
 997     {
 998     case 0x03ac : out[k++]=0x9d; out[k++]=0x81; break;
 999     case 0x03ad : out[k++]=0x9d; out[k++]=0x85; break;
1000     case 0x03ae : out[k++]=0x9d; out[k++]=0x87; break;
1001     case 0x03af : out[k++]=0x9d; out[k++]=0x89; break;
1002     case 0x03cc : out[k++]=0x9d; out[k++]=0x8f; break;
1003     case 0x03cd : out[k++]=0x9d; out[k++]=0x95; break;
1004     case 0x03ce : out[k++]=0x9d; out[k++]=0x99; break;
1005     case 0x0390 : out[k++]=0x9d; out[k++]=0x9e; out[k++]=0x89; break;
1006     case 0x03b0 : out[k++]=0x9d; out[k++]=0x9e; out[k++]=0x95; break;
1007     case 0x0386 : out[k++]=0x9d; out[k++]=0x9f; out[k++]=0x81; break;
1008     case 0x0388 : out[k++]=0x9d; out[k++]=0x9f; out[k++]=0x85; break;
1009     case 0x0389 : out[k++]=0x9d; out[k++]=0x9f; out[k++]=0x87; break;
1010     case 0x038a : out[k++]=0x9d; out[k++]=0x9f; out[k++]=0x89; break;
1011     case 0x038c : out[k++]=0x9d; out[k++]=0x9f; out[k++]=0x8f; break;
1012     case 0x038e : out[k++]=0x9d; out[k++]=0x9f; out[k++]=0x95; break;
1013     case 0x038f : out[k++]=0x9d; out[k++]=0x9f; out[k++]=0x99; break;
1014     case 0x03ca : out[k++]=0x9e; out[k++]=0x89; break;
1015     case 0x03cb : out[k++]=0x9e; out[k++]=0x95; break;
1016     case 0x03aa : out[k++]=0x9e; out[k++]=0x9f; out[k++]=0x89; break;
1017     case 0x03ab : out[k++]=0x9e; out[k++]=0x9f; out[k++]=0x95; break;
1018     case 0x0391 : out[k++]=0x9f; out[k++]=0x81; break;
1019     case 0x0392 : out[k++]=0x9f; out[k++]=0x82; break;
1020     case 0x0393 : out[k++]=0x9f; out[k++]=0x83; break;
1021     case 0x0394 : out[k++]=0x9f; out[k++]=0x84; break;
1022     case 0x0395 : out[k++]=0x9f; out[k++]=0x85; break;
1023     case 0x0396 : out[k++]=0x9f; out[k++]=0x86; break;
1024     case 0x0397 : out[k++]=0x9f; out[k++]=0x87; break;
1025     case 0x0398 : out[k++]=0x9f; out[k++]=0x88; break;
1026     case 0x0399 : out[k++]=0x9f; out[k++]=0x89; break;
1027     case 0x039a : out[k++]=0x9f; out[k++]=0x8a; break;
1028     case 0x039b : out[k++]=0x9f; out[k++]=0x8b; break;
1029     case 0x039c : out[k++]=0x9f; out[k++]=0x8c; break;
1030     case 0x039d : out[k++]=0x9f; out[k++]=0x8d; break;
1031     case 0x039e : out[k++]=0x9f; out[k++]=0x8e; break;
1032     case 0x039f : out[k++]=0x9f; out[k++]=0x8f; break;
1033     case 0x03a0 : out[k++]=0x9f; out[k++]=0x90; break;
1034     case 0x03a1 : out[k++]=0x9f; out[k++]=0x91; break;
1035     case 0x03a3 : out[k++]=0x9f; out[k++]=0x93; break;
1036     case 0x03a4 : out[k++]=0x9f; out[k++]=0x94; break;
1037     case 0x03a5 : out[k++]=0x9f; out[k++]=0x95; break;
1038     case 0x03a6 : out[k++]=0x9f; out[k++]=0x96; break;
1039     case 0x03a7 : out[k++]=0x9f; out[k++]=0x97; break;
1040     case 0x03a8 : out[k++]=0x9f; out[k++]=0x98; break;
1041     case 0x03a9 : out[k++]=0x9f; out[k++]=0x99; break;
1042     case 0x03b1 : out[k++]=0x81; break;
1043     case 0x03b2 : out[k++]=0x82; break;
1044     case 0x03b3 : out[k++]=0x83; break;
1045     case 0x03b4 : out[k++]=0x84; break;
1046     case 0x03b5 : out[k++]=0x85; break;
1047     case 0x03b6 : out[k++]=0x86; break;
1048     case 0x03b7 : out[k++]=0x87; break;
1049     case 0x03b8 : out[k++]=0x88; break;
1050     case 0x03b9 : out[k++]=0x89; break;
1051     case 0x03ba : out[k++]=0x8a; break;
1052     case 0x03bb : out[k++]=0x8b; break;
1053     case 0x03bc : out[k++]=0x8c; break;
1054     case 0x03bd : out[k++]=0x8d; break;
1055     case 0x03be : out[k++]=0x8e; break;
1056     case 0x03bf : out[k++]=0x8f; break;
1057     case 0x03c0 : out[k++]=0x90; break;
1058     case 0x03c1 : out[k++]=0x91; break;
1059     case 0x03c2 : out[k++]=0x92; break;
1060     case 0x03c3 : out[k++]=0x93; break;
1061     case 0x03c4 : out[k++]=0x94; break;
1062     case 0x03c5 : out[k++]=0x95; break;
1063     case 0x03c6 : out[k++]=0x96; break;
1064     case 0x03c7 : out[k++]=0x96; break;
1065     case 0x03c8 : out[k++]=0x98; break;
1066     case 0x03c9 : out[k++]=0x99; break;
1067     default:
1068         if (x > 255)
1069         {
1070             cd->my_errno = YAZ_ICONV_EILSEQ;
1071             return (size_t) -1;
1072         }
1073         out[k++] = x;
1074         break;
1075     }
1076     *outbytesleft -= k;
1077     (*outbuf) += k;
1078     return 0;
1079 }
1080
1081
1082 static unsigned long yaz_read_marc8_comb (yaz_iconv_t cd, unsigned char *inp,
1083                                           size_t inbytesleft, size_t *no_read,
1084                                           int *comb);
1085
1086 static unsigned long yaz_read_marc8 (yaz_iconv_t cd, unsigned char *inp,
1087                                      size_t inbytesleft, size_t *no_read)
1088 {
1089     unsigned long x;
1090     if (cd->comb_offset < cd->comb_size)
1091     {
1092         *no_read = cd->comb_no_read[cd->comb_offset];
1093         x = cd->comb_x[cd->comb_offset];
1094
1095         /* special case for double-diacritic combining characters,
1096            INVERTED BREVE and DOUBLE TILDE.
1097            We'll increment the no_read counter by 1, since we want to skip over
1098            the processing of the closing ligature character
1099         */
1100         /* this code is no longer necessary.. our handlers code in
1101            yaz_marc8_?_conv (generated by charconv.tcl) now returns
1102            0 and no_read=1 when a sequence does not match the input.
1103            The SECOND HALFs in codetables.xml produces a non-existant
1104            entry in the conversion trie.. Hence when met, the input byte is
1105            skipped as it should (in yaz_iconv)
1106         */
1107 #if 0
1108         if (x == 0x0361 || x == 0x0360)
1109             *no_read += 1;
1110 #endif
1111         cd->comb_offset++;
1112         return x;
1113     }
1114
1115     cd->comb_offset = 0;
1116     for (cd->comb_size = 0; cd->comb_size < 8; cd->comb_size++)
1117     {
1118         int comb = 0;
1119
1120         if (inbytesleft == 0 && cd->comb_size)
1121         {
1122             cd->my_errno = YAZ_ICONV_EINVAL;
1123             x = 0;
1124             *no_read = 0;
1125             break;
1126         }
1127         x = yaz_read_marc8_comb(cd, inp, inbytesleft, no_read, &comb);
1128         if (!comb || !x)
1129             break;
1130         cd->comb_x[cd->comb_size] = x;
1131         cd->comb_no_read[cd->comb_size] = *no_read;
1132         inp += *no_read;
1133         inbytesleft = inbytesleft - *no_read;
1134     }
1135     return x;
1136 }
1137
1138 static unsigned long yaz_read_marc8s(yaz_iconv_t cd, unsigned char *inp,
1139                                      size_t inbytesleft, size_t *no_read)
1140 {
1141     unsigned long x = yaz_read_marc8(cd, inp, inbytesleft, no_read);
1142     if (x && cd->comb_size == 1)
1143     {
1144         /* For MARC8s we try to get a Latin-1 page code out of it */
1145         int i;
1146         for (i = 0; latin1_comb[i].x1; i++)
1147             if (cd->comb_x[0] == latin1_comb[i].x2 && x == latin1_comb[i].x1)
1148             {
1149                 *no_read += cd->comb_no_read[0];
1150                 cd->comb_size = 0;
1151                 x = latin1_comb[i].y;
1152                 break;
1153             }
1154     }
1155     return x;
1156 }
1157
1158 static unsigned long yaz_read_marc8_comb(yaz_iconv_t cd, unsigned char *inp,
1159                                          size_t inbytesleft, size_t *no_read,
1160                                          int *comb)
1161 {
1162     *no_read = 0;
1163     while(inbytesleft >= 1 && inp[0] == 27)
1164     {
1165         size_t inbytesleft0 = inbytesleft;
1166         inp++;
1167         inbytesleft--;
1168         while(inbytesleft > 0 && strchr("(,$!)-", *inp))
1169         {
1170             inbytesleft--;
1171             inp++;
1172         }
1173         if (inbytesleft <= 0)
1174         {
1175             *no_read = 0;
1176             cd->my_errno = YAZ_ICONV_EINVAL;
1177             return 0;
1178         }
1179         cd->marc8_esc_mode = *inp++;
1180         inbytesleft--;
1181         (*no_read) += inbytesleft0 - inbytesleft;
1182     }
1183     if (inbytesleft <= 0)
1184         return 0;
1185     else
1186     {
1187         unsigned long x;
1188         size_t no_read_sub = 0;
1189         *comb = 0;
1190
1191         switch(cd->marc8_esc_mode)
1192         {
1193         case 'B':  /* Basic ASCII */
1194         case 's':  /* ASCII */
1195         case 'E':  /* ANSEL */
1196             x = yaz_marc8_42_conv(inp, inbytesleft, &no_read_sub, comb);
1197             if (!x)
1198             {
1199                 no_read_sub = 0;
1200                 x = yaz_marc8_45_conv(inp, inbytesleft, &no_read_sub, comb);
1201             }
1202             break;
1203         case 'g':  /* Greek */
1204             x = yaz_marc8_67_conv(inp, inbytesleft, &no_read_sub, comb);
1205             break;
1206         case 'b':  /* Subscripts */
1207             x = yaz_marc8_62_conv(inp, inbytesleft, &no_read_sub, comb);
1208             break;
1209         case 'p':  /* Superscripts */
1210             x = yaz_marc8_70_conv(inp, inbytesleft, &no_read_sub, comb);
1211             break;
1212         case '2':  /* Basic Hebrew */
1213             x = yaz_marc8_32_conv(inp, inbytesleft, &no_read_sub, comb);
1214             break;
1215         case 'N':  /* Basic Cyrillic */
1216             x = yaz_marc8_4E_conv(inp, inbytesleft, &no_read_sub, comb);
1217             break;
1218         case 'Q':  /* Extended Cyrillic */
1219             x = yaz_marc8_51_conv(inp, inbytesleft, &no_read_sub, comb);
1220             break;
1221         case '3':  /* Basic Arabic */
1222             x = yaz_marc8_33_conv(inp, inbytesleft, &no_read_sub, comb);
1223             break;
1224         case '4':  /* Extended Arabic */
1225             x = yaz_marc8_34_conv(inp, inbytesleft, &no_read_sub, comb);
1226             break;
1227         case 'S':  /* Greek */
1228             x = yaz_marc8_53_conv(inp, inbytesleft, &no_read_sub, comb);
1229             break;
1230         case '1':  /* Chinese, Japanese, Korean (EACC) */
1231             x = yaz_marc8_31_conv(inp, inbytesleft, &no_read_sub, comb);
1232             break;
1233         default:
1234             *no_read = 0;
1235             cd->my_errno = YAZ_ICONV_EILSEQ;
1236             return 0;
1237         }
1238         *no_read += no_read_sub;
1239         return x;
1240     }
1241 }
1242
1243 static size_t yaz_write_UTF8(yaz_iconv_t cd, unsigned long x,
1244                              char **outbuf, size_t *outbytesleft)
1245 {
1246     return yaz_write_UTF8_char(x, outbuf, outbytesleft, &cd->my_errno);
1247 }
1248
1249 size_t yaz_write_UTF8_char(unsigned long x,
1250                            char **outbuf, size_t *outbytesleft,
1251                            int *error)
1252 {
1253     unsigned char *outp = (unsigned char *) *outbuf;
1254
1255     if (x <= 0x7f && *outbytesleft >= 1)
1256     {
1257         *outp++ = (unsigned char) x;
1258         (*outbytesleft)--;
1259     }
1260     else if (x <= 0x7ff && *outbytesleft >= 2)
1261     {
1262         *outp++ = (unsigned char) ((x >> 6) | 0xc0);
1263         *outp++ = (unsigned char) ((x & 0x3f) | 0x80);
1264         (*outbytesleft) -= 2;
1265     }
1266     else if (x <= 0xffff && *outbytesleft >= 3)
1267     {
1268         *outp++ = (unsigned char) ((x >> 12) | 0xe0);
1269         *outp++ = (unsigned char) (((x >> 6) & 0x3f) | 0x80);
1270         *outp++ = (unsigned char) ((x & 0x3f) | 0x80);
1271         (*outbytesleft) -= 3;
1272     }
1273     else if (x <= 0x1fffff && *outbytesleft >= 4)
1274     {
1275         *outp++ = (unsigned char) ((x >> 18) | 0xf0);
1276         *outp++ = (unsigned char) (((x >> 12) & 0x3f) | 0x80);
1277         *outp++ = (unsigned char) (((x >> 6)  & 0x3f) | 0x80);
1278         *outp++ = (unsigned char) ((x & 0x3f) | 0x80);
1279         (*outbytesleft) -= 4;
1280     }
1281     else if (x <= 0x3ffffff && *outbytesleft >= 5)
1282     {
1283         *outp++ = (unsigned char) ((x >> 24) | 0xf8);
1284         *outp++ = (unsigned char) (((x >> 18) & 0x3f) | 0x80);
1285         *outp++ = (unsigned char) (((x >> 12) & 0x3f) | 0x80);
1286         *outp++ = (unsigned char) (((x >> 6)  & 0x3f) | 0x80);
1287         *outp++ = (unsigned char) ((x & 0x3f) | 0x80);
1288         (*outbytesleft) -= 5;
1289     }
1290     else if (*outbytesleft >= 6)
1291     {
1292         *outp++ = (unsigned char) ((x >> 30) | 0xfc);
1293         *outp++ = (unsigned char) (((x >> 24) & 0x3f) | 0x80);
1294         *outp++ = (unsigned char) (((x >> 18) & 0x3f) | 0x80);
1295         *outp++ = (unsigned char) (((x >> 12) & 0x3f) | 0x80);
1296         *outp++ = (unsigned char) (((x >> 6)  & 0x3f) | 0x80);
1297         *outp++ = (unsigned char) ((x & 0x3f) | 0x80);
1298         (*outbytesleft) -= 6;
1299     }
1300     else
1301     {
1302         *error = YAZ_ICONV_E2BIG;  /* not room for output */
1303         return (size_t)(-1);
1304     }
1305     *outbuf = (char *) outp;
1306     return 0;
1307 }
1308
1309 static size_t yaz_write_ISO8859_1 (yaz_iconv_t cd, unsigned long x,
1310                                    char **outbuf, size_t *outbytesleft)
1311 {
1312     /* list of two char unicode sequence that, when combined, are
1313        equivalent to single unicode chars that can be represented in
1314        ISO-8859-1/Latin-1.
1315        Regular iconv on Linux at least does not seem to convert these,
1316        but since MARC-8 to UTF-8 generates these composed sequence
1317        we get a better chance of a successful MARC-8 -> ISO-8859-1
1318        conversion */
1319     unsigned char *outp = (unsigned char *) *outbuf;
1320
1321     if (cd->compose_char)
1322     {
1323         int i;
1324         for (i = 0; latin1_comb[i].x1; i++)
1325             if (cd->compose_char == latin1_comb[i].x1 && x == latin1_comb[i].x2)
1326             {
1327                 x = latin1_comb[i].y;
1328                 break;
1329             }
1330         if (*outbytesleft < 1)
1331         {  /* no room. Retain compose_char and bail out */
1332             cd->my_errno = YAZ_ICONV_E2BIG;
1333             return (size_t)(-1);
1334         }
1335         if (!latin1_comb[i].x1)
1336         {   /* not found. Just write compose_char */
1337             *outp++ = (unsigned char) cd->compose_char;
1338             (*outbytesleft)--;
1339             *outbuf = (char *) outp;
1340         }
1341         /* compose_char used so reset it. x now holds current char */
1342         cd->compose_char = 0;
1343     }
1344
1345     if (x > 32 && x < 127 && cd->compose_char == 0)
1346     {
1347         cd->compose_char = x;
1348         return 0;
1349     }
1350     else if (x > 255 || x < 1)
1351     {
1352         cd->my_errno = YAZ_ICONV_EILSEQ;
1353         return (size_t) -1;
1354     }
1355     else if (*outbytesleft < 1)
1356     {
1357         cd->my_errno = YAZ_ICONV_E2BIG;
1358         return (size_t)(-1);
1359     }
1360     *outp++ = (unsigned char) x;
1361     (*outbytesleft)--;
1362     *outbuf = (char *) outp;
1363     return 0;
1364 }
1365
1366 static size_t yaz_flush_ISO8859_1(yaz_iconv_t cd,
1367                                   char **outbuf, size_t *outbytesleft)
1368 {
1369     if (cd->compose_char)
1370     {
1371         unsigned char *outp = (unsigned char *) *outbuf;
1372         if (*outbytesleft < 1)
1373         {
1374             cd->my_errno = YAZ_ICONV_E2BIG;
1375             return (size_t)(-1);
1376         }
1377         *outp++ = (unsigned char) cd->compose_char;
1378         (*outbytesleft)--;
1379         *outbuf = (char *) outp;
1380         cd->compose_char = 0;
1381     }
1382     return 0;
1383 }
1384
1385 static size_t yaz_write_UCS4 (yaz_iconv_t cd, unsigned long x,
1386                               char **outbuf, size_t *outbytesleft)
1387 {
1388     unsigned char *outp = (unsigned char *) *outbuf;
1389     if (*outbytesleft >= 4)
1390     {
1391         *outp++ = (unsigned char) (x>>24);
1392         *outp++ = (unsigned char) (x>>16);
1393         *outp++ = (unsigned char) (x>>8);
1394         *outp++ = (unsigned char) x;
1395         (*outbytesleft) -= 4;
1396     }
1397     else
1398     {
1399         cd->my_errno = YAZ_ICONV_E2BIG;
1400         return (size_t)(-1);
1401     }
1402     *outbuf = (char *) outp;
1403     return 0;
1404 }
1405
1406 static size_t yaz_write_UCS4LE (yaz_iconv_t cd, unsigned long x,
1407                                 char **outbuf, size_t *outbytesleft)
1408 {
1409     unsigned char *outp = (unsigned char *) *outbuf;
1410     if (*outbytesleft >= 4)
1411     {
1412         *outp++ = (unsigned char) x;
1413         *outp++ = (unsigned char) (x>>8);
1414         *outp++ = (unsigned char) (x>>16);
1415         *outp++ = (unsigned char) (x>>24);
1416         (*outbytesleft) -= 4;
1417     }
1418     else
1419     {
1420         cd->my_errno = YAZ_ICONV_E2BIG;
1421         return (size_t)(-1);
1422     }
1423     *outbuf = (char *) outp;
1424     return 0;
1425 }
1426
1427 static unsigned long lookup_marc8(yaz_iconv_t cd,
1428                                   unsigned long x, int *comb,
1429                                   const char **page_chr)
1430 {
1431     char utf8_buf[7];
1432     char *utf8_outbuf = utf8_buf;
1433     size_t utf8_outbytesleft = sizeof(utf8_buf)-1, r;
1434
1435     r = yaz_write_UTF8(cd, x, &utf8_outbuf, &utf8_outbytesleft);
1436     if (r == (size_t)(-1))
1437     {
1438         cd->my_errno = YAZ_ICONV_EILSEQ;
1439         return 0;
1440     }
1441     else
1442     {
1443         unsigned char *inp;
1444         size_t inbytesleft, no_read_sub = 0;
1445         unsigned long x;
1446
1447         *utf8_outbuf = '\0';
1448         inp = (unsigned char *) utf8_buf;
1449         inbytesleft = strlen(utf8_buf);
1450
1451         x = yaz_marc8r_42_conv(inp, inbytesleft, &no_read_sub, comb);
1452         if (x)
1453         {
1454             *page_chr = "\033(B";
1455             return x;
1456         }
1457         x = yaz_marc8r_45_conv(inp, inbytesleft, &no_read_sub, comb);
1458         if (x)
1459         {
1460             *page_chr = "\033(B";
1461             return x;
1462         }
1463         x = yaz_marc8r_67_conv(inp, inbytesleft, &no_read_sub, comb);
1464         if (x)
1465         {
1466             *page_chr = "\033g";
1467             return x;
1468         }
1469         x = yaz_marc8r_62_conv(inp, inbytesleft, &no_read_sub, comb);
1470         if (x)
1471         {
1472             *page_chr = "\033b";
1473             return x;
1474         }
1475         x = yaz_marc8r_70_conv(inp, inbytesleft, &no_read_sub, comb);
1476         if (x)
1477         {
1478             *page_chr = "\033p";
1479             return x;
1480         }
1481         x = yaz_marc8r_32_conv(inp, inbytesleft, &no_read_sub, comb);
1482         if (x)
1483         {
1484             *page_chr = "\033(2";
1485             return x;
1486         }
1487         x = yaz_marc8r_4E_conv(inp, inbytesleft, &no_read_sub, comb);
1488         if (x)
1489         {
1490             *page_chr = "\033(N";
1491             return x;
1492         }
1493         x = yaz_marc8r_51_conv(inp, inbytesleft, &no_read_sub, comb);
1494         if (x)
1495         {
1496             *page_chr = "\033(Q";
1497             return x;
1498         }
1499         x = yaz_marc8r_33_conv(inp, inbytesleft, &no_read_sub, comb);
1500         if (x)
1501         {
1502             *page_chr = "\033(3";
1503             return x;
1504         }
1505         x = yaz_marc8r_34_conv(inp, inbytesleft, &no_read_sub, comb);
1506         if (x)
1507         {
1508             *page_chr = "\033(4";
1509             return x;
1510         }
1511         x = yaz_marc8r_53_conv(inp, inbytesleft, &no_read_sub, comb);
1512         if (x)
1513         {
1514             *page_chr = "\033(S";
1515             return x;
1516         }
1517         x = yaz_marc8r_31_conv(inp, inbytesleft, &no_read_sub, comb);
1518         if (x)
1519         {
1520             *page_chr = "\033$1";
1521             return x;
1522         }
1523         cd->my_errno = YAZ_ICONV_EILSEQ;
1524         return x;
1525     }
1526 }
1527
1528 static size_t flush_combos(yaz_iconv_t cd,
1529                            char **outbuf, size_t *outbytesleft)
1530 {
1531     unsigned long y = cd->write_marc8_last;
1532     unsigned char byte;
1533     char out_buf[10];
1534     size_t i, out_no = 0;
1535
1536     if (!y)
1537         return 0;
1538
1539     byte = (unsigned char )((y>>16) & 0xff);
1540     if (byte)
1541         out_buf[out_no++] = byte;
1542     byte = (unsigned char)((y>>8) & 0xff);
1543     if (byte)
1544         out_buf[out_no++] = byte;
1545     byte = (unsigned char )(y & 0xff);
1546     if (byte)
1547         out_buf[out_no++] = byte;
1548
1549     if (out_no + cd->write_marc8_comb_no + 1 > *outbytesleft)
1550     {
1551         cd->my_errno = YAZ_ICONV_E2BIG;
1552         return (size_t) (-1);
1553     }
1554
1555     for (i = 0; i < cd->write_marc8_comb_no; i++)
1556     {
1557         /* all MARC-8 combined characters are simple bytes */
1558         byte = (unsigned char )(cd->write_marc8_comb_ch[i]);
1559         *(*outbuf)++ = byte;
1560         (*outbytesleft)--;
1561     }
1562     memcpy(*outbuf, out_buf, out_no);
1563     *outbuf += out_no;
1564     (*outbytesleft) -= out_no;
1565     if (cd->write_marc8_second_half_char)
1566     {
1567         *(*outbuf)++ = cd->write_marc8_second_half_char;
1568         (*outbytesleft)--;
1569     }
1570
1571     cd->write_marc8_last = 0;
1572     cd->write_marc8_comb_no = 0;
1573     cd->write_marc8_second_half_char = 0;
1574     return 0;
1575 }
1576
1577 static size_t yaz_write_marc8_page_chr(yaz_iconv_t cd,
1578                                        char **outbuf, size_t *outbytesleft,
1579                                        const char *page_chr)
1580 {
1581     const char *old_page_chr = cd->write_marc8_page_chr;
1582     if (strcmp(page_chr, old_page_chr))
1583     {
1584         size_t plen = 0;
1585         const char *page_out = page_chr;
1586
1587         if (*outbytesleft < 8)
1588         {
1589             cd->my_errno = YAZ_ICONV_E2BIG;
1590
1591             return (size_t) (-1);
1592         }
1593         cd->write_marc8_page_chr = page_chr;
1594
1595         if (!strcmp(old_page_chr, "\033p")
1596             || !strcmp(old_page_chr, "\033g")
1597             || !strcmp(old_page_chr, "\033b"))
1598         {
1599             /* Technique 1 leave */
1600             page_out = "\033s";
1601             if (strcmp(page_chr, "\033(B")) /* Not going ASCII page? */
1602             {
1603                 /* Must leave script + enter new page */
1604                 plen = strlen(page_out);
1605                 memcpy(*outbuf, page_out, plen);
1606                 (*outbuf) += plen;
1607                 (*outbytesleft) -= plen;
1608                 page_out = page_chr;
1609             }
1610         }
1611         plen = strlen(page_out);
1612         memcpy(*outbuf, page_out, plen);
1613         (*outbuf) += plen;
1614         (*outbytesleft) -= plen;
1615     }
1616     return 0;
1617 }
1618
1619
1620 static size_t yaz_write_marc8_2(yaz_iconv_t cd, unsigned long x,
1621                                 char **outbuf, size_t *outbytesleft)
1622 {
1623     int comb = 0;
1624     const char *page_chr = 0;
1625     unsigned long y = lookup_marc8(cd, x, &comb, &page_chr);
1626
1627     if (!y)
1628         return (size_t) (-1);
1629
1630     if (comb)
1631     {
1632         if (x == 0x0361)
1633             cd->write_marc8_second_half_char = 0xEC;
1634         else if (x == 0x0360)
1635             cd->write_marc8_second_half_char = 0xFB;
1636
1637         if (cd->write_marc8_comb_no < 6)
1638             cd->write_marc8_comb_ch[cd->write_marc8_comb_no++] = y;
1639     }
1640     else
1641     {
1642         size_t r = flush_combos(cd, outbuf, outbytesleft);
1643         if (r)
1644             return r;
1645
1646         r = yaz_write_marc8_page_chr(cd, outbuf, outbytesleft, page_chr);
1647         if (r)
1648             return r;
1649         cd->write_marc8_last = y;
1650     }
1651     return 0;
1652 }
1653
1654 static size_t yaz_flush_marc8(yaz_iconv_t cd,
1655                               char **outbuf, size_t *outbytesleft)
1656 {
1657     size_t r = flush_combos(cd, outbuf, outbytesleft);
1658     if (r)
1659         return r;
1660     return yaz_write_marc8_page_chr(cd, outbuf, outbytesleft, "\033(B");
1661 }
1662
1663 static size_t yaz_write_marc8(yaz_iconv_t cd, unsigned long x,
1664                               char **outbuf, size_t *outbytesleft)
1665 {
1666     int i;
1667     for (i = 0; latin1_comb[i].x1; i++)
1668     {
1669         if (x == latin1_comb[i].y)
1670         {
1671             size_t r ;
1672             /* save the output pointers .. */
1673             char *outbuf0 = *outbuf;
1674             size_t outbytesleft0 = *outbytesleft;
1675             int last_ch = cd->write_marc8_last;
1676
1677             r = yaz_write_marc8_2(cd, latin1_comb[i].x1,
1678                                   outbuf, outbytesleft);
1679             if (r)
1680                 return r;
1681             r = yaz_write_marc8_2(cd, latin1_comb[i].x2,
1682                                   outbuf, outbytesleft);
1683             if (r && cd->my_errno == YAZ_ICONV_E2BIG)
1684             {
1685                 /* not enough room. reset output to original values */
1686                 *outbuf = outbuf0;
1687                 *outbytesleft = outbytesleft0;
1688                 cd->write_marc8_last = last_ch;
1689             }
1690             return r;
1691         }
1692     }
1693     return yaz_write_marc8_2(cd, x, outbuf, outbytesleft);
1694 }
1695
1696
1697 #if HAVE_WCHAR_H
1698 static size_t yaz_write_wchar_t(yaz_iconv_t cd, unsigned long x,
1699                                 char **outbuf, size_t *outbytesleft)
1700 {
1701     unsigned char *outp = (unsigned char *) *outbuf;
1702
1703     if (*outbytesleft >= sizeof(wchar_t))
1704     {
1705         wchar_t wch = x;
1706         memcpy(outp, &wch, sizeof(wch));
1707         outp += sizeof(wch);
1708         (*outbytesleft) -= sizeof(wch);
1709     }
1710     else
1711     {
1712         cd->my_errno = YAZ_ICONV_E2BIG;
1713         return (size_t)(-1);
1714     }
1715     *outbuf = (char *) outp;
1716     return 0;
1717 }
1718 #endif
1719
1720 int yaz_iconv_isbuiltin(yaz_iconv_t cd)
1721 {
1722     return cd->read_handle && cd->write_handle;
1723 }
1724
1725 yaz_iconv_t yaz_iconv_open (const char *tocode, const char *fromcode)
1726 {
1727     yaz_iconv_t cd = (yaz_iconv_t) xmalloc (sizeof(*cd));
1728
1729     cd->write_handle = 0;
1730     cd->read_handle = 0;
1731     cd->init_handle = 0;
1732     cd->flush_handle = 0;
1733     cd->my_errno = YAZ_ICONV_UNKNOWN;
1734
1735     /* a useful hack: if fromcode has leading @,
1736        the library not use YAZ's own conversions .. */
1737     if (fromcode[0] == '@')
1738         fromcode++;
1739     else
1740     {
1741         if (!yaz_matchstr(fromcode, "UTF8"))
1742         {
1743             cd->read_handle = yaz_read_UTF8;
1744             cd->init_handle = yaz_init_UTF8;
1745         }
1746         else if (!yaz_matchstr(fromcode, "ISO88591"))
1747             cd->read_handle = yaz_read_ISO8859_1;
1748         else if (!yaz_matchstr(fromcode, "UCS4"))
1749             cd->read_handle = yaz_read_UCS4;
1750         else if (!yaz_matchstr(fromcode, "UCS4LE"))
1751             cd->read_handle = yaz_read_UCS4LE;
1752         else if (!yaz_matchstr(fromcode, "MARC8"))
1753             cd->read_handle = yaz_read_marc8;
1754         else if (!yaz_matchstr(fromcode, "MARC8s"))
1755             cd->read_handle = yaz_read_marc8s;
1756         else if (!yaz_matchstr(fromcode, "advancegreek"))
1757             cd->read_handle = yaz_read_advancegreek;
1758         else if (!yaz_matchstr(fromcode, "iso54281984"))
1759             cd->read_handle = yaz_read_iso5428_1984;
1760         else if (!yaz_matchstr(fromcode, "iso5428:1984"))
1761             cd->read_handle = yaz_read_iso5428_1984;
1762 #if HAVE_WCHAR_H
1763         else if (!yaz_matchstr(fromcode, "WCHAR_T"))
1764             cd->read_handle = yaz_read_wchar_t;
1765 #endif
1766
1767         if (!yaz_matchstr(tocode, "UTF8"))
1768             cd->write_handle = yaz_write_UTF8;
1769         else if (!yaz_matchstr(tocode, "ISO88591"))
1770         {
1771             cd->write_handle = yaz_write_ISO8859_1;
1772             cd->flush_handle = yaz_flush_ISO8859_1;
1773         }
1774         else if (!yaz_matchstr (tocode, "UCS4"))
1775             cd->write_handle = yaz_write_UCS4;
1776         else if (!yaz_matchstr(tocode, "UCS4LE"))
1777             cd->write_handle = yaz_write_UCS4LE;
1778         else if (!yaz_matchstr(tocode, "MARC8"))
1779         {
1780             cd->write_handle = yaz_write_marc8;
1781             cd->flush_handle = yaz_flush_marc8;
1782         }
1783         else if (!yaz_matchstr(tocode, "MARC8s"))
1784         {
1785             cd->write_handle = yaz_write_marc8;
1786             cd->flush_handle = yaz_flush_marc8;
1787         }
1788         else if (!yaz_matchstr(tocode, "advancegreek"))
1789         {
1790             cd->write_handle = yaz_write_advancegreek;
1791         }
1792         else if (!yaz_matchstr(tocode, "iso54281984"))
1793         {
1794             cd->write_handle = yaz_write_iso5428_1984;
1795         }
1796         else if (!yaz_matchstr(tocode, "iso5428:1984"))
1797         {
1798             cd->write_handle = yaz_write_iso5428_1984;
1799         }
1800 #if HAVE_WCHAR_H
1801         else if (!yaz_matchstr(tocode, "WCHAR_T"))
1802             cd->write_handle = yaz_write_wchar_t;
1803 #endif
1804     }
1805 #if HAVE_ICONV_H
1806     cd->iconv_cd = 0;
1807     if (!cd->read_handle || !cd->write_handle)
1808     {
1809         cd->iconv_cd = iconv_open (tocode, fromcode);
1810         if (cd->iconv_cd == (iconv_t) (-1))
1811         {
1812             xfree (cd);
1813             return 0;
1814         }
1815     }
1816 #else
1817     if (!cd->read_handle || !cd->write_handle)
1818     {
1819         xfree (cd);
1820         return 0;
1821     }
1822 #endif
1823     cd->init_flag = 1;
1824     return cd;
1825 }
1826
1827 size_t yaz_iconv(yaz_iconv_t cd, char **inbuf, size_t *inbytesleft,
1828                  char **outbuf, size_t *outbytesleft)
1829 {
1830     char *inbuf0 = 0;
1831     size_t r = 0;
1832
1833 #if HAVE_ICONV_H
1834     if (cd->iconv_cd)
1835     {
1836         size_t r =
1837             iconv(cd->iconv_cd, inbuf, inbytesleft, outbuf, outbytesleft);
1838         if (r == (size_t)(-1))
1839         {
1840             switch (yaz_errno())
1841             {
1842             case E2BIG:
1843                 cd->my_errno = YAZ_ICONV_E2BIG;
1844                 break;
1845             case EINVAL:
1846                 cd->my_errno = YAZ_ICONV_EINVAL;
1847                 break;
1848             case EILSEQ:
1849                 cd->my_errno = YAZ_ICONV_EILSEQ;
1850                 break;
1851             default:
1852                 cd->my_errno = YAZ_ICONV_UNKNOWN;
1853             }
1854         }
1855         return r;
1856     }
1857 #endif
1858
1859     if (inbuf)
1860         inbuf0 = *inbuf;
1861
1862     if (cd->init_flag)
1863     {
1864         cd->my_errno = YAZ_ICONV_UNKNOWN;
1865         cd->marc8_esc_mode = 'B';
1866
1867         cd->comb_offset = cd->comb_size = 0;
1868         cd->compose_char = 0;
1869
1870         cd->write_marc8_comb_no = 0;
1871         cd->write_marc8_second_half_char = 0;
1872         cd->write_marc8_last = 0;
1873         cd->write_marc8_page_chr = "\033(B";
1874
1875         cd->unget_x = 0;
1876         cd->no_read_x = 0;
1877     }
1878
1879     if (cd->init_flag)
1880     {
1881         if (cd->init_handle && inbuf && *inbuf)
1882         {
1883             size_t no_read = 0;
1884             size_t r = (cd->init_handle)(cd, (unsigned char *) *inbuf,
1885                                          *inbytesleft, &no_read);
1886             if (r)
1887             {
1888                 if (cd->my_errno == YAZ_ICONV_EINVAL)
1889                     return r;
1890                 cd->init_flag = 0;
1891                 return r;
1892             }
1893             *inbytesleft -= no_read;
1894             *inbuf += no_read;
1895         }
1896     }
1897     cd->init_flag = 0;
1898
1899     if (!inbuf || !*inbuf)
1900     {
1901         if (outbuf && *outbuf)
1902         {
1903             if (cd->unget_x)
1904                 r = (*cd->write_handle)(cd, cd->unget_x, outbuf, outbytesleft);
1905             if (cd->flush_handle)
1906                 r = (*cd->flush_handle)(cd, outbuf, outbytesleft);
1907         }
1908         if (r == 0)
1909             cd->init_flag = 1;
1910         cd->unget_x = 0;
1911         return r;
1912     }
1913     while (1)
1914     {
1915         unsigned long x;
1916         size_t no_read;
1917
1918         if (cd->unget_x)
1919         {
1920             x = cd->unget_x;
1921             no_read = cd->no_read_x;
1922         }
1923         else
1924         {
1925             if (*inbytesleft == 0)
1926             {
1927                 r = *inbuf - inbuf0;
1928                 break;
1929             }
1930             x = (*cd->read_handle)(cd, (unsigned char *) *inbuf, *inbytesleft,
1931                                    &no_read);
1932             if (no_read == 0)
1933             {
1934                 r = (size_t)(-1);
1935                 break;
1936             }
1937         }
1938         if (x)
1939         {
1940             r = (*cd->write_handle)(cd, x, outbuf, outbytesleft);
1941             if (r)
1942             {
1943                 /* unable to write it. save it because read_handle cannot
1944                    rewind .. */
1945                 if (cd->my_errno == YAZ_ICONV_E2BIG)
1946                 {
1947                     cd->unget_x = x;
1948                     cd->no_read_x = no_read;
1949                     break;
1950                 }
1951             }
1952             cd->unget_x = 0;
1953         }
1954         *inbytesleft -= no_read;
1955         (*inbuf) += no_read;
1956     }
1957     return r;
1958 }
1959
1960 int yaz_iconv_error (yaz_iconv_t cd)
1961 {
1962     return cd->my_errno;
1963 }
1964
1965 int yaz_iconv_close (yaz_iconv_t cd)
1966 {
1967 #if HAVE_ICONV_H
1968     if (cd->iconv_cd)
1969         iconv_close (cd->iconv_cd);
1970 #endif
1971     xfree (cd);
1972     return 0;
1973 }
1974
1975 /*
1976  * Local variables:
1977  * c-basic-offset: 4
1978  * indent-tabs-mode: nil
1979  * End:
1980  * vim: shiftwidth=4 tabstop=8 expandtab
1981  */