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