X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;ds=sidebyside;f=index%2Fzrpn.c;h=caccbcde3be959f469a137d49b8b7c2b8e6cffec;hb=ecf94fc25324414287d3bbfbeba4440e558edd17;hp=dea6c98860d8f81192c4711512c5f43e24e07144;hpb=7c3a0352f0492609a3b6b26b63a72b0b2d207aab;p=idzebra-moved-to-github.git

diff --git a/index/zrpn.c b/index/zrpn.c
index dea6c98..caccbcd 100644
--- a/index/zrpn.c
+++ b/index/zrpn.c
@@ -1,6 +1,6 @@
-/* $Id: zrpn.c,v 1.152 2004-09-14 14:38:07 quinn Exp $
-   Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003,2004
-   Index Data Aps
+/* $Id: zrpn.c,v 1.173 2005-04-13 13:03:47 adam Exp $
+   Copyright (C) 1995-2005
+   Index Data ApS
 
 This file is part of the Zebra server.
 
@@ -36,8 +36,11 @@ Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
 #include <charmap.h>
 #include <rset.h>
 
+/* maximum number of terms in an and/or/phrase item */
+#define TERM_LIST_LENGTH_MAX 256
 
-static const struct key_control it_ctrl = { 
+static const struct key_control it_ctrl =
+{ 
     sizeof(struct it_key),
     2, /* we have sysnos and seqnos in this key, nothing more */
     key_compare_it, 
@@ -48,12 +51,14 @@ static const struct key_control it_ctrl = {
 
 const struct key_control *key_it_ctrl = &it_ctrl;
 
-struct rpn_char_map_info {
+struct rpn_char_map_info
+{
     ZebraMaps zm;
     int reg_type;
 };
 
-typedef struct {
+typedef struct
+{
     int type;
     int major;
     int minor;
@@ -61,18 +66,21 @@ typedef struct {
 } AttrType;
 
 
-static const char **rpn_char_map_handler (void *vp, const char **from, int len)
+static int log_level_set = 0;
+static int log_level_rpn = 0;
+
+static const char **rpn_char_map_handler(void *vp, const char **from, int len)
 {
     struct rpn_char_map_info *p = (struct rpn_char_map_info *) vp;
-    const char **out = zebra_maps_input (p->zm, p->reg_type, from, len, 0);
+    const char **out = zebra_maps_input(p->zm, p->reg_type, from, len, 0);
 #if 0
     if (out && *out)
     {
         const char *outp = *out;
-        yaz_log (LOG_LOG, "---");
+        yaz_log(YLOG_LOG, "---");
         while (*outp)
         {
-            yaz_log (LOG_LOG, "%02X", *outp);
+            yaz_log(YLOG_LOG, "%02X", *outp);
             outp++;
         }
     }
@@ -80,15 +88,15 @@ static const char **rpn_char_map_handler (void *vp, const char **from, int len)
     return out;
 }
 
-static void rpn_char_map_prepare (struct zebra_register *reg, int reg_type,
+static void rpn_char_map_prepare(struct zebra_register *reg, int reg_type,
                                   struct rpn_char_map_info *map_info)
 {
     map_info->zm = reg->zebra_maps;
     map_info->reg_type = reg_type;
-    dict_grep_cmap (reg->dict, map_info, rpn_char_map_handler);
+    dict_grep_cmap(reg->dict, map_info, rpn_char_map_handler);
 }
 
-static int attr_find_ex (AttrType *src, oid_value *attributeSetP,
+static int attr_find_ex(AttrType *src, oid_value *attributeSetP,
                          const char **string_value)
 {
     int num_attributes;
@@ -109,7 +117,7 @@ static int attr_find_ex (AttrType *src, oid_value *attributeSetP,
                 {
                     oident *attrset;
 
-                    attrset = oid_getentbyoid (element->attributeSet);
+                    attrset = oid_getentbyoid(element->attributeSet);
                     *attributeSetP = attrset->value;
                 }
                 return *element->value.numeric;
@@ -121,7 +129,7 @@ static int attr_find_ex (AttrType *src, oid_value *attributeSetP,
                 {
                     oident *attrset;
                     
-                    attrset = oid_getentbyoid (element->attributeSet);
+                    attrset = oid_getentbyoid(element->attributeSet);
                     *attributeSetP = attrset->value;
                 }
                 if (element->value.complex->list[src->minor]->which ==  
@@ -144,7 +152,7 @@ static int attr_find_ex (AttrType *src, oid_value *attributeSetP,
                 else
                     break;
             default:
-                assert (0);
+                assert(0);
             }
         }
         ++(src->major);
@@ -152,12 +160,12 @@ static int attr_find_ex (AttrType *src, oid_value *attributeSetP,
     return -1;
 }
 
-static int attr_find (AttrType *src, oid_value *attributeSetP)
+static int attr_find(AttrType *src, oid_value *attributeSetP)
 {
-    return attr_find_ex (src, attributeSetP, 0);
+    return attr_find_ex(src, attributeSetP, 0);
 }
 
-static void attr_init (AttrType *src, Z_AttributesPlusTerm *zapt,
+static void attr_init(AttrType *src, Z_AttributesPlusTerm *zapt,
                        int type)
 {
     src->zapt = zapt;
@@ -172,7 +180,7 @@ struct grep_info {
 #ifdef TERM_COUNT        
     int *term_no;        
 #endif        
-    ISAMC_P *isam_p_buf;
+    ISAM_P *isam_p_buf;
     int isam_p_size;        
     int isam_p_indx;
     ZebraHandle zh;
@@ -180,14 +188,14 @@ struct grep_info {
     ZebraSet termset;
 };        
 
-static void term_untrans  (ZebraHandle zh, int reg_type,
+static void term_untrans(ZebraHandle zh, int reg_type,
                            char *dst, const char *src)
 {
     int len = 0;
     while (*src)
     {
-        const char *cp = zebra_maps_output (zh->reg->zebra_maps,
-                                            reg_type, &src);
+        const char *cp = zebra_maps_output(zh->reg->zebra_maps,
+					   reg_type, &src);
         if (!cp && len < IT_MAX_WORD-1)
             dst[len++] = *src++;
         else
@@ -197,40 +205,44 @@ static void term_untrans  (ZebraHandle zh, int reg_type,
     dst[len] = '\0';
 }
 
-static void add_isam_p (const char *name, const char *info,
-                        struct grep_info *p)
+static void add_isam_p(const char *name, const char *info,
+		       struct grep_info *p)
 {
+    if (!log_level_set)
+    {
+        log_level_rpn = yaz_log_module_level("rpn");
+        log_level_set = 1;
+    }
     if (p->isam_p_indx == p->isam_p_size)
     {
-        ISAMC_P *new_isam_p_buf;
+        ISAM_P *new_isam_p_buf;
 #ifdef TERM_COUNT        
         int *new_term_no;        
 #endif
         p->isam_p_size = 2*p->isam_p_size + 100;
-        new_isam_p_buf = (ISAMC_P *) xmalloc (sizeof(*new_isam_p_buf) *
-                                             p->isam_p_size);
+        new_isam_p_buf = (ISAM_P *) xmalloc(sizeof(*new_isam_p_buf) *
+					    p->isam_p_size);
         if (p->isam_p_buf)
         {
-            memcpy (new_isam_p_buf, p->isam_p_buf,
+            memcpy(new_isam_p_buf, p->isam_p_buf,
                     p->isam_p_indx * sizeof(*p->isam_p_buf));
-            xfree (p->isam_p_buf);
+            xfree(p->isam_p_buf);
         }
         p->isam_p_buf = new_isam_p_buf;
 
 #ifdef TERM_COUNT
-        new_term_no = (int *) xmalloc (sizeof(*new_term_no) *
-                                       p->isam_p_size);
+        new_term_no = (int *) xmalloc(sizeof(*new_term_no) * p->isam_p_size);
         if (p->term_no)
         {
-            memcpy (new_term_no, p->isam_p_buf,
+            memcpy(new_term_no, p->isam_p_buf,
                     p->isam_p_indx * sizeof(*p->term_no));
-            xfree (p->term_no);
+            xfree(p->term_no);
         }
         p->term_no = new_term_no;
 #endif
     }
-    assert (*info == sizeof(*p->isam_p_buf));
-    memcpy (p->isam_p_buf + p->isam_p_indx, info+1, sizeof(*p->isam_p_buf));
+    assert(*info == sizeof(*p->isam_p_buf));
+    memcpy(p->isam_p_buf + p->isam_p_indx, info+1, sizeof(*p->isam_p_buf));
 
 #if 1
     if (p->termset)
@@ -242,25 +254,25 @@ static void add_isam_p (const char *name, const char *info,
         int len = key_SU_decode (&su_code, name);
         
         term_untrans  (p->zh, p->reg_type, term_tmp, name+len+1);
-        logf (LOG_LOG, "grep: %d %c %s", su_code, name[len], term_tmp);
+        yaz_log(log_level_rpn, "grep: %d %c %s", su_code, name[len], term_tmp);
         zebraExplain_lookup_ord (p->zh->reg->zei,
                                  su_code, &db, &set, &use);
-        logf (LOG_LOG, "grep:  set=%d use=%d db=%s", set, use, db);
+        yaz_log(log_level_rpn, "grep:  set=%d use=%d db=%s", set, use, db);
         
-        resultSetAddTerm (p->zh, p->termset, name[len], db,
-                          set, use, term_tmp);
+        resultSetAddTerm(p->zh, p->termset, name[len], db,
+			 set, use, term_tmp);
     }
 #endif
     (p->isam_p_indx)++;
 }
 
-static int grep_handle (char *name, const char *info, void *p)
+static int grep_handle(char *name, const char *info, void *p)
 {
-    add_isam_p (name, info, (struct grep_info *) p);
+    add_isam_p(name, info, (struct grep_info *) p);
     return 0;
 }
 
-static int term_pre (ZebraMaps zebra_maps, int reg_type, const char **src,
+static int term_pre(ZebraMaps zebra_maps, int reg_type, const char **src,
                      const char *ct1, const char *ct2, int first)
 {
     const char *s1, *s0 = *src;
@@ -269,12 +281,12 @@ static int term_pre (ZebraMaps zebra_maps, int reg_type, const char **src,
     /* skip white space */
     while (*s0)
     {
-        if (ct1 && strchr (ct1, *s0))
+        if (ct1 && strchr(ct1, *s0))
             break;
-        if (ct2 && strchr (ct2, *s0))
+        if (ct2 && strchr(ct2, *s0))
             break;
         s1 = s0;
-        map = zebra_maps_input (zebra_maps, reg_type, &s1, strlen(s1), first);
+        map = zebra_maps_input(zebra_maps, reg_type, &s1, strlen(s1), first);
         if (**map != *CHR_SPACE)
             break;
         s0 = s1;
@@ -283,14 +295,41 @@ static int term_pre (ZebraMaps zebra_maps, int reg_type, const char **src,
     return *s0;
 }
 
+
+static void esc_str(char *out_buf, int out_size,
+		    const char *in_buf, int in_size)
+{
+    int k;
+
+    assert(out_buf);
+    assert(in_buf);
+    assert(out_size > 20);
+    *out_buf = '\0';
+    for (k = 0; k<in_size; k++)
+    {
+	int c = in_buf[k] & 0xff;
+	int pc;
+	if (c < 32 || c > 126)
+	    pc = '?';
+	else
+	    pc = c;
+	sprintf(out_buf +strlen(out_buf), "%02X:%c  ", c, pc);
+	if (strlen(out_buf) > out_size-20)
+	{
+	    strcat(out_buf, "..");
+	    break;
+	}
+    }
+}
+
 #define REGEX_CHARS " []()|.*+?!"
 
-/* term_100: handle term, where trunc=none (no operators at all) */
-static int term_100 (ZebraMaps zebra_maps, int reg_type,
+/* term_100: handle term, where trunc = none(no operators at all) */
+static int term_100(ZebraMaps zebra_maps, int reg_type,
                      const char **src, char *dst, int space_split,
                      char *dst_term)
 {
-    const char *s0, *s1;
+    const char *s0;
     const char **map;
     int i = 0;
     int j = 0;
@@ -298,13 +337,15 @@ static int term_100 (ZebraMaps zebra_maps, int reg_type,
     const char *space_start = 0;
     const char *space_end = 0;
 
-    if (!term_pre (zebra_maps, reg_type, src, NULL, NULL, !space_split))
+    if (!term_pre(zebra_maps, reg_type, src, NULL, NULL, !space_split))
         return 0;
     s0 = *src;
     while (*s0)
     {
-        s1 = s0;
-        map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0), 0);
+        const char *s1 = s0;
+	int q_map_match = 0;
+        map = zebra_maps_search(zebra_maps, reg_type, &s0, strlen(s0), 
+				&q_map_match);
         if (space_split)
         {
             if (**map == *CHR_SPACE)
@@ -322,7 +363,7 @@ static int term_100 (ZebraMaps zebra_maps, int reg_type,
             {   /* reload last space */
                 while (space_start < space_end)
                 {
-                    if (strchr (REGEX_CHARS, *space_start))
+                    if (strchr(REGEX_CHARS, *space_start))
                         dst[i++] = '\\';
                     dst_term[j++] = *space_start;
                     dst[i++] = *space_start++;
@@ -331,14 +372,26 @@ static int term_100 (ZebraMaps zebra_maps, int reg_type,
                 space_start = space_end = 0;
             }
         }
-        /* add non-space char */
-        while (s1 < s0)
-        {
-            if (strchr(REGEX_CHARS, *s1))
-                dst[i++] = '\\';
-            dst_term[j++] = *s1;
-            dst[i++] = *s1++;
-        }
+	/* add non-space char */
+	memcpy(dst_term+j, s1, s0 - s1);
+	j += (s0 - s1);
+	if (!q_map_match)
+	{
+	    while (s1 < s0)
+	    {
+		if (strchr(REGEX_CHARS, *s1))
+		    dst[i++] = '\\';
+		dst[i++] = *s1++;
+	    }
+	}
+	else
+	{
+	    char tmpbuf[80];
+	    esc_str(tmpbuf, sizeof(tmpbuf), map[0], strlen(map[0]));
+	    
+	    strcpy(dst + i, map[0]);
+	    i += strlen(map[0]);
+	}
     }
     dst[i] = '\0';
     dst_term[j] = '\0';
@@ -346,17 +399,17 @@ static int term_100 (ZebraMaps zebra_maps, int reg_type,
     return i;
 }
 
-/* term_101: handle term, where trunc=Process # */
-static int term_101 (ZebraMaps zebra_maps, int reg_type,
+/* term_101: handle term, where trunc = Process # */
+static int term_101(ZebraMaps zebra_maps, int reg_type,
                      const char **src, char *dst, int space_split,
                      char *dst_term)
 {
-    const char *s0, *s1;
+    const char *s0;
     const char **map;
     int i = 0;
     int j = 0;
 
-    if (!term_pre (zebra_maps, reg_type, src, "#", "#", !space_split))
+    if (!term_pre(zebra_maps, reg_type, src, "#", "#", !space_split))
         return 0;
     s0 = *src;
     while (*s0)
@@ -369,17 +422,33 @@ static int term_101 (ZebraMaps zebra_maps, int reg_type,
         }
         else
         {
-            s1 = s0;
-            map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0), 0);
+	    const char *s1 = s0;
+	    int q_map_match = 0;
+	    map = zebra_maps_search(zebra_maps, reg_type, &s0, strlen(s0), 
+				    &q_map_match);
             if (space_split && **map == *CHR_SPACE)
                 break;
-            while (s1 < s0)
-            {
-                if (strchr(REGEX_CHARS, *s1))
-                    dst[i++] = '\\';
-                dst_term[j++] = *s1;
-                dst[i++] = *s1++;
-            }
+
+	    /* add non-space char */
+	    memcpy(dst_term+j, s1, s0 - s1);
+	    j += (s0 - s1);
+	    if (!q_map_match)
+	    {
+		while (s1 < s0)
+		{
+		    if (strchr(REGEX_CHARS, *s1))
+			dst[i++] = '\\';
+		    dst[i++] = *s1++;
+		}
+	    }
+	    else
+	    {
+		char tmpbuf[80];
+		esc_str(tmpbuf, sizeof(tmpbuf), map[0], strlen(map[0]));
+		
+		strcpy(dst + i, map[0]);
+		i += strlen(map[0]);
+	    }
         }
     }
     dst[i] = '\0';
@@ -388,21 +457,21 @@ static int term_101 (ZebraMaps zebra_maps, int reg_type,
     return i;
 }
 
-/* term_103: handle term, where trunc=re-2 (regular expressions) */
-static int term_103 (ZebraMaps zebra_maps, int reg_type, const char **src,
+/* term_103: handle term, where trunc = re-2 (regular expressions) */
+static int term_103(ZebraMaps zebra_maps, int reg_type, const char **src,
                      char *dst, int *errors, int space_split,
                      char *dst_term)
 {
     int i = 0;
     int j = 0;
-    const char *s0, *s1;
+    const char *s0;
     const char **map;
 
-    if (!term_pre (zebra_maps, reg_type, src, "^\\()[].*+?|", "(", !space_split))
+    if (!term_pre(zebra_maps, reg_type, src, "^\\()[].*+?|", "(", !space_split))
         return 0;
     s0 = *src;
     if (errors && *s0 == '+' && s0[1] && s0[2] == '+' && s0[3] &&
-        isdigit (s0[1]))
+        isdigit(((const unsigned char *)s0)[1]))
     {
         *errors = s0[1] - '0';
         s0 += 3;
@@ -411,43 +480,60 @@ static int term_103 (ZebraMaps zebra_maps, int reg_type, const char **src,
     }
     while (*s0)
     {
-        if (strchr ("^\\()[].*+?|-", *s0))
+        if (strchr("^\\()[].*+?|-", *s0))
         {
             dst_term[j++] = *s0;
             dst[i++] = *s0++;
         }
         else
         {
-            s1 = s0;
-            map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0), 0);
-            if (**map == *CHR_SPACE)
+	    const char *s1 = s0;
+	    int q_map_match = 0;
+	    map = zebra_maps_search(zebra_maps, reg_type, &s0, strlen(s0), 
+				    &q_map_match);
+            if (space_split && **map == *CHR_SPACE)
                 break;
-            while (s1 < s0)
-            {
-                if (strchr(REGEX_CHARS, *s1))
-                    dst[i++] = '\\';
-                dst_term[j++] = *s1;
-                dst[i++] = *s1++;
-            }
+
+	    /* add non-space char */
+	    memcpy(dst_term+j, s1, s0 - s1);
+	    j += (s0 - s1);
+	    if (!q_map_match)
+	    {
+		while (s1 < s0)
+		{
+		    if (strchr(REGEX_CHARS, *s1))
+			dst[i++] = '\\';
+		    dst[i++] = *s1++;
+		}
+	    }
+	    else
+	    {
+		char tmpbuf[80];
+		esc_str(tmpbuf, sizeof(tmpbuf), map[0], strlen(map[0]));
+		
+		strcpy(dst + i, map[0]);
+		i += strlen(map[0]);
+	    }
         }
     }
     dst[i] = '\0';
     dst_term[j] = '\0';
     *src = s0;
+    
     return i;
 }
 
-/* term_103: handle term, where trunc=re-1 (regular expressions) */
+/* term_103: handle term, where trunc = re-1 (regular expressions) */
 static int term_102 (ZebraMaps zebra_maps, int reg_type, const char **src,
                      char *dst, int space_split, char *dst_term)
 {
-    return term_103 (zebra_maps, reg_type, src, dst, NULL, space_split,
+    return term_103(zebra_maps, reg_type, src, dst, NULL, space_split,
                      dst_term);
 }
 
 
-/* term_104: handle term, where trunc=Process # and ! */
-static int term_104 (ZebraMaps zebra_maps, int reg_type,
+/* term_104: handle term, where trunc = Process # and ! */
+static int term_104(ZebraMaps zebra_maps, int reg_type,
                      const char **src, char *dst, int space_split,
                      char *dst_term)
 {
@@ -456,7 +542,7 @@ static int term_104 (ZebraMaps zebra_maps, int reg_type,
     int i = 0;
     int j = 0;
 
-    if (!term_pre (zebra_maps, reg_type, src, "?*#", "?*#", !space_split))
+    if (!term_pre(zebra_maps, reg_type, src, "?*#", "?*#", !space_split))
         return 0;
     s0 = *src;
     while (*s0)
@@ -497,9 +583,10 @@ static int term_104 (ZebraMaps zebra_maps, int reg_type,
             dst[i++] = '.';
             dst_term[j++] = *s0++;
         }
+	else
         {
             s1 = s0;
-            map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0), 0);
+            map = zebra_maps_input(zebra_maps, reg_type, &s0, strlen(s0), 0);
             if (space_split && **map == *CHR_SPACE)
                 break;
             while (s1 < s0)
@@ -517,7 +604,7 @@ static int term_104 (ZebraMaps zebra_maps, int reg_type,
     return i;
 }
 
-/* term_105/106: handle term, where trunc=Process * and ! and right trunc */
+/* term_105/106: handle term, where trunc = Process * and ! and right trunc */
 static int term_105 (ZebraMaps zebra_maps, int reg_type,
                      const char **src, char *dst, int space_split,
                      char *dst_term, int right_truncate)
@@ -527,7 +614,7 @@ static int term_105 (ZebraMaps zebra_maps, int reg_type,
     int i = 0;
     int j = 0;
 
-    if (!term_pre (zebra_maps, reg_type, src, "*!", "*!", !space_split))
+    if (!term_pre(zebra_maps, reg_type, src, "*!", "*!", !space_split))
         return 0;
     s0 = *src;
     while (*s0)
@@ -543,9 +630,10 @@ static int term_105 (ZebraMaps zebra_maps, int reg_type,
             dst[i++] = '.';
             dst_term[j++] = *s0++;
         }
+	else
         {
             s1 = s0;
-            map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0), 0);
+            map = zebra_maps_input(zebra_maps, reg_type, &s0, strlen(s0), 0);
             if (space_split && **map == *CHR_SPACE)
                 break;
             while (s1 < s0)
@@ -574,38 +662,38 @@ static int term_105 (ZebraMaps zebra_maps, int reg_type,
  *  val:     border value (inclusive)
  *  islt:    1 if <=; 0 if >=.
  */
-static void gen_regular_rel (char *dst, int val, int islt)
+static void gen_regular_rel(char *dst, int val, int islt)
 {
     int dst_p;
     int w, d, i;
     int pos = 0;
     char numstr[20];
 
-    logf (LOG_DEBUG, "gen_regular_rel. val=%d, islt=%d", val, islt);
+    yaz_log(YLOG_DEBUG, "gen_regular_rel. val=%d, islt=%d", val, islt);
     if (val >= 0)
     {
         if (islt)
-            strcpy (dst, "(-[0-9]+|(");
+            strcpy(dst, "(-[0-9]+|(");
         else
-            strcpy (dst, "((");
+            strcpy(dst, "((");
     } 
     else
     {
         if (!islt)
         {
-            strcpy (dst, "([0-9]+|-(");
-            dst_p = strlen (dst);
+            strcpy(dst, "([0-9]+|-(");
+            dst_p = strlen(dst);
             islt = 1;
         }
         else
         {
-            strcpy (dst, "(-(");
+            strcpy(dst, "(-(");
             islt = 0;
         }
         val = -val;
     }
-    dst_p = strlen (dst);
-    sprintf (numstr, "%d", val);
+    dst_p = strlen(dst);
+    sprintf(numstr, "%d", val);
     for (w = strlen(numstr); --w >= 0; pos++)
     {
         d = numstr[w];
@@ -625,7 +713,7 @@ static void gen_regular_rel (char *dst, int val, int islt)
             }
         }
         
-        strcpy (dst + dst_p, numstr);
+        strcpy(dst + dst_p, numstr);
         dst_p = strlen(dst) - pos - 1;
 
         if (islt)
@@ -668,21 +756,21 @@ static void gen_regular_rel (char *dst, int val, int islt)
     if (islt)
     {
         /* match everything less than 10^(pos-1) */
-        strcat (dst, "0*");
-        for (i=1; i<pos; i++)
-            strcat (dst, "[0-9]?");
+        strcat(dst, "0*");
+        for (i = 1; i<pos; i++)
+            strcat(dst, "[0-9]?");
     }
     else
     {
         /* match everything greater than 10^pos */
         for (i = 0; i <= pos; i++)
-            strcat (dst, "[0-9]");
-        strcat (dst, "[0-9]*");
+            strcat(dst, "[0-9]");
+        strcat(dst, "[0-9]*");
     }
-    strcat (dst, "))");
+    strcat(dst, "))");
 }
 
-void string_rel_add_char (char **term_p, const char *src, int *indx)
+void string_rel_add_char(char **term_p, const char *src, int *indx)
 {
     if (src[*indx] == '\\')
         *(*term_p)++ = src[(*indx)++];
@@ -699,7 +787,7 @@ void string_rel_add_char (char **term_p, const char *src, int *indx)
  *   <= abc     ([-0].*|a[-a].*|ab[-b].*|abc)
  *              ([^a-].*|a[^b-].*|ab[^c-].*|abc)
  */
-static int string_relation (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
+static int string_relation(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
                             const char **term_sub, char *term_dict,
                             oid_value attributeSet,
                             int reg_type, int space_split, char *term_dst)
@@ -710,10 +798,10 @@ static int string_relation (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
     char *term_tmp = term_dict + strlen(term_dict);
     char term_component[2*IT_MAX_WORD+20];
 
-    attr_init (&relation, zapt, 2);
-    relation_value = attr_find (&relation, NULL);
+    attr_init(&relation, zapt, 2);
+    relation_value = attr_find(&relation, NULL);
 
-    logf (LOG_DEBUG, "string relation value=%d", relation_value);
+    yaz_log(YLOG_DEBUG, "string relation value=%d", relation_value);
     switch (relation_value)
     {
     case 1:
@@ -721,7 +809,7 @@ static int string_relation (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
                        term_sub, term_component,
                        space_split, term_dst))
             return 0;
-        logf (LOG_DEBUG, "Relation <");
+        yaz_log(log_level_rpn, "Relation <");
         
         *term_tmp++ = '(';
         for (i = 0; term_component[i]; )
@@ -754,7 +842,7 @@ static int string_relation (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
                        term_sub, term_component,
                        space_split, term_dst))
             return 0;
-        logf (LOG_DEBUG, "Relation <=");
+        yaz_log(log_level_rpn, "Relation <=");
 
         *term_tmp++ = '(';
         for (i = 0; term_component[i]; )
@@ -787,7 +875,7 @@ static int string_relation (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
         if (!term_100 (zh->reg->zebra_maps, reg_type,
                        term_sub, term_component, space_split, term_dst))
             return 0;
-        logf (LOG_DEBUG, "Relation >");
+        yaz_log(log_level_rpn, "Relation >");
 
         *term_tmp++ = '(';
         for (i = 0; term_component[i];)
@@ -822,7 +910,7 @@ static int string_relation (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
         if (!term_100 (zh->reg->zebra_maps, reg_type, term_sub,
                        term_component, space_split, term_dst))
             return 0;
-        logf (LOG_DEBUG, "Relation >=");
+        yaz_log(log_level_rpn, "Relation >=");
 
         *term_tmp++ = '(';
         for (i = 0; term_component[i];)
@@ -858,18 +946,18 @@ static int string_relation (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
         break;
     case 3:
     default:
-        logf (LOG_DEBUG, "Relation =");
+        yaz_log(log_level_rpn, "Relation =");
         if (!term_100 (zh->reg->zebra_maps, reg_type, term_sub,
                        term_component, space_split, term_dst))
             return 0;
-        strcat (term_tmp, "(");
-        strcat (term_tmp, term_component);
-        strcat (term_tmp, ")");
+        strcat(term_tmp, "(");
+        strcat(term_tmp, term_component);
+        strcat(term_tmp, ")");
     }
     return 1;
 }
 
-static int string_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
+static int string_term(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
                         const char **term_sub, 
                         oid_value attributeSet, NMEM stream,
                         struct grep_info *grep_info,
@@ -877,7 +965,7 @@ static int string_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
                         int num_bases, char **basenames,
                         char *term_dst, int xpath_use);
 
-static RSET term_trunc (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
+static RSET term_trunc(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
                         const char **term_sub, 
                         oid_value attributeSet, NMEM stream,
                         struct grep_info *grep_info,
@@ -889,27 +977,32 @@ static RSET term_trunc (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
 {
     int r;
     grep_info->isam_p_indx = 0;
-    r = string_term (zh, zapt, term_sub, attributeSet, stream, grep_info,
+    r = string_term(zh, zapt, term_sub, attributeSet, stream, grep_info,
                      reg_type, complete_flag, num_bases, basenames,
                      term_dst, xpath_use);
     if (r < 1)
         return 0;
-    logf (LOG_DEBUG, "term: %s", term_dst);
-    return rset_trunc (zh, grep_info->isam_p_buf,
+    yaz_log(log_level_rpn, "term: %s", term_dst);
+    return rset_trunc(zh, grep_info->isam_p_buf,
                        grep_info->isam_p_indx, term_dst,
                        strlen(term_dst), rank_type, 1 /* preserve pos */,
                        zapt->term->which, rset_nmem,
                        key_it_ctrl,key_it_ctrl->scope);
 }
+static char *nmem_strdup_i(NMEM nmem, int v)
+{
+    char val_str[64];
+    sprintf (val_str, "%d", v);
+    return nmem_strdup(nmem, val_str);
+}
 
-
-static int string_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
-                        const char **term_sub, 
-                        oid_value attributeSet, NMEM stream,
-                        struct grep_info *grep_info,
-                        int reg_type, int complete_flag,
-                        int num_bases, char **basenames,
-                        char *term_dst, int xpath_use)
+static int string_term(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
+		       const char **term_sub, 
+		       oid_value attributeSet, NMEM stream,
+		       struct grep_info *grep_info,
+		       int reg_type, int complete_flag,
+		       int num_bases, char **basenames,
+		       char *term_dst, int xpath_use)
 {
     char term_dict[2*IT_MAX_WORD+4000];
     int j, r, base_no;
@@ -930,15 +1023,19 @@ static int string_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
     rpn_char_map_prepare (zh->reg, reg_type, &rcmi);
     attr_init (&use, zapt, 1);
     use_value = attr_find_ex (&use, &curAttributeSet, &use_string);
-    logf (LOG_DEBUG, "string_term, use value %d", use_value);
+    yaz_log(log_level_rpn, "string_term, use value %d", use_value);
     attr_init (&truncation, zapt, 5);
     truncation_value = attr_find (&truncation, NULL);
-    logf (LOG_DEBUG, "truncation value %d", truncation_value);
+    yaz_log(log_level_rpn, "truncation value %d", truncation_value);
 
     if (use_value == -1)    /* no attribute - assumy "any" */
         use_value = 1016;
     for (base_no = 0; base_no < num_bases; base_no++)
     {
+	int ord = -1;
+	int attr_ok = 0;
+	int regex_range = 0;
+	int init_pos = 0;
         attent attp;
         data1_local_attribute id_xpath_attr;
         data1_local_attribute *local_attr;
@@ -954,25 +1051,50 @@ static int string_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
         }
         if (xpath_use > 0 && use_value == -2) 
         {
-            use_value = xpath_use;
+	    /* xpath mode and we have a string attribute */
             attp.local_attributes = &id_xpath_attr;
             attp.attset_ordinal = VAL_IDXPATH;
             id_xpath_attr.next = 0;
+
+            use_value = xpath_use;  /* xpath_use as use-attribute now */
             id_xpath_attr.local = use_value;
         }
-        else if (curAttributeSet == VAL_IDXPATH)
+        else if (curAttributeSet == VAL_IDXPATH && use_value >= 0)
         {
+	    /* X-Path attribute, use numeric value directly */
             attp.local_attributes = &id_xpath_attr;
             attp.attset_ordinal = VAL_IDXPATH;
             id_xpath_attr.next = 0;
             id_xpath_attr.local = use_value;
         }
-        else
+	else if (use_string &&
+		 (ord = zebraExplain_lookup_attr_str(zh->reg->zei,
+						     use_string)) >= 0)
+	{
+	    /* we have a match for a raw string attribute */
+            char ord_buf[32];
+            int i, ord_len;
+
+            if (prefix_len)
+                term_dict[prefix_len++] = '|';
+            else
+                term_dict[prefix_len++] = '(';
+            
+            ord_len = key_SU_encode (ord, ord_buf);
+            for (i = 0; i<ord_len; i++)
+            {
+                term_dict[prefix_len++] = 1;
+                term_dict[prefix_len++] = ord_buf[i];
+            }
+            attp.local_attributes = 0;  /* no more attributes */
+	}
+        else 
         {
-            if ((r=att_getentbyatt (zh, &attp, curAttributeSet, use_value,
-                                            use_string)))
+	    /* lookup in the .att files . Allow string as well */
+            if ((r = att_getentbyatt (zh, &attp, curAttributeSet, use_value,
+				      use_string)))
             {
-                logf (LOG_DEBUG, "att_getentbyatt fail. set=%d use=%d r=%d",
+                yaz_log(YLOG_DEBUG, "att_getentbyatt fail. set=%d use=%d r=%d",
                       curAttributeSet, use_value, r);
                 if (r == -1)
                 {
@@ -981,11 +1103,7 @@ static int string_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
                     if (use_string)
                         errString = nmem_strdup(stream, use_string);
                     else
-                    {
-                        char val_str[32];
-                        sprintf (val_str, "%d", use_value);
-                        errString = nmem_strdup (stream, val_str);
-                    }
+                        errString = nmem_strdup_i (stream, use_value);
                 }
                 else
                 {
@@ -1003,47 +1121,49 @@ static int string_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
                 continue;
             }
         }
-        for (local_attr = attp.local_attributes; local_attr;
-             local_attr = local_attr->next)
-        {
-            int ord;
-            char ord_buf[32];
-            int i, ord_len;
-            
-            ord = zebraExplain_lookupSU (zh->reg->zei, attp.attset_ordinal,
-                                         local_attr->local);
-            if (ord < 0)
-                continue;
-            if (prefix_len)
-                term_dict[prefix_len++] = '|';
-            else
-                term_dict[prefix_len++] = '(';
-            
-            ord_len = key_SU_encode (ord, ord_buf);
-            for (i = 0; i<ord_len; i++)
-            {
-                term_dict[prefix_len++] = 1;
-                term_dict[prefix_len++] = ord_buf[i];
-            }
-        }
+	for (local_attr = attp.local_attributes; local_attr;
+	     local_attr = local_attr->next)
+	{
+	    char ord_buf[32];
+	    int i, ord_len;
+	    
+	    ord = zebraExplain_lookup_attr_su(zh->reg->zei,
+					      attp.attset_ordinal,
+					      local_attr->local);
+	    if (ord < 0)
+		continue;
+	    if (prefix_len)
+		term_dict[prefix_len++] = '|';
+	    else
+		term_dict[prefix_len++] = '(';
+	    
+	    ord_len = key_SU_encode (ord, ord_buf);
+	    for (i = 0; i<ord_len; i++)
+	    {
+		term_dict[prefix_len++] = 1;
+		term_dict[prefix_len++] = ord_buf[i];
+	    }
+	}
         if (!prefix_len)
         {
 #if 1
             bases_ok++;
 #else
-            char val_str[32];
-            sprintf (val_str, "%d", use_value);
             errCode = 114;
-            errString = nmem_strdup (stream, val_str);
-#endif
+            errString = nmem_strdup_i(stream, use_value);
             continue;
+#endif
         }
-        bases_ok++; /* this has OK attributes */
+	else
+	{
+	    bases_ok++; /* this has OK attributes */
+	    attr_ok = 1;
+	}
 
         term_dict[prefix_len++] = ')';
         term_dict[prefix_len++] = 1;
         term_dict[prefix_len++] = reg_type;
-        logf (LOG_DEBUG, "reg_type = %d", term_dict[prefix_len-1]);
+        yaz_log(log_level_rpn, "reg_type = %d", term_dict[prefix_len-1]);
         term_dict[prefix_len] = '\0';
         j = prefix_len;
         switch (truncation_value)
@@ -1054,113 +1174,92 @@ static int string_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
                                   attributeSet,
                                   reg_type, space_split, term_dst))
                 return 0;
-            logf (LOG_DEBUG, "dict_lookup_grep: %s", term_dict+prefix_len);
-            r = dict_lookup_grep (zh->reg->dict, term_dict, 0,
-                                  grep_info, &max_pos, 0, grep_handle);
-            if (r)
-                logf (LOG_WARN, "dict_lookup_grep fail %d", r);
-            break;
+	    break;
         case 1:          /* right truncation */
             term_dict[j++] = '(';
-            if (!term_100 (zh->reg->zebra_maps, reg_type,
-                           &termp, term_dict + j, space_split, term_dst))
+            if (!term_100(zh->reg->zebra_maps, reg_type,
+			  &termp, term_dict + j, space_split, term_dst))
                 return 0;
-            strcat (term_dict, ".*)");
-            dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info,
-                              &max_pos, 0, grep_handle);
+            strcat(term_dict, ".*)");
             break;
         case 2:          /* keft truncation */
             term_dict[j++] = '('; term_dict[j++] = '.'; term_dict[j++] = '*';
-            if (!term_100 (zh->reg->zebra_maps, reg_type,
-                           &termp, term_dict + j, space_split, term_dst))
+            if (!term_100(zh->reg->zebra_maps, reg_type,
+			  &termp, term_dict + j, space_split, term_dst))
                 return 0;
-            strcat (term_dict, ")");
-            dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info,
-                              &max_pos, 0, grep_handle);
+            strcat(term_dict, ")");
             break;
         case 3:          /* left&right truncation */
             term_dict[j++] = '('; term_dict[j++] = '.'; term_dict[j++] = '*';
-            if (!term_100 (zh->reg->zebra_maps, reg_type,
-                           &termp, term_dict + j, space_split, term_dst))
+            if (!term_100(zh->reg->zebra_maps, reg_type,
+			  &termp, term_dict + j, space_split, term_dst))
                 return 0;
-            strcat (term_dict, ".*)");
-            dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info,
-                              &max_pos, 0, grep_handle);
+            strcat(term_dict, ".*)");
             break;
-            zh->errCode = 120;
-            return -1;
         case 101:        /* process # in term */
             term_dict[j++] = '(';
-            if (!term_101 (zh->reg->zebra_maps, reg_type,
-                           &termp, term_dict + j, space_split, term_dst))
+            if (!term_101(zh->reg->zebra_maps, reg_type,
+			  &termp, term_dict + j, space_split, term_dst))
                 return 0;
-            strcat (term_dict, ")");
-            r = dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info,
-                                  &max_pos, 0, grep_handle);
-            if (r)
-                logf (LOG_WARN, "dict_lookup_grep err, trunc=#: %d", r);
+            strcat(term_dict, ")");
             break;
         case 102:        /* Regexp-1 */
             term_dict[j++] = '(';
-            if (!term_102 (zh->reg->zebra_maps, reg_type,
-                           &termp, term_dict + j, space_split, term_dst))
+            if (!term_102(zh->reg->zebra_maps, reg_type,
+			  &termp, term_dict + j, space_split, term_dst))
                 return 0;
-            strcat (term_dict, ")");
-            logf (LOG_DEBUG, "Regexp-1 tolerance=%d", r);
-            r = dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info,
-                                  &max_pos, 0, grep_handle);
-            if (r)
-                logf (LOG_WARN, "dict_lookup_grep err, trunc=regular: %d",
-                      r);
+            strcat(term_dict, ")");
             break;
         case 103:       /* Regexp-2 */
             r = 1;
             term_dict[j++] = '(';
+	    init_pos = 2;
             if (!term_103 (zh->reg->zebra_maps, reg_type,
-                           &termp, term_dict + j, &r, space_split, term_dst))
+                           &termp, term_dict + j, &regex_range,
+			   space_split, term_dst))
                 return 0;
-            strcat (term_dict, ")");
-            logf (LOG_DEBUG, "Regexp-2 tolerance=%d", r);
-            r = dict_lookup_grep (zh->reg->dict, term_dict, r, grep_info,
-                                  &max_pos, 2, grep_handle);
-            if (r)
-                logf (LOG_WARN, "dict_lookup_grep err, trunc=eregular: %d",
-                      r);
-            break;
+            strcat(term_dict, ")");
         case 104:        /* process # and ! in term */
             term_dict[j++] = '(';
             if (!term_104 (zh->reg->zebra_maps, reg_type,
                            &termp, term_dict + j, space_split, term_dst))
                 return 0;
-            strcat (term_dict, ")");
-            r = dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info,
-                                  &max_pos, 0, grep_handle);
-            if (r)
-                logf (LOG_WARN, "dict_lookup_grep err, trunc=#/!: %d", r);
+            strcat(term_dict, ")");
             break;
         case 105:        /* process * and ! in term */
             term_dict[j++] = '(';
             if (!term_105 (zh->reg->zebra_maps, reg_type,
                            &termp, term_dict + j, space_split, term_dst, 1))
                 return 0;
-            strcat (term_dict, ")");
-            r = dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info,
-                                  &max_pos, 0, grep_handle);
-            if (r)
-                logf (LOG_WARN, "dict_lookup_grep err, trunc=*/!: %d", r);
+            strcat(term_dict, ")");
             break;
         case 106:        /* process * and ! in term */
             term_dict[j++] = '(';
             if (!term_105 (zh->reg->zebra_maps, reg_type,
                            &termp, term_dict + j, space_split, term_dst, 0))
                 return 0;
-            strcat (term_dict, ")");
-            r = dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info,
-                                  &max_pos, 0, grep_handle);
-            if (r)
-                logf (LOG_WARN, "dict_lookup_grep err, trunc=*/!: %d", r);
+            strcat(term_dict, ")");
             break;
-        }
+	default:
+	    zh->errCode = 120;
+	    zh->errString = nmem_strdup_i(stream, truncation_value);
+	    return -1;
+        }
+	if (attr_ok)
+	{
+	    char buf[80];
+	    const char *input = term_dict + prefix_len;
+	    esc_str(buf, sizeof(buf), input, strlen(input));
+	}
+	if (attr_ok)
+	{
+	    yaz_log(log_level_rpn, "dict_lookup_grep: %s", term_dict+prefix_len);
+	    r = dict_lookup_grep(zh->reg->dict, term_dict, regex_range,
+				 grep_info, &max_pos, init_pos,
+				 grep_handle);
+	    if (r)
+		yaz_log(YLOG_WARN, "dict_lookup_grep fail %d", r);
+	}
     }
     if (!bases_ok)
     {
@@ -1169,7 +1268,7 @@ static int string_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
         return -1;
     }
     *term_sub = termp;
-    logf (LOG_DEBUG, "%d positions", grep_info->isam_p_indx);
+    yaz_log(YLOG_DEBUG, "%d positions", grep_info->isam_p_indx);
     return 1;
 }
 
@@ -1226,7 +1325,7 @@ static int zapt_term_to_utf8 (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
 }
 
 /* convert APT SCAN term to internal cmap */
-static int trans_scan_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
+static int trans_scan_term(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
                             char *termz, int reg_type)
 {
     char termz0[IT_MAX_WORD];
@@ -1300,7 +1399,7 @@ char *normalize_term(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
         return nmem_strdup(stream, termz);
     else
     {
-        char *buf = (char*) nmem_malloc (stream, wrbuf_len(wrbuf)+1);
+        char *buf = (char*) nmem_malloc(stream, wrbuf_len(wrbuf)+1);
         memcpy (buf, wrbuf_buf(wrbuf), wrbuf_len(wrbuf));
         buf[wrbuf_len(wrbuf)] = '\0';
         return buf;
@@ -1351,7 +1450,7 @@ static int grep_info_prepare (ZebraHandle zh,
         }
         else
             termset_name = termset_value_string;
-        logf (LOG_LOG, "creating termset set %s", termset_name);
+        yaz_log(log_level_rpn, "creating termset set %s", termset_name);
         grep_info->termset = resultSetAdd (zh, termset_name, 1);
         if (!grep_info->termset)
         {
@@ -1375,8 +1474,8 @@ static RSET rpn_search_APT_phrase (ZebraHandle zh,
                                    NMEM rset_nmem)
 {
     char term_dst[IT_MAX_WORD+1];
-    RSET rset[60], result;
-    int rset_no = 0;
+    RSET rset[TERM_LIST_LENGTH_MAX], result;
+    size_t rset_no = 0;
     struct grep_info grep_info;
     char *termz = normalize_term(zh, zapt, termz_org, stream, reg_type);
     const char *termp = termz;
@@ -1384,10 +1483,10 @@ static RSET rpn_search_APT_phrase (ZebraHandle zh,
     *term_dst = 0;
     if (grep_info_prepare (zh, zapt, &grep_info, reg_type, stream))
         return 0;
-    while (1)
+    for (; rset_no < sizeof(rset)/sizeof(*rset); rset_no++)
     { 
-        logf (LOG_DEBUG, "APT_phrase termp=%s", termp);
-        rset[rset_no] = term_trunc (zh, zapt, &termp, attributeSet,
+        yaz_log(log_level_rpn, "APT_phrase termp=%s", termp);
+        rset[rset_no] = term_trunc(zh, zapt, &termp, attributeSet,
                                     stream, &grep_info,
                                     reg_type, complete_flag,
                                     num_bases, basenames,
@@ -1395,8 +1494,6 @@ static RSET rpn_search_APT_phrase (ZebraHandle zh,
                                     xpath_use,rset_nmem);
         if (!rset[rset_no])
             break;
-        if (++rset_no >= (int) (sizeof(rset)/sizeof(*rset)))
-            break;
     }
     grep_info_delete (&grep_info);
     if (rset_no == 0)
@@ -1423,18 +1520,18 @@ static RSET rpn_search_APT_or_list (ZebraHandle zh,
                                     NMEM rset_nmem)
 {
     char term_dst[IT_MAX_WORD+1];
-    RSET rset[60];
-    int rset_no = 0;
+    RSET rset[TERM_LIST_LENGTH_MAX];
+    size_t rset_no = 0;
     struct grep_info grep_info;
     char *termz = normalize_term(zh, zapt, termz_org, stream, reg_type);
     const char *termp = termz;
 
     if (grep_info_prepare (zh, zapt, &grep_info, reg_type, stream))
         return 0;
-    while (1)
+    for (; rset_no < sizeof(rset)/sizeof(*rset); rset_no++)
     { 
-        logf (LOG_DEBUG, "APT_or_list termp=%s", termp);
-        rset[rset_no] = term_trunc (zh, zapt, &termp, attributeSet,
+        yaz_log(log_level_rpn, "APT_or_list termp=%s", termp);
+        rset[rset_no] = term_trunc(zh, zapt, &termp, attributeSet,
                                     stream, &grep_info,
                                     reg_type, complete_flag,
                                     num_bases, basenames,
@@ -1442,14 +1539,12 @@ static RSET rpn_search_APT_or_list (ZebraHandle zh,
                                     xpath_use,rset_nmem);
         if (!rset[rset_no])
             break;
-        if (++rset_no >= (int) (sizeof(rset)/sizeof(*rset)))
-            break;
     }
     grep_info_delete (&grep_info);
     if (rset_no == 0)
         return rsnull_create (rset_nmem,key_it_ctrl);  
-    return rsmultior_create(rset_nmem, key_it_ctrl,key_it_ctrl->scope,
-                            rset_no, rset);
+    return rsmulti_or_create(rset_nmem, key_it_ctrl,key_it_ctrl->scope,
+			     rset_no, rset);
 }
 
 static RSET rpn_search_APT_and_list (ZebraHandle zh,
@@ -1464,18 +1559,18 @@ static RSET rpn_search_APT_and_list (ZebraHandle zh,
                                      NMEM rset_nmem)
 {
     char term_dst[IT_MAX_WORD+1];
-    RSET rset[60], result;
-    int i, rset_no = 0;
+    RSET rset[TERM_LIST_LENGTH_MAX];
+    size_t rset_no = 0;
     struct grep_info grep_info;
     char *termz = normalize_term(zh, zapt, termz_org, stream, reg_type);
     const char *termp = termz;
 
     if (grep_info_prepare (zh, zapt, &grep_info, reg_type, stream))
         return 0;
-    while (1)
+    for (; rset_no < sizeof(rset)/sizeof(*rset); rset_no++)
     { 
-        logf (LOG_DEBUG, "APT_and_list termp=%s", termp);
-        rset[rset_no] = term_trunc (zh, zapt, &termp, attributeSet,
+        yaz_log(log_level_rpn, "APT_and_list termp=%s", termp);
+        rset[rset_no] = term_trunc(zh, zapt, &termp, attributeSet,
                                     stream, &grep_info,
                                     reg_type, complete_flag,
                                     num_bases, basenames,
@@ -1483,19 +1578,13 @@ static RSET rpn_search_APT_and_list (ZebraHandle zh,
                                     xpath_use, rset_nmem);
         if (!rset[rset_no])
             break;
-        assert (rset[rset_no]);
-        if (++rset_no >= (int) (sizeof(rset)/sizeof(*rset)))
-            break;
     }
     grep_info_delete (&grep_info);
     if (rset_no == 0)
-        return rsnull_create (rset_nmem,key_it_ctrl); 
-    result = rset[0];
-    /* FIXME - Use a proper rsmultiand */
-    for (i = 1; i<rset_no; i++)
-        result= rsbool_create_and(rset_nmem,key_it_ctrl,key_it_ctrl->scope,
-                result, rset[i] );
-    return result;
+        return rsnull_create(rset_nmem,key_it_ctrl); 
+    
+    return rsmulti_and_create(rset_nmem, key_it_ctrl, key_it_ctrl->scope,
+			      rset_no, rset);
 }
 
 static int numeric_relation (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
@@ -1516,7 +1605,7 @@ static int numeric_relation (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
     attr_init (&relation, zapt, 2);
     relation_value = attr_find (&relation, NULL);
 
-    logf (LOG_DEBUG, "numeric relation value=%d", relation_value);
+    yaz_log(log_level_rpn, "numeric relation value=%d", relation_value);
 
     if (!term_100 (zh->reg->zebra_maps, reg_type, term_sub, term_tmp, 1,
                    term_dst))
@@ -1525,36 +1614,36 @@ static int numeric_relation (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
     switch (relation_value)
     {
     case 1:
-        logf (LOG_DEBUG, "Relation <");
+        yaz_log(log_level_rpn, "Relation <");
         gen_regular_rel (term_tmp, term_value-1, 1);
         break;
     case 2:
-        logf (LOG_DEBUG, "Relation <=");
+        yaz_log(log_level_rpn, "Relation <=");
         gen_regular_rel (term_tmp, term_value, 1);
         break;
     case 4:
-        logf (LOG_DEBUG, "Relation >=");
+        yaz_log(log_level_rpn, "Relation >=");
         gen_regular_rel (term_tmp, term_value, 0);
         break;
     case 5:
-        logf (LOG_DEBUG, "Relation >");
+        yaz_log(log_level_rpn, "Relation >");
         gen_regular_rel (term_tmp, term_value+1, 0);
         break;
     case 3:
     default:
-        logf (LOG_DEBUG, "Relation =");
+        yaz_log(log_level_rpn, "Relation =");
         sprintf (term_tmp, "(0*%d)", term_value);
     }
-    logf (LOG_DEBUG, "dict_lookup_grep: %s", term_tmp);
-    r = dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info, max_pos,
+    yaz_log(log_level_rpn, "dict_lookup_grep: %s", term_tmp);
+    r = dict_lookup_grep(zh->reg->dict, term_dict, 0, grep_info, max_pos,
                           0, grep_handle);
     if (r)
-        logf (LOG_WARN, "dict_lookup_grep fail, rel=gt: %d", r);
-    logf (LOG_DEBUG, "%d positions", grep_info->isam_p_indx);
+        yaz_log(YLOG_WARN, "dict_lookup_grep fail, rel = gt: %d", r);
+    yaz_log(log_level_rpn, "%d positions", grep_info->isam_p_indx);
     return 1;
 }
 
-static int numeric_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
+static int numeric_term(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
                          const char **term_sub, 
                          oid_value attributeSet, struct grep_info *grep_info,
                          int reg_type, int complete_flag,
@@ -1606,16 +1695,14 @@ static int numeric_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
         }
         else
         {
-            if ((r=att_getentbyatt (zh, &attp, curAttributeSet, use_value,
+            if ((r = att_getentbyatt (zh, &attp, curAttributeSet, use_value,
                                             use_string)))
             {
-                logf (LOG_DEBUG, "att_getentbyatt fail. set=%d use=%d r=%d",
+                yaz_log(YLOG_DEBUG, "att_getentbyatt fail. set=%d use=%d r=%d",
                       curAttributeSet, use_value, r);
                 if (r == -1)
                 {
-                    char val_str[32];
-                    sprintf (val_str, "%d", use_value);
-                    errString = nmem_strdup (stream, val_str);
+                    errString = nmem_strdup_i(stream, use_value);
                     errCode = 114;
                 }
                 else
@@ -1636,8 +1723,9 @@ static int numeric_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
             char ord_buf[32];
             int i, ord_len;
 
-            ord = zebraExplain_lookupSU (zh->reg->zei, attp.attset_ordinal,
-                                          local_attr->local);
+            ord = zebraExplain_lookup_attr_su(zh->reg->zei,
+					      attp.attset_ordinal,
+					      local_attr->local);
             if (ord < 0)
                 continue;
             if (prefix_len)
@@ -1654,17 +1742,15 @@ static int numeric_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
         }
         if (!prefix_len)
         {
-            char val_str[32];
-            sprintf (val_str, "%d", use_value);
             errCode = 114;
-            errString = nmem_strdup (stream, val_str);
+            errString = nmem_strdup_i(stream, use_value);
             continue;
         }
         bases_ok++;
         term_dict[prefix_len++] = ')';        
         term_dict[prefix_len++] = 1;
         term_dict[prefix_len++] = reg_type;
-        logf (LOG_DEBUG, "reg_type = %d", term_dict[prefix_len-1]);
+        yaz_log(YLOG_DEBUG, "reg_type = %d", term_dict[prefix_len-1]);
         term_dict[prefix_len] = '\0';
         if (!numeric_relation (zh, zapt, &termp, term_dict,
                                attributeSet, grep_info, &max_pos, reg_type,
@@ -1678,7 +1764,7 @@ static int numeric_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
         return -1;
     }
     *term_sub = termp;
-    logf (LOG_DEBUG, "%d positions", grep_info->isam_p_indx);
+    yaz_log(YLOG_DEBUG, "%d positions", grep_info->isam_p_indx);
     return 1;
 }
 
@@ -1694,44 +1780,41 @@ static RSET rpn_search_APT_numeric (ZebraHandle zh,
 {
     char term_dst[IT_MAX_WORD+1];
     const char *termp = termz;
-    RSET rset[60], result;
-    int i, r, rset_no = 0;
+    RSET rset[TERM_LIST_LENGTH_MAX];
+    int  r;
+    size_t rset_no = 0;
     struct grep_info grep_info;
 
+    yaz_log(log_level_rpn, "APT_numeric t='%s'",termz);
     if (grep_info_prepare (zh, zapt, &grep_info, reg_type, stream))
         return 0;
-    while (1)
+    for (; rset_no < sizeof(rset)/sizeof(*rset); rset_no++)
     { 
-        logf (LOG_DEBUG, "APT_numeric termp=%s", termp);
+        yaz_log(YLOG_DEBUG, "APT_numeric termp=%s", termp);
         grep_info.isam_p_indx = 0;
-        r = numeric_term (zh, zapt, &termp, attributeSet, &grep_info,
+        r = numeric_term(zh, zapt, &termp, attributeSet, &grep_info,
                           reg_type, complete_flag, num_bases, basenames,
                           term_dst, xpath_use,
                           stream);
         if (r < 1)
             break;
-        logf (LOG_DEBUG, "term: %s", term_dst);
-        rset[rset_no] = rset_trunc (zh, grep_info.isam_p_buf,
+        yaz_log(YLOG_DEBUG, "term: %s", term_dst);
+        rset[rset_no] = rset_trunc(zh, grep_info.isam_p_buf,
                                     grep_info.isam_p_indx, term_dst,
                                     strlen(term_dst), rank_type,
                                     0 /* preserve position */,
                                     zapt->term->which, rset_nmem, 
                                     key_it_ctrl,key_it_ctrl->scope);
-        assert (rset[rset_no]);
-        if (++rset_no >= (int) (sizeof(rset)/sizeof(*rset)))
-            break;
+	if (!rset[rset_no])
+	    break;
     }
     grep_info_delete (&grep_info);
     if (rset_no == 0)
-        return rsnull_create (rset_nmem,key_it_ctrl);
-    result = rset[0];
-    for (i = 1; i<rset_no; i++)
-    {
-        /* FIXME - Use a proper multi-and */
-        result= rsbool_create_and(rset_nmem,key_it_ctrl,key_it_ctrl->scope,
-                result, rset[i] );
-    }
-    return result;
+        return rsnull_create(rset_nmem,key_it_ctrl);
+    if (rset_no == 1)
+        return rset[0];
+    return rsmulti_and_create(rset_nmem,key_it_ctrl,key_it_ctrl->scope,
+			      rset_no, rset);
 }
 
 static RSET rpn_search_APT_local (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
@@ -1744,31 +1827,16 @@ static RSET rpn_search_APT_local (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
     RSFD rsfd;
     struct it_key key;
     int sys;
-    /*
-    rset_temp_parms parms;
-
-    parms.cmp = key_compare_it;
-    parms.key_size = sizeof (struct it_key);
-    parms.temp_path = res_get (zh->res, "setTmpDir");
-    result = rset_create (rset_kind_temp, &parms);
-    */
     result = rstemp_create( rset_nmem,key_it_ctrl,key_it_ctrl->scope,
-                     res_get (zh->res, "setTmpDir") );
+                     res_get (zh->res, "setTmpDir"),0 );
     rsfd = rset_open (result, RSETF_WRITE);
 
     sys = atoi(termz);
     if (sys <= 0)
         sys = 1;
-#if IT_KEY_NEW
     key.mem[0] = sys;
     key.mem[1] = 1;
     key.len = 2;
-#else
-    key.sysno = sys;
-    key.seqno = 1;
-    if (key.sysno <= 0)
-        key.sysno = 1;
-#endif
     rset_write (rsfd, &key);
     rset_close (rsfd);
     return result;
@@ -1801,7 +1869,7 @@ static RSET rpn_sort_spec (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
     {
         sort_sequence->num_specs = 10;
         sort_sequence->specs = (Z_SortKeySpec **)
-            nmem_malloc (stream, sort_sequence->num_specs *
+            nmem_malloc(stream, sort_sequence->num_specs *
                          sizeof(*sort_sequence->specs));
         for (i = 0; i<sort_sequence->num_specs; i++)
             sort_sequence->specs[i] = 0;
@@ -1821,35 +1889,35 @@ static RSET rpn_sort_spec (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
     if (!oid_ent_to_oid (&oe, oid))
         return 0;
 
-    sks = (Z_SortKeySpec *) nmem_malloc (stream, sizeof(*sks));
+    sks = (Z_SortKeySpec *) nmem_malloc(stream, sizeof(*sks));
     sks->sortElement = (Z_SortElement *)
-        nmem_malloc (stream, sizeof(*sks->sortElement));
+        nmem_malloc(stream, sizeof(*sks->sortElement));
     sks->sortElement->which = Z_SortElement_generic;
     sk = sks->sortElement->u.generic = (Z_SortKey *)
-        nmem_malloc (stream, sizeof(*sk));
+        nmem_malloc(stream, sizeof(*sk));
     sk->which = Z_SortKey_sortAttributes;
     sk->u.sortAttributes = (Z_SortAttributes *)
-        nmem_malloc (stream, sizeof(*sk->u.sortAttributes));
+        nmem_malloc(stream, sizeof(*sk->u.sortAttributes));
 
     sk->u.sortAttributes->id = oid;
     sk->u.sortAttributes->list = (Z_AttributeList *)
-        nmem_malloc (stream, sizeof(*sk->u.sortAttributes->list));
+        nmem_malloc(stream, sizeof(*sk->u.sortAttributes->list));
     sk->u.sortAttributes->list->num_attributes = 1;
     sk->u.sortAttributes->list->attributes = (Z_AttributeElement **)
-        nmem_malloc (stream, sizeof(*sk->u.sortAttributes->list->attributes));
+        nmem_malloc(stream, sizeof(*sk->u.sortAttributes->list->attributes));
     ae = *sk->u.sortAttributes->list->attributes = (Z_AttributeElement *)
-        nmem_malloc (stream, sizeof(**sk->u.sortAttributes->list->attributes));
+        nmem_malloc(stream, sizeof(**sk->u.sortAttributes->list->attributes));
     ae->attributeSet = 0;
     ae->attributeType = (int *)
-        nmem_malloc (stream, sizeof(*ae->attributeType));
+        nmem_malloc(stream, sizeof(*ae->attributeType));
     *ae->attributeType = 1;
     ae->which = Z_AttributeValue_numeric;
     ae->value.numeric = (int *)
-        nmem_malloc (stream, sizeof(*ae->value.numeric));
+        nmem_malloc(stream, sizeof(*ae->value.numeric));
     *ae->value.numeric = use_value;
 
     sks->sortRelation = (int *)
-        nmem_malloc (stream, sizeof(*sks->sortRelation));
+        nmem_malloc(stream, sizeof(*sks->sortRelation));
     if (sort_relation_value == 1)
         *sks->sortRelation = Z_SortKeySpec_ascending;
     else if (sort_relation_value == 2)
@@ -1858,7 +1926,7 @@ static RSET rpn_sort_spec (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
         *sks->sortRelation = Z_SortKeySpec_ascending;
 
     sks->caseSensitivity = (int *)
-        nmem_malloc (stream, sizeof(*sks->caseSensitivity));
+        nmem_malloc(stream, sizeof(*sks->caseSensitivity));
     *sks->caseSensitivity = 0;
 
     sks->which = Z_SortKeySpec_null;
@@ -1897,7 +1965,7 @@ static RSET xpath_trunc(ZebraHandle zh, NMEM stream,
     char term_dict[2048];
     char ord_buf[32];
     int prefix_len = 0;
-    int ord = zebraExplain_lookupSU (zh->reg->zei, curAttributeSet, use);
+    int ord = zebraExplain_lookup_attr_su(zh->reg->zei, curAttributeSet, use);
     int ord_len, i, r, max_pos;
     int term_type = Z_Term_characterString;
     const char *flags = "void";
@@ -1922,14 +1990,14 @@ static RSET xpath_trunc(ZebraHandle zh, NMEM stream,
     term_dict[prefix_len++] = 1;
     term_dict[prefix_len++] = reg_type;
     
-    strcpy (term_dict+prefix_len, term);
+    strcpy(term_dict+prefix_len, term);
     
     grep_info.isam_p_indx = 0;
-    r = dict_lookup_grep (zh->reg->dict, term_dict, 0,
+    r = dict_lookup_grep(zh->reg->dict, term_dict, 0,
                           &grep_info, &max_pos, 0, grep_handle);
-    yaz_log (LOG_LOG, "%s %d positions", term,
+    yaz_log (YLOG_DEBUG, "%s %d positions", term,
              grep_info.isam_p_indx);
-    rset = rset_trunc (zh, grep_info.isam_p_buf,
+    rset = rset_trunc(zh, grep_info.isam_p_buf,
                        grep_info.isam_p_indx, term, strlen(term),
                        flags, 1, term_type,rset_nmem,
                        key_it_ctrl, key_it_ctrl->scope);
@@ -1951,10 +2019,10 @@ static RSET rpn_search_xpath (ZebraHandle zh,
     if (xpath_len < 0)
         return rset;
 
-    yaz_log (LOG_LOG, "len=%d", xpath_len);
+    yaz_log (YLOG_DEBUG, "xpath len=%d", xpath_len);
     for (i = 0; i<xpath_len; i++)
     {
-        yaz_log (LOG_LOG, "XPATH %d %s", i, xpath[i].part);
+        yaz_log (log_level_rpn, "XPATH %d %s", i, xpath[i].part);
 
     }
 
@@ -1968,14 +2036,14 @@ static RSET rpn_search_xpath (ZebraHandle zh,
 
       /      ->    none
 
-   a[@attr=value]/b[@other=othervalue]
+   a[@attr = value]/b[@other = othervalue]
 
  /e/@a val      range(e/,range(@a,freetext(w,1015,val),@a),e/)
  /a/b val       range(b/a/,freetext(w,1016,val),b/a/)
  /a/b/@c val    range(b/a/,range(@c,freetext(w,1016,val),@c),b/a/)
- /a/b[@c=y] val range(b/a/,freetext(w,1016,val),b/a/,@c=y)
- /a[@c=y]/b val range(a/,range(b/a/,freetext(w,1016,val),b/a/),a/,@c=y)
- /a[@c=x]/b[@c=y] range(a/,range(b/a/,freetext(w,1016,val),b/a/,@c=y),a/,@c=x)
+ /a/b[@c = y] val range(b/a/,freetext(w,1016,val),b/a/,@c = y)
+ /a[@c = y]/b val range(a/,range(b/a/,freetext(w,1016,val),b/a/),a/,@c = y)
+ /a[@c = x]/b[@c = y] range(a/,range(b/a/,freetext(w,1016,val),b/a/,@c = y),a/,@c = x)
       
     */
 
@@ -2050,7 +2118,7 @@ static RSET rpn_search_xpath (ZebraHandle zh,
                     }
                 }
                 wrbuf_puts(wbuf, "");
-                rset_attr = xpath_trunc (
+                rset_attr = xpath_trunc(
                     zh, stream, '0', wrbuf_buf(wbuf), 3, 
                     curAttributeSet,rset_nmem);
                 wrbuf_free(wbuf, 1);
@@ -2060,7 +2128,7 @@ static RSET rpn_search_xpath (ZebraHandle zh,
                 if (!first_path)
                     continue;
             }
-            yaz_log (LOG_LOG, "xpath_rev (%d) = %s", level, xpath_rev);
+            yaz_log (log_level_rpn, "xpath_rev (%d) = %s", level, xpath_rev);
             if (strlen(xpath_rev))
             {
                 rset_start_tag = xpath_trunc(zh, stream, '0', 
@@ -2069,18 +2137,10 @@ static RSET rpn_search_xpath (ZebraHandle zh,
                 rset_end_tag = xpath_trunc(zh, stream, '0', 
                         xpath_rev, 2, curAttributeSet, rset_nmem);
 
-                /*
-                parms.key_size = sizeof(struct it_key);
-                parms.cmp = key_compare_it;
-                parms.rset_l = rset_start_tag;
-                parms.rset_m = rset;
-                parms.rset_r = rset_end_tag;
-                parms.rset_attr = rset_attr;
-                parms.printer = key_print_it;
-                rset = rset_create (rset_kind_between, &parms);
-                */
-                rset=rsbetween_create( rset_nmem,key_it_ctrl,key_it_ctrl->scope,
-                        rset_start_tag, rset, rset_end_tag, rset_attr);
+                rset = rsbetween_create(rset_nmem, key_it_ctrl,
+					key_it_ctrl->scope,
+					rset_start_tag, rset,
+					rset_end_tag, rset_attr);
             }
             first_path = 0;
         }
@@ -2108,13 +2168,18 @@ static RSET rpn_search_APT (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
     int xpath_use = 0;
     struct xpath_location_step xpath[10];
 
+    if (!log_level_set)
+    {
+        log_level_rpn = yaz_log_module_level("rpn");
+        log_level_set = 1;
+    }
     zebra_maps_attr (zh->reg->zebra_maps, zapt, &reg_id, &search_type,
                      rank_type, &complete_flag, &sort_flag);
     
-    logf (LOG_DEBUG, "reg_id=%c", reg_id);
-    logf (LOG_DEBUG, "complete_flag=%d", complete_flag);
-    logf (LOG_DEBUG, "search_type=%s", search_type);
-    logf (LOG_DEBUG, "rank_type=%s", rank_type);
+    yaz_log(YLOG_DEBUG, "reg_id=%c", reg_id);
+    yaz_log(YLOG_DEBUG, "complete_flag=%d", complete_flag);
+    yaz_log(YLOG_DEBUG, "search_type=%s", search_type);
+    yaz_log(YLOG_DEBUG, "rank_type=%s", rank_type);
 
     if (zapt_term_to_utf8(zh, zapt, termz))
         return 0;
@@ -2184,38 +2249,37 @@ static RSET rpn_search_structure (ZebraHandle zh, Z_RPNStructure *zs,
     if (zs->which == Z_RPNStructure_complex)
     {
         Z_Operator *zop = zs->u.complex->roperator;
-        RSET rset_l;
-        RSET rset_r;
+        RSET rsets[2]; /* l and r argument */
 
-        rset_l = rpn_search_structure (zh, zs->u.complex->s1,
+        rsets[0]=rpn_search_structure (zh, zs->u.complex->s1,
                                        attributeSet, stream, rset_nmem,
                                        sort_sequence,
                                        num_bases, basenames);
-        if (rset_l == NULL)
+        if (rsets[0] == NULL)
             return NULL;
-        rset_r = rpn_search_structure (zh, zs->u.complex->s2,
+        rsets[1]=rpn_search_structure (zh, zs->u.complex->s2,
                                        attributeSet, stream, rset_nmem,
                                        sort_sequence,
                                        num_bases, basenames);
-        if (rset_r == NULL)
+        if (rsets[1] == NULL)
         {
-            rset_delete (rset_l);
+            rset_delete (rsets[0]);
             return NULL;
         }
 
         switch (zop->which)
         {
         case Z_Operator_and:
-            r = rsbool_create_and(rset_nmem,key_it_ctrl, key_it_ctrl->scope,
-                    rset_l,rset_r );
+            r = rsmulti_and_create(rset_nmem, key_it_ctrl, key_it_ctrl->scope,
+				   2, rsets);
             break;
         case Z_Operator_or:
-            r = rsbool_create_or(rset_nmem,key_it_ctrl, key_it_ctrl->scope,
-                    rset_l,rset_r );
+            r = rsmulti_or_create(rset_nmem, key_it_ctrl, key_it_ctrl->scope,
+				  2, rsets);
             break;
         case Z_Operator_and_not:
             r = rsbool_create_not(rset_nmem,key_it_ctrl, key_it_ctrl->scope,
-                    rset_l,rset_r );
+                    rsets[0],rsets[1]);
             break;
         case Z_Operator_prox:
             if (zop->u.prox->which != Z_ProximityOperator_known)
@@ -2225,7 +2289,7 @@ static RSET rpn_search_structure (ZebraHandle zh, Z_RPNStructure *zs,
             }
             if (*zop->u.prox->u.known != Z_ProxUnit_word)
             {
-                char *val = (char *) nmem_malloc (stream, 16);
+                char *val = (char *) nmem_malloc(stream, 16);
                 zh->errCode = 132;
                 zh->errString = val;
                 sprintf (val, "%d", *zop->u.prox->u.known);
@@ -2234,12 +2298,8 @@ static RSET rpn_search_structure (ZebraHandle zh, Z_RPNStructure *zs,
             else
             {
                 /* new / old prox */
-                RSET twosets[2];
-                
-                twosets[0] = rset_l;
-                twosets[1] = rset_r;
-                r=rsprox_create(rset_nmem,key_it_ctrl,key_it_ctrl->scope,
-                         2, twosets, 
+                r = rsprox_create(rset_nmem,key_it_ctrl,key_it_ctrl->scope,
+                         2, rsets, 
                          *zop->u.prox->ordered,
                          (!zop->u.prox->exclusion ? 
                               0 : *zop->u.prox->exclusion),
@@ -2256,14 +2316,14 @@ static RSET rpn_search_structure (ZebraHandle zh, Z_RPNStructure *zs,
     {
         if (zs->u.simple->which == Z_Operand_APT)
         {
-            logf (LOG_DEBUG, "rpn_search_APT");
+            yaz_log(YLOG_DEBUG, "rpn_search_APT");
             r = rpn_search_APT (zh, zs->u.simple->u.attributesPlusTerm,
                                 attributeSet, stream, sort_sequence,
                                 num_bases, basenames,rset_nmem);
         }
         else if (zs->u.simple->which == Z_Operand_resultSetId)
         {
-            logf (LOG_DEBUG, "rpn_search_ref");
+            yaz_log(YLOG_DEBUG, "rpn_search_ref");
             r = resultSetRef (zh, zs->u.simple->u.resultSetId);
             if (!r)
             {
@@ -2291,10 +2351,10 @@ static RSET rpn_search_structure (ZebraHandle zh, Z_RPNStructure *zs,
 }
 
 
-RSET rpn_search (ZebraHandle zh, NMEM nmem, NMEM rset_nmem,
-                 Z_RPNQuery *rpn, int num_bases, char **basenames, 
-                 const char *setname,
-                 ZebraSet sset)
+RSET rpn_search(ZebraHandle zh, NMEM nmem, NMEM rset_nmem,
+		Z_RPNQuery *rpn, int num_bases, char **basenames, 
+		const char *setname,
+		ZebraSet sset)
 {
     RSET rset;
     oident *attrset;
@@ -2307,10 +2367,10 @@ RSET rpn_search (ZebraHandle zh, NMEM nmem, NMEM rset_nmem,
     zh->hits = 0;
 
     sort_sequence = (Z_SortKeySpecList *)
-        nmem_malloc (nmem, sizeof(*sort_sequence));
-    sort_sequence->num_specs = 10;
+        nmem_malloc(nmem, sizeof(*sort_sequence));
+    sort_sequence->num_specs = 10; /* FIXME - Hard-coded number */
     sort_sequence->specs = (Z_SortKeySpec **)
-        nmem_malloc (nmem, sort_sequence->num_specs *
+        nmem_malloc(nmem, sort_sequence->num_specs *
                      sizeof(*sort_sequence->specs));
     for (i = 0; i<sort_sequence->num_specs; i++)
         sort_sequence->specs[i] = 0;
@@ -2324,21 +2384,21 @@ RSET rpn_search (ZebraHandle zh, NMEM nmem, NMEM rset_nmem,
         return 0;
 
     if (zh->errCode)
-        logf (LOG_DEBUG, "search error: %d", zh->errCode);
+        yaz_log(YLOG_DEBUG, "search error: %d", zh->errCode);
     
     for (i = 0; sort_sequence->specs[i]; i++)
         ;
     sort_sequence->num_specs = i;
     if (!i)
-        resultSetRank (zh, sset, rset);
+        resultSetRank (zh, sset, rset, rset_nmem);
     else
     {
-        logf (LOG_DEBUG, "resultSetSortSingle in rpn_search");
+        yaz_log(YLOG_DEBUG, "resultSetSortSingle in rpn_search");
         resultSetSortSingle (zh, nmem, sset, rset,
                              sort_sequence, &sort_status);
         if (zh->errCode)
         {
-            logf (LOG_DEBUG, "resultSetSortSingle status = %d", zh->errCode);
+            yaz_log(YLOG_DEBUG, "resultSetSortSingle status = %d", zh->errCode);
         }
     }
     return rset;
@@ -2346,7 +2406,7 @@ RSET rpn_search (ZebraHandle zh, NMEM nmem, NMEM rset_nmem,
 
 struct scan_info_entry {
     char *term;
-    ISAMC_P isam_p;
+    ISAM_P isam_p;
 };
 
 struct scan_info {
@@ -2368,10 +2428,10 @@ static int scan_handle (char *name, const char *info, int pos, void *client)
     else
         idx = - pos - 1;
     scan_info->list[idx].term = (char *)
-        odr_malloc (scan_info->odr, strlen(name + len_prefix)+1);
-    strcpy (scan_info->list[idx].term, name + len_prefix);
-    assert (*info == sizeof(ISAMC_P));
-    memcpy (&scan_info->list[idx].isam_p, info+1, sizeof(ISAMC_P));
+        odr_malloc(scan_info->odr, strlen(name + len_prefix)+1);
+    strcpy(scan_info->list[idx].term, name + len_prefix);
+    assert (*info == sizeof(ISAM_P));
+    memcpy (&scan_info->list[idx].isam_p, info+1, sizeof(ISAM_P));
     return 0;
 }
 
@@ -2398,13 +2458,13 @@ static void scan_term_untrans (ZebraHandle zh, NMEM stream, int reg_type,
             len = 0;
         else
             len = outbuf - term_dst;
-        *dst = nmem_malloc (stream, len + 1);
+        *dst = nmem_malloc(stream, len + 1);
         if (len > 0)
             memcpy (*dst, term_dst, len);
         (*dst)[len] = '\0';
     }
     else
-        *dst = nmem_strdup (stream, term_src);
+        *dst = nmem_strdup(stream, term_src);
 }
 
 static void count_set (RSET r, int *count)
@@ -2414,32 +2474,24 @@ static void count_set (RSET r, int *count)
     struct it_key key;
     RSFD rfd;
 
-    logf (LOG_DEBUG, "count_set");
+    yaz_log(YLOG_DEBUG, "count_set");
 
     *count = 0;
     rfd = rset_open (r, RSETF_READ);
-    while (rset_read (rfd, &key))
+    while (rset_read (rfd, &key,0 /* never mind terms */))
     {
-#if IT_KEY_NEW
         if (key.mem[0] != psysno)
         {
             psysno = key.mem[0];
             (*count)++;
         }
-#else
-        if (key.sysno != psysno)
-        {
-            psysno = key.sysno;
-            (*count)++;
-        }
-#endif
         kno++;
     }
     rset_close (rfd);
-    logf (LOG_DEBUG, "%d keys, %d records", kno, *count);
+    yaz_log(YLOG_DEBUG, "%d keys, %d records", kno, *count);
 }
 
-void rpn_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
+void rpn_scan(ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
                oid_value attributeset,
                int num_bases, char **basenames,
                int *position, int *num_entries, ZebraScanEntry **list,
@@ -2469,7 +2521,7 @@ void rpn_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
     char rank_type[128];
     int complete_flag;
     int sort_flag;
-    NMEM rset_nmem=NULL; 
+    NMEM rset_nmem = NULL; 
 
     *list = 0;
 
@@ -2502,7 +2554,7 @@ void rpn_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
         }
     }
         
-    yaz_log (LOG_DEBUG, "position = %d, num = %d set=%d",
+    yaz_log (YLOG_DEBUG, "position = %d, num = %d set=%d",
              pos, num, attributeset);
         
     attr_init (&use, zapt, 1);
@@ -2515,50 +2567,64 @@ void rpn_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
         zh->errCode = 113;
         return ;
     }
-    yaz_log (LOG_DEBUG, "use_value = %d", use_value);
+    yaz_log (YLOG_DEBUG, "use_value = %d", use_value);
 
     if (use_value == -1)
         use_value = 1016;
     for (base_no = 0; base_no < num_bases && ord_no < 32; base_no++)
     {
-        int r;
-        attent attp;
-        data1_local_attribute *local_attr;
-
-        if ((r=att_getentbyatt (zh, &attp, attributeset, use_value,
-                                use_string)))
-        {
-            logf (LOG_DEBUG, "att_getentbyatt fail. set=%d use=%d",
-                  attributeset, use_value);
-            if (r == -1)
-            {
-                char val_str[32];
-                sprintf (val_str, "%d", use_value);
-                errCode = 114;
-                errString = odr_strdup (stream, val_str);
-            }   
-            else
-                errCode = 121;
-            continue;
-        }
-        if (zebraExplain_curDatabase (zh->reg->zei, basenames[base_no]))
-        {
-            zh->errString = basenames[base_no];
-            zh->errCode = 109; /* Database unavailable */
-            *num_entries = 0;
-            return;
-        }
-        bases_ok++;
-        for (local_attr = attp.local_attributes; local_attr && ord_no < 32;
-             local_attr = local_attr->next)
-        {
-            int ord;
-
-            ord = zebraExplain_lookupSU (zh->reg->zei, attp.attset_ordinal,
-                                         local_attr->local);
-            if (ord > 0)
-                ords[ord_no++] = ord;
-        }
+	data1_local_attribute *local_attr;
+	attent attp;
+	int ord;
+
+	if (zebraExplain_curDatabase (zh->reg->zei, basenames[base_no]))
+	{
+	    zh->errString = basenames[base_no];
+	    zh->errCode = 109; /* Database unavailable */
+	    *num_entries = 0;
+	    return;
+	}
+
+	if (use_string &&
+	    (ord = zebraExplain_lookup_attr_str(zh->reg->zei,
+						use_string)) >= 0)
+	{
+	    /* we have a match for a raw string attribute */
+	    if (ord > 0)
+		ords[ord_no++] = ord;
+            attp.local_attributes = 0;  /* no more attributes */
+	}
+	else
+	{
+	    int r;
+	    
+	    if ((r = att_getentbyatt (zh, &attp, attributeset, use_value,
+				      use_string)))
+	    {
+		yaz_log(YLOG_DEBUG, "att_getentbyatt fail. set=%d use=%d",
+			attributeset, use_value);
+		if (r == -1)
+		{
+		    char val_str[32];
+		    sprintf (val_str, "%d", use_value);
+		    errCode = 114;
+		    errString = odr_strdup (stream, val_str);
+		}   
+		else
+		    errCode = 121;
+		continue;
+	    }
+	}
+	bases_ok++;
+	for (local_attr = attp.local_attributes; local_attr && ord_no < 32;
+	     local_attr = local_attr->next)
+	{
+	    ord = zebraExplain_lookup_attr_su(zh->reg->zei,
+					      attp.attset_ordinal,
+					      local_attr->local);
+	    if (ord > 0)
+		ords[ord_no++] = ord;
+	}
     }
     if (!bases_ok && errCode)
     {
@@ -2568,11 +2634,6 @@ void rpn_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
     }
     if (ord_no == 0)
     {
-        char val_str[32];
-        sprintf (val_str, "%d", use_value);
-        zh->errCode = 114;
-        zh->errString = odr_strdup (stream, val_str);
-
         *num_entries = 0;
         return;
     }
@@ -2580,7 +2641,7 @@ void rpn_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
     before = pos-1;
     after = 1+num-pos;
     scan_info_array = (struct scan_info *)
-        odr_malloc (stream, ord_no * sizeof(*scan_info_array));
+        odr_malloc(stream, ord_no * sizeof(*scan_info_array));
     for (i = 0; i < ord_no; i++)
     {
         int j, prefix_len = 0;
@@ -2595,25 +2656,25 @@ void rpn_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
         scan_info->odr = stream;
 
         scan_info->list = (struct scan_info_entry *)
-            odr_malloc (stream, (before+after) * sizeof(*scan_info->list));
+            odr_malloc(stream, (before+after) * sizeof(*scan_info->list));
         for (j = 0; j<before+after; j++)
             scan_info->list[j].term = NULL;
 
         prefix_len += key_SU_encode (ords[i], termz + prefix_len);
         termz[prefix_len++] = reg_id;
         termz[prefix_len] = 0;
-        strcpy (scan_info->prefix, termz);
+        strcpy(scan_info->prefix, termz);
 
-        if (trans_scan_term (zh, zapt, termz+prefix_len, reg_id))
+        if (trans_scan_term(zh, zapt, termz+prefix_len, reg_id))
             return ;
-                    
-        dict_scan (zh->reg->dict, termz, &before_tmp, &after_tmp,
-                   scan_info, scan_handle);
+	
+        dict_scan(zh->reg->dict, termz, &before_tmp, &after_tmp,
+		  scan_info, scan_handle);
     }
     glist = (ZebraScanEntry *)
-        odr_malloc (stream, (before+after)*sizeof(*glist));
+        odr_malloc(stream, (before+after)*sizeof(*glist));
 
-    rset_nmem=nmem_create();
+    rset_nmem = nmem_create();
 
     /* consider terms after main term */
     for (i = 0; i < ord_no; i++)
@@ -2630,7 +2691,7 @@ void rpn_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
         for (j = 0; j < ord_no; j++)
         {
             if (ptr[j] < before+after &&
-                (tst=scan_info_array[j].list[ptr[j]].term) &&
+                (tst = scan_info_array[j].list[ptr[j]].term) &&
                 (!mterm || strcmp (tst, mterm) < 0))
             {
                 j0 = j;
@@ -2641,104 +2702,117 @@ void rpn_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
             break;
         scan_term_untrans (zh, stream->mem, reg_id,
                            &glist[i+before].term, mterm);
-        rset = rset_trunc (zh, &scan_info_array[j0].list[ptr[j0]].isam_p, 1,
-                           glist[i+before].term, strlen(glist[i+before].term),
-                           NULL, 0, zapt->term->which, rset_nmem, 
-                           key_it_ctrl,key_it_ctrl->scope);
+        rset = rset_trunc(zh, &scan_info_array[j0].list[ptr[j0]].isam_p, 1,
+			  glist[i+before].term, strlen(glist[i+before].term),
+			  NULL, 0, zapt->term->which, rset_nmem, 
+			  key_it_ctrl,key_it_ctrl->scope);
         ptr[j0]++;
         for (j = j0+1; j<ord_no; j++)
         {
             if (ptr[j] < before+after &&
-                (tst=scan_info_array[j].list[ptr[j]].term) &&
+                (tst = scan_info_array[j].list[ptr[j]].term) &&
                 !strcmp (tst, mterm))
             {
-                RSET rset2;
-
-                rset2 =
-                   rset_trunc (zh, &scan_info_array[j].list[ptr[j]].isam_p, 1,
-                               glist[i+before].term,
-                               strlen(glist[i+before].term), NULL, 0,
-                               zapt->term->which,rset_nmem,
-                               key_it_ctrl, key_it_ctrl->scope);
-                rset = rsbool_create_or(rset_nmem,key_it_ctrl,
-                               key_it_ctrl->scope, rset, rset2);
-                /* FIXME - Use a proper multi-or */
-
+                RSET rsets[2];
+		
+		rsets[0] = rset;
+                rsets[1] =
+		    rset_trunc(zh, &scan_info_array[j].list[ptr[j]].isam_p, 1,
+			       glist[i+before].term,
+			       strlen(glist[i+before].term), NULL, 0,
+			       zapt->term->which,rset_nmem,
+			       key_it_ctrl, key_it_ctrl->scope);
+                rset = rsmulti_or_create(rset_nmem, key_it_ctrl,
+					 2, key_it_ctrl->scope, rsets);
                 ptr[j]++;
             }
         }
         if (limit_set)
-            rset = rsbool_create_and(rset_nmem,key_it_ctrl,key_it_ctrl->scope,
-                            rset, rset_dup(limit_set));
-        count_set (rset, &glist[i+before].occurrences);
-        rset_delete (rset);
+	{
+	    RSET rsets[2];
+	    rsets[0] = rset;
+	    rsets[1] = rset_dup(limit_set);
+	    
+	    rset = rsmulti_and_create(rset_nmem, key_it_ctrl,
+				      key_it_ctrl->scope, 2, rsets);
+	}
+	count_set(rset, &glist[i+before].occurrences);
+	rset_delete(rset);
     }
     if (i < after)
     {
-        *num_entries -= (after-i);
-        *is_partial = 1;
+	*num_entries -= (after-i);
+	*is_partial = 1;
     }
-
+    
     /* consider terms before main term */
     for (i = 0; i<ord_no; i++)
-        ptr[i] = 0;
-
+	ptr[i] = 0;
+    
     for (i = 0; i<before; i++)
     {
-        int j, j0 = -1;
-        const char *mterm = NULL;
-        const char *tst;
-        RSET rset;
-        
-        for (j = 0; j <ord_no; j++)
-        {
-            if (ptr[j] < before &&
-                (tst=scan_info_array[j].list[before-1-ptr[j]].term) &&
-                (!mterm || strcmp (tst, mterm) > 0))
-            {
-                j0 = j;
-                mterm = tst;
-            }
-        }
-        if (j0 == -1)
-            break;
-
-        scan_term_untrans (zh, stream->mem, reg_id,
-                           &glist[before-1-i].term, mterm);
-
-        rset = rset_trunc
-               (zh, &scan_info_array[j0].list[before-1-ptr[j0]].isam_p, 1,
-                glist[before-1-i].term, strlen(glist[before-1-i].term),
-                NULL, 0, zapt->term->which,rset_nmem,
-                key_it_ctrl,key_it_ctrl->scope);
-
-        ptr[j0]++;
-
-        for (j = j0+1; j<ord_no; j++)
-        {
-            if (ptr[j] < before &&
-                (tst=scan_info_array[j].list[before-1-ptr[j]].term) &&
-                !strcmp (tst, mterm))
-            {
-                RSET rset2;
-
-                rset2 = rset_trunc (zh,
-                         &scan_info_array[j].list[before-1-ptr[j]].isam_p, 1,
-                                    glist[before-1-i].term,
-                                    strlen(glist[before-1-i].term), NULL, 0,
-                                    zapt->term->which, rset_nmem,
-                                    key_it_ctrl, key_it_ctrl->scope);
-                rset = rsbool_create_and(rset_nmem,key_it_ctrl,
-                            key_it_ctrl->scope, rset, rset2);
-                /* FIXME - multi-and ?? */
-                ptr[j]++;
-            }
-        }
+	int j, j0 = -1;
+	const char *mterm = NULL;
+	const char *tst;
+	RSET rset;
+	
+	for (j = 0; j <ord_no; j++)
+	{
+	    if (ptr[j] < before &&
+		(tst = scan_info_array[j].list[before-1-ptr[j]].term) &&
+		(!mterm || strcmp (tst, mterm) > 0))
+	    {
+		j0 = j;
+		    mterm = tst;
+	    }
+	}
+	if (j0 == -1)
+	    break;
+	
+	scan_term_untrans (zh, stream->mem, reg_id,
+			   &glist[before-1-i].term, mterm);
+	
+	rset = rset_trunc
+	    (zh, &scan_info_array[j0].list[before-1-ptr[j0]].isam_p, 1,
+	     glist[before-1-i].term, strlen(glist[before-1-i].term),
+	     NULL, 0, zapt->term->which,rset_nmem,
+	     key_it_ctrl,key_it_ctrl->scope);
+	
+	ptr[j0]++;
+	
+	for (j = j0+1; j<ord_no; j++)
+	{
+	    if (ptr[j] < before &&
+		(tst = scan_info_array[j].list[before-1-ptr[j]].term) &&
+		!strcmp (tst, mterm))
+	    {
+		RSET rsets[2];
+		
+		rsets[0] = rset;
+		rsets[1] = rset_trunc(
+		    zh,
+		    &scan_info_array[j].list[before-1-ptr[j]].isam_p, 1,
+		    glist[before-1-i].term,
+		    strlen(glist[before-1-i].term), NULL, 0,
+		    zapt->term->which, rset_nmem,
+		    key_it_ctrl, key_it_ctrl->scope);
+		rset = rsmulti_or_create(rset_nmem, key_it_ctrl,
+					 2, key_it_ctrl->scope, rsets);
+		
+		ptr[j]++;
+	    }
+	}
         if (limit_set)
-            rset = rsbool_create_and(rset_nmem,key_it_ctrl,key_it_ctrl->scope,
-                            rset, rset_dup(limit_set));
-        count_set (rset, &glist[before-1-i].occurrences);
-        rset_delete (rset);
+	{
+	    RSET rsets[2];
+	    rsets[0] = rset;
+	    rsets[1] = rset_dup(limit_set);
+	    
+	    rset = rsmulti_and_create(rset_nmem, key_it_ctrl,
+				      key_it_ctrl->scope, 2, rsets);
+	}
+	count_set (rset, &glist[before-1-i].occurrences);
+	rset_delete (rset);
     }
     i = before-i;
     if (i)
@@ -2747,13 +2821,13 @@ void rpn_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
         *position -= i;
         *num_entries -= i;
     }
-
+    
     nmem_destroy(rset_nmem);
     *list = glist + i;               /* list is set to first 'real' entry */
     
-    logf (LOG_DEBUG, "position = %d, num_entries = %d",
-          *position, *num_entries);
+    yaz_log(YLOG_DEBUG, "position = %d, num_entries = %d",
+	    *position, *num_entries);
     if (zh->errCode)
-        logf (LOG_DEBUG, "scan error: %d", zh->errCode);
+        yaz_log(YLOG_DEBUG, "scan error: %d", zh->errCode);
 }
-              
+