06f42599cbe57bf97b6199f75a93e0d303e76ce3
[idzebra-moved-to-github.git] / index / zrpn.c
1 /*
2  * Copyright (C) 1995-2002, Index Data
3  * All rights reserved.
4  * Sebastian Hammer, Adam Dickmeiss
5  *
6  * $Id: zrpn.c,v 1.113 2002-04-12 14:40:42 adam Exp $
7  */
8 #include <stdio.h>
9 #include <assert.h>
10 #ifdef WIN32
11 #include <io.h>
12 #else
13 #include <unistd.h>
14 #endif
15 #include <ctype.h>
16
17 #include "index.h"
18
19 #include <charmap.h>
20 #include <rstemp.h>
21 #include <rsnull.h>
22 #include <rsbool.h>
23 #include <rsbetween.h>
24
25 struct rpn_char_map_info {
26     ZebraMaps zm;
27     int reg_type;
28 };
29
30 static const char **rpn_char_map_handler (void *vp, const char **from, int len)
31 {
32     struct rpn_char_map_info *p = (struct rpn_char_map_info *) vp;
33     return zebra_maps_input (p->zm, p->reg_type, from, len);
34 }
35
36 static void rpn_char_map_prepare (struct zebra_register *reg, int reg_type,
37                                   struct rpn_char_map_info *map_info)
38 {
39     map_info->zm = reg->zebra_maps;
40     map_info->reg_type = reg_type;
41     dict_grep_cmap (reg->dict, map_info, rpn_char_map_handler);
42 }
43
44 typedef struct {
45     int type;
46     int major;
47     int minor;
48     Z_AttributesPlusTerm *zapt;
49 } AttrType;
50
51 static int attr_find_ex (AttrType *src, oid_value *attributeSetP,
52                          const char **string_value)
53 {
54     int num_attributes;
55
56 #ifdef ASN_COMPILED
57     num_attributes = src->zapt->attributes->num_attributes;
58 #else
59     num_attributes = src->zapt->num_attributes;
60 #endif
61     while (src->major < num_attributes)
62     {
63         Z_AttributeElement *element;
64
65 #ifdef ASN_COMPILED
66         element = src->zapt->attributes->attributes[src->major];
67 #else
68         element = src->zapt->attributeList[src->major];
69 #endif
70         if (src->type == *element->attributeType)
71         {
72             switch (element->which) 
73             {
74             case Z_AttributeValue_numeric:
75                 ++(src->major);
76                 if (element->attributeSet && attributeSetP)
77                 {
78                     oident *attrset;
79
80                     attrset = oid_getentbyoid (element->attributeSet);
81                     *attributeSetP = attrset->value;
82                 }
83                 return *element->value.numeric;
84                 break;
85             case Z_AttributeValue_complex:
86                 if (src->minor >= element->value.complex->num_list)
87                     break;
88                 if (element->value.complex->list[src->minor]->which ==  
89                     Z_StringOrNumeric_numeric)
90                 {
91                     ++(src->minor);
92                     if (element->attributeSet && attributeSetP)
93                     {
94                         oident *attrset;
95                         
96                         attrset = oid_getentbyoid (element->attributeSet);
97                         *attributeSetP = attrset->value;
98                     }
99                     return
100                         *element->value.complex->list[src->minor-1]->u.numeric;
101                 }
102                 else if (element->value.complex->list[src->minor]->which ==  
103                          Z_StringOrNumeric_string)
104                 {
105                     if (!string_value)
106                         break;
107                     ++(src->minor);
108                     *string_value = 
109                         element->value.complex->list[src->minor-1]->u.string;
110                     return -2;
111                 }
112                 else
113                     break;
114             default:
115                 assert (0);
116             }
117         }
118         ++(src->major);
119     }
120     return -1;
121 }
122
123 static int attr_find (AttrType *src, oid_value *attributeSetP)
124 {
125     return attr_find_ex (src, attributeSetP, 0);
126 }
127
128 static void attr_init (AttrType *src, Z_AttributesPlusTerm *zapt,
129                        int type)
130 {
131     src->zapt = zapt;
132     src->type = type;
133     src->major = 0;
134     src->minor = 0;
135 }
136
137 #define TERM_COUNT        
138        
139 struct grep_info {        
140 #ifdef TERM_COUNT        
141     int *term_no;        
142 #endif        
143     ISAMS_P *isam_p_buf;
144     int isam_p_size;        
145     int isam_p_indx;
146     ZebraHandle zh;
147     int reg_type;
148     ZebraSet termset;
149 };        
150
151 static void term_untrans  (ZebraHandle zh, int reg_type,
152                            char *dst, const char *src)
153 {
154     while (*src)
155     {
156         const char *cp = zebra_maps_output (zh->reg->zebra_maps,
157                                             reg_type, &src);
158         if (!cp)
159             *dst++ = *src++;
160         else
161             while (*cp)
162                 *dst++ = *cp++;
163     }
164     *dst = '\0';
165 }
166
167 static void add_isam_p (const char *name, const char *info,
168                         struct grep_info *p)
169 {
170     if (p->isam_p_indx == p->isam_p_size)
171     {
172         ISAMS_P *new_isam_p_buf;
173 #ifdef TERM_COUNT        
174         int *new_term_no;        
175 #endif
176         p->isam_p_size = 2*p->isam_p_size + 100;
177         new_isam_p_buf = (ISAMS_P *) xmalloc (sizeof(*new_isam_p_buf) *
178                                              p->isam_p_size);
179         if (p->isam_p_buf)
180         {
181             memcpy (new_isam_p_buf, p->isam_p_buf,
182                     p->isam_p_indx * sizeof(*p->isam_p_buf));
183             xfree (p->isam_p_buf);
184         }
185         p->isam_p_buf = new_isam_p_buf;
186
187 #ifdef TERM_COUNT
188         new_term_no = (int *) xmalloc (sizeof(*new_term_no) *
189                                        p->isam_p_size);
190         if (p->term_no)
191         {
192             memcpy (new_term_no, p->isam_p_buf,
193                     p->isam_p_indx * sizeof(*p->term_no));
194             xfree (p->term_no);
195         }
196         p->term_no = new_term_no;
197 #endif
198     }
199     assert (*info == sizeof(*p->isam_p_buf));
200     memcpy (p->isam_p_buf + p->isam_p_indx, info+1, sizeof(*p->isam_p_buf));
201
202 #if 1
203     if (p->termset)
204     {
205         const char *db;
206         int set, use;
207         char term_tmp[512];
208         int su_code = 0;
209         int len = key_SU_decode (&su_code, name);
210         
211         term_untrans  (p->zh, p->reg_type, term_tmp, name+len+1);
212         logf (LOG_LOG, "grep: %d %c %s", su_code, name[len], term_tmp);
213         zebraExplain_lookup_ord (p->zh->reg->zei,
214                                  su_code, &db, &set, &use);
215         logf (LOG_LOG, "grep:  set=%d use=%d db=%s", set, use, db);
216         
217         resultSetAddTerm (p->zh, p->termset, name[len], db,
218                           set, use, term_tmp);
219     }
220 #endif
221     (p->isam_p_indx)++;
222 }
223
224 static int grep_handle (char *name, const char *info, void *p)
225 {
226     add_isam_p (name, info, (struct grep_info *) p);
227     return 0;
228 }
229
230 static int term_pre (ZebraMaps zebra_maps, int reg_type, const char **src,
231                      const char *ct1, const char *ct2)
232 {
233     const char *s1, *s0 = *src;
234     const char **map;
235
236     /* skip white space */
237     while (*s0)
238     {
239         if (ct1 && strchr (ct1, *s0))
240             break;
241         if (ct2 && strchr (ct2, *s0))
242             break;
243         s1 = s0;
244         map = zebra_maps_input (zebra_maps, reg_type, &s1, strlen(s1));
245         if (**map != *CHR_SPACE)
246             break;
247         s0 = s1;
248     }
249     *src = s0;
250     return *s0;
251 }
252
253 /* term_100: handle term, where trunc=none (no operators at all) */
254 static int term_100 (ZebraMaps zebra_maps, int reg_type,
255                      const char **src, char *dst, int space_split,
256                      char *dst_term)
257 {
258     const char *s0, *s1;
259     const char **map;
260     int i = 0;
261     int j = 0;
262
263     const char *space_start = 0;
264     const char *space_end = 0;
265
266     if (!term_pre (zebra_maps, reg_type, src, NULL, NULL))
267         return 0;
268     s0 = *src;
269     while (*s0)
270     {
271         s1 = s0;
272         map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
273         if (space_split)
274         {
275             if (**map == *CHR_SPACE)
276                 break;
277         }
278         else  /* complete subfield only. */
279         {
280             if (**map == *CHR_SPACE)
281             {   /* save space mapping for later  .. */
282                 space_start = s1;
283                 space_end = s0;
284                 continue;
285             }
286             else if (space_start)
287             {   /* reload last space */
288                 while (space_start < space_end)
289                 {
290                     if (!isalnum (*space_start) && *space_start != '-')
291                         dst[i++] = '\\';
292                     dst_term[j++] = *space_start;
293                     dst[i++] = *space_start++;
294                 }
295                 /* and reset */
296                 space_start = space_end = 0;
297             }
298         }
299         /* add non-space char */
300         while (s1 < s0)
301         {
302             if (!isalnum (*s1) && *s1 != '-')
303                 dst[i++] = '\\';
304             dst_term[j++] = *s1;
305             dst[i++] = *s1++;
306         }
307     }
308     dst[i] = '\0';
309     dst_term[j] = '\0';
310     *src = s0;
311     return i;
312 }
313
314 /* term_101: handle term, where trunc=Process # */
315 static int term_101 (ZebraMaps zebra_maps, int reg_type,
316                      const char **src, char *dst, int space_split,
317                      char *dst_term)
318 {
319     const char *s0, *s1;
320     const char **map;
321     int i = 0;
322     int j = 0;
323
324     if (!term_pre (zebra_maps, reg_type, src, "#", "#"))
325         return 0;
326     s0 = *src;
327     while (*s0)
328     {
329         if (*s0 == '#')
330         {
331             dst[i++] = '.';
332             dst[i++] = '*';
333             dst_term[j++] = *s0++;
334         }
335         else
336         {
337             s1 = s0;
338             map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
339             if (space_split && **map == *CHR_SPACE)
340                 break;
341             while (s1 < s0)
342             {
343                 if (!isalnum (*s1))
344                     dst[i++] = '\\';
345                 dst_term[j++] = *s1;
346                 dst[i++] = *s1++;
347             }
348         }
349     }
350     dst[i] = '\0';
351     dst_term[j++] = '\0';
352     *src = s0;
353     return i;
354 }
355
356 /* term_103: handle term, where trunc=re-2 (regular expressions) */
357 static int term_103 (ZebraMaps zebra_maps, int reg_type, const char **src,
358                      char *dst, int *errors, int space_split,
359                      char *dst_term)
360 {
361     int i = 0;
362     int j = 0;
363     const char *s0, *s1;
364     const char **map;
365
366     if (!term_pre (zebra_maps, reg_type, src, "^\\()[].*+?|", "("))
367         return 0;
368     s0 = *src;
369     if (errors && *s0 == '+' && s0[1] && s0[2] == '+' && s0[3] &&
370         isdigit (s0[1]))
371     {
372         *errors = s0[1] - '0';
373         s0 += 3;
374         if (*errors > 3)
375             *errors = 3;
376     }
377     while (*s0)
378     {
379         if (strchr ("^\\()[].*+?|-", *s0))
380         {
381             dst_term[j++] = *s0;
382             dst[i++] = *s0++;
383         }
384         else
385         {
386             s1 = s0;
387             map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
388             if (**map == *CHR_SPACE)
389                 break;
390             while (s1 < s0)
391             {
392                 if (!isalnum (*s1))
393                     dst[i++] = '\\';
394                 dst_term[j++] = *s1;
395                 dst[i++] = *s1++;
396             }
397         }
398     }
399     dst[i] = '\0';
400     dst_term[j] = '\0';
401     *src = s0;
402     return i;
403 }
404
405 /* term_103: handle term, where trunc=re-1 (regular expressions) */
406 static int term_102 (ZebraMaps zebra_maps, int reg_type, const char **src,
407                      char *dst, int space_split, char *dst_term)
408 {
409     return term_103 (zebra_maps, reg_type, src, dst, NULL, space_split,
410                      dst_term);
411 }
412
413
414 /* term_104: handle term, where trunc=Process # and ! */
415 static int term_104 (ZebraMaps zebra_maps, int reg_type,
416                      const char **src, char *dst, int space_split,
417                      char *dst_term)
418 {
419     const char *s0, *s1;
420     const char **map;
421     int i = 0;
422     int j = 0;
423
424     if (!term_pre (zebra_maps, reg_type, src, "#!", "#!"))
425         return 0;
426     s0 = *src;
427     while (*s0)
428     {
429         if (*s0 == '#')
430         {
431             dst[i++] = '.';
432             dst[i++] = '*';
433             dst_term[j++] = *s0++;
434         }
435         else if (*s0 == '!')
436         {
437             dst[i++] = '.';
438             dst_term[j++] = *s0++;
439         }
440         {
441             s1 = s0;
442             map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
443             if (space_split && **map == *CHR_SPACE)
444                 break;
445             while (s1 < s0)
446             {
447                 if (!isalnum (*s1))
448                     dst[i++] = '\\';
449                 dst_term[j++] = *s1;
450                 dst[i++] = *s1++;
451             }
452         }
453     }
454     dst[i] = '\0';
455     dst_term[j++] = '\0';
456     *src = s0;
457     return i;
458 }
459
460 /* term_105/106: handle term, where trunc=Process * and ! and right trunc */
461 static int term_105 (ZebraMaps zebra_maps, int reg_type,
462                      const char **src, char *dst, int space_split,
463                      char *dst_term, int right_truncate)
464 {
465     const char *s0, *s1;
466     const char **map;
467     int i = 0;
468     int j = 0;
469
470     if (!term_pre (zebra_maps, reg_type, src, "*!", "*!"))
471         return 0;
472     s0 = *src;
473     while (*s0)
474     {
475         if (*s0 == '*')
476         {
477             dst[i++] = '.';
478             dst[i++] = '*';
479             dst_term[j++] = *s0++;
480         }
481         else if (*s0 == '!')
482         {
483             dst[i++] = '.';
484             dst_term[j++] = *s0++;
485         }
486         {
487             s1 = s0;
488             map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
489             if (space_split && **map == *CHR_SPACE)
490                 break;
491             while (s1 < s0)
492             {
493                 if (!isalnum (*s1))
494                     dst[i++] = '\\';
495                 dst_term[j++] = *s1;
496                 dst[i++] = *s1++;
497             }
498         }
499     }
500     if (right_truncate)
501     {
502         dst[i++] = '.';
503         dst[i++] = '*';
504     }
505     dst[i] = '\0';
506     
507     dst_term[j++] = '\0';
508     *src = s0;
509     return i;
510 }
511
512
513 /* gen_regular_rel - generate regular expression from relation
514  *  val:     border value (inclusive)
515  *  islt:    1 if <=; 0 if >=.
516  */
517 static void gen_regular_rel (char *dst, int val, int islt)
518 {
519     int dst_p;
520     int w, d, i;
521     int pos = 0;
522     char numstr[20];
523
524     logf (LOG_DEBUG, "gen_regular_rel. val=%d, islt=%d", val, islt);
525     if (val >= 0)
526     {
527         if (islt)
528             strcpy (dst, "(-[0-9]+|(");
529         else
530             strcpy (dst, "((");
531     } 
532     else
533     {
534         if (!islt)
535         {
536             strcpy (dst, "([0-9]+|-(");
537             dst_p = strlen (dst);
538             islt = 1;
539         }
540         else
541         {
542             strcpy (dst, "(-(");
543             islt = 0;
544         }
545         val = -val;
546     }
547     dst_p = strlen (dst);
548     sprintf (numstr, "%d", val);
549     for (w = strlen(numstr); --w >= 0; pos++)
550     {
551         d = numstr[w];
552         if (pos > 0)
553         {
554             if (islt)
555             {
556                 if (d == '0')
557                     continue;
558                 d--;
559             } 
560             else
561             {
562                 if (d == '9')
563                     continue;
564                 d++;
565             }
566         }
567         
568         strcpy (dst + dst_p, numstr);
569         dst_p = strlen(dst) - pos - 1;
570
571         if (islt)
572         {
573             if (d != '0')
574             {
575                 dst[dst_p++] = '[';
576                 dst[dst_p++] = '0';
577                 dst[dst_p++] = '-';
578                 dst[dst_p++] = d;
579                 dst[dst_p++] = ']';
580             }
581             else
582                 dst[dst_p++] = d;
583         }
584         else
585         {
586             if (d != '9')
587             { 
588                 dst[dst_p++] = '[';
589                 dst[dst_p++] = d;
590                 dst[dst_p++] = '-';
591                 dst[dst_p++] = '9';
592                 dst[dst_p++] = ']';
593             }
594             else
595                 dst[dst_p++] = d;
596         }
597         for (i = 0; i<pos; i++)
598         {
599             dst[dst_p++] = '[';
600             dst[dst_p++] = '0';
601             dst[dst_p++] = '-';
602             dst[dst_p++] = '9';
603             dst[dst_p++] = ']';
604         }
605         dst[dst_p++] = '|';
606     }
607     dst[dst_p] = '\0';
608     if (islt)
609     {
610         /* match everything less than 10^(pos-1) */
611         strcat (dst, "0*");
612         for (i=1; i<pos; i++)
613             strcat (dst, "[0-9]?");
614     }
615     else
616     {
617         /* match everything greater than 10^pos */
618         for (i = 0; i <= pos; i++)
619             strcat (dst, "[0-9]");
620         strcat (dst, "[0-9]*");
621     }
622     strcat (dst, "))");
623 }
624
625 void string_rel_add_char (char **term_p, const char *src, int *indx)
626 {
627     if (src[*indx] == '\\')
628         *(*term_p)++ = src[(*indx)++];
629     *(*term_p)++ = src[(*indx)++];
630 }
631
632 /*
633  *   >  abc     ([b-].*|a[c-].*|ab[d-].*|abc.+)
634  *              ([^-a].*|a[^-b].*ab[^-c].*|abc.+)
635  *   >= abc     ([b-].*|a[c-].*|ab[c-].*)
636  *              ([^-a].*|a[^-b].*|ab[c-].*)
637  *   <  abc     ([-0].*|a[-a].*|ab[-b].*)
638  *              ([^a-].*|a[^b-].*|ab[^c-].*)
639  *   <= abc     ([-0].*|a[-a].*|ab[-b].*|abc)
640  *              ([^a-].*|a[^b-].*|ab[^c-].*|abc)
641  */
642 static int string_relation (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
643                             const char **term_sub, char *term_dict,
644                             oid_value attributeSet,
645                             int reg_type, int space_split, char *term_dst)
646 {
647     AttrType relation;
648     int relation_value;
649     int i;
650     char *term_tmp = term_dict + strlen(term_dict);
651     char term_component[256];
652
653     attr_init (&relation, zapt, 2);
654     relation_value = attr_find (&relation, NULL);
655
656     logf (LOG_DEBUG, "string relation value=%d", relation_value);
657     switch (relation_value)
658     {
659     case 1:
660         if (!term_100 (zh->reg->zebra_maps, reg_type,
661                        term_sub, term_component,
662                        space_split, term_dst))
663             return 0;
664         logf (LOG_DEBUG, "Relation <");
665         
666         *term_tmp++ = '(';
667         for (i = 0; term_component[i]; )
668         {
669             int j = 0;
670
671             if (i)
672                 *term_tmp++ = '|';
673             while (j < i)
674                 string_rel_add_char (&term_tmp, term_component, &j);
675
676             *term_tmp++ = '[';
677
678             *term_tmp++ = '^';
679             string_rel_add_char (&term_tmp, term_component, &i);
680             *term_tmp++ = '-';
681
682             *term_tmp++ = ']';
683             *term_tmp++ = '.';
684             *term_tmp++ = '*';
685         }
686         *term_tmp++ = ')';
687         *term_tmp = '\0';
688         break;
689     case 2:
690         if (!term_100 (zh->reg->zebra_maps, reg_type,
691                        term_sub, term_component,
692                        space_split, term_dst))
693             return 0;
694         logf (LOG_DEBUG, "Relation <=");
695
696         *term_tmp++ = '(';
697         for (i = 0; term_component[i]; )
698         {
699             int j = 0;
700
701             while (j < i)
702                 string_rel_add_char (&term_tmp, term_component, &j);
703             *term_tmp++ = '[';
704
705             *term_tmp++ = '^';
706             string_rel_add_char (&term_tmp, term_component, &i);
707             *term_tmp++ = '-';
708
709             *term_tmp++ = ']';
710             *term_tmp++ = '.';
711             *term_tmp++ = '*';
712
713             *term_tmp++ = '|';
714         }
715         for (i = 0; term_component[i]; )
716             string_rel_add_char (&term_tmp, term_component, &i);
717         *term_tmp++ = ')';
718         *term_tmp = '\0';
719         break;
720     case 5:
721         if (!term_100 (zh->reg->zebra_maps, reg_type,
722                        term_sub, term_component, space_split, term_dst))
723             return 0;
724         logf (LOG_DEBUG, "Relation >");
725
726         *term_tmp++ = '(';
727         for (i = 0; term_component[i];)
728         {
729             int j = 0;
730
731             while (j < i)
732                 string_rel_add_char (&term_tmp, term_component, &j);
733             *term_tmp++ = '[';
734             
735             *term_tmp++ = '^';
736             *term_tmp++ = '-';
737             string_rel_add_char (&term_tmp, term_component, &i);
738
739             *term_tmp++ = ']';
740             *term_tmp++ = '.';
741             *term_tmp++ = '*';
742
743             *term_tmp++ = '|';
744         }
745         for (i = 0; term_component[i];)
746             string_rel_add_char (&term_tmp, term_component, &i);
747         *term_tmp++ = '.';
748         *term_tmp++ = '+';
749         *term_tmp++ = ')';
750         *term_tmp = '\0';
751         break;
752     case 4:
753         if (!term_100 (zh->reg->zebra_maps, reg_type, term_sub,
754                        term_component, space_split, term_dst))
755             return 0;
756         logf (LOG_DEBUG, "Relation >=");
757
758         *term_tmp++ = '(';
759         for (i = 0; term_component[i];)
760         {
761             int j = 0;
762
763             if (i)
764                 *term_tmp++ = '|';
765             while (j < i)
766                 string_rel_add_char (&term_tmp, term_component, &j);
767             *term_tmp++ = '[';
768
769             if (term_component[i+1])
770             {
771                 *term_tmp++ = '^';
772                 *term_tmp++ = '-';
773                 string_rel_add_char (&term_tmp, term_component, &i);
774             }
775             else
776             {
777                 string_rel_add_char (&term_tmp, term_component, &i);
778                 *term_tmp++ = '-';
779             }
780             *term_tmp++ = ']';
781             *term_tmp++ = '.';
782             *term_tmp++ = '*';
783         }
784         *term_tmp++ = ')';
785         *term_tmp = '\0';
786         break;
787     case 3:
788     default:
789         logf (LOG_DEBUG, "Relation =");
790         if (!term_100 (zh->reg->zebra_maps, reg_type, term_sub,
791                        term_component, space_split, term_dst))
792             return 0;
793         strcat (term_tmp, "(");
794         strcat (term_tmp, term_component);
795         strcat (term_tmp, ")");
796     }
797     return 1;
798 }
799
800 static int string_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
801                         const char **term_sub, 
802                         oid_value attributeSet, NMEM stream,
803                         struct grep_info *grep_info,
804                         int reg_type, int complete_flag,
805                         int num_bases, char **basenames,
806                         char *term_dst);
807
808 static RSET term_trunc (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
809                         const char **term_sub, 
810                         oid_value attributeSet, NMEM stream,
811                         struct grep_info *grep_info,
812                         int reg_type, int complete_flag,
813                         int num_bases, char **basenames,
814                         char *term_dst,
815                         const char *rank_type)
816 {
817     int r;
818     grep_info->isam_p_indx = 0;
819     r = string_term (zh, zapt, term_sub, attributeSet, stream, grep_info,
820                      reg_type, complete_flag, num_bases, basenames,
821                      term_dst);
822     if (r < 1)
823         return 0;
824     logf (LOG_DEBUG, "term: %s", term_dst);
825     return rset_trunc (zh, grep_info->isam_p_buf,
826                        grep_info->isam_p_indx, term_dst,
827                        strlen(term_dst), rank_type, 1 /* preserve pos */);
828 }
829
830
831 static int string_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
832                         const char **term_sub, 
833                         oid_value attributeSet, NMEM stream,
834                         struct grep_info *grep_info,
835                         int reg_type, int complete_flag,
836                         int num_bases, char **basenames,
837                         char *term_dst)
838 {
839     char term_dict[2*IT_MAX_WORD+4000];
840     int j, r, base_no;
841     AttrType truncation;
842     int truncation_value;
843     AttrType use;
844     int use_value;
845     const char *use_string = 0;
846     oid_value curAttributeSet = attributeSet;
847     const char *termp;
848     struct rpn_char_map_info rcmi;
849     int space_split = complete_flag ? 0 : 1;
850
851     rpn_char_map_prepare (zh->reg, reg_type, &rcmi);
852     attr_init (&use, zapt, 1);
853     use_value = attr_find_ex (&use, &curAttributeSet, &use_string);
854     logf (LOG_DEBUG, "string_term, use value %d", use_value);
855     attr_init (&truncation, zapt, 5);
856     truncation_value = attr_find (&truncation, NULL);
857     logf (LOG_DEBUG, "truncation value %d", truncation_value);
858
859     if (use_value == -1)
860         use_value = 1016;
861     if (use_value == -2)
862         use_value = 1016;
863
864     for (base_no = 0; base_no < num_bases; base_no++)
865     {
866         attent attp;
867         data1_local_attribute id_xpath_attr;
868         data1_local_attribute *local_attr;
869         int max_pos, prefix_len = 0;
870
871         termp = *term_sub;
872
873         if (zebraExplain_curDatabase (zh->reg->zei, basenames[base_no]))
874         {
875             zh->errCode = 109; /* Database unavailable */
876             zh->errString = basenames[base_no];
877             return -1;
878         }
879         if (curAttributeSet == VAL_IDXPATH)
880         {
881             attp.local_attributes = &id_xpath_attr;
882             attp.attset_ordinal = curAttributeSet;
883             id_xpath_attr.next = 0;
884             id_xpath_attr.local = use_value;
885         }
886         else
887         {
888             if ((r=att_getentbyatt (zh, &attp, curAttributeSet, use_value)))
889             {
890                 logf (LOG_DEBUG, "att_getentbyatt fail. set=%d use=%d r=%d",
891                       curAttributeSet, use_value, r);
892                 if (r == -1)
893                 {
894                     char val_str[32];
895                     sprintf (val_str, "%d", use_value);
896                     zh->errCode = 114;
897                     zh->errString = nmem_strdup (stream, val_str);
898                 }
899                 else
900                 {
901                     int oid[OID_SIZE];
902                     struct oident oident;
903                     
904                     oident.proto = PROTO_Z3950;
905                     oident.oclass = CLASS_ATTSET;
906                     oident.value = curAttributeSet;
907                     oid_ent_to_oid (&oident, oid);
908                     
909                     zh->errCode = 121;
910                     zh->errString = nmem_strdup (stream, oident.desc);
911                 }
912                 return -1;
913             }
914         }
915         for (local_attr = attp.local_attributes; local_attr;
916              local_attr = local_attr->next)
917         {
918             int ord;
919             char ord_buf[32];
920             int i, ord_len;
921             
922             ord = zebraExplain_lookupSU (zh->reg->zei, attp.attset_ordinal,
923                                          local_attr->local);
924             if (ord < 0)
925                 continue;
926             if (prefix_len)
927                 term_dict[prefix_len++] = '|';
928             else
929                 term_dict[prefix_len++] = '(';
930             
931             ord_len = key_SU_encode (ord, ord_buf);
932             for (i = 0; i<ord_len; i++)
933             {
934                 term_dict[prefix_len++] = 1;
935                 term_dict[prefix_len++] = ord_buf[i];
936             }
937         }
938         if (!prefix_len)
939         {
940             char val_str[32];
941             sprintf (val_str, "%d", use_value);
942             zh->errCode = 114;
943             zh->errString = nmem_strdup (stream, val_str);
944             return -1;
945         }
946         term_dict[prefix_len++] = ')';
947         term_dict[prefix_len++] = 1;
948         term_dict[prefix_len++] = reg_type;
949         logf (LOG_DEBUG, "reg_type = %d", term_dict[prefix_len-1]);
950         term_dict[prefix_len] = '\0';
951         j = prefix_len;
952         switch (truncation_value)
953         {
954         case -1:         /* not specified */
955         case 100:        /* do not truncate */
956             if (!string_relation (zh, zapt, &termp, term_dict,
957                                   attributeSet,
958                                   reg_type, space_split, term_dst))
959                 return 0;
960             logf (LOG_DEBUG, "dict_lookup_grep: %s", term_dict+prefix_len);
961             r = dict_lookup_grep (zh->reg->dict, term_dict, 0,
962                                   grep_info, &max_pos, 0, grep_handle);
963             if (r)
964                 logf (LOG_WARN, "dict_lookup_grep fail, rel=gt: %d", r);
965             break;
966         case 1:          /* right truncation */
967             term_dict[j++] = '(';
968             if (!term_100 (zh->reg->zebra_maps, reg_type,
969                            &termp, term_dict + j, space_split, term_dst))
970                 return 0;
971             strcat (term_dict, ".*)");
972             dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info,
973                               &max_pos, 0, grep_handle);
974             break;
975         case 2:          /* keft truncation */
976             term_dict[j++] = '('; term_dict[j++] = '.'; term_dict[j++] = '*';
977             if (!term_100 (zh->reg->zebra_maps, reg_type,
978                            &termp, term_dict + j, space_split, term_dst))
979                 return 0;
980             strcat (term_dict, ")");
981             dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info,
982                               &max_pos, 0, grep_handle);
983             break;
984         case 3:          /* left&right truncation */
985             term_dict[j++] = '('; term_dict[j++] = '.'; term_dict[j++] = '*';
986             if (!term_100 (zh->reg->zebra_maps, reg_type,
987                            &termp, term_dict + j, space_split, term_dst))
988                 return 0;
989             strcat (term_dict, ".*)");
990             dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info,
991                               &max_pos, 0, grep_handle);
992             break;
993             zh->errCode = 120;
994             return -1;
995         case 101:        /* process # in term */
996             term_dict[j++] = '(';
997             if (!term_101 (zh->reg->zebra_maps, reg_type,
998                            &termp, term_dict + j, space_split, term_dst))
999                 return 0;
1000             strcat (term_dict, ")");
1001             r = dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info,
1002                                   &max_pos, 0, grep_handle);
1003             if (r)
1004                 logf (LOG_WARN, "dict_lookup_grep err, trunc=#: %d", r);
1005             break;
1006         case 102:        /* Regexp-1 */
1007             term_dict[j++] = '(';
1008             if (!term_102 (zh->reg->zebra_maps, reg_type,
1009                            &termp, term_dict + j, space_split, term_dst))
1010                 return 0;
1011             strcat (term_dict, ")");
1012             logf (LOG_DEBUG, "Regexp-1 tolerance=%d", r);
1013             r = dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info,
1014                                   &max_pos, 0, grep_handle);
1015             if (r)
1016                 logf (LOG_WARN, "dict_lookup_grep err, trunc=regular: %d",
1017                       r);
1018             break;
1019         case 103:       /* Regexp-2 */
1020             r = 1;
1021             term_dict[j++] = '(';
1022             if (!term_103 (zh->reg->zebra_maps, reg_type,
1023                            &termp, term_dict + j, &r, space_split, term_dst))
1024                 return 0;
1025             strcat (term_dict, ")");
1026             logf (LOG_DEBUG, "Regexp-2 tolerance=%d", r);
1027             r = dict_lookup_grep (zh->reg->dict, term_dict, r, grep_info,
1028                                   &max_pos, 2, grep_handle);
1029             if (r)
1030                 logf (LOG_WARN, "dict_lookup_grep err, trunc=eregular: %d",
1031                       r);
1032             break;
1033         case 104:        /* process # and ! in term */
1034             term_dict[j++] = '(';
1035             if (!term_104 (zh->reg->zebra_maps, reg_type,
1036                            &termp, term_dict + j, space_split, term_dst))
1037                 return 0;
1038             strcat (term_dict, ")");
1039             r = dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info,
1040                                   &max_pos, 0, grep_handle);
1041             if (r)
1042                 logf (LOG_WARN, "dict_lookup_grep err, trunc=#/!: %d", r);
1043             break;
1044         case 105:        /* process * and ! in term */
1045             term_dict[j++] = '(';
1046             if (!term_105 (zh->reg->zebra_maps, reg_type,
1047                            &termp, term_dict + j, space_split, term_dst, 1))
1048                 return 0;
1049             strcat (term_dict, ")");
1050             r = dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info,
1051                                   &max_pos, 0, grep_handle);
1052             if (r)
1053                 logf (LOG_WARN, "dict_lookup_grep err, trunc=*/!: %d", r);
1054             break;
1055         case 106:        /* process * and ! in term */
1056             term_dict[j++] = '(';
1057             if (!term_105 (zh->reg->zebra_maps, reg_type,
1058                            &termp, term_dict + j, space_split, term_dst, 0))
1059                 return 0;
1060             strcat (term_dict, ")");
1061             r = dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info,
1062                                   &max_pos, 0, grep_handle);
1063             if (r)
1064                 logf (LOG_WARN, "dict_lookup_grep err, trunc=*/!: %d", r);
1065             break;
1066         }
1067     }
1068     *term_sub = termp;
1069     logf (LOG_DEBUG, "%d positions", grep_info->isam_p_indx);
1070     return 1;
1071 }
1072
1073 static void trans_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
1074                         char *termz)
1075 {
1076     size_t sizez;
1077     Z_Term *term = zapt->term;
1078
1079     sizez = term->u.general->len;
1080     if (sizez > IT_MAX_WORD-1)
1081         sizez = IT_MAX_WORD-1;
1082     memcpy (termz, term->u.general->buf, sizez);
1083     termz[sizez] = '\0';
1084 }
1085
1086 static void trans_scan_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
1087                              char *termz, int reg_type)
1088 {
1089     Z_Term *term = zapt->term;
1090     const char **map;
1091     const char *cp = (const char *) term->u.general->buf;
1092     const char *cp_end = cp + term->u.general->len;
1093     const char *src;
1094     int i = 0;
1095     const char *space_map = NULL;
1096     int len;
1097     
1098     while ((len = (cp_end - cp)) > 0)
1099     {
1100         map = zebra_maps_input (zh->reg->zebra_maps, reg_type, &cp, len);
1101         if (**map == *CHR_SPACE)
1102             space_map = *map;
1103         else
1104         {
1105             if (i && space_map)
1106                 for (src = space_map; *src; src++)
1107                     termz[i++] = *src;
1108             space_map = NULL;
1109             for (src = *map; *src; src++)
1110                 termz[i++] = *src;
1111         }
1112     }
1113     termz[i] = '\0';
1114 }
1115
1116 static RSET rpn_prox (ZebraHandle zh, RSET *rset, int rset_no,
1117                       int ordered, int exclusion, int relation, int distance)
1118 {
1119     int i;
1120     RSFD *rsfd;
1121     int  *more;
1122     struct it_key **buf;
1123     RSET result;
1124     char prox_term[1024];
1125     int length_prox_term = 0;
1126     int min_nn = 10000000;
1127     int term_index;
1128     const char *flags = NULL;
1129     
1130     rsfd = (RSFD *) xmalloc (sizeof(*rsfd)*rset_no);
1131     more = (int *) xmalloc (sizeof(*more)*rset_no);
1132     buf = (struct it_key **) xmalloc (sizeof(*buf)*rset_no);
1133
1134     *prox_term = '\0';
1135     for (i = 0; i<rset_no; i++)
1136     {
1137         int j;
1138         for (j = 0; j<rset[i]->no_rset_terms; j++)
1139         {
1140             const char *nflags = rset[i]->rset_terms[j]->flags;
1141             char *term = rset[i]->rset_terms[j]->name;
1142             int lterm = strlen(term);
1143             if (lterm + length_prox_term < sizeof(prox_term)-1)
1144             {
1145                 if (length_prox_term)
1146                     prox_term[length_prox_term++] = ' ';
1147                 strcpy (prox_term + length_prox_term, term);
1148                 length_prox_term += lterm;
1149             }
1150             if (min_nn > rset[i]->rset_terms[j]->nn)
1151                 min_nn = rset[i]->rset_terms[j]->nn;
1152             flags = nflags;
1153         }
1154     }
1155     for (i = 0; i<rset_no; i++)
1156     {
1157         buf[i] = 0;
1158         rsfd[i] = 0;
1159     }
1160     for (i = 0; i<rset_no; i++)
1161     {
1162         buf[i] = (struct it_key *) xmalloc (sizeof(**buf));
1163         rsfd[i] = rset_open (rset[i], RSETF_READ);
1164         if (!(more[i] = rset_read (rset[i], rsfd[i], buf[i], &term_index)))
1165             break;
1166     }
1167     if (i != rset_no)
1168     {
1169         /* at least one is empty ... return null set */
1170         rset_null_parms parms;
1171         
1172         parms.rset_term = rset_term_create (prox_term, length_prox_term,
1173                                             flags);
1174         parms.rset_term->nn = 0;
1175         result = rset_create (rset_kind_null, &parms);
1176     }
1177     else if (ordered && relation == 3 && exclusion == 0 && distance == 1)
1178     {
1179         /* special proximity case = phrase search ... */
1180         rset_temp_parms parms;
1181         RSFD rsfd_result;
1182
1183         parms.rset_term = rset_term_create (prox_term, length_prox_term,
1184                                             flags);
1185         parms.rset_term->nn = min_nn;
1186         parms.cmp = key_compare_it;
1187         parms.key_size = sizeof (struct it_key);
1188         parms.temp_path = res_get (zh->res, "setTmpDir");
1189         result = rset_create (rset_kind_temp, &parms);
1190         rsfd_result = rset_open (result, RSETF_WRITE);
1191         
1192         while (*more)
1193         {
1194             for (i = 1; i<rset_no; i++)
1195             {
1196                 int cmp;
1197                 
1198                 if (!more[i])
1199                 {
1200                     *more = 0;
1201                     break;
1202                 }
1203                 cmp = key_compare_it (buf[i], buf[i-1]);
1204                 if (cmp > 1)
1205                 {
1206                     more[i-1] = rset_read (rset[i-1], rsfd[i-1],
1207                                            buf[i-1], &term_index);
1208                     break;
1209                 }
1210                 else if (cmp == 1)
1211                 {
1212                     if (buf[i-1]->seqno+1 != buf[i]->seqno)
1213                     {
1214                         more[i-1] = rset_read (rset[i-1], rsfd[i-1],
1215                                                buf[i-1], &term_index);
1216                         break;
1217                     }
1218                 }
1219                 else
1220                 {
1221                     more[i] = rset_read (rset[i], rsfd[i], buf[i],
1222                                          &term_index);
1223                     break;
1224                 }
1225             }
1226             if (i == rset_no)
1227             {
1228                 rset_write (result, rsfd_result, buf[0]);
1229                 more[0] = rset_read (*rset, *rsfd, *buf, &term_index);
1230             }
1231         }
1232         rset_close (result, rsfd_result);
1233     }
1234     else if (rset_no == 2)
1235     {
1236         /* generic proximity case (two input sets only) ... */
1237         rset_temp_parms parms;
1238         RSFD rsfd_result;
1239
1240         logf (LOG_LOG, "generic prox, dist = %d, relation = %d, ordered =%d, exclusion=%d",
1241               distance, relation, ordered, exclusion);
1242         parms.rset_term = rset_term_create (prox_term, length_prox_term,
1243                                             flags);
1244         parms.rset_term->nn = min_nn;
1245         parms.cmp = key_compare_it;
1246         parms.key_size = sizeof (struct it_key);
1247         parms.temp_path = res_get (zh->res, "setTmpDir");
1248         result = rset_create (rset_kind_temp, &parms);
1249         rsfd_result = rset_open (result, RSETF_WRITE);
1250
1251         while (more[0] && more[1]) 
1252         {
1253             int cmp = key_compare_it (buf[0], buf[1]);
1254             if (cmp < -1)
1255                 more[0] = rset_read (rset[0], rsfd[0], buf[0], &term_index);
1256             else if (cmp > 1)
1257                 more[1] = rset_read (rset[1], rsfd[1], buf[1], &term_index);
1258             else
1259             {
1260                 int sysno = buf[0]->sysno;
1261                 int seqno[500];
1262                 int n = 0;
1263                 
1264                 seqno[n++] = buf[0]->seqno;
1265                 while ((more[0] = rset_read (rset[0], rsfd[0], buf[0],
1266                                              &term_index)) &&
1267                        sysno == buf[0]->sysno)
1268                     if (n < 500)
1269                         seqno[n++] = buf[0]->seqno;
1270                 do
1271                 {
1272                     for (i = 0; i<n; i++)
1273                     {
1274                         int diff = buf[1]->seqno - seqno[i];
1275                         int excl = exclusion;
1276                         if (!ordered && diff < 0)
1277                             diff = -diff;
1278                         switch (relation)
1279                         {
1280                         case 1:      /* < */
1281                             if (diff < distance && diff >= 0)
1282                                 excl = !excl;
1283                             break;
1284                         case 2:      /* <= */
1285                             if (diff <= distance && diff >= 0)
1286                                 excl = !excl;
1287                             break;
1288                         case 3:      /* == */
1289                             if (diff == distance && diff >= 0)
1290                                 excl = !excl;
1291                             break;
1292                         case 4:      /* >= */
1293                             if (diff >= distance && diff >= 0)
1294                                 excl = !excl;
1295                             break;
1296                         case 5:      /* > */
1297                             if (diff > distance && diff >= 0)
1298                                 excl = !excl;
1299                             break;
1300                         case 6:      /* != */
1301                             if (diff != distance && diff >= 0)
1302                                 excl = !excl;
1303                             break;
1304                         }
1305                         if (excl)
1306                         {
1307                             rset_write (result, rsfd_result, buf[1]);
1308                             break;
1309                         }
1310                     }
1311                 } while ((more[1] = rset_read (rset[1], rsfd[1], buf[1],
1312                                                &term_index)) &&
1313                          sysno == buf[1]->sysno);
1314             }
1315         }
1316         rset_close (result, rsfd_result);
1317     }
1318     else
1319     {
1320         rset_null_parms parms;
1321         
1322         parms.rset_term = rset_term_create (prox_term, length_prox_term,
1323                                             flags);
1324         parms.rset_term->nn = 0;
1325         result = rset_create (rset_kind_null, &parms);
1326     }
1327     for (i = 0; i<rset_no; i++)
1328     {
1329         if (rsfd[i])
1330             rset_close (rset[i], rsfd[i]);
1331         xfree (buf[i]);
1332     }
1333     xfree (buf);
1334     xfree (more);
1335     xfree (rsfd);
1336     return result;
1337 }
1338
1339
1340 char *normalize_term(ZebraHandle zh, Z_AttributesPlusTerm *zapt,
1341                      const char *termz, NMEM stream, unsigned reg_id)
1342 {
1343     WRBUF wrbuf = 0;
1344     AttrType truncation;
1345     int truncation_value;
1346     char *ex_list = 0;
1347
1348     attr_init (&truncation, zapt, 5);
1349     truncation_value = attr_find (&truncation, NULL);
1350
1351     switch (truncation_value)
1352     {
1353     default:
1354         ex_list = "";
1355         break;
1356     case 101:
1357         ex_list = "#";
1358         break;
1359     case 102:
1360     case 103:
1361         ex_list = 0;
1362         break;
1363     case 104:
1364         ex_list = "!#";
1365         break;
1366     case 105:
1367         ex_list = "!*";
1368         break;
1369     }
1370     if (ex_list)
1371         wrbuf = zebra_replace(zh->reg->zebra_maps, reg_id, ex_list,
1372                               termz, strlen(termz));
1373     if (!wrbuf)
1374         return nmem_strdup(stream, termz);
1375     else
1376     {
1377         char *buf = (char*) nmem_malloc (stream, wrbuf_len(wrbuf)+1);
1378         memcpy (buf, wrbuf_buf(wrbuf), wrbuf_len(wrbuf));
1379         buf[wrbuf_len(wrbuf)] = '\0';
1380         return buf;
1381     }
1382 }
1383
1384 static void grep_info_delete (struct grep_info *grep_info)
1385 {
1386 #ifdef TERM_COUNT
1387     xfree(grep_info->term_no);
1388 #endif
1389     xfree (grep_info->isam_p_buf);
1390 }
1391
1392 static int grep_info_prepare (ZebraHandle zh,
1393                               Z_AttributesPlusTerm *zapt,
1394                               struct grep_info *grep_info,
1395                               int reg_type,
1396                               NMEM stream)
1397 {
1398     AttrType termset;
1399     int termset_value_numeric;
1400     const char *termset_value_string;
1401
1402 #ifdef TERM_COUNT
1403     grep_info->term_no = 0;
1404 #endif
1405     grep_info->isam_p_size = 0;
1406     grep_info->isam_p_buf = NULL;
1407     grep_info->zh = zh;
1408     grep_info->reg_type = reg_type;
1409     grep_info->termset = 0;
1410
1411     attr_init (&termset, zapt, 8);
1412     termset_value_numeric =
1413         attr_find_ex (&termset, NULL, &termset_value_string);
1414     if (termset_value_numeric != -1)
1415     {
1416         char resname[32];
1417         const char *termset_name = 0;
1418         if (termset_value_numeric != -2)
1419         {
1420     
1421             sprintf (resname, "%d", termset_value_numeric);
1422             termset_name = resname;
1423         }
1424         else
1425             termset_name = termset_value_string;
1426         logf (LOG_LOG, "creating termset set %s", termset_name);
1427         grep_info->termset = resultSetAdd (zh, termset_name, 1);
1428         if (!grep_info->termset)
1429         {
1430             zh->errCode = 128;
1431             zh->errString = nmem_strdup (stream, termset_name);
1432             return -1;
1433         }
1434     }
1435     return 0;
1436 }
1437                                
1438
1439 static RSET rpn_search_APT_phrase (ZebraHandle zh,
1440                                    Z_AttributesPlusTerm *zapt,
1441                                    const char *termz_org,
1442                                    oid_value attributeSet,
1443                                    NMEM stream,
1444                                    int reg_type, int complete_flag,
1445                                    const char *rank_type,
1446                                    int num_bases, char **basenames)
1447 {
1448     char term_dst[IT_MAX_WORD+1];
1449     RSET rset[60], result;
1450     int i, rset_no = 0;
1451     struct grep_info grep_info;
1452     char *termz = normalize_term(zh, zapt, termz_org, stream, reg_type);
1453     const char *termp = termz;
1454
1455     *term_dst = 0;
1456     if (grep_info_prepare (zh, zapt, &grep_info, reg_type, stream))
1457         return 0;
1458     while (1)
1459     { 
1460         logf (LOG_DEBUG, "APT_phrase termp=%s", termp);
1461         rset[rset_no] = term_trunc (zh, zapt, &termp, attributeSet,
1462                                     stream, &grep_info,
1463                                     reg_type, complete_flag,
1464                                     num_bases, basenames,
1465                                     term_dst, rank_type);
1466         if (!rset[rset_no])
1467             break;
1468         if (++rset_no >= (int) (sizeof(rset)/sizeof(*rset)))
1469             break;
1470     }
1471     grep_info_delete (&grep_info);
1472     if (rset_no == 0)
1473     {
1474         rset_null_parms parms;
1475         
1476         parms.rset_term = rset_term_create (termz, -1, rank_type);
1477         return rset_create (rset_kind_null, &parms);
1478     }
1479     else if (rset_no == 1)
1480         return (rset[0]);
1481     result = rpn_prox (zh, rset, rset_no, 1, 0, 3, 1);
1482     for (i = 0; i<rset_no; i++)
1483         rset_delete (rset[i]);
1484     return result;
1485 }
1486
1487 static RSET rpn_search_APT_or_list (ZebraHandle zh,
1488                                     Z_AttributesPlusTerm *zapt,
1489                                     const char *termz_org,
1490                                     oid_value attributeSet,
1491                                     NMEM stream,
1492                                     int reg_type, int complete_flag,
1493                                     const char *rank_type,
1494                                     int num_bases, char **basenames)
1495 {
1496     char term_dst[IT_MAX_WORD+1];
1497     RSET rset[60], result;
1498     int i, rset_no = 0;
1499     struct grep_info grep_info;
1500     char *termz = normalize_term(zh, zapt, termz_org, stream, reg_type);
1501     const char *termp = termz;
1502
1503     if (grep_info_prepare (zh, zapt, &grep_info, reg_type, stream))
1504         return 0;
1505     while (1)
1506     { 
1507         logf (LOG_DEBUG, "APT_or_list termp=%s", termp);
1508         rset[rset_no] = term_trunc (zh, zapt, &termp, attributeSet,
1509                                     stream, &grep_info,
1510                                     reg_type, complete_flag,
1511                                     num_bases, basenames,
1512                                     term_dst, rank_type);
1513         if (!rset[rset_no])
1514             break;
1515         if (++rset_no >= (int) (sizeof(rset)/sizeof(*rset)))
1516             break;
1517     }
1518     grep_info_delete (&grep_info);
1519     if (rset_no == 0)
1520     {
1521         rset_null_parms parms;
1522         
1523         parms.rset_term = rset_term_create (termz, -1, rank_type);
1524         return rset_create (rset_kind_null, &parms);
1525     }
1526     result = rset[0];
1527     for (i = 1; i<rset_no; i++)
1528     {
1529         rset_bool_parms bool_parms;
1530
1531         bool_parms.rset_l = result;
1532         bool_parms.rset_r = rset[i];
1533         bool_parms.key_size = sizeof(struct it_key);
1534         bool_parms.cmp = key_compare_it;
1535         result = rset_create (rset_kind_or, &bool_parms);
1536     }
1537     return result;
1538 }
1539
1540 static RSET rpn_search_APT_and_list (ZebraHandle zh,
1541                                      Z_AttributesPlusTerm *zapt,
1542                                      const char *termz_org,
1543                                      oid_value attributeSet,
1544                                      NMEM stream,
1545                                      int reg_type, int complete_flag,
1546                                      const char *rank_type,
1547                                      int num_bases, char **basenames)
1548 {
1549     char term_dst[IT_MAX_WORD+1];
1550     RSET rset[60], result;
1551     int i, rset_no = 0;
1552     struct grep_info grep_info;
1553     char *termz = normalize_term(zh, zapt, termz_org, stream, reg_type);
1554     const char *termp = termz;
1555
1556     if (grep_info_prepare (zh, zapt, &grep_info, reg_type, stream))
1557         return 0;
1558     while (1)
1559     { 
1560         logf (LOG_DEBUG, "APT_and_list termp=%s", termp);
1561         rset[rset_no] = term_trunc (zh, zapt, &termp, attributeSet,
1562                                     stream, &grep_info,
1563                                     reg_type, complete_flag,
1564                                     num_bases, basenames,
1565                                     term_dst, rank_type);
1566         if (!rset[rset_no])
1567             break;
1568         assert (rset[rset_no]);
1569         if (++rset_no >= (int) (sizeof(rset)/sizeof(*rset)))
1570             break;
1571     }
1572     grep_info_delete (&grep_info);
1573     if (rset_no == 0)
1574     {
1575         rset_null_parms parms;
1576         
1577         parms.rset_term = rset_term_create (termz, -1, rank_type);
1578         return rset_create (rset_kind_null, &parms);
1579     }
1580     result = rset[0];
1581     for (i = 1; i<rset_no; i++)
1582     {
1583         rset_bool_parms bool_parms;
1584
1585         bool_parms.rset_l = result;
1586         bool_parms.rset_r = rset[i];
1587         bool_parms.key_size = sizeof(struct it_key);
1588         bool_parms.cmp = key_compare_it;
1589         result = rset_create (rset_kind_and, &bool_parms);
1590     }
1591     return result;
1592 }
1593
1594 static int numeric_relation (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
1595                              const char **term_sub,
1596                              char *term_dict,
1597                              oid_value attributeSet,
1598                              struct grep_info *grep_info,
1599                              int *max_pos,
1600                              int reg_type,
1601                              char *term_dst)
1602 {
1603     AttrType relation;
1604     int relation_value;
1605     int term_value;
1606     int r;
1607     char *term_tmp = term_dict + strlen(term_dict);
1608
1609     attr_init (&relation, zapt, 2);
1610     relation_value = attr_find (&relation, NULL);
1611
1612     logf (LOG_DEBUG, "numeric relation value=%d", relation_value);
1613
1614     if (!term_100 (zh->reg->zebra_maps, reg_type, term_sub, term_tmp, 1,
1615                    term_dst))
1616         return 0;
1617     term_value = atoi (term_tmp);
1618     switch (relation_value)
1619     {
1620     case 1:
1621         logf (LOG_DEBUG, "Relation <");
1622         gen_regular_rel (term_tmp, term_value-1, 1);
1623         break;
1624     case 2:
1625         logf (LOG_DEBUG, "Relation <=");
1626         gen_regular_rel (term_tmp, term_value, 1);
1627         break;
1628     case 4:
1629         logf (LOG_DEBUG, "Relation >=");
1630         gen_regular_rel (term_tmp, term_value, 0);
1631         break;
1632     case 5:
1633         logf (LOG_DEBUG, "Relation >");
1634         gen_regular_rel (term_tmp, term_value+1, 0);
1635         break;
1636     case 3:
1637     default:
1638         logf (LOG_DEBUG, "Relation =");
1639         sprintf (term_tmp, "(0*%d)", term_value);
1640     }
1641     logf (LOG_DEBUG, "dict_lookup_grep: %s", term_tmp);
1642     r = dict_lookup_grep (zh->reg->dict, term_dict, 0, grep_info, max_pos,
1643                           0, grep_handle);
1644     if (r)
1645         logf (LOG_WARN, "dict_lookup_grep fail, rel=gt: %d", r);
1646     logf (LOG_DEBUG, "%d positions", grep_info->isam_p_indx);
1647     return 1;
1648 }
1649
1650 static int numeric_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
1651                          const char **term_sub, 
1652                          oid_value attributeSet, struct grep_info *grep_info,
1653                          int reg_type, int complete_flag,
1654                          int num_bases, char **basenames,
1655                          char *term_dst)
1656 {
1657     char term_dict[2*IT_MAX_WORD+2];
1658     int r, base_no;
1659     AttrType use;
1660     int use_value;
1661     oid_value curAttributeSet = attributeSet;
1662     const char *termp;
1663     struct rpn_char_map_info rcmi;
1664
1665     rpn_char_map_prepare (zh->reg, reg_type, &rcmi);
1666     attr_init (&use, zapt, 1);
1667     use_value = attr_find (&use, &curAttributeSet);
1668     logf (LOG_DEBUG, "numeric_term, use value %d", use_value);
1669
1670     if (use_value == -1)
1671         use_value = 1016;
1672
1673     for (base_no = 0; base_no < num_bases; base_no++)
1674     {
1675         attent attp;
1676         data1_local_attribute *local_attr;
1677         int max_pos, prefix_len = 0;
1678
1679         termp = *term_sub;
1680         if ((r=att_getentbyatt (zh, &attp, curAttributeSet, use_value)))
1681         {
1682             logf (LOG_DEBUG, "att_getentbyatt fail. set=%d use=%d r=%d",
1683                   curAttributeSet, use_value, r);
1684             if (r == -1)
1685                 zh->errCode = 114;
1686             else
1687                 zh->errCode = 121;
1688             return -1;
1689         }
1690         if (zebraExplain_curDatabase (zh->reg->zei, basenames[base_no]))
1691         {
1692             zh->errCode = 109; /* Database unavailable */
1693             zh->errString = basenames[base_no];
1694             return -1;
1695         }
1696         for (local_attr = attp.local_attributes; local_attr;
1697              local_attr = local_attr->next)
1698         {
1699             int ord;
1700             char ord_buf[32];
1701             int i, ord_len;
1702
1703             ord = zebraExplain_lookupSU (zh->reg->zei, attp.attset_ordinal,
1704                                           local_attr->local);
1705             if (ord < 0)
1706                 continue;
1707             if (prefix_len)
1708                 term_dict[prefix_len++] = '|';
1709             else
1710                 term_dict[prefix_len++] = '(';
1711
1712             ord_len = key_SU_encode (ord, ord_buf);
1713             for (i = 0; i<ord_len; i++)
1714             {
1715                 term_dict[prefix_len++] = 1;
1716                 term_dict[prefix_len++] = ord_buf[i];
1717             }
1718         }
1719         if (!prefix_len)
1720         {
1721             zh->errCode = 114;
1722             return -1;
1723         }
1724         term_dict[prefix_len++] = ')';        
1725         term_dict[prefix_len++] = 1;
1726         term_dict[prefix_len++] = reg_type;
1727         logf (LOG_DEBUG, "reg_type = %d", term_dict[prefix_len-1]);
1728         term_dict[prefix_len] = '\0';
1729         if (!numeric_relation (zh, zapt, &termp, term_dict,
1730                                attributeSet, grep_info, &max_pos, reg_type,
1731                                term_dst))
1732             return 0;
1733     }
1734     *term_sub = termp;
1735     logf (LOG_DEBUG, "%d positions", grep_info->isam_p_indx);
1736     return 1;
1737 }
1738
1739 static RSET rpn_search_APT_numeric (ZebraHandle zh,
1740                                     Z_AttributesPlusTerm *zapt,
1741                                     const char *termz,
1742                                     oid_value attributeSet,
1743                                     NMEM stream,
1744                                     int reg_type, int complete_flag,
1745                                     const char *rank_type,
1746                                     int num_bases, char **basenames)
1747 {
1748     char term_dst[IT_MAX_WORD+1];
1749     const char *termp = termz;
1750     RSET rset[60], result;
1751     int i, r, rset_no = 0;
1752     struct grep_info grep_info;
1753
1754     if (grep_info_prepare (zh, zapt, &grep_info, reg_type, stream))
1755         return 0;
1756     while (1)
1757     { 
1758         logf (LOG_DEBUG, "APT_numeric termp=%s", termp);
1759         grep_info.isam_p_indx = 0;
1760         r = numeric_term (zh, zapt, &termp, attributeSet, &grep_info,
1761                           reg_type, complete_flag, num_bases, basenames,
1762                           term_dst);
1763         if (r < 1)
1764             break;
1765         logf (LOG_DEBUG, "term: %s", term_dst);
1766         rset[rset_no] = rset_trunc (zh, grep_info.isam_p_buf,
1767                                     grep_info.isam_p_indx, term_dst,
1768                                     strlen(term_dst), rank_type,
1769                                     0 /* preserve position */);
1770         assert (rset[rset_no]);
1771         if (++rset_no >= (int) (sizeof(rset)/sizeof(*rset)))
1772             break;
1773     }
1774     grep_info_delete (&grep_info);
1775     if (rset_no == 0)
1776     {
1777         rset_null_parms parms;
1778         
1779         parms.rset_term = rset_term_create (term_dst, -1, rank_type);
1780         return rset_create (rset_kind_null, &parms);
1781     }
1782     result = rset[0];
1783     for (i = 1; i<rset_no; i++)
1784     {
1785         rset_bool_parms bool_parms;
1786
1787         bool_parms.rset_l = result;
1788         bool_parms.rset_r = rset[i];
1789         bool_parms.key_size = sizeof(struct it_key);
1790         bool_parms.cmp = key_compare_it;
1791         result = rset_create (rset_kind_and, &bool_parms);
1792     }
1793     return result;
1794 }
1795
1796 static RSET rpn_search_APT_local (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
1797                                   const char *termz,
1798                                   oid_value attributeSet,
1799                                   NMEM stream,
1800                                   const char *rank_type)
1801 {
1802     RSET result;
1803     RSFD rsfd;
1804     struct it_key key;
1805     rset_temp_parms parms;
1806
1807     parms.rset_term = rset_term_create (termz, -1, rank_type);
1808     parms.cmp = key_compare_it;
1809     parms.key_size = sizeof (struct it_key);
1810     parms.temp_path = res_get (zh->res, "setTmpDir");
1811     result = rset_create (rset_kind_temp, &parms);
1812     rsfd = rset_open (result, RSETF_WRITE);
1813
1814     key.sysno = atoi (termz);
1815     key.seqno = 1;
1816     if (key.sysno <= 0)
1817         key.sysno = 1;
1818     rset_write (result, rsfd, &key);
1819     rset_close (result, rsfd);
1820     return result;
1821 }
1822
1823 static RSET rpn_sort_spec (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
1824                            oid_value attributeSet, NMEM stream,
1825                            Z_SortKeySpecList *sort_sequence,
1826                            const char *rank_type)
1827 {
1828     rset_null_parms parms;    
1829     int i;
1830     int sort_relation_value;
1831     AttrType sort_relation_type;
1832     int use_value;
1833     AttrType use_type;
1834     Z_SortKeySpec *sks;
1835     Z_SortKey *sk;
1836     Z_AttributeElement *ae;
1837     int oid[OID_SIZE];
1838     oident oe;
1839     char termz[20];
1840     
1841     attr_init (&sort_relation_type, zapt, 7);
1842     sort_relation_value = attr_find (&sort_relation_type, &attributeSet);
1843
1844     attr_init (&use_type, zapt, 1);
1845     use_value = attr_find (&use_type, &attributeSet);
1846
1847     if (!sort_sequence->specs)
1848     {
1849         sort_sequence->num_specs = 10;
1850         sort_sequence->specs = (Z_SortKeySpec **)
1851             nmem_malloc (stream, sort_sequence->num_specs *
1852                          sizeof(*sort_sequence->specs));
1853         for (i = 0; i<sort_sequence->num_specs; i++)
1854             sort_sequence->specs[i] = 0;
1855     }
1856     if (zapt->term->which != Z_Term_general)
1857         i = 0;
1858     else
1859         i = atoi_n ((char *) zapt->term->u.general->buf,
1860                     zapt->term->u.general->len);
1861     if (i >= sort_sequence->num_specs)
1862         i = 0;
1863     sprintf (termz, "%d", i);
1864
1865     oe.proto = PROTO_Z3950;
1866     oe.oclass = CLASS_ATTSET;
1867     oe.value = attributeSet;
1868     if (!oid_ent_to_oid (&oe, oid))
1869         return 0;
1870
1871     sks = (Z_SortKeySpec *) nmem_malloc (stream, sizeof(*sks));
1872     sks->sortElement = (Z_SortElement *)
1873         nmem_malloc (stream, sizeof(*sks->sortElement));
1874     sks->sortElement->which = Z_SortElement_generic;
1875     sk = sks->sortElement->u.generic = (Z_SortKey *)
1876         nmem_malloc (stream, sizeof(*sk));
1877     sk->which = Z_SortKey_sortAttributes;
1878     sk->u.sortAttributes = (Z_SortAttributes *)
1879         nmem_malloc (stream, sizeof(*sk->u.sortAttributes));
1880
1881     sk->u.sortAttributes->id = oid;
1882     sk->u.sortAttributes->list = (Z_AttributeList *)
1883         nmem_malloc (stream, sizeof(*sk->u.sortAttributes->list));
1884     sk->u.sortAttributes->list->num_attributes = 1;
1885     sk->u.sortAttributes->list->attributes = (Z_AttributeElement **)
1886         nmem_malloc (stream, sizeof(*sk->u.sortAttributes->list->attributes));
1887     ae = *sk->u.sortAttributes->list->attributes = (Z_AttributeElement *)
1888         nmem_malloc (stream, sizeof(**sk->u.sortAttributes->list->attributes));
1889     ae->attributeSet = 0;
1890     ae->attributeType = (int *)
1891         nmem_malloc (stream, sizeof(*ae->attributeType));
1892     *ae->attributeType = 1;
1893     ae->which = Z_AttributeValue_numeric;
1894     ae->value.numeric = (int *)
1895         nmem_malloc (stream, sizeof(*ae->value.numeric));
1896     *ae->value.numeric = use_value;
1897
1898     sks->sortRelation = (int *)
1899         nmem_malloc (stream, sizeof(*sks->sortRelation));
1900     if (sort_relation_value == 1)
1901         *sks->sortRelation = Z_SortRelation_ascending;
1902     else if (sort_relation_value == 2)
1903         *sks->sortRelation = Z_SortRelation_descending;
1904     else 
1905         *sks->sortRelation = Z_SortRelation_ascending;
1906
1907     sks->caseSensitivity = (int *)
1908         nmem_malloc (stream, sizeof(*sks->caseSensitivity));
1909     *sks->caseSensitivity = 0;
1910
1911 #ifdef ASN_COMPILED
1912     sks->which = Z_SortKeySpec_null;
1913     sks->u.null = odr_nullval ();
1914 #else
1915     sks->missingValueAction = 0;
1916 #endif
1917
1918     sort_sequence->specs[i] = sks;
1919
1920     parms.rset_term = rset_term_create (termz, -1, rank_type);
1921     return rset_create (rset_kind_null, &parms);
1922 }
1923
1924 static RSET rpn_search_xpath (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
1925                               oid_value attributeSet,
1926                               int num_bases, char **basenames,
1927                               NMEM stream, const char *rank_type, RSET rset)
1928 {
1929     AttrType use;
1930     const char *use_string = 0;
1931     oid_value curAttributeSet = attributeSet;
1932     char term_dict[2048];
1933     int base_no;
1934     struct grep_info grep_info;
1935     struct rpn_char_map_info rcmi;
1936
1937     yaz_log (LOG_LOG, "rpn_search_xpath 1");
1938     attr_init (&use, zapt, 1);
1939     attr_find_ex (&use, &curAttributeSet, &use_string);
1940
1941     if (curAttributeSet != VAL_IDXPATH)
1942     {
1943         yaz_log (LOG_LOG, "rpn_search_xpath - not 1");
1944         return rset;
1945     }
1946     if (!use_string)
1947     {
1948         yaz_log (LOG_LOG, "rpn_search_xpath - not 2");
1949         return rset;
1950     }
1951
1952     rpn_char_map_prepare (zh->reg, '0', &rcmi);
1953
1954     if (grep_info_prepare (zh, zapt, &grep_info, '0', stream))
1955         return 0;
1956
1957     yaz_log (LOG_LOG, "rpn_search_xpath 2");
1958     for (base_no = 0; base_no < num_bases; base_no++)
1959     {
1960         rset_between_parms parms;
1961         RSET rset_start_tag, rset_end_tag;
1962         int ord, ord_len, i, r, max_pos;
1963         int prefix_len ;
1964         char ord_buf[32];
1965         if (zebraExplain_curDatabase (zh->reg->zei, basenames[base_no]))
1966         {
1967             zh->errCode = 109; /* Database unavailable */
1968             zh->errString = basenames[base_no];
1969             return rset;
1970         }
1971
1972         prefix_len = 0;
1973         ord = zebraExplain_lookupSU (zh->reg->zei, curAttributeSet, 1);
1974         if (ord < 0)
1975             continue;
1976         if (prefix_len)
1977             term_dict[prefix_len++] = '|';
1978         else
1979             term_dict[prefix_len++] = '(';
1980         
1981         ord_len = key_SU_encode (ord, ord_buf);
1982         for (i = 0; i<ord_len; i++)
1983         {
1984             term_dict[prefix_len++] = 1;
1985             term_dict[prefix_len++] = ord_buf[i];
1986         }
1987         term_dict[prefix_len++] = ')';
1988         term_dict[prefix_len++] = 1;
1989         term_dict[prefix_len++] = '0';
1990         strcpy (term_dict+prefix_len, use_string);
1991         grep_info.isam_p_indx = 0;
1992         yaz_log (LOG_LOG, "rpn_search_xpath 3 %s", term_dict+prefix_len);
1993         r = dict_lookup_grep (zh->reg->dict, term_dict, 0,
1994                               &grep_info, &max_pos, 0, grep_handle);
1995         yaz_log (LOG_LOG, "%s %d positions", use_string,
1996                  grep_info.isam_p_indx);
1997         rset_start_tag =
1998             rset_trunc (zh, grep_info.isam_p_buf,
1999                         grep_info.isam_p_indx, use_string, strlen(use_string),
2000                         rank_type, 1);
2001
2002         prefix_len = 0;
2003         ord = zebraExplain_lookupSU (zh->reg->zei, curAttributeSet, 2);
2004         if (ord < 0)
2005             continue;
2006         if (prefix_len)
2007             term_dict[prefix_len++] = '|';
2008         else
2009             term_dict[prefix_len++] = '(';
2010         
2011         ord_len = key_SU_encode (ord, ord_buf);
2012         for (i = 0; i<ord_len; i++)
2013         {
2014             term_dict[prefix_len++] = 1;
2015             term_dict[prefix_len++] = ord_buf[i];
2016         }
2017         term_dict[prefix_len++] = ')';
2018         term_dict[prefix_len++] = 1;
2019         term_dict[prefix_len++] = '0';
2020         strcpy (term_dict+prefix_len, use_string);
2021         grep_info.isam_p_indx = 0;
2022         r = dict_lookup_grep (zh->reg->dict, term_dict, 0,
2023                               &grep_info, &max_pos, 0, grep_handle);
2024
2025         yaz_log (LOG_LOG, "%s %d positions", use_string,
2026                  grep_info.isam_p_indx);
2027         rset_end_tag =
2028             rset_trunc (zh, grep_info.isam_p_buf,
2029                         grep_info.isam_p_indx, use_string, strlen(use_string),
2030                         rank_type, 1);
2031
2032         parms.key_size = sizeof(struct it_key);
2033         parms.cmp = key_compare_it;
2034         parms.rset_l = rset_start_tag;
2035         parms.rset_m = rset;
2036         parms.rset_r = rset_end_tag;
2037         yaz_log (LOG_LOG, "rpn_search_xpath 4");
2038         rset = rset_create (rset_kind_between, &parms);
2039     }
2040     grep_info_delete (&grep_info);
2041
2042     return rset;
2043 }
2044
2045
2046
2047 static RSET rpn_search_APT (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
2048                             oid_value attributeSet, NMEM stream,
2049                             Z_SortKeySpecList *sort_sequence,
2050                             int num_bases, char **basenames)
2051 {
2052     unsigned reg_id;
2053     char *search_type = NULL;
2054     char rank_type[128];
2055     int complete_flag;
2056     int sort_flag;
2057     char termz[IT_MAX_WORD+1];
2058     RSET rset = 0;
2059
2060     zebra_maps_attr (zh->reg->zebra_maps, zapt, &reg_id, &search_type,
2061                      rank_type, &complete_flag, &sort_flag);
2062     
2063     logf (LOG_DEBUG, "reg_id=%c", reg_id);
2064     logf (LOG_DEBUG, "complete_flag=%d", complete_flag);
2065     logf (LOG_DEBUG, "search_type=%s", search_type);
2066     logf (LOG_DEBUG, "rank_type=%s", rank_type);
2067
2068     if (zapt->term->which != Z_Term_general)
2069     {
2070         zh->errCode = 124;
2071         return NULL;
2072     }
2073     trans_term (zh, zapt, termz);
2074
2075     if (sort_flag)
2076         return rpn_sort_spec (zh, zapt, attributeSet, stream, sort_sequence,
2077                               rank_type);
2078
2079     if (!strcmp (search_type, "phrase"))
2080     {
2081         rset = rpn_search_APT_phrase (zh, zapt, termz, attributeSet, stream,
2082                                       reg_id, complete_flag, rank_type,
2083                                       num_bases, basenames);
2084     }
2085     else if (!strcmp (search_type, "and-list"))
2086     {
2087         rset = rpn_search_APT_and_list (zh, zapt, termz, attributeSet, stream,
2088                                         reg_id, complete_flag, rank_type,
2089                                         num_bases, basenames);
2090     }
2091     else if (!strcmp (search_type, "or-list"))
2092     {
2093         rset = rpn_search_APT_or_list (zh, zapt, termz, attributeSet, stream,
2094                                        reg_id, complete_flag, rank_type,
2095                                        num_bases, basenames);
2096     }
2097     else if (!strcmp (search_type, "local"))
2098     {
2099         rset = rpn_search_APT_local (zh, zapt, termz, attributeSet, stream,
2100                                      rank_type);
2101     }
2102     else if (!strcmp (search_type, "numeric"))
2103     {
2104         rset = rpn_search_APT_numeric (zh, zapt, termz, attributeSet, stream,
2105                                        reg_id, complete_flag, rank_type,
2106                                        num_bases, basenames);
2107     }
2108     else
2109         zh->errCode = 118;
2110     return rpn_search_xpath (zh, zapt, attributeSet, num_bases, basenames,
2111                              stream, rank_type, rset);
2112 }
2113
2114 static RSET rpn_search_structure (ZebraHandle zh, Z_RPNStructure *zs,
2115                                   oid_value attributeSet, NMEM stream,
2116                                   Z_SortKeySpecList *sort_sequence,
2117                                   int num_bases, char **basenames)
2118 {
2119     RSET r = NULL;
2120     if (zs->which == Z_RPNStructure_complex)
2121     {
2122         Z_Operator *zop = zs->u.complex->roperator;
2123         rset_bool_parms bool_parms;
2124
2125         bool_parms.rset_l = rpn_search_structure (zh, zs->u.complex->s1,
2126                                                   attributeSet, stream,
2127                                                   sort_sequence,
2128                                                   num_bases, basenames);
2129         if (bool_parms.rset_l == NULL)
2130             return NULL;
2131         bool_parms.rset_r = rpn_search_structure (zh, zs->u.complex->s2,
2132                                                   attributeSet, stream,
2133                                                   sort_sequence,
2134                                                   num_bases, basenames);
2135         if (bool_parms.rset_r == NULL)
2136         {
2137             rset_delete (bool_parms.rset_l);
2138             return NULL;
2139         }
2140         bool_parms.key_size = sizeof(struct it_key);
2141         bool_parms.cmp = key_compare_it;
2142
2143         switch (zop->which)
2144         {
2145         case Z_Operator_and:
2146             r = rset_create (rset_kind_and, &bool_parms);
2147             break;
2148         case Z_Operator_or:
2149             r = rset_create (rset_kind_or, &bool_parms);
2150             break;
2151         case Z_Operator_and_not:
2152             r = rset_create (rset_kind_not, &bool_parms);
2153             break;
2154         case Z_Operator_prox:
2155 #ifdef ASN_COMPILED
2156             if (zop->u.prox->which != Z_ProximityOperator_known)
2157             {
2158                 zh->errCode = 132;
2159                 return NULL;
2160             }
2161 #else
2162             if (zop->u.prox->which != Z_ProxCode_known)
2163             {
2164                 zh->errCode = 132;
2165                 return NULL;
2166             }
2167 #endif
2168
2169 #ifdef ASN_COMPILED
2170             if (*zop->u.prox->u.known != Z_ProxUnit_word)
2171             {
2172                 char *val = (char *) nmem_malloc (stream, 16);
2173                 zh->errCode = 132;
2174                 zh->errString = val;
2175                 sprintf (val, "%d", *zop->u.prox->u.known);
2176                 return NULL;
2177             }
2178 #else
2179             if (*zop->u.prox->proximityUnitCode != Z_ProxUnit_word)
2180             {
2181                 char *val = (char *) nmem_malloc (stream, 16);
2182                 zh->errCode = 132;
2183                 zh->errString = val;
2184                 sprintf (val, "%d", *zop->u.prox->proximityUnitCode);
2185                 return NULL;
2186             }
2187 #endif
2188             else
2189             {
2190                 RSET rsets[2];
2191
2192                 rsets[0] = bool_parms.rset_l;
2193                 rsets[1] = bool_parms.rset_r;
2194                 
2195                 r = rpn_prox (zh, rsets, 2, 
2196                               *zop->u.prox->ordered,
2197                               (!zop->u.prox->exclusion ? 0 :
2198                                *zop->u.prox->exclusion),
2199                               *zop->u.prox->relationType,
2200                               *zop->u.prox->distance);
2201                 rset_delete (rsets[0]);
2202                 rset_delete (rsets[1]);
2203             }
2204             break;
2205         default:
2206             zh->errCode = 110;
2207             return NULL;
2208         }
2209     }
2210     else if (zs->which == Z_RPNStructure_simple)
2211     {
2212         if (zs->u.simple->which == Z_Operand_APT)
2213         {
2214             logf (LOG_DEBUG, "rpn_search_APT");
2215             r = rpn_search_APT (zh, zs->u.simple->u.attributesPlusTerm,
2216                                 attributeSet, stream, sort_sequence,
2217                                 num_bases, basenames);
2218         }
2219         else if (zs->u.simple->which == Z_Operand_resultSetId)
2220         {
2221             logf (LOG_DEBUG, "rpn_search_ref");
2222             r = resultSetRef (zh, zs->u.simple->u.resultSetId);
2223             if (!r)
2224             {
2225                 r = rset_create (rset_kind_null, NULL);
2226                 zh->errCode = 30;
2227                 zh->errString =
2228                     nmem_strdup (stream, zs->u.simple->u.resultSetId);
2229                 return 0;
2230             }
2231         }
2232         else
2233         {
2234             zh->errCode = 3;
2235             return 0;
2236         }
2237     }
2238     else
2239     {
2240         zh->errCode = 3;
2241         return 0;
2242     }
2243     return r;
2244 }
2245
2246
2247 RSET rpn_search (ZebraHandle zh, NMEM nmem,
2248                  Z_RPNQuery *rpn, int num_bases, char **basenames, 
2249                  const char *setname,
2250                  ZebraSet sset)
2251 {
2252     RSET rset;
2253     oident *attrset;
2254     oid_value attributeSet;
2255     Z_SortKeySpecList *sort_sequence;
2256     int sort_status, i;
2257
2258     zh->errCode = 0;
2259     zh->errString = NULL;
2260     zh->hits = 0;
2261
2262     sort_sequence = (Z_SortKeySpecList *)
2263         nmem_malloc (nmem, sizeof(*sort_sequence));
2264     sort_sequence->num_specs = 10;
2265     sort_sequence->specs = (Z_SortKeySpec **)
2266         nmem_malloc (nmem, sort_sequence->num_specs *
2267                      sizeof(*sort_sequence->specs));
2268     for (i = 0; i<sort_sequence->num_specs; i++)
2269         sort_sequence->specs[i] = 0;
2270     
2271     attrset = oid_getentbyoid (rpn->attributeSetId);
2272     attributeSet = attrset->value;
2273     rset = rpn_search_structure (zh, rpn->RPNStructure, attributeSet,
2274                                  nmem, sort_sequence, num_bases, basenames);
2275     if (!rset)
2276         return 0;
2277
2278     if (zh->errCode)
2279         logf (LOG_DEBUG, "search error: %d", zh->errCode);
2280     
2281     for (i = 0; sort_sequence->specs[i]; i++)
2282         ;
2283     sort_sequence->num_specs = i;
2284     if (!i)
2285         resultSetRank (zh, sset, rset);
2286     else
2287     {
2288         logf (LOG_DEBUG, "resultSetSortSingle in rpn_search");
2289         resultSetSortSingle (zh, nmem, sset, rset,
2290                              sort_sequence, &sort_status);
2291         if (zh->errCode)
2292         {
2293             logf (LOG_DEBUG, "resultSetSortSingle status = %d", zh->errCode);
2294         }
2295     }
2296     return rset;
2297 }
2298
2299 struct scan_info_entry {
2300     char *term;
2301     ISAMS_P isam_p;
2302 };
2303
2304 struct scan_info {
2305     struct scan_info_entry *list;
2306     ODR odr;
2307     int before, after;
2308     char prefix[20];
2309 };
2310
2311 static int scan_handle (char *name, const char *info, int pos, void *client)
2312 {
2313     int len_prefix, idx;
2314     struct scan_info *scan_info = (struct scan_info *) client;
2315
2316     len_prefix = strlen(scan_info->prefix);
2317     if (memcmp (name, scan_info->prefix, len_prefix))
2318         return 1;
2319     if (pos > 0)        idx = scan_info->after - pos + scan_info->before;
2320     else
2321         idx = - pos - 1;
2322     scan_info->list[idx].term = (char *)
2323         odr_malloc (scan_info->odr, strlen(name + len_prefix)+1);
2324     strcpy (scan_info->list[idx].term, name + len_prefix);
2325     assert (*info == sizeof(ISAMS_P));
2326     memcpy (&scan_info->list[idx].isam_p, info+1, sizeof(ISAMS_P));
2327     return 0;
2328 }
2329
2330 static void scan_term_untrans (ZebraHandle zh, NMEM stream, int reg_type,
2331                                char **dst, const char *src)
2332 {
2333     char term_dst[1024];
2334     
2335     term_untrans (zh, reg_type, term_dst, src);
2336     
2337     *dst = (char *) nmem_malloc (stream, strlen(term_dst)+1);
2338     strcpy (*dst, term_dst);
2339 }
2340
2341 static void count_set (RSET r, int *count)
2342 {
2343     int psysno = 0;
2344     int kno = 0;
2345     struct it_key key;
2346     RSFD rfd;
2347     int term_index;
2348
2349     logf (LOG_DEBUG, "count_set");
2350
2351     *count = 0;
2352     rfd = rset_open (r, RSETF_READ);
2353     while (rset_read (r, rfd, &key, &term_index))
2354     {
2355         if (key.sysno != psysno)
2356         {
2357             psysno = key.sysno;
2358             (*count)++;
2359         }
2360         kno++;
2361     }
2362     rset_close (r, rfd);
2363     logf (LOG_DEBUG, "%d keys, %d records", kno, *count);
2364 }
2365
2366 void rpn_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
2367                oid_value attributeset,
2368                int num_bases, char **basenames,
2369                int *position, int *num_entries, ZebraScanEntry **list,
2370                int *is_partial)
2371 {
2372     int i;
2373     int pos = *position;
2374     int num = *num_entries;
2375     int before;
2376     int after;
2377     int base_no;
2378     char termz[IT_MAX_WORD+20];
2379     AttrType use;
2380     int use_value;
2381     struct scan_info *scan_info_array;
2382     ZebraScanEntry *glist;
2383     int ords[32], ord_no = 0;
2384     int ptr[32];
2385
2386     unsigned reg_id;
2387     char *search_type = NULL;
2388     char rank_type[128];
2389     int complete_flag;
2390     int sort_flag;
2391     *list = 0;
2392
2393     if (attributeset == VAL_NONE)
2394         attributeset = VAL_BIB1;
2395
2396     yaz_log (LOG_DEBUG, "position = %d, num = %d set=%d",
2397              pos, num, attributeset);
2398         
2399     attr_init (&use, zapt, 1);
2400     use_value = attr_find (&use, &attributeset);
2401
2402     if (zebra_maps_attr (zh->reg->zebra_maps, zapt, &reg_id, &search_type,
2403                          rank_type, &complete_flag, &sort_flag))
2404     {
2405         *num_entries = 0;
2406         zh->errCode = 113;
2407         return ;
2408     }
2409     yaz_log (LOG_DEBUG, "use_value = %d", use_value);
2410
2411     if (use_value == -1)
2412         use_value = 1016;
2413     for (base_no = 0; base_no < num_bases && ord_no < 32; base_no++)
2414     {
2415         int r;
2416         attent attp;
2417         data1_local_attribute *local_attr;
2418
2419         if ((r=att_getentbyatt (zh, &attp, attributeset, use_value)))
2420         {
2421             logf (LOG_DEBUG, "att_getentbyatt fail. set=%d use=%d",
2422                   attributeset, use_value);
2423             if (r == -1)
2424                 zh->errCode = 114;
2425             else
2426                 zh->errCode = 121;
2427             *num_entries = 0;
2428             return;
2429         }
2430         if (zebraExplain_curDatabase (zh->reg->zei, basenames[base_no]))
2431         {
2432             zh->errString = basenames[base_no];
2433             zh->errCode = 109; /* Database unavailable */
2434             *num_entries = 0;
2435             return;
2436         }
2437         for (local_attr = attp.local_attributes; local_attr && ord_no < 32;
2438              local_attr = local_attr->next)
2439         {
2440             int ord;
2441
2442             ord = zebraExplain_lookupSU (zh->reg->zei, attp.attset_ordinal,
2443                                          local_attr->local);
2444             if (ord > 0)
2445                 ords[ord_no++] = ord;
2446         }
2447     }
2448     if (ord_no == 0)
2449     {
2450         *num_entries = 0;
2451         zh->errCode = 113;
2452         return;
2453     }
2454     /* prepare dictionary scanning */
2455     before = pos-1;
2456     after = 1+num-pos;
2457     scan_info_array = (struct scan_info *)
2458         odr_malloc (stream, ord_no * sizeof(*scan_info_array));
2459     for (i = 0; i < ord_no; i++)
2460     {
2461         int j, prefix_len = 0;
2462         int before_tmp = before, after_tmp = after;
2463         struct scan_info *scan_info = scan_info_array + i;
2464         struct rpn_char_map_info rcmi;
2465
2466         rpn_char_map_prepare (zh->reg, reg_id, &rcmi);
2467
2468         scan_info->before = before;
2469         scan_info->after = after;
2470         scan_info->odr = stream;
2471
2472         scan_info->list = (struct scan_info_entry *)
2473             odr_malloc (stream, (before+after) * sizeof(*scan_info->list));
2474         for (j = 0; j<before+after; j++)
2475             scan_info->list[j].term = NULL;
2476
2477         prefix_len += key_SU_encode (ords[i], termz + prefix_len);
2478         termz[prefix_len++] = reg_id;
2479         termz[prefix_len] = 0;
2480         strcpy (scan_info->prefix, termz);
2481
2482         trans_scan_term (zh, zapt, termz+prefix_len, reg_id);
2483                     
2484         dict_scan (zh->reg->dict, termz, &before_tmp, &after_tmp,
2485                    scan_info, scan_handle);
2486     }
2487     glist = (ZebraScanEntry *)
2488         odr_malloc (stream, (before+after)*sizeof(*glist));
2489
2490     /* consider terms after main term */
2491     for (i = 0; i < ord_no; i++)
2492         ptr[i] = before;
2493     
2494     *is_partial = 0;
2495     for (i = 0; i<after; i++)
2496     {
2497         int j, j0 = -1;
2498         const char *mterm = NULL;
2499         const char *tst;
2500         RSET rset;
2501         
2502         for (j = 0; j < ord_no; j++)
2503         {
2504             if (ptr[j] < before+after &&
2505                 (tst=scan_info_array[j].list[ptr[j]].term) &&
2506                 (!mterm || strcmp (tst, mterm) < 0))
2507             {
2508                 j0 = j;
2509                 mterm = tst;
2510             }
2511         }
2512         if (j0 == -1)
2513             break;
2514         scan_term_untrans (zh, stream->mem, reg_id,
2515                            &glist[i+before].term, mterm);
2516         rset = rset_trunc (zh, &scan_info_array[j0].list[ptr[j0]].isam_p, 1,
2517                            glist[i+before].term, strlen(glist[i+before].term),
2518                            NULL, 0);
2519
2520         ptr[j0]++;
2521         for (j = j0+1; j<ord_no; j++)
2522         {
2523             if (ptr[j] < before+after &&
2524                 (tst=scan_info_array[j].list[ptr[j]].term) &&
2525                 !strcmp (tst, mterm))
2526             {
2527                 rset_bool_parms bool_parms;
2528                 RSET rset2;
2529
2530                 rset2 =
2531                    rset_trunc (zh, &scan_info_array[j].list[ptr[j]].isam_p, 1,
2532                                glist[i+before].term,
2533                                strlen(glist[i+before].term), NULL, 0);
2534
2535                 bool_parms.key_size = sizeof(struct it_key);
2536                 bool_parms.cmp = key_compare_it;
2537                 bool_parms.rset_l = rset;
2538                 bool_parms.rset_r = rset2;
2539               
2540                 rset = rset_create (rset_kind_or, &bool_parms);
2541
2542                 ptr[j]++;
2543             }
2544         }
2545         count_set (rset, &glist[i+before].occurrences);
2546         rset_delete (rset);
2547     }
2548     if (i < after)
2549     {
2550         *num_entries -= (after-i);
2551         *is_partial = 1;
2552     }
2553
2554     /* consider terms before main term */
2555     for (i = 0; i<ord_no; i++)
2556         ptr[i] = 0;
2557
2558     for (i = 0; i<before; i++)
2559     {
2560         int j, j0 = -1;
2561         const char *mterm = NULL;
2562         const char *tst;
2563         RSET rset;
2564         
2565         for (j = 0; j <ord_no; j++)
2566         {
2567             if (ptr[j] < before &&
2568                 (tst=scan_info_array[j].list[before-1-ptr[j]].term) &&
2569                 (!mterm || strcmp (tst, mterm) > 0))
2570             {
2571                 j0 = j;
2572                 mterm = tst;
2573             }
2574         }
2575         if (j0 == -1)
2576             break;
2577
2578         scan_term_untrans (zh, stream->mem, reg_id,
2579                            &glist[before-1-i].term, mterm);
2580
2581         rset = rset_trunc
2582                (zh, &scan_info_array[j0].list[before-1-ptr[j0]].isam_p, 1,
2583                 glist[before-1-i].term, strlen(glist[before-1-i].term),
2584                 NULL, 0);
2585
2586         ptr[j0]++;
2587
2588         for (j = j0+1; j<ord_no; j++)
2589         {
2590             if (ptr[j] < before &&
2591                 (tst=scan_info_array[j].list[before-1-ptr[j]].term) &&
2592                 !strcmp (tst, mterm))
2593             {
2594                 rset_bool_parms bool_parms;
2595                 RSET rset2;
2596
2597                 rset2 = rset_trunc (zh,
2598                          &scan_info_array[j].list[before-1-ptr[j]].isam_p, 1,
2599                                     glist[before-1-i].term,
2600                                     strlen(glist[before-1-i].term), NULL, 0);
2601
2602                 bool_parms.key_size = sizeof(struct it_key);
2603                 bool_parms.cmp = key_compare_it;
2604                 bool_parms.rset_l = rset;
2605                 bool_parms.rset_r = rset2;
2606               
2607                 rset = rset_create (rset_kind_or, &bool_parms);
2608
2609                 ptr[j]++;
2610             }
2611         }
2612         count_set (rset, &glist[before-1-i].occurrences);
2613         rset_delete (rset);
2614     }
2615     i = before-i;
2616     if (i)
2617     {
2618         *is_partial = 1;
2619         *position -= i;
2620         *num_entries -= i;
2621     }
2622     *list = glist + i;               /* list is set to first 'real' entry */
2623     
2624     logf (LOG_DEBUG, "position = %d, num_entries = %d",
2625           *position, *num_entries);
2626     if (zh->errCode)
2627         logf (LOG_DEBUG, "scan error: %d", zh->errCode);
2628 }
2629