util/zebramap.c

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