util/charmap.c

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