util/zebramap.c

   1 /* $Id: zebramap.c,v 1.69 2007-11-08 09:30:05 adam Exp $
   2    Copyright (C) 1995-2007
   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 #include <assert.h>
  24 #include <stdlib.h>
  25 #include <ctype.h>
  26
  27 #include <charmap.h>
  28 #include <attrfind.h>
  29 #include <yaz/yaz-util.h>
  30
  31 #if YAZ_HAVE_ICU
  32 #include <yaz/icu.h>
  33 #endif
  34 #include <zebramap.h>
  35
  36 #define ZEBRA_MAP_TYPE_SORT  1
  37 #define ZEBRA_MAP_TYPE_INDEX 2
  38 #define ZEBRA_MAP_TYPE_STATICRANK 3
  39
  40 #define ZEBRA_REPLACE_ANY  300
  41
  42 struct zebra_map {
  43     const char *id;
  44     int completeness;
  45     int positioned;
  46     int alwaysmatches;
  47     int first_in_field;
  48     int type;
  49     int use_chain;
  50     union {
  51         struct {
  52             int entry_size;
  53         } sort;
  54     } u;
  55     chrmaptab maptab;
  56     const char *maptab_name;
  57     const char *locale;
  58     zebra_maps_t zebra_maps;
  59 #if YAZ_HAVE_XML2
  60     xmlDocPtr doc;
  61 #endif
  62 #if YAZ_HAVE_ICU
  63     struct icu_chain *icu_chain;
  64 #endif
  65     WRBUF simple_buf;
  66     size_t simple_off;
  67     struct zebra_map *next;
  68 };
  69
  70 struct zebra_maps_s {
  71     char *tabpath;
  72     char *tabroot;
  73     NMEM nmem;
  74     char temp_map_str[2];
  75     const char *temp_map_ptr[2];
  76     WRBUF wrbuf_1;
  77     int no_files_read;
  78     zebra_map_t map_list;
  79     zebra_map_t last_map;
  80 };
  81
  82 void zebra_maps_close(zebra_maps_t zms)
  83 {
  84     struct zebra_map *zm = zms->map_list;
  85     while (zm)
  86     {
  87         if (zm->maptab)
  88             chrmaptab_destroy(zm->maptab);
  89 #if YAZ_HAVE_ICU
  90         if (zm->icu_chain)
  91             icu_chain_destroy(zm->icu_chain);
  92 #endif
  93 #if YAZ_HAVE_XML2
  94         xmlFreeDoc(zm->doc);
  95 #endif
  96         wrbuf_destroy(zm->simple_buf);
  97         zm = zm->next;
  98     }
  99     wrbuf_destroy(zms->wrbuf_1);
 100     nmem_destroy(zms->nmem);
 101     xfree(zms);
 102 }
 103
 104 zebra_map_t zebra_add_map(zebra_maps_t zms, const char *index_type,
 105                           int map_type)
 106 {
 107     zebra_map_t zm = (zebra_map_t) nmem_malloc(zms->nmem, sizeof(*zm));
 108
 109     zm->zebra_maps = zms;
 110     zm->id = nmem_strdup(zms->nmem, index_type);
 111     zm->maptab_name = 0;
 112     zm->use_chain = 0;
 113     zm->locale = 0;
 114     zm->maptab = 0;
 115     zm->type = map_type;
 116     zm->completeness = 0;
 117     zm->positioned = 0;
 118     zm->alwaysmatches = 0;
 119     zm->first_in_field = 0;
 120
 121     if (zms->last_map)
 122         zms->last_map->next = zm;
 123     else
 124         zms->map_list = zm;
 125     zms->last_map = zm;
 126     zm->next = 0;
 127 #if YAZ_HAVE_ICU
 128     zm->icu_chain = 0;
 129 #endif
 130 #if YAZ_HAVE_XML2
 131     zm->doc = 0;
 132 #endif
 133     zm->simple_buf = wrbuf_alloc();
 134     return zm;
 135 }
 136
 137 static int parse_command(zebra_maps_t zms, int argc, char **argv,
 138                          const char *fname, int lineno)
 139 {
 140     zebra_map_t zm = zms->last_map;
 141     if (argc == 1)
 142     {
 143         yaz_log(YLOG_WARN, "%s:%d: Missing arguments for '%s'",
 144                 fname, lineno, argv[0]);
 145         return -1;
 146     }
 147     if (argc > 2)
 148     {
 149         yaz_log(YLOG_WARN, "%s:%d: Too many arguments for '%s'",
 150                 fname, lineno, argv[0]);
 151         return -1;
 152     }
 153     if (!yaz_matchstr(argv[0], "index"))
 154     {
 155         zm = zebra_add_map(zms, argv[1], ZEBRA_MAP_TYPE_INDEX);
 156         zm->positioned = 1;
 157     }
 158     else if (!yaz_matchstr(argv[0], "sort"))
 159     {
 160         zm = zebra_add_map(zms, argv[1], ZEBRA_MAP_TYPE_SORT);
 161         zm->u.sort.entry_size = 80;
 162     }
 163     else if (!yaz_matchstr(argv[0], "staticrank"))
 164     {
 165         zm = zebra_add_map(zms, argv[1], ZEBRA_MAP_TYPE_STATICRANK);
 166         zm->completeness = 1;
 167     }
 168     else if (!zm)
 169     {
 170         yaz_log(YLOG_WARN, "%s:%d: Missing sort/index before '%s'",
 171                 fname, lineno, argv[0]);
 172         return -1;
 173     }
 174     else if (!yaz_matchstr(argv[0], "charmap") && argc == 2)
 175     {
 176         if (zm->type != ZEBRA_MAP_TYPE_STATICRANK)
 177             zm->maptab_name = nmem_strdup(zms->nmem, argv[1]);
 178         else
 179         {
 180             yaz_log(YLOG_WARN|YLOG_FATAL, "%s:%d: charmap for "
 181                     "staticrank is invalid", fname, lineno);
 182             yaz_log(YLOG_LOG, "Type is %d", zm->type);
 183             return -1;
 184         }
 185     }
 186     else if (!yaz_matchstr(argv[0], "completeness") && argc == 2)
 187     {
 188         zm->completeness = atoi(argv[1]);
 189     }
 190     else if (!yaz_matchstr(argv[0], "position") && argc == 2)
 191     {
 192         zm->positioned = atoi(argv[1]);
 193     }
 194     else if (!yaz_matchstr(argv[0], "alwaysmatches") && argc == 2)
 195     {
 196         if (zm->type != ZEBRA_MAP_TYPE_STATICRANK)
 197             zm->alwaysmatches = atoi(argv[1]);
 198         else
 199         {
 200             yaz_log(YLOG_WARN|YLOG_FATAL, "%s:%d: alwaysmatches for "
 201                     "staticrank is invalid", fname, lineno);
 202             return -1;
 203         }
 204     }
 205     else if (!yaz_matchstr(argv[0], "firstinfield") && argc == 2)
 206     {
 207         zm->first_in_field = atoi(argv[1]);
 208     }
 209     else if (!yaz_matchstr(argv[0], "entrysize") && argc == 2)
 210     {
 211         if (zm->type == ZEBRA_MAP_TYPE_SORT)
 212             zm->u.sort.entry_size = atoi(argv[1]);
 213         else
 214         {
 215             yaz_log(YLOG_WARN,
 216                     "%s:%d: entrysize only valid in sort section",
 217                     fname, lineno);
 218             return -1;
 219         }
 220     }
 221     else if (!yaz_matchstr(argv[0], "locale"))
 222     {
 223         zm->locale = nmem_strdup(zms->nmem, argv[1]);
 224     }
 225     else if (!yaz_matchstr(argv[0], "simplechain"))
 226     {
 227         zm->use_chain = 1;
 228 #if YAZ_HAVE_ICU
 229         zm->icu_chain = 0;
 230 #endif
 231     }
 232     else if (!yaz_matchstr(argv[0], "icuchain"))
 233     {
 234 #if YAZ_HAVE_XML2
 235         if (!zm->locale)
 236         {
 237             yaz_log(YLOG_WARN, "%s:%d: locale required before icuchain",
 238                     fname, lineno);
 239             return -1;
 240         }
 241         zm->doc = xmlParseFile(argv[1]);
 242         if (!zm->doc)
 243         {
 244             yaz_log(YLOG_WARN, "%s:%d: Could not load icuchain config '%s'",
 245                     fname, lineno, argv[1]);
 246             return -1;
 247         }
 248         else
 249         {
 250 #if YAZ_HAVE_ICU
 251             UErrorCode status;
 252             xmlNode *xml_node = xmlDocGetRootElement(zm->doc);
 253             zm->icu_chain =
 254                 icu_chain_xml_config(xml_node, zm->locale,
 255 /* not sure about sort for this function yet.. */
 256 #if 1
 257                                      1,
 258 #else
 259                                      zm->type == ZEBRA_MAP_TYPE_SORT,
 260 #endif
 261                                      &status);
 262             if (!zm->icu_chain)
 263             {
 264                 yaz_log(YLOG_WARN, "%s:%d: Failed to load ICU chain %s",
 265                         fname, lineno, argv[1]);
 266             }
 267             zm->use_chain = 1;
 268 #else
 269             yaz_log(YLOG_WARN, "%s:%d: ICU support unavailable",
 270                     fname, lineno);
 271             return -1;
 272 #endif
 273         }
 274 #else
 275         yaz_log(YLOG_WARN, "%s:%d: XML support unavailable",
 276                 fname, lineno);
 277         return -1;
 278 #endif
 279     }
 280     else
 281     {
 282         yaz_log(YLOG_WARN, "%s:%d: Unrecognized directive '%s'",
 283                 fname, lineno, argv[0]);
 284         return -1;
 285     }
 286     return 0;
 287 }
 288
 289 ZEBRA_RES zebra_maps_read_file(zebra_maps_t zms, const char *fname)
 290 {
 291     FILE *f;
 292     char line[512];
 293     char *argv[10];
 294     int argc;
 295     int lineno = 0;
 296     int failures = 0;
 297
 298     if (!(f = yaz_fopen(zms->tabpath, fname, "r", zms->tabroot)))
 299     {
 300         yaz_log(YLOG_ERRNO|YLOG_FATAL, "%s", fname);
 301         return ZEBRA_FAIL;
 302     }
 303     while ((argc = readconf_line(f, &lineno, line, 512, argv, 10)))
 304     {
 305         int r = parse_command(zms, argc, argv, fname, lineno);
 306         if (r)
 307             failures++;
 308     }
 309     yaz_fclose(f);
 310
 311     if (failures)
 312         return ZEBRA_FAIL;
 313
 314     (zms->no_files_read)++;
 315     return ZEBRA_OK;
 316 }
 317
 318 zebra_maps_t zebra_maps_open(Res res, const char *base_path,
 319                              const char *profile_path)
 320 {
 321     zebra_maps_t zms = (zebra_maps_t) xmalloc(sizeof(*zms));
 322
 323     zms->nmem = nmem_create();
 324     zms->tabpath = profile_path ? nmem_strdup(zms->nmem, profile_path) : 0;
 325     zms->tabroot = 0;
 326     if (base_path)
 327         zms->tabroot = nmem_strdup(zms->nmem, base_path);
 328     zms->map_list = 0;
 329     zms->last_map = 0;
 330
 331     zms->temp_map_str[0] = '\0';
 332     zms->temp_map_str[1] = '\0';
 333
 334     zms->temp_map_ptr[0] = zms->temp_map_str;
 335     zms->temp_map_ptr[1] = NULL;
 336
 337     zms->wrbuf_1 = wrbuf_alloc();
 338
 339     zms->no_files_read = 0;
 340     return zms;
 341 }
 342
 343 zebra_map_t zebra_map_get(zebra_maps_t zms, const char *id)
 344 {
 345     zebra_map_t zm;
 346     for (zm = zms->map_list; zm; zm = zm->next)
 347         if (!strcmp(zm->id, id))
 348             break;
 349     return zm;
 350 }
 351
 352 zebra_map_t zebra_map_get_or_add(zebra_maps_t zms, const char *id)
 353 {
 354     struct zebra_map *zm = zebra_map_get(zms, id);
 355     if (!zm)
 356     {
 357         zm = zebra_add_map(zms, id, ZEBRA_MAP_TYPE_INDEX);
 358
 359         /* no reason to warn if no maps are read from file */
 360         if (zms->no_files_read)
 361             yaz_log(YLOG_WARN, "Unknown register type: %s", id);
 362
 363         zm->maptab_name = nmem_strdup(zms->nmem, "@");
 364         zm->completeness = 0;
 365         zm->positioned = 1;
 366     }
 367     return zm;
 368 }
 369
 370 chrmaptab zebra_charmap_get(zebra_map_t zm)
 371 {
 372     if (!zm->maptab)
 373     {
 374         if (!zm->maptab_name || !yaz_matchstr(zm->maptab_name, "@"))
 375             return NULL;
 376         if (!(zm->maptab = chrmaptab_create(zm->zebra_maps->tabpath,
 377                                             zm->maptab_name,
 378                                             zm->zebra_maps->tabroot)))
 379             yaz_log(YLOG_WARN, "Failed to read character table %s",
 380                     zm->maptab_name);
 381         else
 382             yaz_log(YLOG_DEBUG, "Read character table %s", zm->maptab_name);
 383     }
 384     return zm->maptab;
 385 }
 386
 387 const char **zebra_maps_input(zebra_map_t zm,
 388                               const char **from, int len, int first)
 389 {
 390     chrmaptab maptab = zebra_charmap_get(zm);
 391     if (maptab)
 392         return chr_map_input(maptab, from, len, first);
 393
 394     zm->zebra_maps->temp_map_str[0] = **from;
 395
 396     (*from)++;
 397     return zm->zebra_maps->temp_map_ptr;
 398 }
 399
 400 const char **zebra_maps_search(zebra_map_t zm,
 401                                const char **from, int len,  int *q_map_match)
 402 {
 403     chrmaptab maptab;
 404
 405     *q_map_match = 0;
 406     maptab = zebra_charmap_get(zm);
 407     if (maptab)
 408     {
 409         const char **map;
 410         map = chr_map_q_input(maptab, from, len, 0);
 411         if (map && map[0])
 412         {
 413             *q_map_match = 1;
 414             return map;
 415         }
 416         map = chr_map_input(maptab, from, len, 0);
 417         if (map)
 418             return map;
 419     }
 420     zm->zebra_maps->temp_map_str[0] = **from;
 421
 422     (*from)++;
 423     return zm->zebra_maps->temp_map_ptr;
 424 }
 425
 426 const char *zebra_maps_output(zebra_map_t zm,
 427                               const char **from)
 428 {
 429     chrmaptab maptab = zebra_charmap_get(zm);
 430     if (!maptab)
 431         return 0;
 432     return chr_map_output(maptab, from, 1);
 433 }
 434
 435
 436 /* ------------------------------------ */
 437
 438 int zebra_maps_is_complete(zebra_map_t zm)
 439 {
 440     if (zm)
 441         return zm->completeness;
 442     return 0;
 443 }
 444
 445 int zebra_maps_is_positioned(zebra_map_t zm)
 446 {
 447     if (zm)
 448         return zm->positioned;
 449     return 0;
 450 }
 451
 452 int zebra_maps_is_index(zebra_map_t zm)
 453 {
 454     if (zm)
 455         return zm->type == ZEBRA_MAP_TYPE_INDEX;
 456     return 0;
 457 }
 458
 459 int zebra_maps_is_staticrank(zebra_map_t zm)
 460 {
 461     if (zm)
 462         return zm->type == ZEBRA_MAP_TYPE_STATICRANK;
 463     return 0;
 464 }
 465
 466 int zebra_maps_is_sort(zebra_map_t zm)
 467 {
 468     if (zm)
 469         return zm->type == ZEBRA_MAP_TYPE_SORT;
 470     return 0;
 471 }
 472
 473 int zebra_maps_is_alwaysmatches(zebra_map_t zm)
 474 {
 475     if (zm)
 476         return zm->alwaysmatches;
 477     return 0;
 478 }
 479
 480 int zebra_maps_is_first_in_field(zebra_map_t zm)
 481 {
 482     if (zm)
 483         return zm->first_in_field;
 484     return 0;
 485 }
 486
 487 int zebra_maps_sort(zebra_maps_t zms, Z_SortAttributes *sortAttributes,
 488                     int *numerical)
 489 {
 490     AttrType use;
 491     AttrType structure;
 492     int structure_value;
 493     attr_init_AttrList(&use, sortAttributes->list, 1);
 494     attr_init_AttrList(&structure, sortAttributes->list, 4);
 495
 496     *numerical = 0;
 497     structure_value = attr_find(&structure, 0);
 498     if (structure_value == 109)
 499         *numerical = 1;
 500     return attr_find(&use, NULL);
 501 }
 502
 503 int zebra_maps_attr(zebra_maps_t zms, Z_AttributesPlusTerm *zapt,
 504                     const char **index_type, char **search_type, char *rank_type,
 505                     int *complete_flag, int *sort_flag)
 506 {
 507     AttrType completeness;
 508     AttrType structure;
 509     AttrType relation;
 510     AttrType sort_relation;
 511     AttrType weight;
 512     AttrType use;
 513     int completeness_value;
 514     int structure_value;
 515     const char *structure_str = 0;
 516     int relation_value;
 517     int sort_relation_value;
 518     int weight_value;
 519     int use_value;
 520
 521     attr_init_APT(&structure, zapt, 4);
 522     attr_init_APT(&completeness, zapt, 6);
 523     attr_init_APT(&relation, zapt, 2);
 524     attr_init_APT(&sort_relation, zapt, 7);
 525     attr_init_APT(&weight, zapt, 9);
 526     attr_init_APT(&use, zapt, 1);
 527
 528     completeness_value = attr_find(&completeness, NULL);
 529     structure_value = attr_find_ex(&structure, NULL, &structure_str);
 530     relation_value = attr_find(&relation, NULL);
 531     sort_relation_value = attr_find(&sort_relation, NULL);
 532     weight_value = attr_find(&weight, NULL);
 533     use_value = attr_find(&use, NULL);
 534
 535     if (completeness_value == 2 || completeness_value == 3)
 536         *complete_flag = 1;
 537     else
 538         *complete_flag = 0;
 539     *index_type = 0;
 540
 541     *sort_flag =(sort_relation_value > 0) ? 1 : 0;
 542     *search_type = "phrase";
 543     strcpy(rank_type, "void");
 544     if (relation_value == 102)
 545     {
 546         if (weight_value == -1)
 547             weight_value = 34;
 548         sprintf(rank_type, "rank,w=%d,u=%d", weight_value, use_value);
 549     }
 550     if (*complete_flag)
 551         *index_type = "p";
 552     else
 553         *index_type = "w";
 554     switch (structure_value)
 555     {
 556     case 6:   /* word list */
 557         *search_type = "and-list";
 558         break;
 559     case 105: /* free-form-text */
 560         *search_type = "or-list";
 561         break;
 562     case 106: /* document-text */
 563         *search_type = "or-list";
 564         break;
 565     case -1:
 566     case 1:   /* phrase */
 567     case 2:   /* word */
 568     case 108: /* string */
 569         *search_type = "phrase";
 570         break;
 571     case 107: /* local-number */
 572         *search_type = "local";
 573         *index_type = 0;
 574         break;
 575     case 109: /* numeric string */
 576         *index_type = "n";
 577         *search_type = "numeric";
 578         break;
 579     case 104: /* urx */
 580         *index_type = "u";
 581         *search_type = "phrase";
 582         break;
 583     case 3:   /* key */
 584         *index_type = "0";
 585         *search_type = "phrase";
 586         break;
 587     case 4:  /* year */
 588         *index_type = "y";
 589         *search_type = "phrase";
 590         break;
 591     case 5:  /* date */
 592         *index_type = "d";
 593         *search_type = "phrase";
 594         break;
 595     case -2:
 596         if (structure_str && *structure_str)
 597             *index_type = structure_str;
 598         else
 599             return -1;
 600         break;
 601     default:
 602         return -1;
 603     }
 604     return 0;
 605 }
 606
 607 WRBUF zebra_replace(zebra_map_t zm, const char *ex_list,
 608                     const char *input_str, int input_len)
 609 {
 610     wrbuf_rewind(zm->zebra_maps->wrbuf_1);
 611     wrbuf_write(zm->zebra_maps->wrbuf_1, input_str, input_len);
 612     return zm->zebra_maps->wrbuf_1;
 613 }
 614
 615 #define SE_CHARS ";,.()-/?<> \r\n\t"
 616
 617 static int tokenize_simple(zebra_map_t zm,
 618                            const char **result_buf, size_t *result_len)
 619 {
 620     char *buf = wrbuf_buf(zm->simple_buf);
 621     size_t len = wrbuf_len(zm->simple_buf);
 622     size_t i = zm->simple_off;
 623     size_t start;
 624
 625     while (i < len && strchr(SE_CHARS, buf[i]))
 626         i++;
 627     start = i;
 628     while (i < len && !strchr(SE_CHARS, buf[i]))
 629     {
 630         if (buf[i] > 32 && buf[i] < 127)
 631             buf[i] = tolower(buf[i]);
 632         i++;
 633     }
 634
 635     zm->simple_off = i;
 636     if (start != i)
 637     {
 638         *result_buf = buf + start;
 639         *result_len = i - start;
 640         return 1;
 641     }
 642     return 0;
 643  }
 644
 645 int zebra_map_tokenize(zebra_map_t zm,
 646                        const char *buf, size_t len,
 647                        const char **result_buf, size_t *result_len)
 648 {
 649     assert(zm->use_chain);
 650
 651     if (buf)
 652     {
 653         wrbuf_rewind(zm->simple_buf);
 654         wrbuf_write(zm->simple_buf, buf, len);
 655         zm->simple_off = 0;
 656     }
 657
 658 #if YAZ_HAVE_ICU
 659     if (!zm->icu_chain)
 660         return tokenize_simple(zm, result_buf, result_len);
 661     else
 662     {
 663         UErrorCode status;
 664         if (buf)
 665         {
 666             yaz_log(YLOG_LOG, "assicn_cstr %s", wrbuf_cstr(zm->simple_buf));
 667             icu_chain_assign_cstr(zm->icu_chain,
 668                                   wrbuf_cstr(zm->simple_buf),
 669                                   &status);
 670             assert(U_SUCCESS(status));
 671         }
 672         while (icu_chain_next_token(zm->icu_chain, &status))
 673         {
 674             assert(U_SUCCESS(status));
 675             *result_buf = icu_chain_token_norm(zm->icu_chain);
 676             assert(*result_buf);
 677             yaz_log(YLOG_LOG, "got result %s", *result_buf);
 678             *result_len = strlen(*result_buf);
 679             if (**result_buf != '\0')
 680                 return 1;
 681         }
 682         assert(U_SUCCESS(status));
 683     }
 684     return 0;
 685 #else
 686     return tokenize_simple(zm, result_buf, result_len);
 687 #endif
 688 }
 689
 690 int zebra_maps_is_icu(zebra_map_t zm)
 691 {
 692 #if YAZ_HAVE_ICU
 693     return zm->use_chain;
 694 #else
 695     return 0;
 696 #endif
 697 }
 698
 699
 700 /*
 701  * Local variables:
 702  * c-basic-offset: 4
 703  * indent-tabs-mode: nil
 704  * End:
 705  * vim: shiftwidth=4 tabstop=8 expandtab
 706  */
 707