util/charmap.c

   1 /* $Id: charmap.c,v 1.36 2005-03-11 17:56:36 adam Exp $
   2    Copyright (C) 1995-2005
   3    Index Data ApS
   4
   5 This file is part of the Zebra server.
   6
   7 Zebra is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with Zebra; see the file LICENSE.zebra.  If not, write to the
  19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.
  21 */
  22
  23
  24
  25 /*
  26  * Support module to handle character-conversions into and out of the
  27  * Zebra dictionary.
  28  */
  29
  30 #include <ctype.h>
  31 #include <string.h>
  32 #include <stdlib.h>
  33 #include <assert.h>
  34
  35 typedef unsigned ucs4_t;
  36
  37 #include <charmap.h>
  38
  39 #include <yaz/yaz-util.h>
  40
  41 #define CHR_MAXSTR 1024
  42 #define CHR_MAXEQUIV 32
  43
  44 const unsigned char CHR_FIELD_BEGIN = '^';
  45
  46 const char *CHR_UNKNOWN = "\001";
  47 const char *CHR_SPACE   = "\002";
  48 const char *CHR_CUT     = "\003";
  49 const char *CHR_BASE    = "\005";
  50
  51 struct chrmaptab_info
  52 {
  53     chr_t_entry *input;         /* mapping table for input data */
  54     chr_t_entry *q_input;       /* mapping table for queries */
  55     unsigned char *output[256]; /* return mapping - for display of registers */
  56     int base_uppercase;         /* Start of upper-case ordinals */
  57     NMEM nmem;
  58 };
  59
  60 /*
  61  * Character map trie node.
  62  */
  63 struct chr_t_entry
  64 {
  65     chr_t_entry **children;  /* array of children */
  66     unsigned char **target;  /* target for this node, if any */
  67 };
  68
  69 /*
  70  * General argument structure for callback functions (internal use only)
  71  */
  72 typedef struct chrwork
  73 {
  74     chrmaptab map;
  75     char string[CHR_MAXSTR+1];
  76 } chrwork;
  77
  78 /*
  79  * Callback for equivalent stuff
  80  */
  81 typedef struct
  82 {
  83     NMEM nmem;
  84     int no_eq;
  85     char *eq[CHR_MAXEQUIV];
  86 } chr_equiv_work;
  87 /*
  88  * Add an entry to the character map.
  89  */
  90 static chr_t_entry *set_map_string(chr_t_entry *root, NMEM nmem,
  91                                    const char *from, int len, char *to,
  92                                    const char *from_0)
  93 {
  94     if (!from_0)
  95         from_0 = from;
  96     if (!root)
  97     {
  98         root = (chr_t_entry *) nmem_malloc(nmem, sizeof(*root));
  99         root->children = 0;
 100         root->target = 0;
 101     }
 102     if (!len)
 103     {
 104         if (!root->target || !root->target[0] || strcmp(root->target[0], to))
 105         {
 106             if (from_0 &&
 107                 root->target && root->target[0] && root->target[0][0] &&
 108                 strcmp (root->target[0], CHR_UNKNOWN))
 109             {
 110                 yaz_log (YLOG_WARN, "duplicate entry for charmap from '%s'",
 111                          from_0);
 112             }
 113             root->target = (unsigned char **)
 114                 nmem_malloc(nmem, sizeof(*root->target)*2);
 115             root->target[0] = (unsigned char *) nmem_strdup(nmem, to);
 116             root->target[1] = 0;
 117         }
 118     }
 119     else
 120     {
 121         if (!root->children)
 122         {
 123             int i;
 124
 125             root->children = (chr_t_entry **)
 126                 nmem_malloc(nmem, sizeof(chr_t_entry*) * 256);
 127             for (i = 0; i < 256; i++)
 128                 root->children[i] = 0;
 129         }
 130         if (!(root->children[(unsigned char) *from] =
 131             set_map_string(root->children[(unsigned char) *from], nmem,
 132                            from + 1, len - 1, to, from_0)))
 133             return 0;
 134     }
 135     return root;
 136 }
 137
 138 static chr_t_entry *find_entry(chr_t_entry *t, const char **from, int len)
 139 {
 140     chr_t_entry *res;
 141
 142     if (len && t->children && t->children[(unsigned char) **from])
 143     {
 144         const char *pos = *from;
 145
 146         (*from)++;
 147         if ((res = find_entry(t->children[(unsigned char) *pos],
 148             from, len - 1)))
 149             return res;
 150         /* no match */
 151         *from = pos;
 152     }
 153     /* no children match. use ourselves, if we have a target */
 154     return t->target ? t : 0;
 155 }
 156
 157 static chr_t_entry *find_entry_x(chr_t_entry *t, const char **from, int *len, int first)
 158 {
 159     chr_t_entry *res;
 160
 161     while (*len <= 0)
 162     {   /* switch to next buffer */
 163         if (*len < 0)
 164             break;
 165         from++;
 166         len++;
 167     }
 168     if (*len > 0 && t->children)
 169     {
 170         const char *old_from = *from;
 171         int old_len = *len;
 172
 173         res = 0;
 174
 175         if (first && t->children[CHR_FIELD_BEGIN])
 176         {
 177             if ((res = find_entry_x(t->children[CHR_FIELD_BEGIN], from, len, 0)) && res != t->children[CHR_FIELD_BEGIN])
 178                 return res;
 179             else
 180                 res = 0;
 181             /* otherwhise there was no match on beginning of field, move on */
 182         }
 183
 184         if (!res && t->children[(unsigned char) **from])
 185         {
 186             (*len)--;
 187             (*from)++;
 188             if ((res = find_entry_x(t->children[(unsigned char) *old_from],
 189                                     from, len, 0)))
 190                 return res;
 191             /* no match */
 192             *len = old_len;
 193             *from = old_from;
 194         }
 195     }
 196     /* no children match. use ourselves, if we have a target */
 197     return t->target ? t : 0;
 198 }
 199
 200 const char **chr_map_input_x(chrmaptab maptab, const char **from, int *len, int first)
 201 {
 202     chr_t_entry *t = maptab->input;
 203     chr_t_entry *res;
 204
 205     if (!(res = find_entry_x(t, from, len, first)))
 206         abort();
 207     return (const char **) (res->target);
 208 }
 209
 210 const char **chr_map_input(chrmaptab maptab, const char **from, int len, int first)
 211 {
 212     chr_t_entry *t = maptab->input;
 213     chr_t_entry *res;
 214     int len_tmp[2];
 215
 216     len_tmp[0] = len;
 217     len_tmp[1] = -1;
 218     if (!(res = find_entry_x(t, from, len_tmp, first)))
 219         abort();
 220     return (const char **) (res->target);
 221 }
 222
 223 const char **chr_map_q_input(chrmaptab maptab,
 224                              const char **from, int len, int first)
 225 {
 226     chr_t_entry *t = maptab->q_input;
 227     chr_t_entry *res;
 228     int len_tmp[2];
 229
 230     len_tmp[0] = len;
 231     len_tmp[1] = -1;
 232     if (!(res = find_entry_x(t, from, len_tmp, first)))
 233         return 0;
 234     return (const char **) (res->target);
 235 }
 236
 237 const char *chr_map_output(chrmaptab maptab, const char **from, int len)
 238 {
 239     unsigned char c = ** (unsigned char **) from;
 240     (*from)++;
 241     return (const char*) maptab->output[c];
 242 }
 243
 244 unsigned char zebra_prim(char **s)
 245 {
 246     unsigned char c;
 247     unsigned int i = 0;
 248
 249     yaz_log (YLOG_DEBUG, "prim %.3s", *s);
 250     if (**s == '\\')
 251     {
 252         (*s)++;
 253         c = **s;
 254         switch (c)
 255         {
 256         case '\\': c = '\\'; (*s)++; break;
 257         case 'r': c = '\r'; (*s)++; break;
 258         case 'n': c = '\n'; (*s)++; break;
 259         case 't': c = '\t'; (*s)++; break;
 260         case 's': c = ' '; (*s)++; break;
 261         case 'x': sscanf(*s, "x%2x", &i); c = i; *s += 3; break;
 262         case '0':
 263         case '1':
 264         case '2':
 265         case '3':
 266         case '4':
 267         case '5':
 268         case '6':
 269         case '7':
 270         case '8':
 271         case '9':
 272             sscanf(*s, "%3o", &i);
 273             c = i;
 274             *s += 3;
 275             break;
 276         default:
 277             (*s)++;
 278         }
 279     }
 280     else
 281     {
 282         c = **s;
 283         ++(*s);
 284     }
 285     return c;
 286 }
 287
 288 static int zebra_ucs4_strlen(ucs4_t *s)
 289 {
 290     int i = 0;
 291     while (*s++)
 292         i++;
 293     return i;
 294 }
 295
 296 ucs4_t zebra_prim_w(ucs4_t **s)
 297 {
 298     ucs4_t c;
 299     ucs4_t i = 0;
 300     char fmtstr[8];
 301
 302     yaz_log (YLOG_DEBUG, "prim_w %.3s", (char *) *s);
 303     if (**s == '\\')
 304     {
 305         (*s)++;
 306         c = **s;
 307         switch (c)
 308         {
 309         case '\\': c = '\\'; (*s)++; break;
 310         case 'r': c = '\r'; (*s)++; break;
 311         case 'n': c = '\n'; (*s)++; break;
 312         case 't': c = '\t'; (*s)++; break;
 313         case 's': c = ' '; (*s)++; break;
 314         case 'x':
 315             if (zebra_ucs4_strlen(*s) >= 3)
 316             {
 317                 fmtstr[0] = (*s)[1];
 318                 fmtstr[1] = (*s)[2];
 319                 fmtstr[2] = 0;
 320                 sscanf(fmtstr, "%x", &i);
 321                 c = i;
 322                 *s += 3;
 323             }
 324             break;
 325         case '0':
 326         case '1':
 327         case '2':
 328         case '3':
 329         case '4':
 330         case '5':
 331         case '6':
 332         case '7':
 333         case '8':
 334         case '9':
 335             if (zebra_ucs4_strlen(*s) >= 3)
 336             {
 337                 fmtstr[0] = (*s)[0];
 338                 fmtstr[1] = (*s)[1];
 339                 fmtstr[2] = (*s)[2];
 340                 fmtstr[3] = 0;
 341                 sscanf(fmtstr, "%o", &i);
 342                 c = i;
 343                 *s += 3;
 344             }
 345             break;
 346         case 'L':
 347             if (zebra_ucs4_strlen(*s) >= 5)
 348             {
 349                 fmtstr[0] = (*s)[1];
 350                 fmtstr[1] = (*s)[2];
 351                 fmtstr[2] = (*s)[3];
 352                 fmtstr[3] = (*s)[4];
 353                 fmtstr[4] = 0;
 354                 sscanf(fmtstr, "%x", &i);
 355                 c = i;
 356                 *s += 5;
 357             }
 358             break;
 359         default:
 360             (*s)++;
 361         }
 362     }
 363     else
 364     {
 365         c = **s;
 366         ++(*s);
 367     }
 368     yaz_log (YLOG_DEBUG, "out %d", c);
 369     return c;
 370 }
 371
 372 /*
 373  * Callback function.
 374  * Add an entry to the value space.
 375  */
 376 static void fun_addentry(const char *s, void *data, int num)
 377 {
 378     chrmaptab tab = (chrmaptab) data;
 379     char tmp[2];
 380
 381     tmp[0] = num; tmp[1] = '\0';
 382     tab->input = set_map_string(tab->input, tab->nmem, s, strlen(s), tmp, 0);
 383     tab->output[num + tab->base_uppercase] =
 384         (unsigned char *) nmem_strdup(tab->nmem, s);
 385 }
 386
 387 /*
 388  * Callback function.
 389  * Add a space-entry to the value space.
 390  */
 391 static void fun_addspace(const char *s, void *data, int num)
 392 {
 393     chrmaptab tab = (chrmaptab) data;
 394     tab->input = set_map_string(tab->input, tab->nmem, s, strlen(s),
 395                                 (char*) CHR_SPACE, 0);
 396 }
 397
 398 /*
 399  * Callback function.
 400  * Add a space-entry to the value space.
 401  */
 402 static void fun_addcut(const char *s, void *data, int num)
 403 {
 404     chrmaptab tab = (chrmaptab) data;
 405     tab->input = set_map_string(tab->input, tab->nmem, s, strlen(s),
 406                                 (char*) CHR_CUT, 0);
 407 }
 408
 409 /*
 410  * Create a string containing the mapped characters provided.
 411  */
 412 static void fun_mkstring(const char *s, void *data, int num)
 413 {
 414     chrwork *arg = (chrwork *) data;
 415     const char **res, *p = s;
 416
 417     res = chr_map_input(arg->map, &s, strlen(s), 0);
 418     if (*res == (char*) CHR_UNKNOWN)
 419         yaz_log(YLOG_WARN, "Map: '%s' has no mapping", p);
 420     strncat(arg->string, *res, CHR_MAXSTR - strlen(arg->string));
 421     arg->string[CHR_MAXSTR] = '\0';
 422 }
 423
 424 /*
 425  * Create an unmodified string (scan_string handler).
 426  */
 427 static void fun_add_equivalent_string(const char *s, void *data, int num)
 428 {
 429     chr_equiv_work *arg = (chr_equiv_work *) data;
 430
 431     if (arg->no_eq == CHR_MAXEQUIV)
 432         return;
 433     arg->eq[arg->no_eq++] = nmem_strdup(arg->nmem, s);
 434 }
 435
 436 /*
 437  * Add a map to the string contained in the argument.
 438  */
 439 static void fun_add_map(const char *s, void *data, int num)
 440 {
 441     chrwork *arg = (chrwork *) data;
 442
 443     assert(arg->map->input);
 444     yaz_log (YLOG_DEBUG, "set map %.*s", (int) strlen(s), s);
 445     set_map_string(arg->map->input, arg->map->nmem, s, strlen(s), arg->string,
 446                    0);
 447     for (s = arg->string; *s; s++)
 448         yaz_log (YLOG_DEBUG, " %3d", (unsigned char) *s);
 449 }
 450
 451 static int scan_to_utf8 (yaz_iconv_t t, ucs4_t *from, size_t inlen,
 452                         char *outbuf, size_t outbytesleft)
 453 {
 454     size_t inbytesleft = inlen * sizeof(ucs4_t);
 455     char *inbuf = (char*) from;
 456     size_t ret;
 457
 458     if (t == 0)
 459         *outbuf++ = *from;  /* ISO-8859-1 is OK here */
 460     else
 461     {
 462         ret = yaz_iconv (t, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
 463         if (ret == (size_t) (-1))
 464         {
 465             yaz_log(YLOG_LOG, "from: %2X %2X %2X %2X",
 466                     from[0], from[1], from[2], from[3]);
 467             yaz_log (YLOG_WARN|YLOG_ERRNO, "bad unicode sequence");
 468             return -1;
 469         }
 470     }
 471     *outbuf = '\0';
 472     return 0;
 473 }
 474
 475 static int scan_string(char *s_native,
 476                        yaz_iconv_t t_unicode, yaz_iconv_t t_utf8,
 477                        void (*fun)(const char *c, void *data, int num),
 478                        void *data, int *num)
 479 {
 480     char str[1024];
 481
 482     ucs4_t arg[512];
 483     ucs4_t arg_prim[512];
 484     ucs4_t *s0, *s = arg;
 485     ucs4_t c, begin, end;
 486     size_t i;
 487
 488     if (t_unicode != 0)
 489     {
 490         char *outbuf = (char *) arg;
 491         char *inbuf = s_native;
 492         size_t outbytesleft = sizeof(arg)-4;
 493         size_t inbytesleft = strlen(s_native);
 494         size_t ret;
 495         ret = yaz_iconv(t_unicode, &inbuf, &inbytesleft,
 496                         &outbuf, &outbytesleft);
 497         if (ret == (size_t)(-1))
 498             return -1;
 499         i = (outbuf - (char*) arg)/sizeof(ucs4_t);
 500     }
 501     else
 502     {
 503         for (i = 0; s_native[i]; i++)
 504             arg[i] = s_native[i] & 255; /* ISO-8859-1 conversion */
 505     }
 506     arg[i] = 0;      /* terminate */
 507     if (s[0] == 0xfeff || s[0] == 0xfeff)  /* skip byte Order Mark */
 508         s++;
 509     while (*s)
 510     {
 511         switch (*s)
 512         {
 513         case '{':
 514             s++;
 515             begin = zebra_prim_w(&s);
 516             if (*s != '-')
 517             {
 518                 yaz_log(YLOG_FATAL, "Bad range in char-map");
 519                 return -1;
 520             }
 521             s++;
 522             end = zebra_prim_w(&s);
 523             if (end <= begin)
 524             {
 525                 yaz_log(YLOG_FATAL, "Bad range in char-map");
 526                 return -1;
 527             }
 528             s++;
 529             for (c = begin; c <= end; c++)
 530             {
 531                 if (scan_to_utf8 (t_utf8, &c, 1, str, sizeof(str)-1))
 532                     return -1;
 533                 (*fun)(str, data, num ? (*num)++ : 0);
 534             }
 535             break;
 536         case '[': s++; abort(); break;
 537         case '(':
 538             ++s;
 539             s0 = s; i = 0;
 540             while (*s != ')' || s[-1] == '\\')
 541                 arg_prim[i++] = zebra_prim_w(&s);
 542             arg_prim[i] = 0;
 543             if (scan_to_utf8 (t_utf8, arg_prim, zebra_ucs4_strlen(arg_prim), str, sizeof(str)-1))
 544                 return -1;
 545             (*fun)(str, data, num ? (*num)++ : 0);
 546             s++;
 547             break;
 548         default:
 549             c = zebra_prim_w(&s);
 550             if (scan_to_utf8 (t_utf8, &c, 1, str, sizeof(str)-1))
 551                 return -1;
 552             (*fun)(str, data, num ? (*num)++ : 0);
 553         }
 554     }
 555     return 0;
 556 }
 557
 558 chrmaptab chrmaptab_create(const char *tabpath, const char *name, int map_only,
 559                            const char *tabroot)
 560 {
 561     FILE *f;
 562     char line[512], *argv[50];
 563     chrmaptab res;
 564     int lineno = 0;
 565     int errors = 0;
 566     int argc, num = (int) *CHR_BASE, i;
 567     NMEM nmem;
 568     yaz_iconv_t t_unicode = 0;
 569     yaz_iconv_t t_utf8 = 0;
 570     unsigned endian = 31;
 571     const char *ucs4_native = "UCS-4";
 572
 573     if (*(char*) &endian == 31)      /* little endian? */
 574         ucs4_native = "UCS-4LE";
 575
 576     t_utf8 = yaz_iconv_open ("UTF-8", ucs4_native);
 577
 578     yaz_log (YLOG_DEBUG, "maptab %s open", name);
 579     if (!(f = yaz_fopen(tabpath, name, "r", tabroot)))
 580     {
 581         yaz_log(YLOG_WARN|YLOG_ERRNO, "%s", name);
 582         return 0;
 583     }
 584     nmem = nmem_create ();
 585     res = (chrmaptab) nmem_malloc(nmem, sizeof(*res));
 586     res->nmem = nmem;
 587     res->input = (chr_t_entry *) nmem_malloc(res->nmem, sizeof(*res->input));
 588     res->input->target = (unsigned char **)
 589         nmem_malloc(res->nmem, sizeof(*res->input->target) * 2);
 590     res->input->target[0] = (unsigned char*) CHR_UNKNOWN;
 591     res->input->target[1] = 0;
 592     res->input->children = (chr_t_entry **)
 593         nmem_malloc(res->nmem, sizeof(res->input) * 256);
 594     for (i = 0; i < 256; i++)
 595     {
 596         res->input->children[i] = (chr_t_entry *)
 597             nmem_malloc(res->nmem, sizeof(*res->input));
 598         res->input->children[i]->children = 0;
 599         res->input->children[i]->target = (unsigned char **)
 600             nmem_malloc (res->nmem, 2 * sizeof(unsigned char *));
 601         res->input->children[i]->target[1] = 0;
 602         if (map_only)
 603         {
 604             res->input->children[i]->target[0] = (unsigned char *)
 605                 nmem_malloc (res->nmem, 2 * sizeof(unsigned char));
 606             res->input->children[i]->target[0][0] = i;
 607             res->input->children[i]->target[0][1] = 0;
 608         }
 609         else
 610             res->input->children[i]->target[0] = (unsigned char*) CHR_UNKNOWN;
 611     }
 612     res->q_input = (chr_t_entry *)
 613         nmem_malloc(res->nmem, sizeof(*res->q_input));
 614     res->q_input->target = 0;
 615     res->q_input->children = 0;
 616
 617     for (i = *CHR_BASE; i < 256; i++)
 618         res->output[i] = 0;
 619     res->output[(int) *CHR_SPACE] = (unsigned char *) " ";
 620     res->output[(int) *CHR_UNKNOWN] = (unsigned char*) "@";
 621     res->base_uppercase = 0;
 622
 623     while (!errors && (argc = readconf_line(f, &lineno, line, 512, argv, 50)))
 624         if (!map_only && !yaz_matchstr(argv[0], "lowercase"))
 625         {
 626             if (argc != 2)
 627             {
 628                 yaz_log(YLOG_FATAL, "Syntax error in charmap");
 629                 ++errors;
 630             }
 631             if (scan_string(argv[1], t_unicode, t_utf8, fun_addentry,
 632                             res, &num) < 0)
 633             {
 634                 yaz_log(YLOG_FATAL, "Bad value-set specification");
 635                 ++errors;
 636             }
 637             res->base_uppercase = num;
 638             res->output[(int) *CHR_SPACE + num] = (unsigned char *) " ";
 639             res->output[(int) *CHR_UNKNOWN + num] = (unsigned char*) "@";
 640             num = (int) *CHR_BASE;
 641         }
 642         else if (!map_only && !yaz_matchstr(argv[0], "uppercase"))
 643         {
 644             if (!res->base_uppercase)
 645             {
 646                 yaz_log(YLOG_FATAL, "Uppercase directive with no lowercase set");
 647                 ++errors;
 648             }
 649             if (argc != 2)
 650             {
 651                 yaz_log(YLOG_FATAL, "Missing arg for uppercase directive");
 652                 ++errors;
 653             }
 654             if (scan_string(argv[1], t_unicode, t_utf8, fun_addentry,
 655                             res, &num) < 0)
 656             {
 657                 yaz_log(YLOG_FATAL, "Bad value-set specification");
 658                 ++errors;
 659             }
 660         }
 661         else if (!map_only && !yaz_matchstr(argv[0], "space"))
 662         {
 663             if (argc != 2)
 664             {
 665                 yaz_log(YLOG_FATAL, "Syntax error in charmap for space");
 666                 ++errors;
 667             }
 668             if (scan_string(argv[1], t_unicode, t_utf8,
 669                             fun_addspace, res, 0) < 0)
 670             {
 671                 yaz_log(YLOG_FATAL, "Bad space specification");
 672                 ++errors;
 673             }
 674         }
 675         else if (!map_only && !yaz_matchstr(argv[0], "cut"))
 676         {
 677             if (argc != 2)
 678             {
 679                 yaz_log(YLOG_FATAL, "Syntax error in charmap for cut");
 680                 ++errors;
 681             }
 682             if (scan_string(argv[1], t_unicode, t_utf8,
 683                             fun_addcut, res, 0) < 0)
 684             {
 685                 yaz_log(YLOG_FATAL, "Bad cut specification");
 686                 ++errors;
 687             }
 688         }
 689         else if (!yaz_matchstr(argv[0], "map"))
 690         {
 691             chrwork buf;
 692
 693             if (argc != 3)
 694             {
 695                 yaz_log(YLOG_FATAL, "charmap directive map requires 2 args");
 696                 ++errors;
 697             }
 698             buf.map = res;
 699             buf.string[0] = '\0';
 700             if (scan_string(argv[2], t_unicode, t_utf8,
 701                             fun_mkstring, &buf, 0) < 0)
 702             {
 703                 yaz_log(YLOG_FATAL, "Bad map target");
 704                 ++errors;
 705             }
 706             if (scan_string(argv[1], t_unicode, t_utf8,
 707                             fun_add_map, &buf, 0) < 0)
 708             {
 709                 yaz_log(YLOG_FATAL, "Bad map source");
 710                 ++errors;
 711             }
 712         }
 713         else if (!yaz_matchstr(argv[0], "equivalent"))
 714         {
 715             chr_equiv_work w;
 716
 717             if (argc != 2)
 718             {
 719                 yaz_log(YLOG_FATAL, "equivalent requires 1 argument");
 720                 ++errors;
 721             }
 722             w.nmem = res->nmem;
 723             w.no_eq = 0;
 724             if (scan_string(argv[1], t_unicode, t_utf8,
 725                             fun_add_equivalent_string, &w, 0) < 0)
 726             {
 727                 yaz_log(YLOG_FATAL, "equivalent: invalid string");
 728                 ++errors;
 729             }
 730             else if (w.no_eq == 0)
 731             {
 732                 yaz_log(YLOG_FATAL, "equivalent: no strings");
 733                 ++errors;
 734             }
 735             else
 736             {
 737                 char *result_str;
 738                 int i, slen = 5;
 739
 740                 /* determine length of regular expression */
 741                 for (i = 0; i<w.no_eq; i++)
 742                     slen += strlen(w.eq[i]) + 1;
 743                 result_str = nmem_malloc(res->nmem, slen + 5);
 744
 745                 /* build the regular expression */
 746                 *result_str = '\0';
 747                 slen = 0;
 748                 for (i = 0; i<w.no_eq; i++)
 749                 {
 750                     result_str[slen++]  = i ? '|' : '(';
 751                     strcpy(result_str + slen, w.eq[i]);
 752                     slen += strlen(w.eq[i]);
 753                 }
 754                 result_str[slen++] = ')';
 755                 result_str[slen] = '\0';
 756
 757                 /* each eq will map to this regular expression */
 758                 for (i = 0; i<w.no_eq; i++)
 759                 {
 760                     set_map_string(res->q_input, res->nmem,
 761                                    w.eq[i], strlen(w.eq[i]),
 762                                    result_str, 0);
 763                 }
 764             }
 765         }
 766         else if (!yaz_matchstr(argv[0], "encoding"))
 767         {
 768             /*
 769              * Fix me. When t_unicode==0 and use encoding directive in *.chr file the beheviour of the
 770              * zebra need to comment next part of code.
 771              */
 772
 773             /* Original code */
 774 #if 1
 775             if (t_unicode != 0)
 776                 yaz_iconv_close (t_unicode);
 777             t_unicode = yaz_iconv_open (ucs4_native, argv[1]);
 778 #endif
 779             /*
 780              * Fix me. It is additional staff for conversion of characters from local encoding
 781              * of *.chr file to UTF-8 (internal encoding).
 782              * NOTE: The derective encoding must be first directive in *.chr file.
 783              */
 784             /* For whatever reason Oleg enabled this.. */
 785 #if 0
 786             if (t_utf8 != 0)
 787                 yaz_iconv_close(t_utf8);
 788             t_utf8 = yaz_iconv_open ("UTF-8", argv[1]);
 789 #endif
 790         }
 791         else
 792         {
 793             yaz_log(YLOG_WARN, "Syntax error at '%s' in %s", line, name);
 794         }
 795
 796     yaz_fclose(f);
 797     if (errors)
 798     {
 799         chrmaptab_destroy(res);
 800         res = 0;
 801     }
 802     yaz_log (YLOG_DEBUG, "maptab %s close %d errors", name, errors);
 803     if (t_utf8 != 0)
 804         yaz_iconv_close(t_utf8);
 805     if (t_unicode != 0)
 806         yaz_iconv_close(t_unicode);
 807     return res;
 808 }
 809
 810 void chrmaptab_destroy(chrmaptab tab)
 811 {
 812     if (tab)
 813         nmem_destroy (tab->nmem);
 814 }
 815
 816