util/charmap.c

   1 /*
   2  * Copyright (C) 1996-2002, Index Data
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Id: charmap.c,v 1.24 2002-07-26 14:43:09 adam Exp $
   7  *
   8  */
   9
  10 /*
  11  * Support module to handle character-conversions into and out of the
  12  * Zebra dictionary.
  13  */
  14
  15 #include <ctype.h>
  16 #include <string.h>
  17 #include <assert.h>
  18
  19 #if HAVE_ICONV_H
  20 #include <iconv.h>
  21 #else
  22 typedef int iconv_t;
  23 static size_t iconv(iconv_t t, char **buf, size_t *inbytesleft,
  24                     char **outbuf, size_t *outbytesleft)
  25 {
  26     return -1;
  27 }
  28 #endif
  29
  30 typedef unsigned ucs4_t;
  31
  32 #include <yaz/yaz-util.h>
  33 #include <charmap.h>
  34
  35
  36 #define CHR_MAXSTR 1024
  37 #define CHR_MAXEQUIV 32
  38
  39 const char *CHR_UNKNOWN = "\001";
  40 const char *CHR_SPACE   = "\002";
  41 const char *CHR_BASE    = "\003";
  42
  43 struct chrmaptab_info
  44 {
  45     chr_t_entry *input;         /* mapping table for input data */
  46     chr_t_entry *q_input;       /* mapping table for queries */
  47     unsigned char *output[256]; /* return mapping - for display of registers */
  48     int base_uppercase;         /* Start of upper-case ordinals */
  49     NMEM nmem;
  50 };
  51
  52 /*
  53  * Character map trie node.
  54  */
  55 struct chr_t_entry
  56 {
  57     chr_t_entry **children;  /* array of children */
  58     unsigned char **target;  /* target for this node, if any */
  59 };
  60
  61 /*
  62  * General argument structure for callback functions (internal use only)
  63  */
  64 typedef struct chrwork
  65 {
  66     chrmaptab map;
  67     char string[CHR_MAXSTR+1];
  68 } chrwork;
  69
  70 /*
  71  * Add an entry to the character map.
  72  */
  73 static chr_t_entry *set_map_string(chr_t_entry *root, NMEM nmem,
  74                                    const char *from, int len, char *to,
  75                                    const char *from_0)
  76 {
  77     if (!from_0)
  78         from_0 = from;
  79     if (!root)
  80     {
  81         root = (chr_t_entry *) nmem_malloc(nmem, sizeof(*root));
  82         root->children = 0;
  83         root->target = 0;
  84     }
  85     if (!len)
  86     {
  87         if (!root->target || !root->target[0] || strcmp(root->target[0], to))
  88         {
  89             if (from_0 &&
  90                 root->target && root->target[0] && root->target[0][0] &&
  91                 strcmp (root->target[0], CHR_UNKNOWN))
  92             {
  93                 yaz_log (LOG_WARN, "duplicate entry for charmap from '%s'",
  94                          from_0);
  95             }
  96             root->target = (unsigned char **)
  97                 nmem_malloc(nmem, sizeof(*root->target)*2);
  98             root->target[0] = (unsigned char *) nmem_strdup(nmem, to);
  99             root->target[1] = 0;
 100         }
 101     }
 102     else
 103     {
 104         if (!root->children)
 105         {
 106             int i;
 107
 108             root->children = (chr_t_entry **)
 109                 nmem_malloc(nmem, sizeof(chr_t_entry*) * 256);
 110             for (i = 0; i < 256; i++)
 111                 root->children[i] = 0;
 112         }
 113         if (!(root->children[(unsigned char) *from] =
 114             set_map_string(root->children[(unsigned char) *from], nmem,
 115                            from + 1, len - 1, to, from_0)))
 116             return 0;
 117     }
 118     return root;
 119 }
 120
 121 static chr_t_entry *find_entry(chr_t_entry *t, const char **from, int len)
 122 {
 123     chr_t_entry *res;
 124
 125     if (len && t->children && t->children[(unsigned char) **from])
 126     {
 127         const char *pos = *from;
 128
 129         (*from)++;
 130         if ((res = find_entry(t->children[(unsigned char) *pos],
 131             from, len - 1)))
 132             return res;
 133         /* no match */
 134         *from = pos;
 135     }
 136     /* no children match. use ourselves, if we have a target */
 137     return t->target ? t : 0;
 138 }
 139
 140 static chr_t_entry *find_entry_x(chr_t_entry *t, const char **from, int *len)
 141 {
 142     chr_t_entry *res;
 143
 144     while (*len <= 0)
 145     {   /* switch to next buffer */
 146         if (*len < 0)
 147             break;
 148         from++;
 149         len++;
 150     }
 151     if (*len > 0 && t->children && t->children[(unsigned char) **from])
 152     {
 153         const char *old_from = *from;
 154         int old_len = *len;
 155
 156         (*len)--;
 157         (*from)++;
 158         if ((res = find_entry_x(t->children[(unsigned char) *old_from],
 159                                 from, len)))
 160             return res;
 161         /* no match */
 162         *len = old_len;
 163         *from = old_from;
 164     }
 165     /* no children match. use ourselves, if we have a target */
 166     return t->target ? t : 0;
 167 }
 168
 169 const char **chr_map_input_x(chrmaptab maptab, const char **from, int *len)
 170 {
 171     chr_t_entry *t = maptab->input;
 172     chr_t_entry *res;
 173
 174     if (!(res = find_entry_x(t, from, len)))
 175         abort();
 176     return (const char **) (res->target);
 177 }
 178
 179 const char **chr_map_input(chrmaptab maptab, const char **from, int len)
 180 {
 181     chr_t_entry *t = maptab->input;
 182     chr_t_entry *res;
 183     int len_tmp[2];
 184
 185     len_tmp[0] = len;
 186     len_tmp[1] = -1;
 187     if (!(res = find_entry_x(t, from, len_tmp)))
 188         abort();
 189     return (const char **) (res->target);
 190 }
 191
 192 const char *chr_map_output(chrmaptab maptab, const char **from, int len)
 193 {
 194     unsigned char c = ** (unsigned char **) from;
 195     (*from)++;
 196     return (const char*) maptab->output[c];
 197 }
 198
 199 unsigned char zebra_prim(char **s)
 200 {
 201     unsigned char c;
 202     unsigned int i = 0;
 203
 204     yaz_log (LOG_DEBUG, "prim %.3s", *s);
 205     if (**s == '\\')
 206     {
 207         (*s)++;
 208         c = **s;
 209         switch (c)
 210         {
 211         case '\\': c = '\\'; (*s)++; break;
 212         case 'r': c = '\r'; (*s)++; break;
 213         case 'n': c = '\n'; (*s)++; break;
 214         case 't': c = '\t'; (*s)++; break;
 215         case 's': c = ' '; (*s)++; break;
 216         case 'x': sscanf(*s, "x%2x", &i); c = i; *s += 3; break;
 217         case '0':
 218         case '1':
 219         case '2':
 220         case '3':
 221         case '4':
 222         case '5':
 223         case '6':
 224         case '7':
 225         case '8':
 226         case '9':
 227             sscanf(*s, "%3o", &i);
 228             c = i;
 229             *s += 3;
 230             break;
 231         default:
 232             (*s)++;
 233         }
 234     }
 235     else
 236     {
 237         c = **s;
 238         ++(*s);
 239     }
 240     return c;
 241 }
 242
 243 ucs4_t zebra_prim_w(ucs4_t **s)
 244 {
 245     ucs4_t c;
 246     ucs4_t i = 0;
 247     char fmtstr[8];
 248
 249     yaz_log (LOG_DEBUG, "prim %.3s", (char *) *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':
 262             fmtstr[0] = (*s)[0];
 263             fmtstr[1] = (*s)[1];
 264             fmtstr[2] = (*s)[2];
 265             fmtstr[3] = 0;
 266             sscanf(fmtstr, "x%2x", &i);
 267             c = i;
 268             *s += 3; break;
 269         case '0':
 270         case '1':
 271         case '2':
 272         case '3':
 273         case '4':
 274         case '5':
 275         case '6':
 276         case '7':
 277         case '8':
 278         case '9':
 279             fmtstr[0] = (*s)[0];
 280             fmtstr[1] = (*s)[1];
 281             fmtstr[2] = (*s)[2];
 282             fmtstr[3] = 0;
 283             sscanf(fmtstr, "%3o", &i);
 284             c = i;
 285             *s += 3;
 286             break;
 287         default:
 288             (*s)++;
 289         }
 290     }
 291     else
 292     {
 293         c = **s;
 294         ++(*s);
 295     }
 296     yaz_log (LOG_DEBUG, "out %d", c);
 297     return c;
 298 }
 299
 300 /*
 301  * Callback function.
 302  * Add an entry to the value space.
 303  */
 304 static void fun_addentry(const char *s, void *data, int num)
 305 {
 306     chrmaptab tab = (chrmaptab) data;
 307     char tmp[2];
 308
 309     tmp[0] = num; tmp[1] = '\0';
 310     tab->input = set_map_string(tab->input, tab->nmem, s, strlen(s), tmp, 0);
 311     tab->output[num + tab->base_uppercase] =
 312         (unsigned char *) nmem_strdup(tab->nmem, s);
 313 }
 314
 315 /*
 316  * Callback function.
 317  * Add a space-entry to the value space.
 318  */
 319 static void fun_addspace(const char *s, void *data, int num)
 320 {
 321     chrmaptab tab = (chrmaptab) data;
 322     tab->input = set_map_string(tab->input, tab->nmem, s, strlen(s),
 323                                 (char*) CHR_SPACE, 0);
 324 }
 325
 326 /*
 327  * Create a string containing the mapped characters provided.
 328  */
 329 static void fun_mkstring(const char *s, void *data, int num)
 330 {
 331     chrwork *arg = (chrwork *) data;
 332     const char **res, *p = s;
 333
 334     res = chr_map_input(arg->map, &s, strlen(s));
 335     if (*res == (char*) CHR_UNKNOWN)
 336         logf(LOG_WARN, "Map: '%s' has no mapping", p);
 337     strncat(arg->string, *res, CHR_MAXSTR - strlen(arg->string));
 338     arg->string[CHR_MAXSTR] = '\0';
 339 }
 340
 341 /*
 342  * Add a map to the string contained in the argument.
 343  */
 344 static void fun_add_map(const char *s, void *data, int num)
 345 {
 346     chrwork *arg = (chrwork *) data;
 347
 348     assert(arg->map->input);
 349     logf (LOG_DEBUG, "set map %.*s", (int) strlen(s), s);
 350     set_map_string(arg->map->input, arg->map->nmem, s, strlen(s), arg->string,
 351                    0);
 352     for (s = arg->string; *s; s++)
 353         logf (LOG_DEBUG, " %3d", (unsigned char) *s);
 354 }
 355
 356 /*
 357  * Add a query map to the string contained in the argument.
 358  */
 359 static void fun_add_qmap(const char *s, void *data, int num)
 360 {
 361     chrwork *arg = (chrwork *) data;
 362
 363     assert(arg->map->q_input);
 364     logf (LOG_DEBUG, "set qmap %.*s", (int) strlen(s), s);
 365     set_map_string(arg->map->q_input, arg->map->nmem, s,
 366                    strlen(s), arg->string, 0);
 367     for (s = arg->string; *s; s++)
 368         logf (LOG_DEBUG, " %3d", (unsigned char) *s);
 369 }
 370
 371 static int scan_to_utf8 (iconv_t t, ucs4_t *from, size_t inlen,
 372                         char *outbuf, size_t outbytesleft)
 373 {
 374     size_t inbytesleft = inlen * sizeof(ucs4_t);
 375     char *inbuf = (char*) from;
 376     size_t ret;
 377
 378     if (t == (iconv_t)(-1))
 379         *outbuf++ = *from;  /* ISO-8859-1 is OK here */
 380     else
 381     {
 382         ret = iconv (t, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
 383         if (ret == (size_t) (-1))
 384         {
 385             yaz_log (LOG_WARN|LOG_ERRNO, "bad unicode sequence");
 386             return -1;
 387         }
 388     }
 389     *outbuf = '\0';
 390     return 0;
 391 }
 392
 393 static int scan_string(char *s_native,
 394                        iconv_t t_unicode, iconv_t t_utf8,
 395                        void (*fun)(const char *c, void *data, int num),
 396                        void *data, int *num)
 397 {
 398     char str[1024];
 399
 400     ucs4_t arg[512];
 401     ucs4_t *s0, *s = arg;
 402     ucs4_t c, begin, end;
 403     size_t i, j;
 404
 405     if (t_unicode != (iconv_t)(-1))
 406     {
 407         char *outbuf = (char *) arg;
 408         char *inbuf = s_native;
 409         size_t outbytesleft = sizeof(arg)-4;
 410         size_t inbytesleft = strlen(s_native);
 411         size_t ret;
 412         ret = iconv(t_unicode, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
 413         if (ret == (size_t)(-1))
 414             return -1;
 415         i = (outbuf - (char*) arg)/sizeof(ucs4_t);
 416     }
 417     else
 418     {
 419         for (i = 0; s_native[i]; i++)
 420             arg[i] = s_native[i] & 255; /* ISO-8859-1 conversion */
 421     }
 422     arg[i] = 0;      /* terminate */
 423     if (s[0] == 0xfeff || s[0] == 0xfeff)  /* skip byte Order Mark */
 424         s++;
 425     while (*s)
 426     {
 427         switch (*s)
 428         {
 429         case '{':
 430             s++;
 431             begin = zebra_prim_w(&s);
 432             if (*s != '-')
 433             {
 434                 logf(LOG_FATAL, "Bad range in char-map");
 435                 return -1;
 436             }
 437             s++;
 438             end = zebra_prim_w(&s);
 439             if (end <= begin)
 440             {
 441                 logf(LOG_FATAL, "Bad range in char-map");
 442                 return -1;
 443             }
 444             s++;
 445             for (c = begin; c <= end; c++)
 446             {
 447                 if (scan_to_utf8 (t_utf8, &c, 1, str, sizeof(str)-1))
 448                     return -1;
 449                 (*fun)(str, data, num ? (*num)++ : 0);
 450             }
 451             break;
 452         case '[': s++; abort(); break;
 453         case '(':
 454             ++s;
 455             s0 = s;
 456             while (*s != ')' || s[-1] == '\\')
 457                 s++;
 458             *s = 0;
 459             if (scan_to_utf8 (t_utf8, s0, s - s0, str, sizeof(str)-1))
 460                 return -1;
 461             (*fun)(str, data, num ? (*num)++ : 0);
 462             s++;
 463             break;
 464         default:
 465             c = zebra_prim_w(&s);
 466             if (scan_to_utf8 (t_utf8, &c, 1, str, sizeof(str)-1))
 467                 return -1;
 468             (*fun)(str, data, num ? (*num)++ : 0);
 469         }
 470     }
 471     return 0;
 472 }
 473
 474 chrmaptab chrmaptab_create(const char *tabpath, const char *name, int map_only,
 475                            const char *tabroot)
 476 {
 477     FILE *f;
 478     char line[512], *argv[50];
 479     chrmaptab res;
 480     int lineno = 0;
 481     int errors = 0;
 482     int argc, num = (int) *CHR_BASE, i;
 483     NMEM nmem;
 484     iconv_t t_unicode = (iconv_t)(-1);
 485     iconv_t t_utf8 = (iconv_t)(-1);
 486     unsigned endian = 31;
 487     const char *ucs4_native = "UCS-4";
 488
 489     if (*(char*) &endian == 31)      /* little endian? */
 490         ucs4_native = "UCS-4LE";
 491
 492 #if HAVE_ICONV_H
 493     t_utf8 = iconv_open ("UTF-8", ucs4_native);
 494 #endif
 495     logf (LOG_DEBUG, "maptab %s open", name);
 496     if (!(f = yaz_fopen(tabpath, name, "r", tabroot)))
 497     {
 498         logf(LOG_WARN|LOG_ERRNO, "%s", name);
 499         return 0;
 500     }
 501     nmem = nmem_create ();
 502     res = (chrmaptab) nmem_malloc(nmem, sizeof(*res));
 503     res->nmem = nmem;
 504     res->input = (chr_t_entry *) nmem_malloc(res->nmem, sizeof(*res->input));
 505     res->input->target = (unsigned char **)
 506         nmem_malloc(res->nmem, sizeof(*res->input->target) * 2);
 507     res->input->target[0] = (unsigned char*) CHR_UNKNOWN;
 508     res->input->target[1] = 0;
 509     res->input->children = (chr_t_entry **)
 510         nmem_malloc(res->nmem, sizeof(res->input) * 256);
 511     for (i = 0; i < 256; i++)
 512     {
 513         res->input->children[i] = (chr_t_entry *)
 514             nmem_malloc(res->nmem, sizeof(*res->input));
 515         res->input->children[i]->children = 0;
 516         res->input->children[i]->target = (unsigned char **)
 517             nmem_malloc (res->nmem, 2 * sizeof(unsigned char *));
 518         res->input->children[i]->target[1] = 0;
 519         if (map_only)
 520         {
 521             res->input->children[i]->target[0] = (unsigned char *)
 522                 nmem_malloc (res->nmem, 2 * sizeof(unsigned char));
 523             res->input->children[i]->target[0][0] = i;
 524             res->input->children[i]->target[0][1] = 0;
 525         }
 526         else
 527             res->input->children[i]->target[0] = (unsigned char*) CHR_UNKNOWN;
 528     }
 529     res->q_input = (chr_t_entry *)
 530         nmem_malloc(res->nmem, sizeof(*res->q_input));
 531     res->q_input->target = 0;
 532     res->q_input->children = 0;
 533
 534     for (i = *CHR_BASE; i < 256; i++)
 535         res->output[i] = 0;
 536     res->output[(int) *CHR_SPACE] = (unsigned char *) " ";
 537     res->output[(int) *CHR_UNKNOWN] = (unsigned char*) "@";
 538     res->base_uppercase = 0;
 539
 540     while (!errors && (argc = readconf_line(f, &lineno, line, 512, argv, 50)))
 541         if (!map_only && !yaz_matchstr(argv[0], "lowercase"))
 542         {
 543             if (argc != 2)
 544             {
 545                 logf(LOG_FATAL, "Syntax error in charmap");
 546                 ++errors;
 547             }
 548             if (scan_string(argv[1], t_unicode, t_utf8, fun_addentry,
 549                             res, &num) < 0)
 550             {
 551                 logf(LOG_FATAL, "Bad value-set specification");
 552                 ++errors;
 553             }
 554             res->base_uppercase = num;
 555             res->output[(int) *CHR_SPACE + num] = (unsigned char *) " ";
 556             res->output[(int) *CHR_UNKNOWN + num] = (unsigned char*) "@";
 557             num = (int) *CHR_BASE;
 558         }
 559         else if (!map_only && !yaz_matchstr(argv[0], "uppercase"))
 560         {
 561             if (!res->base_uppercase)
 562             {
 563                 logf(LOG_FATAL, "Uppercase directive with no lowercase set");
 564                 ++errors;
 565             }
 566             if (argc != 2)
 567             {
 568                 logf(LOG_FATAL, "Missing arg for uppercase directive");
 569                 ++errors;
 570             }
 571             if (scan_string(argv[1], t_unicode, t_utf8, fun_addentry,
 572                             res, &num) < 0)
 573             {
 574                 logf(LOG_FATAL, "Bad value-set specification");
 575                 ++errors;
 576             }
 577         }
 578         else if (!map_only && !yaz_matchstr(argv[0], "space"))
 579         {
 580             if (argc != 2)
 581             {
 582                 logf(LOG_FATAL, "Syntax error in charmap");
 583                 ++errors;
 584             }
 585             if (scan_string(argv[1], t_unicode, t_utf8,
 586                             fun_addspace, res, 0) < 0)
 587             {
 588                 logf(LOG_FATAL, "Bad space specification");
 589                 ++errors;
 590             }
 591         }
 592         else if (!yaz_matchstr(argv[0], "map"))
 593         {
 594             chrwork buf;
 595
 596             if (argc != 3)
 597             {
 598                 logf(LOG_FATAL, "charmap directive map requires 2 args");
 599                 ++errors;
 600             }
 601             buf.map = res;
 602             buf.string[0] = '\0';
 603             if (scan_string(argv[2], t_unicode, t_utf8,
 604                             fun_mkstring, &buf, 0) < 0)
 605             {
 606                 logf(LOG_FATAL, "Bad map target");
 607                 ++errors;
 608             }
 609             if (scan_string(argv[1], t_unicode, t_utf8,
 610                             fun_add_map, &buf, 0) < 0)
 611             {
 612                 logf(LOG_FATAL, "Bad map source");
 613                 ++errors;
 614             }
 615         }
 616         else if (!yaz_matchstr(argv[0], "qmap"))
 617         {
 618             chrwork buf;
 619
 620             if (argc != 3)
 621             {
 622                 logf(LOG_FATAL, "charmap directive qmap requires 2 args");
 623                 ++errors;
 624             }
 625             buf.map = res;
 626             buf.string[0] = '\0';
 627             if (scan_string(argv[2], t_unicode, t_utf8,
 628                             fun_mkstring, &buf, 0) < 0)
 629             {
 630                 logf(LOG_FATAL, "Bad qmap target");
 631                 ++errors;
 632             }
 633             if (scan_string(argv[1], t_unicode, t_utf8,
 634                             fun_add_qmap, &buf, 0) < 0)
 635             {
 636                 logf(LOG_FATAL, "Bad qmap source");
 637                 ++errors;
 638             }
 639         }
 640         else if (!yaz_matchstr(argv[0], "encoding"))
 641         {
 642 #if HAVE_ICONV_H
 643             if (t_unicode != (iconv_t)(-1))
 644                 iconv_close (t_unicode);
 645             t_unicode = iconv_open (ucs4_native, argv[1]);
 646 #else
 647             logf (LOG_WARN, "Encoding ignored. iconv not installed");
 648 #endif
 649         }
 650         else
 651         {
 652             logf(LOG_WARN, "Syntax error at '%s' in %s", line, name);
 653         }
 654
 655     yaz_fclose(f);
 656     if (errors)
 657     {
 658         chrmaptab_destroy(res);
 659         res = 0;
 660     }
 661     logf (LOG_DEBUG, "maptab %s close %d errors", name, errors);
 662 #if HAVE_ICONV_H
 663     if (t_utf8 != (iconv_t)(-1))
 664         iconv_close(t_utf8);
 665     if (t_unicode != (iconv_t)(-1))
 666         iconv_close(t_unicode);
 667 #endif
 668     return res;
 669 }
 670
 671 void chrmaptab_destroy(chrmaptab tab)
 672 {
 673     if (tab)
 674         nmem_destroy (tab->nmem);
 675 }
 676
 677