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