index/zrpn.c

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