Allow no default.idx at all. Make zebra_maps_read_file public.

diff --git a/include/idzebra/zebramap.h b/include/idzebra/zebramap.h
index 980fc23..0349316 100644 (file)
--- a/include/idzebra/zebramap.h
+++ b/include/idzebra/zebramap.h
@@ -1,4 +1,4 @@
-/* $Id: zebramap.h,v 1.4 2005-03-11 17:56:33 adam Exp $
+/* $Id: zebramap.h,v 1.5 2006-03-28 12:39:07 adam Exp $
    Copyright (C) 1995-2005
    Index Data ApS
 
@@ -31,7 +31,10 @@ YAZ_BEGIN_CDECL
 typedef struct zebra_maps *ZebraMaps;
 
 YAZ_EXPORT
-ZebraMaps zebra_maps_open (Res res, const char *base);
+ZebraMaps zebra_maps_open (Res res, const char *base_path,
+                          const char *profile_path);
+YAZ_EXPORT
+ZEBRA_RES zebra_maps_read_file(ZebraMaps zms, const char *fname);
 
 YAZ_EXPORT
 void zebra_maps_close (ZebraMaps zm);

diff --git a/index/zebraapi.c b/index/zebraapi.c
index 3296732..e32e590 100644 (file)
--- a/index/zebraapi.c
+++ b/index/zebraapi.c
@@ -1,4 +1,4 @@
-/* $Id: zebraapi.c,v 1.206 2006-03-26 14:17:01 adam Exp $
+/* $Id: zebraapi.c,v 1.207 2006-03-28 12:39:07 adam Exp $
    Copyright (C) 1995-2005
    Index Data ApS
 
@@ -332,7 +332,9 @@ struct zebra_register *zebra_register_open(ZebraService zs, const char *name,
     data1_set_tabroot (reg->dh, reg_path);
     reg->recTypes = recTypes_init (zs->record_classes, reg->dh);
 
-    if ((reg->zebra_maps = zebra_maps_open (res, reg_path)) == 0)
+    reg->zebra_maps =
+       zebra_maps_open(res, reg_path, profilePath);
+    if (!reg->zebra_maps)
     {
        recTypes_destroy(reg->recTypes);
        bfs_destroy(reg->bfs);
@@ -341,7 +343,6 @@ struct zebra_register *zebra_register_open(ZebraService zs, const char *name,
        xfree(reg);
        return 0;
     }
-
     reg->rank_classes = NULL;
 
     reg->key_buf = 0;
@@ -376,6 +377,16 @@ struct zebra_register *zebra_register_open(ZebraService zs, const char *name,
     if (!strcmp (recordCompression, "bzip2"))
        record_compression = REC_COMPRESS_BZIP2;
 
+    if (1)
+    {
+       const char *index_fname = res_get_def(res, "index", "default.idx");
+       if (index_fname && *index_fname)
+       {
+           if (zebra_maps_read_file(reg->zebra_maps, index_fname) != ZEBRA_OK)
+               ret = ZEBRA_FAIL;
+       }
+    }
+
     if (!(reg->records = rec_open (reg->bfs, rw, record_compression)))
     {
        yaz_log (YLOG_WARN, "rec_open failed");

diff --git a/util/zebramap.c b/util/zebramap.c
index 5f472b9..67b2b2f 100644 (file)
--- a/util/zebramap.c
+++ b/util/zebramap.c
@@ -1,23 +1,23 @@
-/* $Id: zebramap.c,v 1.45 2006-03-26 14:05:19 adam Exp $
+/* $Id: zebramap.c,v 1.46 2006-03-28 12:39:08 adam Exp $
    Copyright (C) 1995-2005
    Index Data ApS
 
-This file is part of the Zebra server.
+   This file is part of the Zebra server.
 
-Zebra is free software; you can redistribute it and/or modify it under
-the terms of the GNU General Public License as published by the Free
-Software Foundation; either version 2, or (at your option) any later
-version.
+   Zebra is free software; you can redistribute it and/or modify it under
+   the terms of the GNU General Public License as published by the Free
+   Software Foundation; either version 2, or (at your option) any later
+   version.
 
-Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
-WARRANTY; without even the implied warranty of MERCHANTABILITY or
-FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-for more details.
+   Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
+   WARRANTY; without even the implied warranty of MERCHANTABILITY or
+   FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+   for more details.
 
-You should have received a copy of the GNU General Public License
-along with Zebra; see the file LICENSE.zebra.  If not, write to the
-Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
-02111-1307, USA.
+   You should have received a copy of the GNU General Public License
+   along with Zebra; see the file LICENSE.zebra.  If not, write to the
+   Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
+   02111-1307, USA.
 */
 
 #include <assert.h>
@@ -61,24 +61,24 @@ struct zebra_maps {
     const char *temp_map_ptr[2];
     struct zebra_map **lookup_array;
     WRBUF wrbuf_1;
+    int no_maps;
 };
 
-void zebra_maps_close (ZebraMaps zms)
+void zebra_maps_close(ZebraMaps zms)
 {
     struct zebra_map *zm = zms->map_list;
     while (zm)
     {
        if (zm->maptab)
-           chrmaptab_destroy (zm->maptab);
+           chrmaptab_destroy(zm->maptab);
        zm = zm->next;
     }
-    wrbuf_free (zms->wrbuf_1, 1);
-    nmem_destroy (zms->nmem);
-    xfree (zms);
+    wrbuf_free(zms->wrbuf_1, 1);
+    nmem_destroy(zms->nmem);
+    xfree(zms);
 }
 
-/* Returns 0 if all is well, -1 on fatal error */
-static int zebra_map_read (ZebraMaps zms, const char *name, int fail_fatal)
+ZEBRA_RES zebra_maps_read_file(ZebraMaps zms, const char *fname)
 {
     FILE *f;
     char line[512];
@@ -87,35 +87,35 @@ static int zebra_map_read (ZebraMaps zms, const char *name, int fail_fatal)
     int lineno = 0;
     struct zebra_map **zm = 0, *zp;
 
-    if (!(f = yaz_fopen(zms->tabpath, name, "r", zms->tabroot)))
+    if (!(f = yaz_fopen(zms->tabpath, fname, "r", zms->tabroot)))
     {
-       int level = fail_fatal ? YLOG_FATAL : YLOG_WARN;
-       yaz_log(level|YLOG_ERRNO, "%s", name);
-       return -1;
+       yaz_log(YLOG_ERRNO|YLOG_FATAL, "%s", fname);
+       return ZEBRA_FAIL;
     }
     while ((argc = readconf_line(f, &lineno, line, 512, argv, 10)))
     {
-       if (!yaz_matchstr (argv[0], "index") && argc == 2)
+       if (!yaz_matchstr(argv[0], "index") && argc == 2)
        {
            if (!zm)
                zm = &zms->map_list;
            else
                zm = &(*zm)->next;
-           *zm = (struct zebra_map *) nmem_malloc (zms->nmem, sizeof(**zm));
+           *zm = (struct zebra_map *) nmem_malloc(zms->nmem, sizeof(**zm));
            (*zm)->reg_id = argv[1][0];
            (*zm)->maptab_name = NULL;
            (*zm)->maptab = NULL;
            (*zm)->type = ZEBRA_MAP_TYPE_INDEX;
            (*zm)->completeness = 0;
            (*zm)->positioned = 1;
+           zms->no_maps++;
        }
-       else if (!yaz_matchstr (argv[0], "sort") && argc == 2)
+       else if (!yaz_matchstr(argv[0], "sort") && argc == 2)
        {
            if (!zm)
                zm = &zms->map_list;
            else
                zm = &(*zm)->next;
-           *zm = (struct zebra_map *) nmem_malloc (zms->nmem, sizeof(**zm));
+           *zm = (struct zebra_map *) nmem_malloc(zms->nmem, sizeof(**zm));
            (*zm)->reg_id = argv[1][0];
            (*zm)->maptab_name = NULL;
            (*zm)->type = ZEBRA_MAP_TYPE_SORT;
@@ -123,54 +123,48 @@ static int zebra_map_read (ZebraMaps zms, const char *name, int fail_fatal)
            (*zm)->maptab = NULL;
            (*zm)->completeness = 0;
            (*zm)->positioned = 0;
+           zms->no_maps++;
        }
-       else if (zm && !yaz_matchstr (argv[0], "charmap") && argc == 2)
+       else if (zm && !yaz_matchstr(argv[0], "charmap") && argc == 2)
        {
-           (*zm)->maptab_name = nmem_strdup (zms->nmem, argv[1]);
+           (*zm)->maptab_name = nmem_strdup(zms->nmem, argv[1]);
        }
-       else if (zm && !yaz_matchstr (argv[0], "completeness") && argc == 2)
+       else if (zm && !yaz_matchstr(argv[0], "completeness") && argc == 2)
        {
-           (*zm)->completeness = atoi (argv[1]);
+           (*zm)->completeness = atoi(argv[1]);
        }
-       else if (zm && !yaz_matchstr (argv[0], "position") && argc == 2)
+       else if (zm && !yaz_matchstr(argv[0], "position") && argc == 2)
        {
-           (*zm)->positioned = atoi (argv[1]);
+           (*zm)->positioned = atoi(argv[1]);
        }
-        else if (zm && !yaz_matchstr (argv[0], "entrysize") && argc == 2)
+        else if (zm && !yaz_matchstr(argv[0], "entrysize") && argc == 2)
         {
             if ((*zm)->type == ZEBRA_MAP_TYPE_SORT)
-               (*zm)->u.sort.entry_size = atoi (argv[1]);
+               (*zm)->u.sort.entry_size = atoi(argv[1]);
         }
     }
     if (zm)
        (*zm)->next = NULL;
-    yaz_fclose (f);
+    yaz_fclose(f);
 
     for (zp = zms->map_list; zp; zp = zp->next)
        zms->lookup_array[zp->reg_id] = zp;
 
-    return 0;
-}
-
-static void zms_map_handle (void *p, const char *name, const char *value)
-{
-    ZebraMaps zms = (ZebraMaps) p;
-    
-    (void) zebra_map_read (zms, value, 0);
+    return ZEBRA_OK;
 }
 
-ZebraMaps zebra_maps_open (Res res, const char *base)
+ZebraMaps zebra_maps_open(Res res, const char *base_path,
+                         const char *profile_path)
 {
-    ZebraMaps zms = (ZebraMaps) xmalloc (sizeof(*zms));
+    ZebraMaps zms = (ZebraMaps) xmalloc(sizeof(*zms));
     int i;
 
-    zms->nmem = nmem_create ();
-    zms->tabpath = nmem_strdup (zms->nmem,
-                               res_get_def (res, "profilePath",
-                                             DEFAULT_PROFILE_PATH));
+    zms->nmem = nmem_create();
+    zms->no_maps = 0;
+    zms->tabpath = nmem_strdup(zms->nmem, profile_path);
     zms->tabroot = 0;
-    if (base)
-        zms->tabroot = nmem_strdup (zms->nmem, base);
+    if (base_path)
+        zms->tabroot = nmem_strdup(zms->nmem, base_path);
     zms->map_list = NULL;
 
     zms->temp_map_str[0] = '\0';
@@ -180,36 +174,33 @@ ZebraMaps zebra_maps_open (Res res, const char *base)
     zms->temp_map_ptr[1] = NULL;
 
     zms->lookup_array = (struct zebra_map**)
-       nmem_malloc (zms->nmem, sizeof(*zms->lookup_array)*256);
+       nmem_malloc(zms->nmem, sizeof(*zms->lookup_array)*256);
     zms->wrbuf_1 = wrbuf_alloc();
 
     for (i = 0; i<256; i++)
        zms->lookup_array[i] = 0;
-    if (!res || !res_trav (res, "index", zms, zms_map_handle))
-       if (zebra_map_read (zms, "default.idx", 1) < 0)
-       {
-           zebra_maps_close(zms);
-           return 0;
-       }
     return zms;
 }
 
-struct zebra_map *zebra_map_get (ZebraMaps zms, unsigned reg_id)
+struct zebra_map *zebra_map_get(ZebraMaps zms, unsigned reg_id)
 {
     assert(reg_id >= 0 && reg_id <= 255);
     return zms->lookup_array[reg_id];
 }
 
-chrmaptab zebra_charmap_get (ZebraMaps zms, unsigned reg_id)
+chrmaptab zebra_charmap_get(ZebraMaps zms, unsigned reg_id)
 {
-    struct zebra_map *zm = zebra_map_get (zms, reg_id);
+    struct zebra_map *zm = zebra_map_get(zms, reg_id);
     if (!zm)
     {
-       zm = (struct zebra_map *) nmem_malloc (zms->nmem, sizeof(*zm));
-       yaz_log (YLOG_WARN, "Unknown register type: %c", reg_id);
+       zm = (struct zebra_map *) nmem_malloc(zms->nmem, sizeof(*zm));
+       
+       /* no reason to warn if no maps are installed at ALL */
+       if (zms->no_maps)
+           yaz_log(YLOG_WARN, "Unknown register type: %c", reg_id);
 
        zm->reg_id = reg_id;
-       zm->maptab_name = nmem_strdup (zms->nmem, "@");
+       zm->maptab_name = nmem_strdup(zms->nmem, "@");
        zm->maptab = NULL;
        zm->type = ZEBRA_MAP_TYPE_INDEX;
        zm->completeness = 0;
@@ -220,25 +211,25 @@ chrmaptab zebra_charmap_get (ZebraMaps zms, unsigned reg_id)
     }
     if (!zm->maptab)
     {
-       if (!zm->maptab_name || !yaz_matchstr (zm->maptab_name, "@"))
+       if (!zm->maptab_name || !yaz_matchstr(zm->maptab_name, "@"))
            return NULL;
-       if (!(zm->maptab = chrmaptab_create (zms->tabpath,
-                                            zm->maptab_name,
-                                             zms->tabroot)))
+       if (!(zm->maptab = chrmaptab_create(zms->tabpath,
+                                           zm->maptab_name,
+                                           zms->tabroot)))
            yaz_log(YLOG_WARN, "Failed to read character table %s",
-                zm->maptab_name);
+                   zm->maptab_name);
        else
            yaz_log(YLOG_DEBUG, "Read character table %s", zm->maptab_name);
     }
     return zm->maptab;
 }
 
-const char **zebra_maps_input (ZebraMaps zms, unsigned reg_id,
-                              const char **from, int len, int first)
+const char **zebra_maps_input(ZebraMaps zms, unsigned reg_id,
+                             const char **from, int len, int first)
 {
     chrmaptab maptab;
 
-    maptab = zebra_charmap_get (zms, reg_id);
+    maptab = zebra_charmap_get(zms, reg_id);
     if (maptab)
        return chr_map_input(maptab, from, len, first);
     
@@ -254,7 +245,7 @@ const char **zebra_maps_search(ZebraMaps zms, unsigned reg_id,
     chrmaptab maptab;
     
     *q_map_match = 0;
-    maptab = zebra_charmap_get (zms, reg_id);
+    maptab = zebra_charmap_get(zms, reg_id);
     if (maptab)
     {
        const char **map;
@@ -277,10 +268,10 @@ const char **zebra_maps_search(ZebraMaps zms, unsigned reg_id,
 const char *zebra_maps_output(ZebraMaps zms, unsigned reg_id,
                              const char **from)
 {
-    chrmaptab maptab = zebra_charmap_get (zms, reg_id);
+    chrmaptab maptab = zebra_charmap_get(zms, reg_id);
     if (!maptab)
        return 0;
-    return chr_map_output (maptab, from, 1);
+    return chr_map_output(maptab, from, 1);
 }
 
 
@@ -294,7 +285,7 @@ typedef struct {
     int num_attributes;
 } AttrType;
 
-static int attr_find (AttrType *src, oid_value *attributeSetP)
+static int attr_find(AttrType *src, oid_value *attributeSetP)
 {
     while (src->major < src->num_attributes)
     {
@@ -311,7 +302,7 @@ static int attr_find (AttrType *src, oid_value *attributeSetP)
                 {
                     oident *attrset;
 
-                    attrset = oid_getentbyoid (element->attributeSet);
+                    attrset = oid_getentbyoid(element->attributeSet);
                     *attributeSetP = attrset->value;
                 }
                 return *element->value.numeric;
@@ -326,12 +317,12 @@ static int attr_find (AttrType *src, oid_value *attributeSetP)
                 {
                     oident *attrset;
 
-                    attrset = oid_getentbyoid (element->attributeSet);
+                    attrset = oid_getentbyoid(element->attributeSet);
                     *attributeSetP = attrset->value;
                 }
                 return *element->value.complex->list[src->minor-1]->u.numeric;
             default:
-                assert (0);
+                assert(0);
             }
         }
         ++(src->major);
@@ -339,7 +330,7 @@ static int attr_find (AttrType *src, oid_value *attributeSetP)
     return -1;
 }
 
-static void attr_init_APT (AttrType *src, Z_AttributesPlusTerm *zapt, int type)
+static void attr_init_APT(AttrType *src, Z_AttributesPlusTerm *zapt, int type)
 {
     src->attributeList = zapt->attributes->attributes;
     src->num_attributes = zapt->attributes->num_attributes;
@@ -348,7 +339,7 @@ static void attr_init_APT (AttrType *src, Z_AttributesPlusTerm *zapt, int type)
     src->minor = 0;
 }
 
-static void attr_init_AttrList (AttrType *src, Z_AttributeList *list, int type)
+static void attr_init_AttrList(AttrType *src, Z_AttributeList *list, int type)
 {
     src->attributeList = list->attributes;
     src->num_attributes = list->num_attributes;
@@ -359,49 +350,49 @@ static void attr_init_AttrList (AttrType *src, Z_AttributeList *list, int type)
 
 /* ------------------------------------ */
 
-int zebra_maps_is_complete (ZebraMaps zms, unsigned reg_id)
+int zebra_maps_is_complete(ZebraMaps zms, unsigned reg_id)
 { 
-    struct zebra_map *zm = zebra_map_get (zms, reg_id);
+    struct zebra_map *zm = zebra_map_get(zms, reg_id);
     if (zm)
        return zm->completeness;
     return 0;
 }
 
-int zebra_maps_is_positioned (ZebraMaps zms, unsigned reg_id)
+int zebra_maps_is_positioned(ZebraMaps zms, unsigned reg_id)
 {
-    struct zebra_map *zm = zebra_map_get (zms, reg_id);
+    struct zebra_map *zm = zebra_map_get(zms, reg_id);
     if (zm)
        return zm->positioned;
     return 0;
 }
     
-int zebra_maps_is_sort (ZebraMaps zms, unsigned reg_id)
+int zebra_maps_is_sort(ZebraMaps zms, unsigned reg_id)
 {
-    struct zebra_map *zm = zebra_map_get (zms, reg_id);
+    struct zebra_map *zm = zebra_map_get(zms, reg_id);
     if (zm)
        return zm->type == ZEBRA_MAP_TYPE_SORT;
     return 0;
 }
 
-int zebra_maps_sort (ZebraMaps zms, Z_SortAttributes *sortAttributes,
-                     int *numerical)
+int zebra_maps_sort(ZebraMaps zms, Z_SortAttributes *sortAttributes,
+                   int *numerical)
 {
     AttrType use;
     AttrType structure;
     int structure_value;
-    attr_init_AttrList (&use, sortAttributes->list, 1);
-    attr_init_AttrList (&structure, sortAttributes->list, 4);
+    attr_init_AttrList(&use, sortAttributes->list, 1);
+    attr_init_AttrList(&structure, sortAttributes->list, 4);
 
     *numerical = 0;
-    structure_value = attr_find (&structure, 0);
+    structure_value = attr_find(&structure, 0);
     if (structure_value == 109)
         *numerical = 1;
-    return attr_find (&use, NULL);
+    return attr_find(&use, NULL);
 }
 
-int zebra_maps_attr (ZebraMaps zms, Z_AttributesPlusTerm *zapt,
-                    unsigned *reg_id, char **search_type, char *rank_type,
-                    int *complete_flag, int *sort_flag)
+int zebra_maps_attr(ZebraMaps zms, Z_AttributesPlusTerm *zapt,
+                   unsigned *reg_id, char **search_type, char *rank_type,
+                   int *complete_flag, int *sort_flag)
 {
     AttrType completeness;
     AttrType structure;
@@ -416,18 +407,18 @@ int zebra_maps_attr (ZebraMaps zms, Z_AttributesPlusTerm *zapt,
     int weight_value;
     int use_value;
 
-    attr_init_APT (&structure, zapt, 4);
-    attr_init_APT (&completeness, zapt, 6);
-    attr_init_APT (&relation, zapt, 2);
-    attr_init_APT (&sort_relation, zapt, 7);
-    attr_init_APT (&weight, zapt, 9);
-    attr_init_APT (&use, zapt, 1);
-
-    completeness_value = attr_find (&completeness, NULL);
-    structure_value = attr_find (&structure, NULL);
-    relation_value = attr_find (&relation, NULL);
-    sort_relation_value = attr_find (&sort_relation, NULL);
-    weight_value = attr_find (&weight, NULL);
+    attr_init_APT(&structure, zapt, 4);
+    attr_init_APT(&completeness, zapt, 6);
+    attr_init_APT(&relation, zapt, 2);
+    attr_init_APT(&sort_relation, zapt, 7);
+    attr_init_APT(&weight, zapt, 9);
+    attr_init_APT(&use, zapt, 1);
+
+    completeness_value = attr_find(&completeness, NULL);
+    structure_value = attr_find(&structure, NULL);
+    relation_value = attr_find(&relation, NULL);
+    sort_relation_value = attr_find(&sort_relation, NULL);
+    weight_value = attr_find(&weight, NULL);
     use_value = attr_find(&use, NULL);
 
     if (completeness_value == 2 || completeness_value == 3)
@@ -436,14 +427,14 @@ int zebra_maps_attr (ZebraMaps zms, Z_AttributesPlusTerm *zapt,
        *complete_flag = 0;
     *reg_id = 0;
 
-    *sort_flag = (sort_relation_value > 0) ? 1 : 0;
+    *sort_flag =(sort_relation_value > 0) ? 1 : 0;
     *search_type = "phrase";
-    strcpy (rank_type, "void");
+    strcpy(rank_type, "void");
     if (relation_value == 102)
     {
         if (weight_value == -1)
             weight_value = 34;
-        sprintf (rank_type, "rank,w=%d,u=%d", weight_value, use_value);
+        sprintf(rank_type, "rank,w=%d,u=%d", weight_value, use_value);
     }
     if (relation_value == 103)
     {