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.23 2002-07-25 13:06:44 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         size_t i;
 383         for (i = 0; i<inlen; i++)
 384             yaz_log (LOG_LOG, "%08X", from[i]);
 385         ret = iconv (t, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
 386         if (ret == (size_t) (-1))
 387         {
 388             yaz_log (LOG_WARN|LOG_ERRNO, "bad unicode sequence");
 389             for (i = 0; i<inlen; i++)
 390                 yaz_log (LOG_LOG, "%08X", from[i]);
 391             return -1;
 392         }
 393     }
 394     *outbuf = '\0';
 395     return 0;
 396 }
 397
 398 static int scan_string(char *s_native,
 399                        iconv_t t_unicode, iconv_t t_utf8,
 400                        void (*fun)(const char *c, void *data, int num),
 401                        void *data, int *num)
 402 {
 403     char str[1024];
 404
 405     ucs4_t arg[512];
 406     ucs4_t *s0, *s = arg;
 407     ucs4_t c, begin, end;
 408     size_t i, j;
 409
 410     if (t_unicode != (iconv_t)(-1))
 411     {
 412         char *outbuf = (char *) arg;
 413         char *inbuf = s_native;
 414         size_t outbytesleft = sizeof(arg)-4;
 415         size_t inbytesleft = strlen(s_native);
 416         size_t ret;
 417         ret = iconv(t_unicode, &inbuf, &inbytesleft, &outbuf, &outbytesleft);
 418         if (ret == (size_t)(-1))
 419             return -1;
 420         i = (outbuf - (char*) arg)/sizeof(ucs4_t);
 421         yaz_log (LOG_LOG, "to unicode");
 422     }
 423     else
 424     {
 425         for (i = 0; s_native[i]; i++)
 426             arg[i] = s_native[i] & 255; /* ISO-8859-1 conversion */
 427         yaz_log (LOG_LOG, "to virtual unicode");
 428     }
 429     arg[i] = 0;      /* terminate */
 430     for (j = 0; j<i; j++)
 431         yaz_log (LOG_LOG, " %d %8X %d %c", j, arg[j], arg[j],
 432                  (arg[j] > 33 && arg[j] < 127) ? arg[j] : '?');
 433     if (s[0] == 0xfeff || s[0] == 0xfeff)  /* skip byte Order Mark */
 434         s++;
 435     while (*s)
 436     {
 437         switch (*s)
 438         {
 439         case '{':
 440             s++;
 441             begin = zebra_prim_w(&s);
 442             if (*s != '-')
 443             {
 444                 logf(LOG_FATAL, "Bad range in char-map");
 445                 return -1;
 446             }
 447             s++;
 448             end = zebra_prim_w(&s);
 449             if (end <= begin)
 450             {
 451                 logf(LOG_FATAL, "Bad range in char-map");
 452                 return -1;
 453             }
 454             s++;
 455             for (c = begin; c <= end; c++)
 456             {
 457                 if (scan_to_utf8 (t_utf8, &c, 1, str, sizeof(str)-1))
 458                     return -1;
 459                 (*fun)(str, data, num ? (*num)++ : 0);
 460             }
 461             break;
 462         case '[': s++; abort(); break;
 463         case '(':
 464             ++s;
 465             s0 = s;
 466             while (*s != ')' || s[-1] == '\\')
 467                 s++;
 468             *s = 0;
 469             if (scan_to_utf8 (t_utf8, s0, s - s0, str, sizeof(str)-1))
 470                 return -1;
 471             (*fun)(str, data, num ? (*num)++ : 0);
 472             s++;
 473             break;
 474         default:
 475             c = zebra_prim_w(&s);
 476             if (scan_to_utf8 (t_utf8, &c, 1, str, sizeof(str)-1))
 477                 return -1;
 478             (*fun)(str, data, num ? (*num)++ : 0);
 479         }
 480     }
 481     return 0;
 482 }
 483
 484 chrmaptab chrmaptab_create(const char *tabpath, const char *name, int map_only,
 485                            const char *tabroot)
 486 {
 487     FILE *f;
 488     char line[512], *argv[50];
 489     chrmaptab res;
 490     int lineno = 0;
 491     int errors = 0;
 492     int argc, num = (int) *CHR_BASE, i;
 493     NMEM nmem;
 494     iconv_t t_unicode = (iconv_t)(-1);
 495     iconv_t t_utf8 = (iconv_t)(-1);
 496     unsigned endian = 31;
 497     const char *ucs4_native = "UCS-4";
 498
 499     if (*(char*) &endian == 31)      /* little endian? */
 500         ucs4_native = "UCS-4LE";
 501
 502 #if HAVE_ICONV_H
 503     t_utf8 = iconv_open ("UTF-8", ucs4_native);
 504 #endif
 505     logf (LOG_DEBUG, "maptab %s open", name);
 506     if (!(f = yaz_fopen(tabpath, name, "r", tabroot)))
 507     {
 508         logf(LOG_WARN|LOG_ERRNO, "%s", name);
 509         return 0;
 510     }
 511     nmem = nmem_create ();
 512     res = (chrmaptab) nmem_malloc(nmem, sizeof(*res));
 513     res->nmem = nmem;
 514     res->input = (chr_t_entry *) nmem_malloc(res->nmem, sizeof(*res->input));
 515     res->input->target = (unsigned char **)
 516         nmem_malloc(res->nmem, sizeof(*res->input->target) * 2);
 517     res->input->target[0] = (unsigned char*) CHR_UNKNOWN;
 518     res->input->target[1] = 0;
 519     res->input->children = (chr_t_entry **)
 520         nmem_malloc(res->nmem, sizeof(res->input) * 256);
 521     for (i = 0; i < 256; i++)
 522     {
 523         res->input->children[i] = (chr_t_entry *)
 524             nmem_malloc(res->nmem, sizeof(*res->input));
 525         res->input->children[i]->children = 0;
 526         res->input->children[i]->target = (unsigned char **)
 527             nmem_malloc (res->nmem, 2 * sizeof(unsigned char *));
 528         res->input->children[i]->target[1] = 0;
 529         if (map_only)
 530         {
 531             res->input->children[i]->target[0] = (unsigned char *)
 532                 nmem_malloc (res->nmem, 2 * sizeof(unsigned char));
 533             res->input->children[i]->target[0][0] = i;
 534             res->input->children[i]->target[0][1] = 0;
 535         }
 536         else
 537             res->input->children[i]->target[0] = (unsigned char*) CHR_UNKNOWN;
 538     }
 539     res->q_input = (chr_t_entry *)
 540         nmem_malloc(res->nmem, sizeof(*res->q_input));
 541     res->q_input->target = 0;
 542     res->q_input->children = 0;
 543
 544     for (i = *CHR_BASE; i < 256; i++)
 545         res->output[i] = 0;
 546     res->output[(int) *CHR_SPACE] = (unsigned char *) " ";
 547     res->output[(int) *CHR_UNKNOWN] = (unsigned char*) "@";
 548     res->base_uppercase = 0;
 549
 550     while (!errors && (argc = readconf_line(f, &lineno, line, 512, argv, 50)))
 551         if (!map_only && !yaz_matchstr(argv[0], "lowercase"))
 552         {
 553             if (argc != 2)
 554             {
 555                 logf(LOG_FATAL, "Syntax error in charmap");
 556                 ++errors;
 557             }
 558             if (scan_string(argv[1], t_unicode, t_utf8, fun_addentry,
 559                             res, &num) < 0)
 560             {
 561                 logf(LOG_FATAL, "Bad value-set specification");
 562                 ++errors;
 563             }
 564             res->base_uppercase = num;
 565             res->output[(int) *CHR_SPACE + num] = (unsigned char *) " ";
 566             res->output[(int) *CHR_UNKNOWN + num] = (unsigned char*) "@";
 567             num = (int) *CHR_BASE;
 568         }
 569         else if (!map_only && !yaz_matchstr(argv[0], "uppercase"))
 570         {
 571             if (!res->base_uppercase)
 572             {
 573                 logf(LOG_FATAL, "Uppercase directive with no lowercase set");
 574                 ++errors;
 575             }
 576             if (argc != 2)
 577             {
 578                 logf(LOG_FATAL, "Missing arg for uppercase directive");
 579                 ++errors;
 580             }
 581             if (scan_string(argv[1], t_unicode, t_utf8, fun_addentry,
 582                             res, &num) < 0)
 583             {
 584                 logf(LOG_FATAL, "Bad value-set specification");
 585                 ++errors;
 586             }
 587         }
 588         else if (!map_only && !yaz_matchstr(argv[0], "space"))
 589         {
 590             if (argc != 2)
 591             {
 592                 logf(LOG_FATAL, "Syntax error in charmap");
 593                 ++errors;
 594             }
 595             if (scan_string(argv[1], t_unicode, t_utf8,
 596                             fun_addspace, res, 0) < 0)
 597             {
 598                 logf(LOG_FATAL, "Bad space specification");
 599                 ++errors;
 600             }
 601         }
 602         else if (!yaz_matchstr(argv[0], "map"))
 603         {
 604             chrwork buf;
 605
 606             if (argc != 3)
 607             {
 608                 logf(LOG_FATAL, "charmap directive map requires 2 args");
 609                 ++errors;
 610             }
 611             buf.map = res;
 612             buf.string[0] = '\0';
 613             if (scan_string(argv[2], t_unicode, t_utf8,
 614                             fun_mkstring, &buf, 0) < 0)
 615             {
 616                 logf(LOG_FATAL, "Bad map target");
 617                 ++errors;
 618             }
 619             if (scan_string(argv[1], t_unicode, t_utf8,
 620                             fun_add_map, &buf, 0) < 0)
 621             {
 622                 logf(LOG_FATAL, "Bad map source");
 623                 ++errors;
 624             }
 625         }
 626         else if (!yaz_matchstr(argv[0], "qmap"))
 627         {
 628             chrwork buf;
 629
 630             if (argc != 3)
 631             {
 632                 logf(LOG_FATAL, "charmap directive qmap requires 2 args");
 633                 ++errors;
 634             }
 635             buf.map = res;
 636             buf.string[0] = '\0';
 637             if (scan_string(argv[2], t_unicode, t_utf8,
 638                             fun_mkstring, &buf, 0) < 0)
 639             {
 640                 logf(LOG_FATAL, "Bad qmap target");
 641                 ++errors;
 642             }
 643             if (scan_string(argv[1], t_unicode, t_utf8,
 644                             fun_add_qmap, &buf, 0) < 0)
 645             {
 646                 logf(LOG_FATAL, "Bad qmap source");
 647                 ++errors;
 648             }
 649         }
 650         else if (!yaz_matchstr(argv[0], "encoding"))
 651         {
 652 #if HAVE_ICONV_H
 653             if (t_unicode != (iconv_t)(-1))
 654                 iconv_close (t_unicode);
 655             t_unicode = iconv_open (ucs4_native, argv[1]);
 656 #else
 657             logf (LOG_WARN, "Encoding ignored. iconv not installed");
 658 #endif
 659         }
 660         else
 661         {
 662             logf(LOG_WARN, "Syntax error at '%s' in %s", line, name);
 663         }
 664
 665     yaz_fclose(f);
 666     if (errors)
 667     {
 668         chrmaptab_destroy(res);
 669         res = 0;
 670     }
 671     logf (LOG_DEBUG, "maptab %s close %d errors", name, errors);
 672 #if HAVE_ICONV_H
 673     if (t_utf8 != (iconv_t)(-1))
 674         iconv_close(t_utf8);
 675     if (t_unicode != (iconv_t)(-1))
 676         iconv_close(t_unicode);
 677 #endif
 678     return res;
 679 }
 680
 681 void chrmaptab_destroy(chrmaptab tab)
 682 {
 683     if (tab)
 684         nmem_destroy (tab->nmem);
 685 }
 686
 687