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