projects / idzebra-moved-to-github.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
nmake: align with pazpar2 WRT icu/libxslt
[idzebra-moved-to-github.git] / index / recgrs.c
diff --git a/index/recgrs.c b/index/recgrs.c
index 46805ab..386e541 100644 (file)
--- a/index/recgrs.c
+++ b/index/recgrs.c
@@ -1,8 +1,5 @@
-/* $Id: recgrs.c,v 1.12 2006-12-22 13:57:27 adam Exp $
-   Copyright (C) 1995-2006
-   Index Data ApS
-
-This file is part of the Zebra server.
+/* This file is part of the Zebra server.
+   Copyright (C) Index Data
 
 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
 
 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
@@ -20,13 +17,17 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
 */
 
 
 */
 
+#if HAVE_CONFIG_H
+#include <config.h>
+#endif
 #include <stdio.h>
 #include <assert.h>
 #include <sys/types.h>
 #include <ctype.h>
 
 #include <yaz/log.h>
 #include <stdio.h>
 #include <assert.h>
 #include <sys/types.h>
 #include <ctype.h>
 
 #include <yaz/log.h>
-#include <yaz/oid.h>
+#include <yaz/oid_db.h>
+#include <yaz/diagbib1.h>
 
 #include <d1_absyn.h>
 #include <idzebra/recgrs.h>
 
 #include <d1_absyn.h>
 #include <idzebra/recgrs.h>
@@ -69,30 +70,30 @@ static int sp_range(struct source_parser *sp, data1_node *n, RecWord *wrd)
 {
     int start, len;
     RecWord tmp_w;
 {
     int start, len;
     RecWord tmp_w;
-    
+
     /* ( */
     sp_lex(sp);
     if (sp->lookahead != '(')
        return 0;
     sp_lex(sp); /* skip ( */
     /* ( */
     sp_lex(sp);
     if (sp->lookahead != '(')
        return 0;
     sp_lex(sp); /* skip ( */
-    
+
     /* 1st arg: string */
     if (!sp_expr(sp, n, wrd))
        return 0;
     /* 1st arg: string */
     if (!sp_expr(sp, n, wrd))
        return 0;
-    
+
     if (sp->lookahead != ',')
     if (sp->lookahead != ',')
-       return 0;       
+       return 0;
     sp_lex(sp); /* skip , */
     sp_lex(sp); /* skip , */
-    
+
     /* 2nd arg: start */
     if (!sp_expr(sp, n, &tmp_w))
        return 0;
     start = atoi_n(tmp_w.term_buf, tmp_w.term_len);
     /* 2nd arg: start */
     if (!sp_expr(sp, n, &tmp_w))
        return 0;
     start = atoi_n(tmp_w.term_buf, tmp_w.term_len);
-    
+
     if (sp->lookahead == ',')
     {
        sp_lex(sp); /* skip , */
     if (sp->lookahead == ',')
     {
        sp_lex(sp); /* skip , */
-       
+
        /* 3rd arg: length */
        if (!sp_expr(sp, n, &tmp_w))
            return 0;
        /* 3rd arg: length */
        if (!sp_expr(sp, n, &tmp_w))
            return 0;
@@ -100,18 +101,24 @@ static int sp_range(struct source_parser *sp, data1_node *n, RecWord *wrd)
     }
     else
        len = wrd->term_len;
     }
     else
        len = wrd->term_len;
-    
+
     /* ) */
     if (sp->lookahead != ')')
     /* ) */
     if (sp->lookahead != ')')
-       return 0;       
+       return 0;
     sp_lex(sp);
     sp_lex(sp);
-    
-    if (wrd->term_buf && wrd->term_len)
+
+    if (wrd->term_buf)
     {
     {
-       wrd->term_buf += start;
-       wrd->term_len -= start;
-       if (wrd->term_len > len)
-           wrd->term_len = len;
+        if (start >= wrd->term_len)
+            wrd->term_len = 0;
+        else
+        {
+            wrd->term_len -= start;
+            wrd->term_buf += start;
+
+            if (wrd->term_len > len)
+                wrd->term_len = len;
+        }
     }
     return 1;
 }
     }
     return 1;
 }
@@ -131,7 +138,7 @@ static int sp_first(struct source_parser *sp, data1_node *n, RecWord *wrd)
        RecWord search_w;
        int i;
        sp_lex(sp); /* skip , */
        RecWord search_w;
        int i;
        sp_lex(sp); /* skip , */
-       
+
        if (!sp_expr(sp, n, &search_w))
            return 0;
        for (i = 0; i<wrd->term_len; i++)
        if (!sp_expr(sp, n, &search_w))
            return 0;
        for (i = 0; i<wrd->term_len; i++)
@@ -175,7 +182,7 @@ static int sp_expr(struct source_parser *sp, data1_node *n, RecWord *wrd)
     else if (sp->len == 3 && !memcmp(sp->tok, "tag", sp->len))
     {
        if (n->which == DATA1N_tag)
     else if (sp->len == 3 && !memcmp(sp->tok, "tag", sp->len))
     {
        if (n->which == DATA1N_tag)
-       {               
+       {
            wrd->term_buf = n->u.tag.tag;
            wrd->term_len = strlen(n->u.tag.tag);
        }
            wrd->term_buf = n->u.tag.tag;
            wrd->term_len = strlen(n->u.tag.tag);
        }
@@ -191,13 +198,13 @@ static int sp_expr(struct source_parser *sp, data1_node *n, RecWord *wrd)
 
        if (!sp_expr(sp, n, &tmp_w))
            return 0;
 
        if (!sp_expr(sp, n, &tmp_w))
            return 0;
-       
+
        wrd->term_buf = "";
        wrd->term_len = 0;
        if (n->which == DATA1N_tag)
        {
            data1_xattr *p = n->u.tag.attributes;
        wrd->term_buf = "";
        wrd->term_len = 0;
        if (n->which == DATA1N_tag)
        {
            data1_xattr *p = n->u.tag.attributes;
-           while (p && strlen(p->name) != tmp_w.term_len && 
+           while (p && strlen(p->name) != tmp_w.term_len &&
                   memcmp (p->name, tmp_w.term_buf, tmp_w.term_len))
                p = p->next;
            if (p)
                   memcmp (p->name, tmp_w.term_buf, tmp_w.term_len))
                p = p->next;
            if (p)
@@ -236,7 +243,7 @@ static int sp_expr(struct source_parser *sp, data1_node *n, RecWord *wrd)
        wrd->term_buf = b;
        sp_lex(sp);
     }
        wrd->term_buf = b;
        sp_lex(sp);
     }
-    else 
+    else
     {
        wrd->term_buf = "";
        wrd->term_len = 0;
     {
        wrd->term_buf = "";
        wrd->term_len = 0;
@@ -260,8 +267,8 @@ static void source_parser_destroy(struct source_parser *sp)
     nmem_destroy(sp->nmem);
     xfree(sp);
 }
     nmem_destroy(sp->nmem);
     xfree(sp);
 }
-    
-static int sp_parse(struct source_parser *sp, 
+
+static int sp_parse(struct source_parser *sp,
                    data1_node *n, RecWord *wrd, const char *src)
 {
     sp->len = 0;
                    data1_node *n, RecWord *wrd, const char *src)
 {
     sp->len = 0;
@@ -279,14 +286,14 @@ int d1_check_xpath_predicate(data1_node *n, struct xpath_predicate *p)
     int res = 1;
     char *attname;
     data1_xattr *attr;
     int res = 1;
     char *attname;
     data1_xattr *attr;
-    
+
     if (!p) {
         return 1;
     } else {
         if (p->which == XPATH_PREDICATE_RELATION) {
             if (p->u.relation.name[0]) {
                 if (*p->u.relation.name != '@') {
     if (!p) {
         return 1;
     } else {
         if (p->which == XPATH_PREDICATE_RELATION) {
             if (p->u.relation.name[0]) {
                 if (*p->u.relation.name != '@') {
-                    yaz_log(YLOG_WARN, 
+                    yaz_log(YLOG_WARN,
                          "  Only attributes (@) are supported in xelm xpath predicates");
                     yaz_log(YLOG_WARN, "predicate %s ignored", p->u.relation.name);
                     return 1;
                          "  Only attributes (@) are supported in xelm xpath predicates");
                     yaz_log(YLOG_WARN, "predicate %s ignored", p->u.relation.name);
                     return 1;
@@ -298,14 +305,14 @@ int d1_check_xpath_predicate(data1_node *n, struct xpath_predicate *p)
                     if (!strcmp(attr->name, attname)) {
                         if (p->u.relation.op[0]) {
                             if (*p->u.relation.op != '=') {
                     if (!strcmp(attr->name, attname)) {
                         if (p->u.relation.op[0]) {
                             if (*p->u.relation.op != '=') {
-                                yaz_log(YLOG_WARN, 
+                                yaz_log(YLOG_WARN,
                                      "Only '=' relation is supported (%s)",p->u.relation.op);
                                 yaz_log(YLOG_WARN, "predicate %s ignored", p->u.relation.name);
                                 res = 1; break;
                             } else {
                                 if (!strcmp(attr->value, p->u.relation.value)) {
                                     res = 1; break;
                                      "Only '=' relation is supported (%s)",p->u.relation.op);
                                 yaz_log(YLOG_WARN, "predicate %s ignored", p->u.relation.name);
                                 res = 1; break;
                             } else {
                                 if (!strcmp(attr->value, p->u.relation.value)) {
                                     res = 1; break;
-                                } 
+                                }
                             }
                         } else {
                             /* attribute exists, no value specified */
                             }
                         } else {
                             /* attribute exists, no value specified */
@@ -317,15 +324,15 @@ int d1_check_xpath_predicate(data1_node *n, struct xpath_predicate *p)
             } else {
                 return 1;
             }
             } else {
                 return 1;
             }
-        } 
+        }
         else if (p->which == XPATH_PREDICATE_BOOLEAN) {
             if (!strcmp(p->u.boolean.op,"and")) {
         else if (p->which == XPATH_PREDICATE_BOOLEAN) {
             if (!strcmp(p->u.boolean.op,"and")) {
-                return d1_check_xpath_predicate(n, p->u.boolean.left) 
-                    && d1_check_xpath_predicate(n, p->u.boolean.right); 
+                return d1_check_xpath_predicate(n, p->u.boolean.left)
+                    && d1_check_xpath_predicate(n, p->u.boolean.right);
             }
             else if (!strcmp(p->u.boolean.op,"or")) {
             }
             else if (!strcmp(p->u.boolean.op,"or")) {
-                return (d1_check_xpath_predicate(n, p->u.boolean.left) 
-                        || d1_check_xpath_predicate(n, p->u.boolean.right)); 
+                return (d1_check_xpath_predicate(n, p->u.boolean.left)
+                        || d1_check_xpath_predicate(n, p->u.boolean.right));
             } else {
                 yaz_log(YLOG_WARN, "Unknown boolean relation %s, ignored",p->u.boolean.op);
                 return 1;
             } else {
                 yaz_log(YLOG_WARN, "Unknown boolean relation %s, ignored",p->u.boolean.op);
                 return 1;
@@ -343,7 +350,7 @@ static int dfa_match_first(struct DFA_state **dfaar, const char *text)
     int i;
     const char *p = text;
     unsigned char c;
     int i;
     const char *p = text;
     unsigned char c;
-    
+
     for (c = *p++, t = s->trans, i = s->tran_no; --i >= 0; t++)
     {
        if (c >= t->ch[0] && c <= t->ch[1])
     for (c = *p++, t = s->trans, i = s->tran_no; --i >= 0; t++)
     {
        if (c >= t->ch[0] && c <= t->ch[1])
@@ -368,7 +375,7 @@ static int dfa_match_first(struct DFA_state **dfaar, const char *text)
 }
 
 /* *ostrich*
 }
 
 /* *ostrich*
-   
+
 New function, looking for xpath "element" definitions in abs, by
 tagpath, using a kind of ugly regxp search.The DFA was built while
 parsing abs, so here we just go trough them and try to match
 New function, looking for xpath "element" definitions in abs, by
 tagpath, using a kind of ugly regxp search.The DFA was built while
 parsing abs, so here we just go trough them and try to match
@@ -390,12 +397,12 @@ data1_termlist *xpath_termlist_by_tagpath(char *tagpath, data1_node *n)
 
     data1_xpelement *xpe = 0;
     data1_node *nn;
 
     data1_xpelement *xpe = 0;
     data1_node *nn;
-#ifdef ENHANCED_XELM 
+#ifdef ENHANCED_XELM
     struct xpath_location_step *xp;
 #endif
     char *pexpr = xmalloc(strlen(tagpath)+5);
     struct xpath_location_step *xp;
 #endif
     char *pexpr = xmalloc(strlen(tagpath)+5);
-    
-    sprintf (pexpr, "/%s\n", tagpath);
+
+    sprintf(pexpr, "/%s\n", tagpath);
 
     for (xpe = abs->xp_elements; xpe; xpe = xpe->next)
         xpe->match_state = -1; /* don't know if it matches yet */
 
     for (xpe = abs->xp_elements; xpe; xpe = xpe->next)
         xpe->match_state = -1; /* don't know if it matches yet */
@@ -417,16 +424,16 @@ data1_termlist *xpath_termlist_by_tagpath(char *tagpath, data1_node *n)
                 xpe1->match_state = ok;
 #endif
         }
                 xpe1->match_state = ok;
 #endif
         }
-        assert (ok == 0 || ok == 1);
+        assert(ok == 0 || ok == 1);
         if (ok) {
         if (ok) {
-#ifdef ENHANCED_XELM 
+#ifdef ENHANCED_XELM
             /* we have to check the perdicates up to the root node */
             xp = xpe->xpath;
             /* we have to check the perdicates up to the root node */
             xp = xpe->xpath;
-            
+
             /* find the first tag up in the node structure */
             for (nn = n; nn && nn->which != DATA1N_tag; nn = nn->parent)
                ;
             /* find the first tag up in the node structure */
             for (nn = n; nn && nn->which != DATA1N_tag; nn = nn->parent)
                ;
-            
+
             /* go from inside out in the node structure, while going
                backwards trough xpath location steps ... */
             for (i = xpe->xpath_len - 1; i>0; i--)
             /* go from inside out in the node structure, while going
                backwards trough xpath location steps ... */
             for (i = xpe->xpath_len - 1; i>0; i--)
@@ -436,7 +443,7 @@ data1_termlist *xpath_termlist_by_tagpath(char *tagpath, data1_node *n)
                     ok = 0;
                     break;
                 }
                     ok = 0;
                     break;
                 }
-                
+
                 if (nn->which == DATA1N_tag)
                     nn = nn->parent;
             }
                 if (nn->which == DATA1N_tag)
                     nn = nn->parent;
             }
@@ -444,12 +451,11 @@ data1_termlist *xpath_termlist_by_tagpath(char *tagpath, data1_node *n)
             if (ok)
                 break;
        }
             if (ok)
                 break;
        }
-    } 
-    
+    }
+
     xfree(pexpr);
     xfree(pexpr);
-    
+
     if (xpe) {
     if (xpe) {
-       yaz_log(YLOG_DEBUG, "Got it");
         return xpe->termlists;
     } else {
         return NULL;
         return xpe->termlists;
     } else {
         return NULL;
@@ -468,32 +474,32 @@ data1_termlist *xpath_termlist_by_tagpath(char *tagpath, data1_node *n)
   *ostrich*
 
   Now, if there is a matching xelm described in abs, for the
   *ostrich*
 
   Now, if there is a matching xelm described in abs, for the
-  indexed element or the attribute,  then the data is handled according 
+  indexed element or the attribute,  then the data is handled according
   to those definitions...
 
   modified by pop, 2002-12-13
 */
 
 /* add xpath index for an attribute */
   to those definitions...
 
   modified by pop, 2002-12-13
 */
 
 /* add xpath index for an attribute */
-static void index_xpath_attr (char *tag_path, char *name, char *value,
+static void index_xpath_attr(char *tag_path, char *name, char *value,
                              char *structure, struct recExtractCtrl *p,
                              RecWord *wrd)
 {
     wrd->index_name = ZEBRA_XPATH_ELM_BEGIN;
                              char *structure, struct recExtractCtrl *p,
                              RecWord *wrd)
 {
     wrd->index_name = ZEBRA_XPATH_ELM_BEGIN;
-    wrd->index_type = '0';
+    wrd->index_type = "0";
     wrd->term_buf = tag_path;
     wrd->term_len = strlen(tag_path);
     (*p->tokenAdd)(wrd);
     wrd->term_buf = tag_path;
     wrd->term_len = strlen(tag_path);
     (*p->tokenAdd)(wrd);
-    
+
     if (value) {
        wrd->index_name = ZEBRA_XPATH_ATTR_CDATA;
     if (value) {
        wrd->index_name = ZEBRA_XPATH_ATTR_CDATA;
-        wrd->index_type = 'w';
+        wrd->index_type = "w";
         wrd->term_buf = value;
         wrd->term_len = strlen(value);
         (*p->tokenAdd)(wrd);
     }
     wrd->index_name = ZEBRA_XPATH_ELM_END;
         wrd->term_buf = value;
         wrd->term_len = strlen(value);
         (*p->tokenAdd)(wrd);
     }
     wrd->index_name = ZEBRA_XPATH_ELM_END;
-    wrd->index_type = '0';
+    wrd->index_type = "0";
     wrd->term_buf = tag_path;
     wrd->term_len = strlen(tag_path);
     (*p->tokenAdd)(wrd);
     wrd->term_buf = tag_path;
     wrd->term_len = strlen(tag_path);
     (*p->tokenAdd)(wrd);
@@ -513,7 +519,7 @@ static void mk_tag_path_full(char *tag_path_full, size_t max, data1_node *n)
            size_t tlen = strlen(nn->u.tag.tag);
            if (tlen + flen > (max - 2))
                break;
            size_t tlen = strlen(nn->u.tag.tag);
            if (tlen + flen > (max - 2))
                break;
-           memcpy (tag_path_full + flen, nn->u.tag.tag, tlen);
+           memcpy(tag_path_full + flen, nn->u.tag.tag, tlen);
            flen += tlen;
            tag_path_full[flen++] = '/';
        }
            flen += tlen;
            tag_path_full[flen++] = '/';
        }
@@ -523,26 +529,7 @@ static void mk_tag_path_full(char *tag_path_full, size_t max, data1_node *n)
     }
     tag_path_full[flen] = 0;
 }
     }
     tag_path_full[flen] = 0;
 }
-       
 
 
-static void index_staticrank(struct recExtractCtrl *p,
-                             RecWord *wrd,
-                             data1_absyn *absyn)
-{
-    const char *staticrank_index = data1_absyn_get_staticrank(absyn);
-
-    if (staticrank_index && !strcmp(wrd->index_name, staticrank_index))
-    {
-        char valz[20];
-        size_t len = wrd->term_len;
-
-        if (len > sizeof(valz)-1)
-            len = sizeof(valz)-1;
-        memcpy(valz, wrd->term_buf, len);
-        valz[len] = '\0';
-        p->staticrank = atozint(valz);
-    }
-}
 
 static void index_xpath(struct source_parser *sp, data1_node *n,
                        struct recExtractCtrl *p,
 
 static void index_xpath(struct source_parser *sp, data1_node *n,
                        struct recExtractCtrl *p,
@@ -555,10 +542,9 @@ static void index_xpath(struct source_parser *sp, data1_node *n,
     char tag_path_full[1024];
     int termlist_only = 1;
     data1_termlist *tl;
     char tag_path_full[1024];
     int termlist_only = 1;
     data1_termlist *tl;
-    int xpdone = 0;
 
 
-    if (!n->root->u.root.absyn 
-        || 
+    if (!n->root->u.root.absyn
+        ||
         n->root->u.root.absyn->xpath_indexing == DATA1_XPATH_INDEXING_ENABLE)
     {
        termlist_only = 0;
         n->root->u.root.absyn->xpath_indexing == DATA1_XPATH_INDEXING_ENABLE)
     {
        termlist_only = 0;
@@ -570,12 +556,11 @@ static void index_xpath(struct source_parser *sp, data1_node *n,
     case DATA1N_data:
         wrd->term_buf = n->u.data.data;
         wrd->term_len = n->u.data.len;
     case DATA1N_data:
         wrd->term_buf = n->u.data.data;
         wrd->term_len = n->u.data.len;
-        xpdone = 0;
 
        mk_tag_path_full(tag_path_full, sizeof(tag_path_full), n);
 
        mk_tag_path_full(tag_path_full, sizeof(tag_path_full), n);
-       
+
        /* If we have a matching termlist... */
        /* If we have a matching termlist... */
-       if (n->root->u.root.absyn && 
+       if (n->root->u.root.absyn &&
            (tl = xpath_termlist_by_tagpath(tag_path_full, n)))
        {
             zint max_seqno = 0;
            (tl = xpath_termlist_by_tagpath(tag_path_full, n)))
        {
             zint max_seqno = 0;
@@ -583,11 +568,11 @@ static void index_xpath(struct source_parser *sp, data1_node *n,
            {
                /* need to copy recword because it may be changed */
                RecWord wrd_tl;
            {
                /* need to copy recword because it may be changed */
                RecWord wrd_tl;
-               wrd->index_type = *tl->structure;
-               memcpy (&wrd_tl, wrd, sizeof(*wrd));
+               wrd->index_type = tl->structure;
+               memcpy(&wrd_tl, wrd, sizeof(*wrd));
                if (tl->source)
                    sp_parse(sp, n, &wrd_tl, tl->source);
                if (tl->source)
                    sp_parse(sp, n, &wrd_tl, tl->source);
-                
+
                 /* this is just the old fashioned attribute based index */
                 wrd_tl.index_name = tl->index_name;
                 if (p->flagShowRecords)
                 /* this is just the old fashioned attribute based index */
                 wrd_tl.index_name = tl->index_name;
                 if (p->flagShowRecords)
@@ -596,41 +581,38 @@ static void index_xpath(struct source_parser *sp, data1_node *n,
                     printf("%*sIdx: [%s]", (level + 1) * 4, "",
                            tl->structure);
                     printf("%s %s", tl->index_name, tl->source);
                     printf("%*sIdx: [%s]", (level + 1) * 4, "",
                            tl->structure);
                     printf("%s %s", tl->index_name, tl->source);
-                    printf (" XData:\"");
+                    printf(" XData:\"");
                     for (i = 0; i<wrd_tl.term_len && i < 40; i++)
                     for (i = 0; i<wrd_tl.term_len && i < 40; i++)
-                        fputc (wrd_tl.term_buf[i], stdout);
-                    fputc ('"', stdout);
+                        fputc(wrd_tl.term_buf[i], stdout);
+                    fputc('"', stdout);
                     if (wrd_tl.term_len > 40)
                     if (wrd_tl.term_len > 40)
-                        printf (" ...");
-                    fputc ('\n', stdout);
+                        printf(" ...");
+                    fputc('\n', stdout);
                 }
                 else
                 {
                     (*p->tokenAdd)(&wrd_tl);
                 }
                 else
                 {
                     (*p->tokenAdd)(&wrd_tl);
-                    index_staticrank(p, &wrd_tl, n->root->u.root.absyn);
                 }
                 if (wrd_tl.seqno > max_seqno)
                     max_seqno = wrd_tl.seqno;
            }
             if (max_seqno)
                 wrd->seqno = max_seqno;
                 }
                 if (wrd_tl.seqno > max_seqno)
                     max_seqno = wrd_tl.seqno;
            }
             if (max_seqno)
                 wrd->seqno = max_seqno;
-                
+
        }
        }
-       /* xpath indexing is done, if there was no termlist given, 
+       /* xpath indexing is done, if there was no termlist given,
           or no ! in the termlist, and default indexing is enabled... */
           or no ! in the termlist, and default indexing is enabled... */
-       if (!p->flagShowRecords && !xpdone && !termlist_only)
+       if (!p->flagShowRecords && !termlist_only)
        {
            wrd->index_name = xpath_index;
        {
            wrd->index_name = xpath_index;
-           wrd->index_type = 'w';
+           wrd->index_type = "w";
            (*p->tokenAdd)(wrd);
        }
         break;
     case DATA1N_tag:
            (*p->tokenAdd)(wrd);
        }
         break;
     case DATA1N_tag:
-        if (termlist_only)
-            return;
        mk_tag_path_full(tag_path_full, sizeof(tag_path_full), n);
 
        mk_tag_path_full(tag_path_full, sizeof(tag_path_full), n);
 
-        wrd->index_type = '0';
+        wrd->index_type = "0";
         wrd->term_buf = tag_path_full;
         wrd->term_len = strlen(tag_path_full);
        wrd->index_name = xpath_index;
         wrd->term_buf = tag_path_full;
         wrd->term_len = strlen(tag_path_full);
        wrd->index_name = xpath_index;
@@ -638,71 +620,74 @@ static void index_xpath(struct source_parser *sp, data1_node *n,
         {
             printf("%*s tag=", (level + 1) * 4, "");
             for (i = 0; i<wrd->term_len && i < 40; i++)
         {
             printf("%*s tag=", (level + 1) * 4, "");
             for (i = 0; i<wrd->term_len && i < 40; i++)
-                fputc (wrd->term_buf[i], stdout);
+                fputc(wrd->term_buf[i], stdout);
             if (i == 40)
             if (i == 40)
-                printf (" ..");
+                printf(" ..");
             printf("\n");
         }
         else
         {
             data1_xattr *xp;
 
             printf("\n");
         }
         else
         {
             data1_xattr *xp;
 
-            (*p->tokenAdd)(wrd);   /* index element pag (AKA tag path) */
-            
+            if (!termlist_only)
+                (*p->tokenAdd)(wrd);   /* index element pag (AKA tag path) */
+
             if (xpath_is_start == 1) /* only for the starting tag... */
             {
 #define MAX_ATTR_COUNT 50
                 data1_termlist *tll[MAX_ATTR_COUNT];
             if (xpath_is_start == 1) /* only for the starting tag... */
             {
 #define MAX_ATTR_COUNT 50
                 data1_termlist *tll[MAX_ATTR_COUNT];
-                
+
                 int i = 0;
                 for (xp = n->u.tag.attributes; xp; xp = xp->next) {
                     char comb[512];
                 int i = 0;
                 for (xp = n->u.tag.attributes; xp; xp = xp->next) {
                     char comb[512];
-                    char attr_tag_path_full[1024]; 
-                    
+                    char attr_tag_path_full[1024];
+
                     /* this could be cached as well */
                     /* this could be cached as well */
-                    sprintf (attr_tag_path_full, "@%s/%s",
+                    sprintf(attr_tag_path_full, "@%s/%s",
                              xp->name, tag_path_full);
                              xp->name, tag_path_full);
-                    
+
                     tll[i] = xpath_termlist_by_tagpath(attr_tag_path_full,n);
                     tll[i] = xpath_termlist_by_tagpath(attr_tag_path_full,n);
-                    
-                    /* attribute  (no value) */
-                    wrd->index_type = '0';
-                    wrd->index_name = ZEBRA_XPATH_ATTR_NAME;
-                    wrd->term_buf = xp->name;
-                    wrd->term_len = strlen(xp->name);
-                    
-                    wrd->seqno--;
-                    (*p->tokenAdd)(wrd);
-                    
-                    if (xp->value 
-                        &&
-                        strlen(xp->name) + strlen(xp->value) < sizeof(comb)-2)
+
+                    if (!termlist_only)
                     {
                     {
-                        /* attribute value exact */
-                        strcpy (comb, xp->name);
-                        strcat (comb, "=");
-                        strcat (comb, xp->value);
-                        
+                        /* attribute  (no value) */
+                        wrd->index_type = "0";
                         wrd->index_name = ZEBRA_XPATH_ATTR_NAME;
                         wrd->index_name = ZEBRA_XPATH_ATTR_NAME;
-                        wrd->index_type = '0';
-                        wrd->term_buf = comb;
-                        wrd->term_len = strlen(comb);
+                        wrd->term_buf = xp->name;
+                        wrd->term_len = strlen(xp->name);
+
                         wrd->seqno--;
                         wrd->seqno--;
-                        
                         (*p->tokenAdd)(wrd);
                         (*p->tokenAdd)(wrd);
-                    }                
+
+                        if (xp->value
+                            &&
+                            strlen(xp->name) + strlen(xp->value) < sizeof(comb)-2)
+                        {
+                            /* attribute value exact */
+                            strcpy(comb, xp->name);
+                            strcat(comb, "=");
+                            strcat(comb, xp->value);
+
+                            wrd->index_name = ZEBRA_XPATH_ATTR_NAME;
+                            wrd->index_type = "0";
+                            wrd->term_buf = comb;
+                            wrd->term_len = strlen(comb);
+                            wrd->seqno--;
+
+                            (*p->tokenAdd)(wrd);
+                        }
+                    }
                     i++;
                 }
                     i++;
                 }
-                
+
                 i = 0;
                 for (xp = n->u.tag.attributes; xp; xp = xp->next) {
                     data1_termlist *tl;
                     char attr_tag_path_full[1024];
                     int xpdone = 0;
                 i = 0;
                 for (xp = n->u.tag.attributes; xp; xp = xp->next) {
                     data1_termlist *tl;
                     char attr_tag_path_full[1024];
                     int xpdone = 0;
-                    
-                    sprintf (attr_tag_path_full, "@%s/%s",
+
+                    sprintf(attr_tag_path_full, "@%s/%s",
                              xp->name, tag_path_full);
                              xp->name, tag_path_full);
-                    
                     if ((tl = tll[i]))
                     {
                         /* If there is a termlist given (=xelm directive) */
                     if ((tl = tll[i]))
                     {
                         /* If there is a termlist given (=xelm directive) */
@@ -711,31 +696,29 @@ static void index_xpath(struct source_parser *sp, data1_node *n,
                            if (!tl->index_name)
                            {
                                 /* add xpath index for the attribute */
                            if (!tl->index_name)
                            {
                                 /* add xpath index for the attribute */
-                                index_xpath_attr (attr_tag_path_full, xp->name,
+                                index_xpath_attr(attr_tag_path_full, xp->name,
                                                   xp->value, tl->structure,
                                                   p, wrd);
                                 xpdone = 1;
                             } else {
                                 /* index attribute value (only path/@attr) */
                                                   xp->value, tl->structure,
                                                   p, wrd);
                                 xpdone = 1;
                             } else {
                                 /* index attribute value (only path/@attr) */
-                                if (xp->value) 
+                                if (xp->value)
                                {
                                    wrd->index_name = tl->index_name;
                                {
                                    wrd->index_name = tl->index_name;
-                                    wrd->index_type = *tl->structure;
+                                    wrd->index_type = tl->structure;
                                     wrd->term_buf = xp->value;
                                     wrd->term_len = strlen(xp->value);
                                     (*p->tokenAdd)(wrd);
                                     wrd->term_buf = xp->value;
                                     wrd->term_len = strlen(xp->value);
                                     (*p->tokenAdd)(wrd);
-                                    index_staticrank(p, wrd,
-                                                     n->root->u.root.absyn);
                                 }
                             }
                         }
                     }
                                 }
                             }
                         }
                     }
-                    /* if there was no termlist for the given path, 
-                       or the termlist didn't have a ! element, index 
+                    /* if there was no termlist for the given path,
+                       or the termlist didn't have a ! element, index
                        the attribute as "w" */
                        the attribute as "w" */
-                    if ((!xpdone) && (!termlist_only))
+                    if (!xpdone && !termlist_only)
                     {
                     {
-                        index_xpath_attr (attr_tag_path_full, xp->name,
+                        index_xpath_attr(attr_tag_path_full, xp->name,
                                           xp->value,  "w", p, wrd);
                     }
                     i++;
                                           xp->value,  "w", p, wrd);
                     }
                     i++;
@@ -745,27 +728,22 @@ static void index_xpath(struct source_parser *sp, data1_node *n,
     }
 }
 
     }
 }
 
-static void index_termlist (struct source_parser *sp, data1_node *par,
+static void index_termlist(struct source_parser *sp, data1_node *par,
                            data1_node *n,
                             struct recExtractCtrl *p, int level, RecWord *wrd)
 {
     data1_termlist *tlist = 0;
                            data1_node *n,
                             struct recExtractCtrl *p, int level, RecWord *wrd)
 {
     data1_termlist *tlist = 0;
-    data1_datatype dtype = DATA1K_string;
-
     /*
      * cycle up towards the root until we find a tag with an att..
      * this has the effect of indexing locally defined tags with
      * the attribute of their ancestor in the record.
      */
     /*
      * cycle up towards the root until we find a tag with an att..
      * this has the effect of indexing locally defined tags with
      * the attribute of their ancestor in the record.
      */
-    
+
     while (!par->u.tag.element)
         if (!par->parent || !(par=get_parent_tag(p->dh, par->parent)))
             break;
     if (!par || !(tlist = par->u.tag.element->termlists))
         return;
     while (!par->u.tag.element)
         if (!par->parent || !(par=get_parent_tag(p->dh, par->parent)))
             break;
     if (!par || !(tlist = par->u.tag.element->termlists))
         return;
-    if (par->u.tag.element->tag)
-        dtype = par->u.tag.element->tag->kind;
-
     for (; tlist; tlist = tlist->next)
     {
        /* consider source */
     for (; tlist; tlist = tlist->next)
     {
        /* consider source */
@@ -781,19 +759,18 @@ static void index_termlist (struct source_parser *sp, data1_node *par,
                printf("%*sIdx: [%s]", (level + 1) * 4, "",
                       tlist->structure);
                printf("%s %s", tlist->index_name, tlist->source);
                printf("%*sIdx: [%s]", (level + 1) * 4, "",
                       tlist->structure);
                printf("%s %s", tlist->index_name, tlist->source);
-               printf (" XData:\"");
+               printf(" XData:\"");
                for (i = 0; i<wrd->term_len && i < 40; i++)
                for (i = 0; i<wrd->term_len && i < 40; i++)
-                   fputc (wrd->term_buf[i], stdout);
-               fputc ('"', stdout);
+                   fputc(wrd->term_buf[i], stdout);
+               fputc('"', stdout);
                if (wrd->term_len > 40)
                if (wrd->term_len > 40)
-                   printf (" ...");
-               fputc ('\n', stdout);
+                   printf(" ...");
+               fputc('\n', stdout);
            }
            else
            {
            }
            else
            {
-               wrd->index_type = *tlist->structure;
+               wrd->index_type = tlist->structure;
                wrd->index_name = tlist->index_name;
                wrd->index_name = tlist->index_name;
-                index_staticrank(p, wrd, n->root->u.root.absyn);
                (*p->tokenAdd)(wrd);
            }
        }
                (*p->tokenAdd)(wrd);
            }
        }
@@ -848,7 +825,7 @@ static int dumpkeys_r(struct source_parser *sp,
             index_termlist(sp, n, n, p, level, wrd);
             /* index start tag */
            if (n->root->u.root.absyn)
             index_termlist(sp, n, n, p, level, wrd);
             /* index start tag */
            if (n->root->u.root.absyn)
-               index_xpath(sp, n, p, level, wrd, ZEBRA_XPATH_ELM_BEGIN, 
+               index_xpath(sp, n, p, level, wrd, ZEBRA_XPATH_ELM_BEGIN,
                            1 /* is start */);
        }
 
                            1 /* is start */);
        }
 
@@ -877,14 +854,14 @@ static int dumpkeys_r(struct source_parser *sp,
            if (par)
                index_termlist(sp, par, n, p, level, wrd);
 
            if (par)
                index_termlist(sp, par, n, p, level, wrd);
 
-           index_xpath(sp, n, p, level, wrd, ZEBRA_XPATH_CDATA, 
+           index_xpath(sp, n, p, level, wrd, ZEBRA_XPATH_CDATA,
                        0 /* is start */);
        }
 
        if (n->which == DATA1N_tag)
        {
             /* index end tag */
                        0 /* is start */);
        }
 
        if (n->which == DATA1N_tag)
        {
             /* index end tag */
-           index_xpath(sp, n, p, level, wrd, ZEBRA_XPATH_ELM_END, 
+           index_xpath(sp, n, p, level, wrd, ZEBRA_XPATH_ELM_END,
                        0 /* is start */);
        }
 
                        0 /* is start */);
        }
 
@@ -906,22 +883,13 @@ static int dumpkeys(data1_node *n, struct recExtractCtrl *p, RecWord *wrd)
 
 int grs_extract_tree(struct recExtractCtrl *p, data1_node *n)
 {
 
 int grs_extract_tree(struct recExtractCtrl *p, data1_node *n)
 {
-    oident oe;
-    int oidtmp[OID_SIZE];
     RecWord wrd;
 
     RecWord wrd;
 
-    oe.proto = PROTO_Z3950;
-    oe.oclass = CLASS_SCHEMA;
-    if (n->u.root.absyn)
-    {
-        oe.value = n->u.root.absyn->reference;
-        
-        if ((oid_ent_to_oid (&oe, oidtmp)))
-            (*p->schemaAdd)(p, oidtmp);
-    }
+    if (n->u.root.absyn && n->u.root.absyn->oid)
+        (*p->schemaAdd)(p, n->u.root.absyn->oid);
     (*p->init)(p, &wrd);
 
     (*p->init)(p, &wrd);
 
-    /* data1_pr_tree(p->dh, n, stdout); */ 
+    /* data1_pr_tree(p->dh, n, stdout); */
 
     return dumpkeys(n, p, &wrd);
 }
 
     return dumpkeys(n, p, &wrd);
 }
@@ -932,8 +900,6 @@ static int grs_extract_sub(void *clientData, struct recExtractCtrl *p,
 {
     data1_node *n;
     struct grs_read_info gri;
 {
     data1_node *n;
     struct grs_read_info gri;
-    oident oe;
-    int oidtmp[OID_SIZE];
     RecWord wrd;
 
     gri.stream = p->stream;
     RecWord wrd;
 
     gri.stream = p->stream;
@@ -944,28 +910,18 @@ static int grs_extract_sub(void *clientData, struct recExtractCtrl *p,
     n = (*grs_read)(&gri);
     if (!n)
         return RECCTRL_EXTRACT_EOF;
     n = (*grs_read)(&gri);
     if (!n)
         return RECCTRL_EXTRACT_EOF;
-    oe.proto = PROTO_Z3950;
-    oe.oclass = CLASS_SCHEMA;
-#if 0
-    if (!n->u.root.absyn)
-        return RECCTRL_EXTRACT_ERROR;
-#endif
-    if (n->u.root.absyn)
-    {
-        oe.value = n->u.root.absyn->reference;
-        if ((oid_ent_to_oid (&oe, oidtmp)))
-            (*p->schemaAdd)(p, oidtmp);
-    }
+    if (n->u.root.absyn && n->u.root.absyn->oid)
+        (*p->schemaAdd)(p, n->u.root.absyn->oid);
     data1_concat_text(p->dh, mem, n);
 
     /* ensure our data1 tree is UTF-8 */
     data1_concat_text(p->dh, mem, n);
 
     /* ensure our data1 tree is UTF-8 */
-    data1_iconv (p->dh, mem, n, "UTF-8", data1_get_encoding(p->dh, n));
+    data1_iconv(p->dh, mem, n, "UTF-8", data1_get_encoding(p->dh, n));
 
 
 
 
-    data1_remove_idzebra_subtree (p->dh, n);
+    data1_remove_idzebra_subtree(p->dh, n);
 
 #if 0
 
 #if 0
-    data1_pr_tree (p->dh, n, stdout);
+    data1_pr_tree(p->dh, n, stdout);
 #endif
 
     (*p->init)(p, &wrd);
 #endif
 
     (*p->init)(p, &wrd);
@@ -980,7 +936,7 @@ int zebra_grs_extract(void *clientData, struct recExtractCtrl *p,
                      data1_node *(*grs_read)(struct grs_read_info *))
 {
     int ret;
                      data1_node *(*grs_read)(struct grs_read_info *))
 {
     int ret;
-    NMEM mem = nmem_create ();
+    NMEM mem = nmem_create();
     ret = grs_extract_sub(clientData, p, mem, grs_read);
     nmem_destroy(mem);
     return ret;
     ret = grs_extract_sub(clientData, p, mem, grs_read);
     nmem_destroy(mem);
     return ret;
@@ -1065,7 +1021,7 @@ static int process_comp(data1_handle dh, data1_node *n, Z_RecordComposition *c,
 }
 
 /* Add Zebra info in separate namespace ...
 }
 
 /* Add Zebra info in separate namespace ...
-        <root 
+        <root
          ...
          <metadata xmlns="http://www.indexdata.dk/zebra/">
           <size>359</size>
          ...
          <metadata xmlns="http://www.indexdata.dk/zebra/">
           <size>359</size>
@@ -1075,7 +1031,7 @@ static int process_comp(data1_handle dh, data1_node *n, Z_RecordComposition *c,
         </root>
 */
 
         </root>
 */
 
-static void zebra_xml_metadata (struct recRetrieveCtrl *p, data1_node *top,
+static void zebra_xml_metadata(struct recRetrieveCtrl *p, data1_node *top,
                                 NMEM mem)
 {
     const char *idzebra_ns[3];
                                 NMEM mem)
 {
     const char *idzebra_ns[3];
@@ -1087,29 +1043,29 @@ static void zebra_xml_metadata (struct recRetrieveCtrl *p, data1_node *top,
     idzebra_ns[1] = "http://www.indexdata.dk/zebra/";
     idzebra_ns[2] = 0;
 
     idzebra_ns[1] = "http://www.indexdata.dk/zebra/";
     idzebra_ns[2] = 0;
 
-    data1_mk_text (p->dh, mem, i2, top);
+    data1_mk_text(p->dh, mem, i2, top);
+
+    n = data1_mk_tag(p->dh, mem, "idzebra", idzebra_ns, top);
 
 
-    n = data1_mk_tag (p->dh, mem, "idzebra", idzebra_ns, top);
+    data1_mk_text(p->dh, mem, "\n", top);
 
 
-    data1_mk_text (p->dh, mem, "\n", top);
+    data1_mk_text(p->dh, mem, i4, n);
 
 
-    data1_mk_text (p->dh, mem, i4, n);
-    
-    data1_mk_tag_data_int (p->dh, n, "size", p->recordSize, mem);
+    data1_mk_tag_data_int(p->dh, n, "size", p->recordSize, mem);
 
     if (p->score != -1)
     {
 
     if (p->score != -1)
     {
-        data1_mk_text (p->dh, mem, i4, n);
-        data1_mk_tag_data_int (p->dh, n, "score", p->score, mem);
+        data1_mk_text(p->dh, mem, i4, n);
+        data1_mk_tag_data_int(p->dh, n, "score", p->score, mem);
     }
     }
-    data1_mk_text (p->dh, mem, i4, n);
-    data1_mk_tag_data_zint (p->dh, n, "localnumber", p->localno, mem);
+    data1_mk_text(p->dh, mem, i4, n);
+    data1_mk_tag_data_zint(p->dh, n, "localnumber", p->localno, mem);
     if (p->fname)
     {
     if (p->fname)
     {
-        data1_mk_text (p->dh, mem, i4, n);
+        data1_mk_text(p->dh, mem, i4, n);
         data1_mk_tag_data_text(p->dh, n, "filename", p->fname, mem);
     }
         data1_mk_tag_data_text(p->dh, n, "filename", p->fname, mem);
     }
-    data1_mk_text (p->dh, mem, i2, n);
+    data1_mk_text(p->dh, mem, i2, n);
 }
 
 int zebra_grs_retrieve(void *clientData, struct recRetrieveCtrl *p,
 }
 
 int zebra_grs_retrieve(void *clientData, struct recRetrieveCtrl *p,
@@ -1123,10 +1079,10 @@ int zebra_grs_retrieve(void *clientData, struct recRetrieveCtrl *p,
     struct grs_read_info gri;
     const char *tagname;
 
     struct grs_read_info gri;
     const char *tagname;
 
-    int requested_schema = VAL_NONE;
+    const Odr_oid *requested_schema = 0;
     data1_marctab *marctab;
     int dummy;
     data1_marctab *marctab;
     int dummy;
-    
+
     mem = nmem_create();
     gri.stream = p->stream;
     gri.mem = mem;
     mem = nmem_create();
     gri.stream = p->stream;
     gri.mem = mem;
@@ -1137,18 +1093,18 @@ int zebra_grs_retrieve(void *clientData, struct recRetrieveCtrl *p,
     node = (*grs_read)(&gri);
     if (!node)
     {
     node = (*grs_read)(&gri);
     if (!node)
     {
-       p->diagnostic = 14;
-        nmem_destroy (mem);
+       p->diagnostic = YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS;
+        nmem_destroy(mem);
        return 0;
     }
     data1_concat_text(p->dh, mem, node);
 
        return 0;
     }
     data1_concat_text(p->dh, mem, node);
 
-    data1_remove_idzebra_subtree (p->dh, node);
+    data1_remove_idzebra_subtree(p->dh, node);
 
 #if 0
 
 #if 0
-    data1_pr_tree (p->dh, node, stdout);
+    data1_pr_tree(p->dh, node, stdout);
 #endif
 #endif
-    top = data1_get_root_tag (p->dh, node);
+    top = data1_get_root_tag(p->dh, node);
 
     yaz_log(YLOG_DEBUG, "grs_retrieve: size");
     tagname = data1_systag_lookup(node->u.root.absyn, "size", "size");
 
     yaz_log(YLOG_DEBUG, "grs_retrieve: size");
     tagname = data1_systag_lookup(node->u.root.absyn, "size", "size");
@@ -1160,7 +1116,7 @@ int zebra_grs_retrieve(void *clientData, struct recRetrieveCtrl *p,
        sprintf(dnew->u.data.data, "%d", p->recordSize);
        dnew->u.data.len = strlen(dnew->u.data.data);
     }
        sprintf(dnew->u.data.data, "%d", p->recordSize);
        dnew->u.data.len = strlen(dnew->u.data.data);
     }
-    
+
     tagname = data1_systag_lookup(node->u.root.absyn, "rank", "rank");
     if (tagname && p->score >= 0 &&
        (dnew = data1_mk_tag_data_wd(p->dh, top, tagname, mem)))
     tagname = data1_systag_lookup(node->u.root.absyn, "rank", "rank");
     if (tagname && p->score >= 0 &&
        (dnew = data1_mk_tag_data_wd(p->dh, top, tagname, mem)))
@@ -1180,51 +1136,55 @@ int zebra_grs_retrieve(void *clientData, struct recRetrieveCtrl *p,
         yaz_log(YLOG_DEBUG, "grs_retrieve: %s", tagname);
        dnew->u.data.what = DATA1I_text;
        dnew->u.data.data = dnew->lbuf;
         yaz_log(YLOG_DEBUG, "grs_retrieve: %s", tagname);
        dnew->u.data.what = DATA1I_text;
        dnew->u.data.data = dnew->lbuf;
-        
+
        sprintf(dnew->u.data.data, ZINT_FORMAT, p->localno);
        dnew->u.data.len = strlen(dnew->u.data.data);
     }
 
        sprintf(dnew->u.data.data, ZINT_FORMAT, p->localno);
        dnew->u.data.len = strlen(dnew->u.data.data);
     }
 
-    if (p->input_format == VAL_TEXT_XML)
-       zebra_xml_metadata (p, top, mem);
+    if (!p->input_format)
+    {  /* SUTRS is default input_format */
+        p->input_format = yaz_oid_recsyn_sutrs;
+    }
+    assert(p->input_format);
+
+    if (!oid_oidcmp(p->input_format, yaz_oid_recsyn_xml))
+        zebra_xml_metadata(p, top, mem);
 
 #if 0
 
 #if 0
-    data1_pr_tree (p->dh, node, stdout);
+    data1_pr_tree(p->dh, node, stdout);
 #endif
     if (p->comp && p->comp->which == Z_RecordComp_complex &&
        p->comp->u.complex->generic &&
         p->comp->u.complex->generic->which == Z_Schema_oid &&
         p->comp->u.complex->generic->schema.oid)
     {
 #endif
     if (p->comp && p->comp->which == Z_RecordComp_complex &&
        p->comp->u.complex->generic &&
         p->comp->u.complex->generic->which == Z_Schema_oid &&
         p->comp->u.complex->generic->schema.oid)
     {
-       oident *oe = oid_getentbyoid (p->comp->u.complex->generic->schema.oid);
-       if (oe)
-           requested_schema = oe->value;
+        requested_schema = p->comp->u.complex->generic->schema.oid;
     }
     /* If schema has been specified, map if possible, then check that
     }
     /* If schema has been specified, map if possible, then check that
-     * we got the right one 
+     * we got the right one
      */
      */
-    if (requested_schema != VAL_NONE)
+    if (requested_schema)
     {
        yaz_log(YLOG_DEBUG, "grs_retrieve: schema mapping");
        for (map = node->u.root.absyn->maptabs; map; map = map->next)
        {
     {
        yaz_log(YLOG_DEBUG, "grs_retrieve: schema mapping");
        for (map = node->u.root.absyn->maptabs; map; map = map->next)
        {
-           if (map->target_absyn_ref == requested_schema)
+           if (!oid_oidcmp(map->oid, requested_schema))
            {
                onode = node;
                if (!(node = data1_map_record(p->dh, onode, map, mem)))
                {
            {
                onode = node;
                if (!(node = data1_map_record(p->dh, onode, map, mem)))
                {
-                   p->diagnostic = 14;
-                   nmem_destroy (mem);
+                   p->diagnostic = YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS;
+                   nmem_destroy(mem);
                    return 0;
                }
                break;
            }
        }
                    return 0;
                }
                break;
            }
        }
-       if (node->u.root.absyn &&
-           requested_schema != node->u.root.absyn->reference)
+       if (node->u.root.absyn
+            && oid_oidcmp(requested_schema, node->u.root.absyn->oid))
        {
        {
-           p->diagnostic = 238;
-           nmem_destroy (mem);
+           p->diagnostic = YAZ_BIB1_RECORD_NOT_AVAILABLE_IN_REQUESTED_SYNTAX;
+           nmem_destroy(mem);
            return 0;
        }
     }
            return 0;
        }
     }
@@ -1237,53 +1197,31 @@ int zebra_grs_retrieve(void *clientData, struct recRetrieveCtrl *p,
     if (node->u.root.absyn)
         for (map = node->u.root.absyn->maptabs; map; map = map->next)
         {
     if (node->u.root.absyn)
         for (map = node->u.root.absyn->maptabs; map; map = map->next)
         {
-            if (map->target_absyn_ref == p->input_format)
+            if (!oid_oidcmp(map->oid, p->input_format))
             {
                 onode = node;
                 if (!(node = data1_map_record(p->dh, onode, map, mem)))
                 {
             {
                 onode = node;
                 if (!(node = data1_map_record(p->dh, onode, map, mem)))
                 {
-                    p->diagnostic = 14;
-                    nmem_destroy (mem);
+                    p->diagnostic = YAZ_BIB1_SYSTEM_ERROR_IN_PRESENTING_RECORDS;
+                    nmem_destroy(mem);
                     return 0;
                 }
                 break;
             }
         }
     yaz_log(YLOG_DEBUG, "grs_retrieve: schemaIdentifier");
                     return 0;
                 }
                 break;
             }
         }
     yaz_log(YLOG_DEBUG, "grs_retrieve: schemaIdentifier");
-    if (node->u.root.absyn &&
-       node->u.root.absyn->reference != VAL_NONE &&
-       p->input_format == VAL_GRS1)
+    if (node->u.root.absyn && node->u.root.absyn->oid
+        && !oid_oidcmp(p->input_format, yaz_oid_recsyn_grs_1))
     {
     {
-       oident oe;
-       Odr_oid *oid;
-       int oidtmp[OID_SIZE];
-       
-       oe.proto = PROTO_Z3950;
-       oe.oclass = CLASS_SCHEMA;
-       oe.value = node->u.root.absyn->reference;
-       
-       if ((oid = oid_ent_to_oid (&oe, oidtmp)))
-       {
-           char tmp[128];
-           data1_handle dh = p->dh;
-           char *p = tmp;
-           int *ii;
-           
-           for (ii = oid; *ii >= 0; ii++)
-           {
-               if (p != tmp)
-                       *(p++) = '.';
-               sprintf(p, "%d", *ii);
-               p += strlen(p);
-           }
-           if ((dnew = data1_mk_tag_data_wd(dh, top, 
-                                             "schemaIdentifier", mem)))
-           {
-               dnew->u.data.what = DATA1I_oid;
-               dnew->u.data.data = (char *) nmem_malloc(mem, p - tmp);
-               memcpy(dnew->u.data.data, tmp, p - tmp);
-               dnew->u.data.len = p - tmp;
-           }
+        char oid_str[OID_STR_MAX];
+        char *dot_str = oid_oid_to_dotstring(node->u.root.absyn->oid, oid_str);
+
+        if (dot_str && (dnew = data1_mk_tag_data_wd(p->dh, top,
+                                                    "schemaIdentifier", mem)))
+        {
+            dnew->u.data.what = DATA1I_oid;
+            dnew->u.data.data = (char *) nmem_strdup(mem, dot_str);
+            dnew->u.data.len = strlen(dot_str);
        }
     }
 
        }
     }
 
@@ -1299,114 +1237,122 @@ int zebra_grs_retrieve(void *clientData, struct recRetrieveCtrl *p,
        selected = 1;
 
 #if 0
        selected = 1;
 
 #if 0
-    data1_pr_tree (p->dh, node, stdout);
+    data1_pr_tree(p->dh, node, stdout);
 #endif
     yaz_log(YLOG_DEBUG, "grs_retrieve: transfer syntax mapping");
 #endif
     yaz_log(YLOG_DEBUG, "grs_retrieve: transfer syntax mapping");
-    switch (p->output_format = (p->input_format != VAL_NONE ?
-                               p->input_format : VAL_SUTRS))
+
+    p->output_format = p->input_format;
+
+    assert(p->input_format);
+    if (!oid_oidcmp(p->input_format, yaz_oid_recsyn_xml))
     {
     {
-    case VAL_TEXT_XML:
 #if 0
 #if 0
-        data1_pr_tree (p->dh, node, stdout);
+        data1_pr_tree(p->dh, node, stdout);
 #endif
        /* default output encoding for XML is UTF-8 */
 #endif
        /* default output encoding for XML is UTF-8 */
-       data1_iconv (p->dh, mem, node,
+       data1_iconv(p->dh, mem, node,
                     p->encoding ? p->encoding : "UTF-8",
                     data1_get_encoding(p->dh, node));
 
        if (!(p->rec_buf = data1_nodetoidsgml(p->dh, node, selected,
                                              &p->rec_len)))
                     p->encoding ? p->encoding : "UTF-8",
                     data1_get_encoding(p->dh, node));
 
        if (!(p->rec_buf = data1_nodetoidsgml(p->dh, node, selected,
                                              &p->rec_len)))
-           p->diagnostic = 238;
+           p->diagnostic = YAZ_BIB1_RECORD_NOT_AVAILABLE_IN_REQUESTED_SYNTAX;
        else
        {
        else
        {
-           char *new_buf = (char*) odr_malloc (p->odr, p->rec_len);
-           memcpy (new_buf, p->rec_buf, p->rec_len);
+           char *new_buf = (char*) odr_malloc(p->odr, p->rec_len);
+           memcpy(new_buf, p->rec_buf, p->rec_len);
            p->rec_buf = new_buf;
        }
            p->rec_buf = new_buf;
        }
-       break;
-    case VAL_GRS1:
-       data1_iconv (p->dh, mem, node, "UTF-8", data1_get_encoding(p->dh, node));
+    }
+    else if (!oid_oidcmp(p->input_format, yaz_oid_recsyn_grs_1))
+    {
+       data1_iconv(p->dh, mem, node, "UTF-8", data1_get_encoding(p->dh, node));
        dummy = 0;
        if (!(p->rec_buf = data1_nodetogr(p->dh, node, selected,
                                          p->odr, &dummy)))
        dummy = 0;
        if (!(p->rec_buf = data1_nodetogr(p->dh, node, selected,
                                          p->odr, &dummy)))
-           p->diagnostic = 238; /* not available in requested syntax */
+           p->diagnostic = YAZ_BIB1_RECORD_NOT_AVAILABLE_IN_REQUESTED_SYNTAX;
        else
            p->rec_len = -1;
        else
            p->rec_len = -1;
-       break;
-    case VAL_EXPLAIN:
+    }
+    else if (!oid_oidcmp(p->input_format, yaz_oid_recsyn_explain))
+    {
        /* ensure our data1 tree is UTF-8 */
        /* ensure our data1 tree is UTF-8 */
-       data1_iconv (p->dh, mem, node, "UTF-8", data1_get_encoding(p->dh, node));
-       
+       data1_iconv(p->dh, mem, node, "UTF-8", data1_get_encoding(p->dh, node));
+
        if (!(p->rec_buf = data1_nodetoexplain(p->dh, node, selected,
                                               p->odr)))
        if (!(p->rec_buf = data1_nodetoexplain(p->dh, node, selected,
                                               p->odr)))
-           p->diagnostic = 238;
+           p->diagnostic = YAZ_BIB1_RECORD_NOT_AVAILABLE_IN_REQUESTED_SYNTAX;
        else
            p->rec_len = -1;
        else
            p->rec_len = -1;
-       break;
-    case VAL_SUMMARY:
+    }
+    else if (!oid_oidcmp(p->input_format, yaz_oid_recsyn_summary))
+    {
        /* ensure our data1 tree is UTF-8 */
        /* ensure our data1 tree is UTF-8 */
-       data1_iconv (p->dh, mem, node, "UTF-8", data1_get_encoding(p->dh, node));
+       data1_iconv(p->dh, mem, node, "UTF-8", data1_get_encoding(p->dh, node));
        if (!(p->rec_buf = data1_nodetosummary(p->dh, node, selected,
                                               p->odr)))
        if (!(p->rec_buf = data1_nodetosummary(p->dh, node, selected,
                                               p->odr)))
-           p->diagnostic = 238;
+           p->diagnostic = YAZ_BIB1_RECORD_NOT_AVAILABLE_IN_REQUESTED_SYNTAX;
        else
            p->rec_len = -1;
        else
            p->rec_len = -1;
-       break;
-    case VAL_SUTRS:
+    }
+    else if (!oid_oidcmp(p->input_format, yaz_oid_recsyn_sutrs))
+    {
        if (p->encoding)
        if (p->encoding)
-            data1_iconv (p->dh, mem, node, p->encoding,
+            data1_iconv(p->dh, mem, node, p->encoding,
                         data1_get_encoding(p->dh, node));
        if (!(p->rec_buf = data1_nodetobuf(p->dh, node, selected,
                                           &p->rec_len)))
                         data1_get_encoding(p->dh, node));
        if (!(p->rec_buf = data1_nodetobuf(p->dh, node, selected,
                                           &p->rec_len)))
-           p->diagnostic = 238;
+           p->diagnostic = YAZ_BIB1_RECORD_NOT_AVAILABLE_IN_REQUESTED_SYNTAX;
        else
        {
        else
        {
-           char *new_buf = (char*) odr_malloc (p->odr, p->rec_len);
-           memcpy (new_buf, p->rec_buf, p->rec_len);
+           char *new_buf = (char*) odr_malloc(p->odr, p->rec_len);
+           memcpy(new_buf, p->rec_buf, p->rec_len);
            p->rec_buf = new_buf;
        }
            p->rec_buf = new_buf;
        }
-       break;
-    case VAL_SOIF:
+    }
+    else if (!oid_oidcmp(p->input_format, yaz_oid_recsyn_soif))
+    {
        if (p->encoding)
        if (p->encoding)
-            data1_iconv (p->dh, mem, node, p->encoding,
+            data1_iconv(p->dh, mem, node, p->encoding,
                         data1_get_encoding(p->dh, node));
        if (!(p->rec_buf = data1_nodetosoif(p->dh, node, selected,
                                            &p->rec_len)))
                         data1_get_encoding(p->dh, node));
        if (!(p->rec_buf = data1_nodetosoif(p->dh, node, selected,
                                            &p->rec_len)))
-           p->diagnostic = 238;
+           p->diagnostic = YAZ_BIB1_RECORD_NOT_AVAILABLE_IN_REQUESTED_SYNTAX;
        else
        {
        else
        {
-           char *new_buf = (char*) odr_malloc (p->odr, p->rec_len);
-           memcpy (new_buf, p->rec_buf, p->rec_len);
+           char *new_buf = (char*) odr_malloc(p->odr, p->rec_len);
+           memcpy(new_buf, p->rec_buf, p->rec_len);
            p->rec_buf = new_buf;
        }
            p->rec_buf = new_buf;
        }
-       break;
-    default:
+    }
+    else
+    {
        if (!node->u.root.absyn)
        if (!node->u.root.absyn)
-       {
-           p->diagnostic = 238;
-           break;
-       }
-       for (marctab = node->u.root.absyn->marc; marctab;
-            marctab = marctab->next)
-           if (marctab->reference == p->input_format)
-               break;
-       if (!marctab)
-       {
-           p->diagnostic = 238;
-           break;
-       }
-       if (p->encoding)
-            data1_iconv (p->dh, mem, node, p->encoding,
-                        data1_get_encoding(p->dh, node));
-       if (!(p->rec_buf = data1_nodetomarc(p->dh, marctab, node,
-                                       selected, &p->rec_len)))
-           p->diagnostic = 238;
-       else
-       {
-           char *new_buf = (char*) odr_malloc (p->odr, p->rec_len);
-           memcpy (new_buf, p->rec_buf, p->rec_len);
-               p->rec_buf = new_buf;
-       }
+           p->diagnostic = YAZ_BIB1_RECORD_NOT_AVAILABLE_IN_REQUESTED_SYNTAX;
+        else
+        {
+            for (marctab = node->u.root.absyn->marc; marctab;
+                 marctab = marctab->next)
+                if (marctab->oid && !oid_oidcmp(marctab->oid, p->input_format))
+                    break;
+            if (!marctab)
+                p->diagnostic = YAZ_BIB1_RECORD_NOT_AVAILABLE_IN_REQUESTED_SYNTAX;
+            else
+            {
+                if (p->encoding)
+                    data1_iconv(p->dh, mem, node, p->encoding,
+                                 data1_get_encoding(p->dh, node));
+                if (!(p->rec_buf = data1_nodetomarc(p->dh, marctab, node,
+                                                    selected, &p->rec_len)))
+                    p->diagnostic = YAZ_BIB1_RECORD_NOT_AVAILABLE_IN_REQUESTED_SYNTAX;
+                else
+                {
+                    char *new_buf = (char*) odr_malloc(p->odr, p->rec_len);
+                    memcpy(new_buf, p->rec_buf, p->rec_len);
+                    p->rec_buf = new_buf;
+                }
+            }
+        }
     }
     nmem_destroy(mem);
     return 0;
     }
     nmem_destroy(mem);
     return 0;
@@ -1415,6 +1361,7 @@ int zebra_grs_retrieve(void *clientData, struct recRetrieveCtrl *p,
 /*
  * Local variables:
  * c-basic-offset: 4
 /*
  * Local variables:
  * c-basic-offset: 4
+ * c-file-style: "Stroustrup"
  * indent-tabs-mode: nil
  * End:
  * vim: shiftwidth=4 tabstop=8 expandtab
  * indent-tabs-mode: nil
  * End:
  * vim: shiftwidth=4 tabstop=8 expandtab
Search Engine