1 /* $Id: zebramap.c,v 1.69 2007-11-08 09:30:05 adam Exp $
2 Copyright (C) 1995-2007
5 This file is part of the Zebra server.
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
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
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
29 #include <yaz/yaz-util.h>
36 #define ZEBRA_MAP_TYPE_SORT 1
37 #define ZEBRA_MAP_TYPE_INDEX 2
38 #define ZEBRA_MAP_TYPE_STATICRANK 3
40 #define ZEBRA_REPLACE_ANY 300
56 const char *maptab_name;
58 zebra_maps_t zebra_maps;
63 struct icu_chain *icu_chain;
67 struct zebra_map *next;
75 const char *temp_map_ptr[2];
82 void zebra_maps_close(zebra_maps_t zms)
84 struct zebra_map *zm = zms->map_list;
88 chrmaptab_destroy(zm->maptab);
91 icu_chain_destroy(zm->icu_chain);
96 wrbuf_destroy(zm->simple_buf);
99 wrbuf_destroy(zms->wrbuf_1);
100 nmem_destroy(zms->nmem);
104 zebra_map_t zebra_add_map(zebra_maps_t zms, const char *index_type,
107 zebra_map_t zm = (zebra_map_t) nmem_malloc(zms->nmem, sizeof(*zm));
109 zm->zebra_maps = zms;
110 zm->id = nmem_strdup(zms->nmem, index_type);
116 zm->completeness = 0;
118 zm->alwaysmatches = 0;
119 zm->first_in_field = 0;
122 zms->last_map->next = zm;
133 zm->simple_buf = wrbuf_alloc();
137 static int parse_command(zebra_maps_t zms, int argc, char **argv,
138 const char *fname, int lineno)
140 zebra_map_t zm = zms->last_map;
143 yaz_log(YLOG_WARN, "%s:%d: Missing arguments for '%s'",
144 fname, lineno, argv[0]);
149 yaz_log(YLOG_WARN, "%s:%d: Too many arguments for '%s'",
150 fname, lineno, argv[0]);
153 if (!yaz_matchstr(argv[0], "index"))
155 zm = zebra_add_map(zms, argv[1], ZEBRA_MAP_TYPE_INDEX);
158 else if (!yaz_matchstr(argv[0], "sort"))
160 zm = zebra_add_map(zms, argv[1], ZEBRA_MAP_TYPE_SORT);
161 zm->u.sort.entry_size = 80;
163 else if (!yaz_matchstr(argv[0], "staticrank"))
165 zm = zebra_add_map(zms, argv[1], ZEBRA_MAP_TYPE_STATICRANK);
166 zm->completeness = 1;
170 yaz_log(YLOG_WARN, "%s:%d: Missing sort/index before '%s'",
171 fname, lineno, argv[0]);
174 else if (!yaz_matchstr(argv[0], "charmap") && argc == 2)
176 if (zm->type != ZEBRA_MAP_TYPE_STATICRANK)
177 zm->maptab_name = nmem_strdup(zms->nmem, argv[1]);
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);
186 else if (!yaz_matchstr(argv[0], "completeness") && argc == 2)
188 zm->completeness = atoi(argv[1]);
190 else if (!yaz_matchstr(argv[0], "position") && argc == 2)
192 zm->positioned = atoi(argv[1]);
194 else if (!yaz_matchstr(argv[0], "alwaysmatches") && argc == 2)
196 if (zm->type != ZEBRA_MAP_TYPE_STATICRANK)
197 zm->alwaysmatches = atoi(argv[1]);
200 yaz_log(YLOG_WARN|YLOG_FATAL, "%s:%d: alwaysmatches for "
201 "staticrank is invalid", fname, lineno);
205 else if (!yaz_matchstr(argv[0], "firstinfield") && argc == 2)
207 zm->first_in_field = atoi(argv[1]);
209 else if (!yaz_matchstr(argv[0], "entrysize") && argc == 2)
211 if (zm->type == ZEBRA_MAP_TYPE_SORT)
212 zm->u.sort.entry_size = atoi(argv[1]);
216 "%s:%d: entrysize only valid in sort section",
221 else if (!yaz_matchstr(argv[0], "locale"))
223 zm->locale = nmem_strdup(zms->nmem, argv[1]);
225 else if (!yaz_matchstr(argv[0], "simplechain"))
232 else if (!yaz_matchstr(argv[0], "icuchain"))
237 yaz_log(YLOG_WARN, "%s:%d: locale required before icuchain",
241 zm->doc = xmlParseFile(argv[1]);
244 yaz_log(YLOG_WARN, "%s:%d: Could not load icuchain config '%s'",
245 fname, lineno, argv[1]);
252 xmlNode *xml_node = xmlDocGetRootElement(zm->doc);
254 icu_chain_xml_config(xml_node, zm->locale,
255 /* not sure about sort for this function yet.. */
259 zm->type == ZEBRA_MAP_TYPE_SORT,
264 yaz_log(YLOG_WARN, "%s:%d: Failed to load ICU chain %s",
265 fname, lineno, argv[1]);
269 yaz_log(YLOG_WARN, "%s:%d: ICU support unavailable",
275 yaz_log(YLOG_WARN, "%s:%d: XML support unavailable",
282 yaz_log(YLOG_WARN, "%s:%d: Unrecognized directive '%s'",
283 fname, lineno, argv[0]);
289 ZEBRA_RES zebra_maps_read_file(zebra_maps_t zms, const char *fname)
298 if (!(f = yaz_fopen(zms->tabpath, fname, "r", zms->tabroot)))
300 yaz_log(YLOG_ERRNO|YLOG_FATAL, "%s", fname);
303 while ((argc = readconf_line(f, &lineno, line, 512, argv, 10)))
305 int r = parse_command(zms, argc, argv, fname, lineno);
314 (zms->no_files_read)++;
318 zebra_maps_t zebra_maps_open(Res res, const char *base_path,
319 const char *profile_path)
321 zebra_maps_t zms = (zebra_maps_t) xmalloc(sizeof(*zms));
323 zms->nmem = nmem_create();
324 zms->tabpath = profile_path ? nmem_strdup(zms->nmem, profile_path) : 0;
327 zms->tabroot = nmem_strdup(zms->nmem, base_path);
331 zms->temp_map_str[0] = '\0';
332 zms->temp_map_str[1] = '\0';
334 zms->temp_map_ptr[0] = zms->temp_map_str;
335 zms->temp_map_ptr[1] = NULL;
337 zms->wrbuf_1 = wrbuf_alloc();
339 zms->no_files_read = 0;
343 zebra_map_t zebra_map_get(zebra_maps_t zms, const char *id)
346 for (zm = zms->map_list; zm; zm = zm->next)
347 if (!strcmp(zm->id, id))
352 zebra_map_t zebra_map_get_or_add(zebra_maps_t zms, const char *id)
354 struct zebra_map *zm = zebra_map_get(zms, id);
357 zm = zebra_add_map(zms, id, ZEBRA_MAP_TYPE_INDEX);
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);
363 zm->maptab_name = nmem_strdup(zms->nmem, "@");
364 zm->completeness = 0;
370 chrmaptab zebra_charmap_get(zebra_map_t zm)
374 if (!zm->maptab_name || !yaz_matchstr(zm->maptab_name, "@"))
376 if (!(zm->maptab = chrmaptab_create(zm->zebra_maps->tabpath,
378 zm->zebra_maps->tabroot)))
379 yaz_log(YLOG_WARN, "Failed to read character table %s",
382 yaz_log(YLOG_DEBUG, "Read character table %s", zm->maptab_name);
387 const char **zebra_maps_input(zebra_map_t zm,
388 const char **from, int len, int first)
390 chrmaptab maptab = zebra_charmap_get(zm);
392 return chr_map_input(maptab, from, len, first);
394 zm->zebra_maps->temp_map_str[0] = **from;
397 return zm->zebra_maps->temp_map_ptr;
400 const char **zebra_maps_search(zebra_map_t zm,
401 const char **from, int len, int *q_map_match)
406 maptab = zebra_charmap_get(zm);
410 map = chr_map_q_input(maptab, from, len, 0);
416 map = chr_map_input(maptab, from, len, 0);
420 zm->zebra_maps->temp_map_str[0] = **from;
423 return zm->zebra_maps->temp_map_ptr;
426 const char *zebra_maps_output(zebra_map_t zm,
429 chrmaptab maptab = zebra_charmap_get(zm);
432 return chr_map_output(maptab, from, 1);
436 /* ------------------------------------ */
438 int zebra_maps_is_complete(zebra_map_t zm)
441 return zm->completeness;
445 int zebra_maps_is_positioned(zebra_map_t zm)
448 return zm->positioned;
452 int zebra_maps_is_index(zebra_map_t zm)
455 return zm->type == ZEBRA_MAP_TYPE_INDEX;
459 int zebra_maps_is_staticrank(zebra_map_t zm)
462 return zm->type == ZEBRA_MAP_TYPE_STATICRANK;
466 int zebra_maps_is_sort(zebra_map_t zm)
469 return zm->type == ZEBRA_MAP_TYPE_SORT;
473 int zebra_maps_is_alwaysmatches(zebra_map_t zm)
476 return zm->alwaysmatches;
480 int zebra_maps_is_first_in_field(zebra_map_t zm)
483 return zm->first_in_field;
487 int zebra_maps_sort(zebra_maps_t zms, Z_SortAttributes *sortAttributes,
493 attr_init_AttrList(&use, sortAttributes->list, 1);
494 attr_init_AttrList(&structure, sortAttributes->list, 4);
497 structure_value = attr_find(&structure, 0);
498 if (structure_value == 109)
500 return attr_find(&use, NULL);
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)
507 AttrType completeness;
510 AttrType sort_relation;
513 int completeness_value;
515 const char *structure_str = 0;
517 int sort_relation_value;
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);
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);
535 if (completeness_value == 2 || completeness_value == 3)
541 *sort_flag =(sort_relation_value > 0) ? 1 : 0;
542 *search_type = "phrase";
543 strcpy(rank_type, "void");
544 if (relation_value == 102)
546 if (weight_value == -1)
548 sprintf(rank_type, "rank,w=%d,u=%d", weight_value, use_value);
554 switch (structure_value)
556 case 6: /* word list */
557 *search_type = "and-list";
559 case 105: /* free-form-text */
560 *search_type = "or-list";
562 case 106: /* document-text */
563 *search_type = "or-list";
568 case 108: /* string */
569 *search_type = "phrase";
571 case 107: /* local-number */
572 *search_type = "local";
575 case 109: /* numeric string */
577 *search_type = "numeric";
581 *search_type = "phrase";
585 *search_type = "phrase";
589 *search_type = "phrase";
593 *search_type = "phrase";
596 if (structure_str && *structure_str)
597 *index_type = structure_str;
607 WRBUF zebra_replace(zebra_map_t zm, const char *ex_list,
608 const char *input_str, int input_len)
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;
615 #define SE_CHARS ";,.()-/?<> \r\n\t"
617 static int tokenize_simple(zebra_map_t zm,
618 const char **result_buf, size_t *result_len)
620 char *buf = wrbuf_buf(zm->simple_buf);
621 size_t len = wrbuf_len(zm->simple_buf);
622 size_t i = zm->simple_off;
625 while (i < len && strchr(SE_CHARS, buf[i]))
628 while (i < len && !strchr(SE_CHARS, buf[i]))
630 if (buf[i] > 32 && buf[i] < 127)
631 buf[i] = tolower(buf[i]);
638 *result_buf = buf + start;
639 *result_len = i - start;
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)
649 assert(zm->use_chain);
653 wrbuf_rewind(zm->simple_buf);
654 wrbuf_write(zm->simple_buf, buf, len);
660 return tokenize_simple(zm, result_buf, result_len);
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),
670 assert(U_SUCCESS(status));
672 while (icu_chain_next_token(zm->icu_chain, &status))
674 assert(U_SUCCESS(status));
675 *result_buf = icu_chain_token_norm(zm->icu_chain);
677 yaz_log(YLOG_LOG, "got result %s", *result_buf);
678 *result_len = strlen(*result_buf);
679 if (**result_buf != '\0')
682 assert(U_SUCCESS(status));
686 return tokenize_simple(zm, result_buf, result_len);
690 int zebra_maps_is_icu(zebra_map_t zm)
693 return zm->use_chain;
703 * indent-tabs-mode: nil
705 * vim: shiftwidth=4 tabstop=8 expandtab