index/zrpn.c

   1 /*
   2  * Copyright (C) 1995-1998, Index Data I/S
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: zrpn.c,v $
   7  * Revision 1.75  1998-03-05 08:45:13  adam
   8  * New result set model and modular ranking system. Moved towards
   9  * descent server API. System information stored as "SGML" records.
  10  *
  11  * Revision 1.74  1998/02/10 12:03:06  adam
  12  * Implemented Sort.
  13  *
  14  * Revision 1.73  1998/01/29 13:40:11  adam
  15  * Better logging for scan service.
  16  *
  17  * Revision 1.72  1998/01/07 13:53:41  adam
  18  * Queries using simple ranked operands returns right number of hits.
  19  *
  20  * Revision 1.71  1997/12/18 10:54:24  adam
  21  * New method result set method rs_hits that returns the number of
  22  * hits in result-set (if known). The ranked result set returns real
  23  * number of hits but only when not combined with other operands.
  24  *
  25  * Revision 1.70  1997/10/31 12:34:43  adam
  26  * Changed a few log statements.
  27  *
  28  * Revision 1.69  1997/10/29 12:05:02  adam
  29  * Server produces diagnostic "Unsupported Attribute Set" when appropriate.
  30  *
  31  * Revision 1.68  1997/10/27 14:33:06  adam
  32  * Moved towards generic character mapping depending on "structure"
  33  * field in abstract syntax file. Fixed a few memory leaks. Fixed
  34  * bug with negative integers when doing searches with relational
  35  * operators.
  36  *
  37  * Revision 1.67  1997/09/29 09:06:10  adam
  38  * Removed one static var in order to make this module thread safe.
  39  *
  40  * Revision 1.66  1997/09/25 14:58:03  adam
  41  * Windows NT port.
  42  *
  43  * Revision 1.65  1997/09/22 12:39:06  adam
  44  * Added get_pos method for the ranked result sets.
  45  *
  46  * Revision 1.64  1997/09/18 08:59:20  adam
  47  * Extra generic handle for the character mapping routines.
  48  *
  49  * Revision 1.63  1997/09/17 12:19:18  adam
  50  * Zebra version corresponds to YAZ version 1.4.
  51  * Changed Zebra server so that it doesn't depend on global common_resource.
  52  *
  53  * Revision 1.62  1997/09/05 15:30:09  adam
  54  * Changed prototype for chr_map_input - added const.
  55  * Added support for C++, headers uses extern "C" for public definitions.
  56  *
  57  * Revision 1.61  1997/02/10 10:21:14  adam
  58  * Bug fix: in search terms character (^) wasn't observed.
  59  *
  60  * Revision 1.60  1997/01/31 11:10:34  adam
  61  * Bug fix: Leading and trailing white space weren't removed in scan tokens.
  62  *
  63  * Revision 1.59  1997/01/17 11:31:46  adam
  64  * Bug fix: complete phrase search didn't work.
  65  *
  66  * Revision 1.58  1996/12/23 15:30:45  adam
  67  * Work on truncation.
  68  * Bug fix: result sets weren't deleted after server shut down.
  69  *
  70  * Revision 1.57  1996/11/11 13:38:02  adam
  71  * Added proximity support in search.
  72  *
  73  * Revision 1.56  1996/11/08 11:10:32  adam
  74  * Buffers used during file match got bigger.
  75  * Compressed ISAM support everywhere.
  76  * Bug fixes regarding masking characters in queries.
  77  * Redesigned Regexp-2 queries.
  78  *
  79  * Revision 1.55  1996/11/04 14:07:44  adam
  80  * Moved truncation code to trunc.c.
  81  *
  82  * Revision 1.54  1996/10/29 14:09:52  adam
  83  * Use of cisam system - enabled if setting isamc is 1.
  84  *
  85  * Revision 1.53  1996/06/26 09:21:43  adam
  86  * Bug fix: local attribute set wasn't obeyed in scan.
  87  *
  88  * Revision 1.52  1996/06/17  14:26:20  adam
  89  * Function gen_regular_rel changed to handle negative numbers.
  90  *
  91  * Revision 1.51  1996/06/11 10:54:15  quinn
  92  * Relevance work
  93  *
  94  * Revision 1.50  1996/06/07  08:51:53  adam
  95  * Bug fix: Character mapping was broken (introducued by last revision).
  96  *
  97  * Revision 1.49  1996/06/04  10:18:11  adam
  98  * Search/scan uses character mapping module.
  99  *
 100  * Revision 1.48  1996/05/28  15:15:01  adam
 101  * Bug fix: Didn't handle unknown database correctly.
 102  *
 103  * Revision 1.47  1996/05/15  18:36:28  adam
 104  * Function trans_term transforms unsearchable characters to blanks.
 105  *
 106  * Revision 1.46  1996/05/15  11:57:56  adam
 107  * Fixed bug introduced by set/field mapping in search operations.
 108  *
 109  * Revision 1.45  1996/05/14  11:34:00  adam
 110  * Scan support in multiple registers/databases.
 111  *
 112  * Revision 1.44  1996/05/14  06:16:44  adam
 113  * Compact use/set bytes used in search service.
 114  *
 115  * Revision 1.43  1996/05/09 09:54:43  adam
 116  * Server supports maps from one logical attributes to a list of physical
 117  * attributes.
 118  * The extraction process doesn't make space consuming 'any' keys.
 119  *
 120  * Revision 1.42  1996/05/09  07:28:56  quinn
 121  * Work towards phrases and multiple registers
 122  *
 123  * Revision 1.41  1996/03/20  09:36:43  adam
 124  * Function dict_lookup_grep got extra parameter, init_pos, which marks
 125  * from which position in pattern approximate pattern matching should occur.
 126  * Approximate pattern matching is used in relevance=re-2.
 127  *
 128  * Revision 1.40  1996/02/02  13:44:44  adam
 129  * The public dictionary functions simply use char instead of Dict_char
 130  * to represent search strings. Dict_char is used internally only.
 131  *
 132  * Revision 1.39  1996/01/03  16:22:13  quinn
 133  * operator->roperator
 134  *
 135  * Revision 1.38  1995/12/11  09:12:55  adam
 136  * The rec_get function returns NULL if record doesn't exist - will
 137  * happen in the server if the result set records have been deleted since
 138  * the creation of the set (i.e. the search).
 139  * The server saves a result temporarily if it is 'volatile', i.e. the
 140  * set is register dependent.
 141  *
 142  * Revision 1.37  1995/12/06  15:05:28  adam
 143  * More verbose in count_set.
 144  *
 145  * Revision 1.36  1995/12/06  12:41:27  adam
 146  * New command 'stat' for the index program.
 147  * Filenames can be read from stdin by specifying '-'.
 148  * Bug fix/enhancement of the transformation from terms to regular
 149  * expressons in the search engine.
 150  *
 151  * Revision 1.35  1995/11/27  09:29:00  adam
 152  * Bug fixes regarding conversion to regular expressions.
 153  *
 154  * Revision 1.34  1995/11/16  17:00:56  adam
 155  * Better logging of rpn query.
 156  *
 157  * Revision 1.33  1995/11/01  13:58:28  quinn
 158  * Moving data1 to yaz/retrieval
 159  *
 160  * Revision 1.32  1995/10/27  14:00:11  adam
 161  * Implemented detection of database availability.
 162  *
 163  * Revision 1.31  1995/10/17  18:02:10  adam
 164  * New feature: databases. Implemented as prefix to words in dictionary.
 165  *
 166  * Revision 1.30  1995/10/16  09:32:38  adam
 167  * More work on relational op.
 168  *
 169  * Revision 1.29  1995/10/13  16:01:49  adam
 170  * Work on relations.
 171  *
 172  * Revision 1.28  1995/10/13  12:26:43  adam
 173  * Optimization of truncation.
 174  *
 175  * Revision 1.27  1995/10/12  17:07:22  adam
 176  * Truncation works.
 177  *
 178  * Revision 1.26  1995/10/12  12:40:54  adam
 179  * Bug fixes in rpn_prox.
 180  *
 181  * Revision 1.25  1995/10/10  13:59:24  adam
 182  * Function rset_open changed its wflag parameter to general flags.
 183  *
 184  * Revision 1.24  1995/10/09  16:18:37  adam
 185  * Function dict_lookup_grep got extra client data parameter.
 186  *
 187  * Revision 1.23  1995/10/06  16:33:37  adam
 188  * Use attribute mappings.
 189  *
 190  * Revision 1.22  1995/10/06  15:07:39  adam
 191  * Structure 'local-number' handled.
 192  *
 193  * Revision 1.21  1995/10/06  13:52:06  adam
 194  * Bug fixes. Handler may abort further scanning.
 195  *
 196  * Revision 1.20  1995/10/06  11:06:33  adam
 197  * Scan entries include 'occurrences' now.
 198  *
 199  * Revision 1.19  1995/10/06  10:43:56  adam
 200  * Scan added. 'occurrences' in scan entries not set yet.
 201  *
 202  * Revision 1.18  1995/10/04  16:57:20  adam
 203  * Key input and merge sort in one pass.
 204  *
 205  * Revision 1.17  1995/10/04  12:55:17  adam
 206  * Bug fix in ranked search. Use=Any keys inserted.
 207  *
 208  * Revision 1.16  1995/10/02  16:24:40  adam
 209  * Use attribute actually used in search requests.
 210  *
 211  * Revision 1.15  1995/10/02  15:18:52  adam
 212  * New member in recRetrieveCtrl: diagnostic.
 213  *
 214  * Revision 1.14  1995/09/28  12:10:32  adam
 215  * Bug fixes. Field prefix used in queries.
 216  *
 217  * Revision 1.13  1995/09/18  14:17:50  adam
 218  * Minor changes.
 219  *
 220  * Revision 1.12  1995/09/15  14:45:21  adam
 221  * Retrieve control.
 222  * Work on truncation.
 223  *
 224  * Revision 1.11  1995/09/14  11:53:27  adam
 225  * First work on regular expressions/truncations.
 226  *
 227  * Revision 1.10  1995/09/11  15:23:26  adam
 228  * More work on relevance search.
 229  *
 230  * Revision 1.9  1995/09/11  13:09:35  adam
 231  * More work on relevance feedback.
 232  *
 233  * Revision 1.8  1995/09/08  14:52:27  adam
 234  * Minor changes. Dictionary is lower case now.
 235  *
 236  * Revision 1.7  1995/09/07  13:58:36  adam
 237  * New parameter: result-set file descriptor (RSFD) to support multiple
 238  * positions within the same result-set.
 239  * Boolean operators: and, or, not implemented.
 240  * Result-set references.
 241  *
 242  * Revision 1.6  1995/09/06  16:11:18  adam
 243  * Option: only one word key per file.
 244  *
 245  * Revision 1.5  1995/09/06  10:33:04  adam
 246  * More work on present. Some log messages removed.
 247  *
 248  * Revision 1.4  1995/09/05  15:28:40  adam
 249  * More work on search engine.
 250  *
 251  * Revision 1.3  1995/09/04  15:20:22  adam
 252  * Minor changes.
 253  *
 254  * Revision 1.2  1995/09/04  12:33:43  adam
 255  * Various cleanup. YAZ util used instead.
 256  *
 257  * Revision 1.1  1995/09/04  09:10:40  adam
 258  * More work on index add/del/update.
 259  * Merge sort implemented.
 260  * Initial work on z39 server.
 261  *
 262  */
 263 #include <stdio.h>
 264 #include <assert.h>
 265 #ifdef WINDOWS
 266 #include <io.h>
 267 #else
 268 #include <unistd.h>
 269 #endif
 270 #include <ctype.h>
 271
 272 #include "zserver.h"
 273
 274 #include <charmap.h>
 275 #include <rstemp.h>
 276 #include <rsnull.h>
 277 #include <rsbool.h>
 278
 279 struct rpn_char_map_info {
 280     ZebraMaps zm;
 281     int reg_type;
 282 };
 283
 284 static const char **rpn_char_map_handler (void *vp, const char **from, int len)
 285 {
 286     struct rpn_char_map_info *p = vp;
 287     return zebra_maps_input (p->zm, p->reg_type, from, len);
 288 }
 289
 290 static void rpn_char_map_prepare (ZebraHandle zh, int reg_type,
 291                                   struct rpn_char_map_info *map_info)
 292 {
 293     map_info->zm = zh->zebra_maps;
 294     map_info->reg_type = reg_type;
 295     dict_grep_cmap (zh->dict, map_info, rpn_char_map_handler);
 296 }
 297
 298 typedef struct {
 299     int type;
 300     int major;
 301     int minor;
 302     Z_AttributesPlusTerm *zapt;
 303 } AttrType;
 304
 305 static int attr_find (AttrType *src, oid_value *attributeSetP)
 306 {
 307     while (src->major < src->zapt->num_attributes)
 308     {
 309         Z_AttributeElement *element;
 310
 311         element = src->zapt->attributeList[src->major];
 312         if (src->type == *element->attributeType)
 313         {
 314             switch (element->which)
 315             {
 316             case Z_AttributeValue_numeric:
 317                 ++(src->major);
 318                 if (element->attributeSet && attributeSetP)
 319                 {
 320                     oident *attrset;
 321
 322                     attrset = oid_getentbyoid (element->attributeSet);
 323                     *attributeSetP = attrset->value;
 324                 }
 325                 return *element->value.numeric;
 326                 break;
 327             case Z_AttributeValue_complex:
 328                 if (src->minor >= element->value.complex->num_list ||
 329                     element->value.complex->list[src->minor]->which !=
 330                     Z_StringOrNumeric_numeric)
 331                     break;
 332                 ++(src->minor);
 333                 if (element->attributeSet && attributeSetP)
 334                 {
 335                     oident *attrset;
 336
 337                     attrset = oid_getentbyoid (element->attributeSet);
 338                     *attributeSetP = attrset->value;
 339                 }
 340                 return *element->value.complex->list[src->minor-1]->u.numeric;
 341             default:
 342                 assert (0);
 343             }
 344         }
 345         ++(src->major);
 346     }
 347     return -1;
 348 }
 349
 350 static void attr_init (AttrType *src, Z_AttributesPlusTerm *zapt,
 351                        int type)
 352 {
 353     src->zapt = zapt;
 354     src->type = type;
 355     src->major = 0;
 356     src->minor = 0;
 357 }
 358
 359 #define TERM_COUNT
 360
 361 struct grep_info {
 362 #ifdef TERM_COUNT
 363     int *term_no;
 364 #endif
 365     ISAM_P *isam_p_buf;
 366     int isam_p_size;
 367     int isam_p_indx;
 368     ZebraHandle zh;
 369     int reg_type;
 370 };
 371
 372 static void term_untrans  (ZebraHandle zh, int reg_type,
 373                            char *dst, const char *src)
 374 {
 375     while (*src)
 376     {
 377         const char *cp = zebra_maps_output (zh->zebra_maps, reg_type, &src);
 378         while (*cp)
 379             *dst++ = *cp++;
 380     }
 381     *dst = '\0';
 382 }
 383
 384 static void add_isam_p (const char *name, const char *info,
 385                         struct grep_info *p)
 386 {
 387     char term_tmp[1024];
 388     if (p->isam_p_indx == p->isam_p_size)
 389     {
 390         ISAM_P *new_isam_p_buf;
 391 #ifdef TERM_COUNT
 392         int *new_term_no;
 393 #endif
 394         p->isam_p_size = 2*p->isam_p_size + 100;
 395         new_isam_p_buf = xmalloc (sizeof(*new_isam_p_buf) *
 396                                   p->isam_p_size);
 397         if (p->isam_p_buf)
 398         {
 399             memcpy (new_isam_p_buf, p->isam_p_buf,
 400                     p->isam_p_indx * sizeof(*p->isam_p_buf));
 401             xfree (p->isam_p_buf);
 402         }
 403         p->isam_p_buf = new_isam_p_buf;
 404
 405 #ifdef TERM_COUNT
 406         new_term_no = xmalloc (sizeof(*new_term_no) *
 407                                   p->isam_p_size);
 408         if (p->term_no)
 409         {
 410             memcpy (new_term_no, p->isam_p_buf,
 411                     p->isam_p_indx * sizeof(*p->term_no));
 412             xfree (p->term_no);
 413         }
 414         p->term_no = new_term_no;
 415 #endif
 416     }
 417     assert (*info == sizeof(*p->isam_p_buf));
 418     memcpy (p->isam_p_buf + p->isam_p_indx, info+1, sizeof(*p->isam_p_buf));
 419
 420     term_untrans  (p->zh, p->reg_type, term_tmp, name+2);
 421     logf (LOG_DEBUG, "grep: %s", term_tmp);
 422
 423     (p->isam_p_indx)++;
 424 }
 425
 426 static int grep_handle (char *name, const char *info, void *p)
 427 {
 428     add_isam_p (name, info, p);
 429     return 0;
 430 }
 431
 432 static int term_pre (ZebraMaps zebra_maps, int reg_type, const char **src,
 433                      const char *ct1, const char *ct2)
 434 {
 435     const char *s1, *s0 = *src;
 436     const char **map;
 437
 438     /* skip white space */
 439     while (*s0)
 440     {
 441         if (ct1 && strchr (ct1, *s0))
 442             break;
 443         if (ct2 && strchr (ct2, *s0))
 444             break;
 445         s1 = s0;
 446         map = zebra_maps_input (zebra_maps, reg_type, &s1, strlen(s1));
 447         if (**map != *CHR_SPACE)
 448             break;
 449         s0 = s1;
 450     }
 451     *src = s0;
 452     return *s0;
 453 }
 454
 455 static int term_100 (ZebraMaps zebra_maps, int reg_type,
 456                      const char **src, char *dst, int space_split,
 457                      char *dst_term)
 458 {
 459     const char *s0, *s1;
 460     const char **map;
 461     int i = 0;
 462     int j = 0;
 463
 464     if (!term_pre (zebra_maps, reg_type, src, NULL, NULL))
 465         return 0;
 466     s0 = *src;
 467     while (*s0)
 468     {
 469         s1 = s0;
 470         map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
 471         if (space_split && **map == *CHR_SPACE)
 472             break;
 473         while (s1 < s0)
 474         {
 475             if (!isalnum (*s1) && *s1 != '-')
 476                 dst[i++] = '\\';
 477             dst_term[j++] = *s1;
 478             dst[i++] = *s1++;
 479         }
 480     }
 481     dst[i] = '\0';
 482     dst_term[j] = '\0';
 483     *src = s0;
 484     return i;
 485 }
 486
 487 static int term_101 (ZebraMaps zebra_maps, int reg_type,
 488                      const char **src, char *dst, int space_split,
 489                      char *dst_term)
 490 {
 491     const char *s0, *s1;
 492     const char **map;
 493     int i = 0;
 494     int j = 0;
 495
 496     if (!term_pre (zebra_maps, reg_type, src, "#", "#"))
 497         return 0;
 498     s0 = *src;
 499     while (*s0)
 500     {
 501         if (*s0 == '#')
 502         {
 503             dst[i++] = '.';
 504             dst[i++] = '*';
 505             dst_term[j++] = *s0++;
 506         }
 507         else
 508         {
 509             s1 = s0;
 510             map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
 511             if (space_split && **map == *CHR_SPACE)
 512                 break;
 513             while (s1 < s0)
 514             {
 515                 if (!isalnum (*s1))
 516                     dst[i++] = '\\';
 517                 dst_term[j++] = *s1;
 518                 dst[i++] = *s1++;
 519             }
 520         }
 521     }
 522     dst[i] = '\0';
 523     dst_term[j++] = '\0';
 524     *src = s0;
 525     return i;
 526 }
 527
 528
 529 static int term_103 (ZebraMaps zebra_maps, int reg_type, const char **src,
 530                      char *dst, int *errors, int space_split,
 531                      char *dst_term)
 532 {
 533     int i = 0;
 534     int j = 0;
 535     const char *s0, *s1;
 536     const char **map;
 537
 538     if (!term_pre (zebra_maps, reg_type, src, "^\\()[].*+?|", "("))
 539         return 0;
 540     s0 = *src;
 541     if (errors && *s0 == '+' && s0[1] && s0[2] == '+' && s0[3] &&
 542         isdigit (s0[1]))
 543     {
 544         *errors = s0[1] - '0';
 545         s0 += 3;
 546         if (*errors > 3)
 547             *errors = 3;
 548     }
 549     while (*s0)
 550     {
 551         if (strchr ("^\\()[].*+?|-", *s0))
 552         {
 553             dst_term[j++] = *s0;
 554             dst[i++] = *s0++;
 555         }
 556         else
 557         {
 558             s1 = s0;
 559             map = zebra_maps_input (zebra_maps, reg_type, &s0, strlen(s0));
 560             if (**map == *CHR_SPACE)
 561                 break;
 562             while (s1 < s0)
 563             {
 564                 if (!isalnum (*s1))
 565                     dst[i++] = '\\';
 566                 dst_term[j++] = *s1;
 567                 dst[i++] = *s1++;
 568             }
 569         }
 570     }
 571     dst[i] = '\0';
 572     dst_term[j] = '\0';
 573     *src = s0;
 574     return i;
 575 }
 576
 577 static int term_102 (ZebraMaps zebra_maps, int reg_type, const char **src,
 578                      char *dst, int space_split, char *dst_term)
 579 {
 580     return term_103 (zebra_maps, reg_type, src, dst, NULL, space_split,
 581                      dst_term);
 582 }
 583
 584 /* gen_regular_rel - generate regular expression from relation
 585  *  val:     border value (inclusive)
 586  *  islt:    1 if <=; 0 if >=.
 587  */
 588 static void gen_regular_rel (char *dst, int val, int islt)
 589 {
 590     int dst_p;
 591     int w, d, i;
 592     int pos = 0;
 593     char numstr[20];
 594
 595     logf (LOG_DEBUG, "gen_regular_rel. val=%d, islt=%d", val, islt);
 596     if (val >= 0)
 597     {
 598         if (islt)
 599             strcpy (dst, "(-[0-9]+|(");
 600         else
 601             strcpy (dst, "((");
 602     }
 603     else
 604     {
 605         if (!islt)
 606         {
 607             strcpy (dst, "([0-9]+|-(");
 608             dst_p = strlen (dst);
 609             islt = 1;
 610         }
 611         else
 612         {
 613             strcpy (dst, "((-");
 614             islt = 0;
 615         }
 616         val = -val;
 617     }
 618     dst_p = strlen (dst);
 619     sprintf (numstr, "%d", val);
 620     for (w = strlen(numstr); --w >= 0; pos++)
 621     {
 622         d = numstr[w];
 623         if (pos > 0)
 624         {
 625             if (islt)
 626             {
 627                 if (d == '0')
 628                     continue;
 629                 d--;
 630             }
 631             else
 632             {
 633                 if (d == '9')
 634                     continue;
 635                 d++;
 636             }
 637         }
 638
 639         strcpy (dst + dst_p, numstr);
 640         dst_p = strlen(dst) - pos - 1;
 641
 642         if (islt)
 643         {
 644             if (d != '0')
 645             {
 646                 dst[dst_p++] = '[';
 647                 dst[dst_p++] = '0';
 648                 dst[dst_p++] = '-';
 649                 dst[dst_p++] = d;
 650                 dst[dst_p++] = ']';
 651             }
 652             else
 653                 dst[dst_p++] = d;
 654         }
 655         else
 656         {
 657             if (d != '9')
 658             {
 659                 dst[dst_p++] = '[';
 660                 dst[dst_p++] = d;
 661                 dst[dst_p++] = '-';
 662                 dst[dst_p++] = '9';
 663                 dst[dst_p++] = ']';
 664             }
 665             else
 666                 dst[dst_p++] = d;
 667         }
 668         for (i = 0; i<pos; i++)
 669         {
 670             dst[dst_p++] = '[';
 671             dst[dst_p++] = '0';
 672             dst[dst_p++] = '-';
 673             dst[dst_p++] = '9';
 674             dst[dst_p++] = ']';
 675         }
 676         dst[dst_p++] = '|';
 677     }
 678     dst[dst_p] = '\0';
 679     if (islt)
 680     {
 681         for (i=1; i<pos; i++)
 682             strcat (dst, "[0-9]?");
 683     }
 684     else
 685     {
 686         for (i = 0; i <= pos; i++)
 687             strcat (dst, "[0-9]");
 688         strcat (dst, "[0-9]*");
 689     }
 690     strcat (dst, "))");
 691 }
 692
 693 static int relational_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
 694                             const char **term_sub,
 695                             char *term_dict,
 696                             oid_value attributeSet,
 697                             struct grep_info *grep_info,
 698                             int *max_pos,
 699                             int reg_type,
 700                             char *term_dst)
 701 {
 702     AttrType relation;
 703     int relation_value;
 704     int term_value;
 705     int r;
 706     char *term_tmp = term_dict + strlen(term_dict);
 707
 708     attr_init (&relation, zapt, 2);
 709     relation_value = attr_find (&relation, NULL);
 710
 711     logf (LOG_DEBUG, "relation value=%d", relation_value);
 712     switch (relation_value)
 713     {
 714     case 1:
 715         if (!term_100 (zh->zebra_maps, reg_type, term_sub, term_tmp, 1,
 716                        term_dst))
 717             return 0;
 718         term_value = atoi (term_tmp);
 719         logf (LOG_DEBUG, "Relation <");
 720         gen_regular_rel (term_tmp, term_value-1, 1);
 721         break;
 722     case 2:
 723         if (!term_100 (zh->zebra_maps, reg_type, term_sub, term_tmp, 1,
 724                        term_dst))
 725             return 0;
 726         term_value = atoi (term_tmp);
 727         logf (LOG_DEBUG, "Relation <=");
 728         gen_regular_rel (term_tmp, term_value, 1);
 729         break;
 730     case 4:
 731         if (!term_100 (zh->zebra_maps, reg_type, term_sub, term_tmp, 1,
 732                        term_dst))
 733             return 0;
 734         term_value = atoi (term_tmp);
 735         logf (LOG_DEBUG, "Relation >=");
 736         gen_regular_rel (term_tmp, term_value, 0);
 737         break;
 738     case 5:
 739         if (!term_100 (zh->zebra_maps, reg_type, term_sub, term_tmp, 1,
 740                        term_dst))
 741             return 0;
 742         term_value = atoi (term_tmp);
 743         logf (LOG_DEBUG, "Relation >");
 744         gen_regular_rel (term_tmp, term_value+1, 0);
 745         break;
 746     default:
 747         return 0;
 748     }
 749     logf (LOG_DEBUG, "dict_lookup_grep: %s", term_tmp);
 750     r = dict_lookup_grep (zh->dict, term_dict, 0, grep_info, max_pos,
 751                           0, grep_handle);
 752     if (r)
 753         logf (LOG_WARN, "dict_lookup_grep fail, rel=gt: %d", r);
 754     logf (LOG_DEBUG, "%d positions", grep_info->isam_p_indx);
 755     return 1;
 756 }
 757
 758 static int field_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
 759                        const char **term_sub,
 760                        oid_value attributeSet, struct grep_info *grep_info,
 761                        int reg_type, int complete_flag,
 762                        int num_bases, char **basenames,
 763                        char *term_dst)
 764 {
 765     char term_dict[2*IT_MAX_WORD+2];
 766     int j, r, base_no;
 767     AttrType truncation;
 768     int truncation_value;
 769     AttrType use;
 770     int use_value;
 771     oid_value curAttributeSet = attributeSet;
 772     const char *termp;
 773     struct rpn_char_map_info rcmi;
 774     int space_split = complete_flag ? 0 : 1;
 775
 776     rpn_char_map_prepare (zh, reg_type, &rcmi);
 777     attr_init (&use, zapt, 1);
 778     use_value = attr_find (&use, &curAttributeSet);
 779     logf (LOG_DEBUG, "field_term, use value %d", use_value);
 780     attr_init (&truncation, zapt, 5);
 781     truncation_value = attr_find (&truncation, NULL);
 782     logf (LOG_DEBUG, "truncation value %d", truncation_value);
 783
 784     if (use_value == -1)
 785         use_value = 1016;
 786
 787     for (base_no = 0; base_no < num_bases; base_no++)
 788     {
 789         attent attp;
 790         data1_local_attribute *local_attr;
 791         int max_pos, prefix_len = 0;
 792
 793         termp = *term_sub;
 794         if ((r=att_getentbyatt (zh, &attp, curAttributeSet, use_value)))
 795         {
 796             logf (LOG_DEBUG, "att_getentbyatt fail. set=%d use=%d r=%d",
 797                   curAttributeSet, use_value, r);
 798             if (r == -1)
 799                 zh->errCode = 114;
 800             else
 801                 zh->errCode = 121;
 802             return -1;
 803         }
 804         if (zebraExplain_curDatabase (zh->zei, basenames[base_no]))
 805         {
 806             zh->errCode = 109; /* Database unavailable */
 807             zh->errString = basenames[base_no];
 808             return -1;
 809         }
 810         for (local_attr = attp.local_attributes; local_attr;
 811              local_attr = local_attr->next)
 812         {
 813             int ord;
 814
 815             ord = zebraExplain_lookupSU (zh->zei, attp.attset_ordinal,
 816                                           local_attr->local);
 817             if (ord < 0)
 818                 continue;
 819             if (prefix_len)
 820                 term_dict[prefix_len++] = '|';
 821             else
 822                 term_dict[prefix_len++] = '(';
 823             term_dict[prefix_len++] = 1;
 824             term_dict[prefix_len++] = ord;
 825         }
 826         if (!prefix_len)
 827         {
 828             zh->errCode = 114;
 829             return -1;
 830         }
 831         term_dict[prefix_len++] = ')';
 832         term_dict[prefix_len++] = 1;
 833         term_dict[prefix_len++] = reg_type;
 834         logf (LOG_DEBUG, "reg_type = %d", term_dict[prefix_len-1]);
 835         term_dict[prefix_len] = '\0';
 836         if (!relational_term (zh, zapt, &termp, term_dict,
 837                               attributeSet, grep_info, &max_pos, reg_type,
 838                               term_dst))
 839         {
 840             j = prefix_len;
 841             switch (truncation_value)
 842             {
 843             case -1:         /* not specified */
 844             case 100:        /* do not truncate */
 845                 term_dict[j++] = '(';
 846                 if (!term_100 (zh->zebra_maps, reg_type,
 847                                &termp, term_dict + j, space_split, term_dst))
 848                     return 0;
 849                 strcat (term_dict, ")");
 850                 r = dict_lookup_grep (zh->dict, term_dict, 0, grep_info,
 851                                       &max_pos, 0, grep_handle);
 852                 if (r)
 853                     logf (LOG_WARN, "dict_lookup_grep err, trunc=none:%d", r);
 854                 break;
 855             case 1:          /* right truncation */
 856                 term_dict[j++] = '(';
 857                 if (!term_100 (zh->zebra_maps, reg_type,
 858                                &termp, term_dict + j, space_split, term_dst))
 859                     return 0;
 860                 strcat (term_dict, ".*)");
 861                 dict_lookup_grep (zh->dict, term_dict, 0, grep_info,
 862                                   &max_pos, 0, grep_handle);
 863                 break;
 864             case 2:          /* left truncation */
 865             case 3:          /* left&right truncation */
 866                 zh->errCode = 120;
 867                 return -1;
 868             case 101:        /* process # in term */
 869                 term_dict[j++] = '(';
 870                 if (!term_101 (zh->zebra_maps, reg_type,
 871                                &termp, term_dict + j, space_split, term_dst))
 872                     return 0;
 873                 strcat (term_dict, ")");
 874                 r = dict_lookup_grep (zh->dict, term_dict, 0, grep_info,
 875                                       &max_pos, 0, grep_handle);
 876                 if (r)
 877                     logf (LOG_WARN, "dict_lookup_grep err, trunc=#: %d", r);
 878                 break;
 879             case 102:        /* Regexp-1 */
 880                 term_dict[j++] = '(';
 881                 if (!term_102 (zh->zebra_maps, reg_type,
 882                                &termp, term_dict + j, space_split, term_dst))
 883                     return 0;
 884                 strcat (term_dict, ")");
 885                 logf (LOG_DEBUG, "Regexp-1 tolerance=%d", r);
 886                 r = dict_lookup_grep (zh->dict, term_dict, 0, grep_info,
 887                                       &max_pos, 0, grep_handle);
 888                 if (r)
 889                     logf (LOG_WARN, "dict_lookup_grep err, trunc=regular: %d",
 890                           r);
 891                 break;
 892              case 103:       /* Regexp-2 */
 893                 r = 1;
 894                 term_dict[j++] = '(';
 895                 if (!term_103 (zh->zebra_maps, reg_type,
 896                                &termp, term_dict + j, &r, space_split, term_dst))
 897                     return 0;
 898                 strcat (term_dict, ")");
 899                 logf (LOG_DEBUG, "Regexp-2 tolerance=%d", r);
 900                 r = dict_lookup_grep (zh->dict, term_dict, r, grep_info,
 901                                       &max_pos, 2, grep_handle);
 902                 if (r)
 903                     logf (LOG_WARN, "dict_lookup_grep err, trunc=eregular: %d",
 904                           r);
 905                 break;
 906             }
 907         }
 908     }
 909     *term_sub = termp;
 910     logf (LOG_DEBUG, "%d positions", grep_info->isam_p_indx);
 911     return 1;
 912 }
 913
 914 static void trans_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
 915                         char *termz)
 916 {
 917     size_t sizez;
 918     Z_Term *term = zapt->term;
 919
 920     sizez = term->u.general->len;
 921     if (sizez > IT_MAX_WORD-1)
 922         sizez = IT_MAX_WORD-1;
 923     memcpy (termz, term->u.general->buf, sizez);
 924     termz[sizez] = '\0';
 925 }
 926
 927 static void trans_scan_term (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
 928                              char *termz, int reg_type)
 929 {
 930     Z_Term *term = zapt->term;
 931     const char **map;
 932     const char *cp = (const char *) term->u.general->buf;
 933     const char *cp_end = cp + term->u.general->len;
 934     const char *src;
 935     int i = 0;
 936     const char *space_map = NULL;
 937     int len;
 938
 939     while ((len = (cp_end - cp)) > 0)
 940     {
 941         map = zebra_maps_input (zh->zebra_maps, reg_type, &cp, len);
 942         if (**map == *CHR_SPACE)
 943             space_map = *map;
 944         else
 945         {
 946             if (i && space_map)
 947                 for (src = space_map; *src; src++)
 948                     termz[i++] = *src;
 949             space_map = NULL;
 950             for (src = *map; *src; src++)
 951                 termz[i++] = *src;
 952         }
 953     }
 954     termz[i] = '\0';
 955 }
 956
 957 static RSET rpn_proximity (ZebraHandle zh, RSET rset1, RSET rset2,
 958                            int ordered,
 959                            int exclusion, int relation, int distance)
 960 {
 961     int i;
 962     RSFD rsfd1, rsfd2;
 963     int  more1, more2;
 964     struct it_key buf1, buf2;
 965     RSFD rsfd_result;
 966     RSET result;
 967     rset_temp_parms parms;
 968     int term_index;
 969
 970     rsfd1 = rset_open (rset1, RSETF_READ);
 971     more1 = rset_read (rset1, rsfd1, &buf1, &term_index);
 972
 973     rsfd2 = rset_open (rset2, RSETF_READ);
 974     more2 = rset_read (rset2, rsfd2, &buf2, &term_index);
 975
 976     parms.key_size = sizeof (struct it_key);
 977     parms.temp_path = res_get (zh->res, "setTmpDir");
 978     result = rset_create (rset_kind_temp, &parms);
 979     rsfd_result = rset_open (result, RSETF_WRITE);
 980
 981     logf (LOG_DEBUG, "rpn_proximity  excl=%d ord=%d rel=%d dis=%d",
 982           exclusion, ordered, relation, distance);
 983     while (more1 && more2)
 984     {
 985         int cmp = key_compare_it (&buf1, &buf2);
 986         if (cmp < -1)
 987             more1 = rset_read (rset1, rsfd1, &buf1, &term_index);
 988         else if (cmp > 1)
 989             more2 = rset_read (rset2, rsfd2, &buf2, &term_index);
 990         else
 991         {
 992             int sysno = buf1.sysno;
 993             int seqno[500];
 994             int n = 0;
 995
 996             seqno[n++] = buf1.seqno;
 997             while ((more1 = rset_read (rset1, rsfd1, &buf1, &term_index)) &&
 998                    sysno == buf1.sysno)
 999                 if (n < 500)
1000                     seqno[n++] = buf1.seqno;
1001             do
1002             {
1003                 for (i = 0; i<n; i++)
1004                 {
1005                     int diff = buf2.seqno - seqno[i];
1006                     int excl = exclusion;
1007                     if (!ordered && diff < 0)
1008                         diff = -diff;
1009                     switch (relation)
1010                     {
1011                     case 1:      /* < */
1012                         if (diff < distance)
1013                             excl = !excl;
1014                         break;
1015                     case 2:      /* <= */
1016                         if (diff <= distance)
1017                             excl = !excl;
1018                         break;
1019                     case 3:      /* == */
1020                         if (diff == distance)
1021                             excl = !excl;
1022                         break;
1023                     case 4:      /* >= */
1024                         if (diff >= distance)
1025                             excl = !excl;
1026                         break;
1027                     case 5:      /* > */
1028                         if (diff > distance)
1029                             excl = !excl;
1030                         break;
1031                     case 6:      /* != */
1032                         if (diff != distance)
1033                             excl = !excl;
1034                         break;
1035                     }
1036                     if (excl)
1037                         rset_write (result, rsfd_result, &buf2);
1038                 }
1039             } while ((more2 = rset_read (rset2, rsfd2, &buf2, &term_index)) &&
1040                       sysno == buf2.sysno);
1041         }
1042     }
1043     rset_close (result, rsfd_result);
1044     rset_close (rset1, rsfd1);
1045     rset_close (rset2, rsfd2);
1046     return result;
1047 }
1048
1049 static RSET rpn_prox (ZebraHandle zh, RSET *rset, int rset_no)
1050 {
1051     int i;
1052     RSFD *rsfd;
1053     int  *more;
1054     struct it_key **buf;
1055     RSET result;
1056     char prox_term[1024];
1057     int length_prox_term = 0;
1058     int min_nn = 10000000;
1059     int term_index;
1060     const char *flags = NULL;
1061
1062     rsfd = xmalloc (sizeof(*rsfd)*rset_no);
1063     more = xmalloc (sizeof(*more)*rset_no);
1064     buf = xmalloc (sizeof(*buf)*rset_no);
1065
1066     for (i = 0; i<rset_no; i++)
1067     {
1068         int j;
1069         buf[i] = xmalloc (sizeof(**buf));
1070         rsfd[i] = rset_open (rset[i], RSETF_READ);
1071         if (!(more[i] = rset_read (rset[i], rsfd[i], buf[i], &term_index)))
1072             break;
1073         for (j = 0; j<rset[i]->no_rset_terms; j++)
1074         {
1075             const char *nflags = rset[i]->rset_terms[j]->flags;
1076             char *term = rset[i]->rset_terms[j]->name;
1077             int lterm = strlen(term);
1078             if (length_prox_term)
1079                 prox_term[length_prox_term++] = ' ';
1080             strcpy (prox_term + length_prox_term, term);
1081             length_prox_term += lterm;
1082             if (min_nn > rset[i]->rset_terms[j]->nn)
1083                 min_nn = rset[i]->rset_terms[j]->nn;
1084             flags = nflags;
1085         }
1086     }
1087     if (i != rset_no)
1088     {
1089         rset_null_parms parms;
1090
1091         while (i >= 0)
1092         {
1093             rset_close (rset[i], rsfd[i]);
1094             xfree (buf[i]);
1095             --i;
1096         }
1097         parms.rset_term = rset_term_create (prox_term, -1, flags);
1098         parms.rset_term->nn = 0;
1099         result = rset_create (rset_kind_null, &parms);
1100     }
1101     else
1102     {
1103         rset_temp_parms parms;
1104         RSFD rsfd_result;
1105
1106         parms.rset_term = rset_term_create (prox_term, -1, flags);
1107         parms.rset_term->nn = min_nn;
1108         parms.key_size = sizeof (struct it_key);
1109         parms.temp_path = res_get (zh->res, "setTmpDir");
1110         result = rset_create (rset_kind_temp, &parms);
1111         rsfd_result = rset_open (result, RSETF_WRITE);
1112
1113         while (*more)
1114         {
1115             for (i = 1; i<rset_no; i++)
1116             {
1117                 int cmp;
1118
1119                 if (!more[i])
1120                 {
1121                     *more = 0;
1122                     break;
1123                 }
1124                 cmp = key_compare_it (buf[i], buf[i-1]);
1125                 if (cmp > 1)
1126                 {
1127                     more[i-1] = rset_read (rset[i-1], rsfd[i-1],
1128                                            buf[i-1], &term_index);
1129                     break;
1130                 }
1131                 else if (cmp == 1)
1132                 {
1133                     if (buf[i-1]->seqno+1 != buf[i]->seqno)
1134                     {
1135                         more[i-1] = rset_read (rset[i-1], rsfd[i-1],
1136                                                buf[i-1], &term_index);
1137                         break;
1138                     }
1139                 }
1140                 else
1141                 {
1142                     more[i] = rset_read (rset[i], rsfd[i], buf[i],
1143                                          &term_index);
1144                     break;
1145                 }
1146             }
1147             if (i == rset_no)
1148             {
1149                 rset_write (result, rsfd_result, buf[0]);
1150                 more[0] = rset_read (*rset, *rsfd, *buf, &term_index);
1151             }
1152         }
1153
1154         for (i = 0; i<rset_no; i++)
1155         {
1156             rset_close (rset[i], rsfd[i]);
1157             xfree (buf[i]);
1158         }
1159         rset_close (result, rsfd_result);
1160     }
1161     xfree (buf);
1162     xfree (more);
1163     xfree (rsfd);
1164     return result;
1165 }
1166
1167 static RSET rpn_search_APT_phrase (ZebraHandle zh,
1168                                    Z_AttributesPlusTerm *zapt,
1169                                    const char *termz,
1170                                    oid_value attributeSet,
1171                                    int reg_type, int complete_flag,
1172                                    const char *rank_type,
1173                                    int num_bases, char **basenames)
1174 {
1175     char term_dst[IT_MAX_WORD+1];
1176     const char *termp = termz;
1177     RSET rset[60], result;
1178     int i, r, rset_no = 0;
1179     struct grep_info grep_info;
1180
1181 #ifdef TERM_COUNT
1182     grep_info.term_no = 0;
1183 #endif
1184     grep_info.isam_p_size = 0;
1185     grep_info.isam_p_buf = NULL;
1186     grep_info.zh = zh;
1187     grep_info.reg_type = reg_type;
1188
1189     while (1)
1190     {
1191         logf (LOG_DEBUG, "APT_phrase termp=%s", termp);
1192         grep_info.isam_p_indx = 0;
1193         r = field_term (zh, zapt, &termp, attributeSet, &grep_info,
1194                         reg_type, complete_flag, num_bases, basenames,
1195                         term_dst);
1196         if (r < 1)
1197             break;
1198         logf (LOG_DEBUG, "term: %s", term_dst);
1199         rset[rset_no] = rset_trunc (zh, grep_info.isam_p_buf,
1200                                     grep_info.isam_p_indx, term_dst,
1201                                     strlen(term_dst), rank_type);
1202         assert (rset[rset_no]);
1203         if (++rset_no >= sizeof(rset)/sizeof(*rset))
1204             break;
1205     }
1206 #ifdef TERM_COUNT
1207     xfree(grep_info.term_no);
1208 #endif
1209     xfree (grep_info.isam_p_buf);
1210     if (rset_no == 0)
1211     {
1212         rset_null_parms parms;
1213
1214         parms.rset_term = rset_term_create (term_dst, -1, rank_type);
1215         return rset_create (rset_kind_null, &parms);
1216     }
1217     else if (rset_no == 1)
1218         return (rset[0]);
1219     result = rpn_prox (zh, rset, rset_no);
1220     for (i = 0; i<rset_no; i++)
1221         rset_delete (rset[i]);
1222     return result;
1223 }
1224
1225 static RSET rpn_search_APT_or_list (ZebraHandle zh,
1226                                     Z_AttributesPlusTerm *zapt,
1227                                     const char *termz,
1228                                     oid_value attributeSet,
1229                                     int reg_type, int complete_flag,
1230                                     const char *rank_type,
1231                                     int num_bases, char **basenames)
1232 {
1233     char term_dst[IT_MAX_WORD+1];
1234     const char *termp = termz;
1235     RSET rset[60], result;
1236     int i, r, rset_no = 0;
1237     struct grep_info grep_info;
1238
1239 #ifdef TERM_COUNT
1240     grep_info.term_no = 0;
1241 #endif
1242     grep_info.isam_p_size = 0;
1243     grep_info.isam_p_buf = NULL;
1244     grep_info.zh = zh;
1245     grep_info.reg_type = reg_type;
1246
1247     while (1)
1248     {
1249         logf (LOG_DEBUG, "APT_or_list termp=%s", termp);
1250         grep_info.isam_p_indx = 0;
1251         r = field_term (zh, zapt, &termp, attributeSet, &grep_info,
1252                         reg_type, complete_flag, num_bases, basenames,
1253                         term_dst);
1254         if (r < 1)
1255             break;
1256         logf (LOG_DEBUG, "term: %s", term_dst);
1257         rset[rset_no] = rset_trunc (zh, grep_info.isam_p_buf,
1258                                     grep_info.isam_p_indx, term_dst,
1259                                     strlen(term_dst), rank_type);
1260         assert (rset[rset_no]);
1261         if (++rset_no >= sizeof(rset)/sizeof(*rset))
1262             break;
1263     }
1264 #ifdef TERM_COUNT
1265     xfree(grep_info.term_no);
1266 #endif
1267     xfree (grep_info.isam_p_buf);
1268     if (rset_no == 0)
1269     {
1270         rset_null_parms parms;
1271
1272         parms.rset_term = rset_term_create (term_dst, -1, rank_type);
1273         return rset_create (rset_kind_null, &parms);
1274     }
1275     result = rset[0];
1276     for (i = 1; i<rset_no; i++)
1277     {
1278         rset_bool_parms bool_parms;
1279
1280         bool_parms.rset_l = result;
1281         bool_parms.rset_r = rset[i];
1282         bool_parms.key_size = sizeof(struct it_key);
1283         bool_parms.cmp = key_compare_it;
1284         result = rset_create (rset_kind_or, &bool_parms);
1285     }
1286     return result;
1287 }
1288
1289 static RSET rpn_search_APT_and_list (ZebraHandle zh,
1290                                      Z_AttributesPlusTerm *zapt,
1291                                      const char *termz,
1292                                      oid_value attributeSet,
1293                                      int reg_type, int complete_flag,
1294                                      const char *rank_type,
1295                                      int num_bases, char **basenames)
1296 {
1297     char term_dst[IT_MAX_WORD+1];
1298     const char *termp = termz;
1299     RSET rset[60], result;
1300     int i, r, rset_no = 0;
1301     struct grep_info grep_info;
1302
1303 #ifdef TERM_COUNT
1304     grep_info.term_no = 0;
1305 #endif
1306     grep_info.isam_p_size = 0;
1307     grep_info.isam_p_buf = NULL;
1308     grep_info.zh = zh;
1309     grep_info.reg_type = reg_type;
1310
1311     while (1)
1312     {
1313         logf (LOG_DEBUG, "APT_and_list termp=%s", termp);
1314         grep_info.isam_p_indx = 0;
1315         r = field_term (zh, zapt, &termp, attributeSet, &grep_info,
1316                         reg_type, complete_flag, num_bases, basenames,
1317                         term_dst);
1318         if (r < 1)
1319             break;
1320         logf (LOG_DEBUG, "term: %s", term_dst);
1321         rset[rset_no] = rset_trunc (zh, grep_info.isam_p_buf,
1322                                     grep_info.isam_p_indx, term_dst,
1323                                     strlen(term_dst), rank_type);
1324         assert (rset[rset_no]);
1325         if (++rset_no >= sizeof(rset)/sizeof(*rset))
1326             break;
1327     }
1328 #ifdef TERM_COUNT
1329     xfree(grep_info.term_no);
1330 #endif
1331     xfree (grep_info.isam_p_buf);
1332     if (rset_no == 0)
1333     {
1334         rset_null_parms parms;
1335
1336         parms.rset_term = rset_term_create (term_dst, -1, rank_type);
1337         return rset_create (rset_kind_null, &parms);
1338     }
1339     result = rset[0];
1340     for (i = 1; i<rset_no; i++)
1341     {
1342         rset_bool_parms bool_parms;
1343
1344         bool_parms.rset_l = result;
1345         bool_parms.rset_r = rset[i];
1346         bool_parms.key_size = sizeof(struct it_key);
1347         bool_parms.cmp = key_compare_it;
1348         result = rset_create (rset_kind_and, &bool_parms);
1349     }
1350     return result;
1351 }
1352
1353
1354 static RSET rpn_search_APT_local (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
1355                                   const char *termz,
1356                                   oid_value attributeSet,
1357                                   const char *rank_type)
1358 {
1359     RSET result;
1360     RSFD rsfd;
1361     struct it_key key;
1362     rset_temp_parms parms;
1363
1364     parms.rset_term = rset_term_create (termz, -1, rank_type);
1365     parms.key_size = sizeof (struct it_key);
1366     parms.temp_path = res_get (zh->res, "setTmpDir");
1367     result = rset_create (rset_kind_temp, &parms);
1368     rsfd = rset_open (result, RSETF_WRITE);
1369
1370     key.sysno = atoi (termz);
1371     key.seqno = 1;
1372     if (key.sysno <= 0)
1373         key.sysno = 1;
1374     rset_write (result, rsfd, &key);
1375     rset_close (result, rsfd);
1376     return result;
1377 }
1378
1379 static RSET rpn_search_APT (ZebraHandle zh, Z_AttributesPlusTerm *zapt,
1380                             oid_value attributeSet,
1381                             int num_bases, char **basenames)
1382 {
1383     unsigned reg_id;
1384     char *search_type = NULL;
1385     char *rank_type = NULL;
1386     int complete_flag;
1387     char termz[IT_MAX_WORD+1];
1388
1389     zebra_maps_attr (zh->zebra_maps, zapt, &reg_id, &search_type,
1390                      &rank_type, &complete_flag);
1391
1392     logf (LOG_DEBUG, "reg_id=%c", reg_id);
1393     logf (LOG_DEBUG, "complete_flag=%d", complete_flag);
1394     logf (LOG_DEBUG, "search_type=%s", search_type);
1395     logf (LOG_DEBUG, "rank_type=%s", rank_type);
1396
1397     if (zapt->term->which != Z_Term_general)
1398     {
1399         zh->errCode = 124;
1400         return NULL;
1401     }
1402     trans_term (zh, zapt, termz);
1403
1404     if (!strcmp (search_type, "phrase"))
1405     {
1406         return rpn_search_APT_phrase (zh, zapt, termz, attributeSet,
1407                                       reg_id, complete_flag, rank_type,
1408                                       num_bases, basenames);
1409     }
1410     else if (!strcmp (search_type, "and-list"))
1411     {
1412         return rpn_search_APT_and_list (zh, zapt, termz, attributeSet,
1413                                         reg_id, complete_flag, rank_type,
1414                                         num_bases, basenames);
1415     }
1416     else if (!strcmp (search_type, "or-list"))
1417     {
1418         return rpn_search_APT_or_list (zh, zapt, termz, attributeSet,
1419                                        reg_id, complete_flag, rank_type,
1420                                        num_bases, basenames);
1421     }
1422     else if (!strcmp (search_type, "local"))
1423     {
1424         return rpn_search_APT_local (zh, zapt, termz, attributeSet,
1425                                      rank_type);
1426     }
1427     zh->errCode = 118;
1428     return NULL;
1429 }
1430
1431 static RSET rpn_search_structure (ZebraHandle zh, Z_RPNStructure *zs,
1432                                   oid_value attributeSet, ODR stream,
1433                                   int num_bases, char **basenames)
1434 {
1435     RSET r = NULL;
1436     if (zs->which == Z_RPNStructure_complex)
1437     {
1438         Z_Operator *zop = zs->u.complex->roperator;
1439         rset_bool_parms bool_parms;
1440
1441         bool_parms.rset_l = rpn_search_structure (zh, zs->u.complex->s1,
1442                                                   attributeSet, stream,
1443                                                   num_bases, basenames);
1444         if (bool_parms.rset_l == NULL)
1445             return NULL;
1446         bool_parms.rset_r = rpn_search_structure (zh, zs->u.complex->s2,
1447                                                   attributeSet, stream,
1448                                                   num_bases, basenames);
1449         if (bool_parms.rset_r == NULL)
1450         {
1451             rset_delete (bool_parms.rset_l);
1452             return NULL;
1453         }
1454         bool_parms.key_size = sizeof(struct it_key);
1455         bool_parms.cmp = key_compare_it;
1456
1457         switch (zop->which)
1458         {
1459         case Z_Operator_and:
1460             r = rset_create (rset_kind_and, &bool_parms);
1461             break;
1462         case Z_Operator_or:
1463             r = rset_create (rset_kind_or, &bool_parms);
1464             break;
1465         case Z_Operator_and_not:
1466             r = rset_create (rset_kind_not, &bool_parms);
1467             break;
1468         case Z_Operator_prox:
1469             if (zop->u.prox->which != Z_ProxCode_known)
1470             {
1471                 zh->errCode = 132;
1472                 return NULL;
1473             }
1474             if (*zop->u.prox->proximityUnitCode != Z_ProxUnit_word)
1475             {
1476                 char *val = odr_malloc (stream, 16);
1477                 zh->errCode = 132;
1478                 zh->errString = val;
1479                 sprintf (val, "%d", *zop->u.prox->proximityUnitCode);
1480                 return NULL;
1481             }
1482             r = rpn_proximity (zh, bool_parms.rset_l, bool_parms.rset_r,
1483                                *zop->u.prox->ordered,
1484                                (!zop->u.prox->exclusion ? 0 :
1485                                          *zop->u.prox->exclusion),
1486                                *zop->u.prox->relationType,
1487                                *zop->u.prox->distance);
1488             break;
1489         default:
1490             zh->errCode = 110;
1491             return NULL;
1492         }
1493     }
1494     else if (zs->which == Z_RPNStructure_simple)
1495     {
1496         if (zs->u.simple->which == Z_Operand_APT)
1497         {
1498             logf (LOG_DEBUG, "rpn_search_APT");
1499             r = rpn_search_APT (zh, zs->u.simple->u.attributesPlusTerm,
1500                                 attributeSet, num_bases, basenames);
1501         }
1502         else if (zs->u.simple->which == Z_Operand_resultSetId)
1503         {
1504             logf (LOG_DEBUG, "rpn_search_ref");
1505             r = resultSetRef (zh, zs->u.simple->u.resultSetId);
1506             if (!r)
1507                 r = rset_create (rset_kind_null, NULL);
1508         }
1509         else
1510         {
1511             zh->errCode = 3;
1512             return NULL;
1513         }
1514     }
1515     else
1516     {
1517         zh->errCode = 3;
1518         return NULL;
1519     }
1520     return r;
1521 }
1522
1523 void rpn_search (ZebraHandle zh, ODR stream,
1524                  Z_RPNQuery *rpn, int num_bases, char **basenames,
1525                  const char *setname)
1526 {
1527     RSET rset;
1528     oident *attrset;
1529     oid_value attributeSet;
1530
1531     zlog_rpn (rpn);
1532
1533     zh->errCode = 0;
1534     zh->errString = NULL;
1535     zh->hits = 0;
1536
1537     attrset = oid_getentbyoid (rpn->attributeSetId);
1538     attributeSet = attrset->value;
1539     rset = rpn_search_structure (zh, rpn->RPNStructure, attributeSet, stream,
1540                                  num_bases, basenames);
1541     if (!rset)
1542         return;
1543
1544     resultSetAdd (zh, setname, 1, rset, &zh->hits);
1545     if (zh->errCode)
1546         logf (LOG_DEBUG, "search error: %d", zh->errCode);
1547 }
1548
1549 struct scan_info_entry {
1550     char *term;
1551     ISAM_P isam_p;
1552 };
1553
1554 struct scan_info {
1555     struct scan_info_entry *list;
1556     ODR odr;
1557     int before, after;
1558     char prefix[20];
1559 };
1560
1561 static int scan_handle (char *name, const char *info, int pos, void *client)
1562 {
1563     int len_prefix, idx;
1564     struct scan_info *scan_info = client;
1565
1566     len_prefix = strlen(scan_info->prefix);
1567     if (memcmp (name, scan_info->prefix, len_prefix))
1568         return 1;
1569     if (pos > 0)
1570         idx = scan_info->after - pos + scan_info->before;
1571     else
1572         idx = - pos - 1;
1573     scan_info->list[idx].term = odr_malloc (scan_info->odr,
1574                                             strlen(name + len_prefix)+1);
1575     strcpy (scan_info->list[idx].term, name + len_prefix);
1576     assert (*info == sizeof(ISAM_P));
1577     memcpy (&scan_info->list[idx].isam_p, info+1, sizeof(ISAM_P));
1578     return 0;
1579 }
1580
1581 static void scan_term_untrans (ZebraHandle zh, ODR stream, int reg_type,
1582                                char **dstp, const char *src)
1583 {
1584     char term_dst[1024], **dst;
1585
1586     term_untrans (zh, reg_type, term_dst, src);
1587
1588     *dst = odr_malloc (stream, strlen(term_dst)+1);
1589     strcpy (*dst, term_dst);
1590 }
1591
1592 static void count_set (RSET r, int *count)
1593 {
1594     int psysno = 0;
1595     int kno = 0;
1596     struct it_key key;
1597     RSFD rfd;
1598     int term_index;
1599
1600     logf (LOG_DEBUG, "count_set");
1601
1602     *count = 0;
1603     rfd = rset_open (r, RSETF_READ);
1604     while (rset_read (r, rfd, &key, &term_index))
1605     {
1606         if (key.sysno != psysno)
1607         {
1608             psysno = key.sysno;
1609             (*count)++;
1610         }
1611         kno++;
1612     }
1613     rset_close (r, rfd);
1614     logf (LOG_DEBUG, "%d keys, %d records", kno, *count);
1615 }
1616
1617 void rpn_scan (ZebraHandle zh, ODR stream, Z_AttributesPlusTerm *zapt,
1618                oid_value attributeset,
1619                int num_bases, char **basenames,
1620                int *position, int *num_entries, ZebraScanEntry **list,
1621                int *is_partial)
1622 {
1623     int i;
1624     int pos = *position;
1625     int num = *num_entries;
1626     int before;
1627     int after;
1628     int base_no;
1629     char termz[IT_MAX_WORD+20];
1630     AttrType use;
1631     int use_value;
1632     struct scan_info *scan_info_array;
1633     ZebraScanEntry *glist;
1634     int ords[32], ord_no = 0;
1635     int ptr[32];
1636
1637     unsigned reg_id;
1638     char *search_type = NULL;
1639     char *rank_type = NULL;
1640     int complete_flag;
1641
1642     if (attributeset == VAL_NONE)
1643         attributeset = VAL_BIB1;
1644
1645     zlog_scan (zapt, attributeset);
1646     logf (LOG_DEBUG, "position = %d, num = %d", pos, num);
1647
1648     attr_init (&use, zapt, 1);
1649     use_value = attr_find (&use, &attributeset);
1650
1651     if (zebra_maps_attr (zh->zebra_maps, zapt, &reg_id, &search_type,
1652                          &rank_type, &complete_flag))
1653     {
1654         zh->errCode = 113;
1655         return ;
1656     }
1657
1658     if (use_value == -1)
1659         use_value = 1016;
1660     for (base_no = 0; base_no < num_bases && ord_no < 32; base_no++)
1661     {
1662         int r;
1663         attent attp;
1664         data1_local_attribute *local_attr;
1665
1666         if ((r=att_getentbyatt (zh, &attp, attributeset, use_value)))
1667         {
1668             logf (LOG_DEBUG, "att_getentbyatt fail. set=%d use=%d",
1669                   attributeset, use_value);
1670             if (r == -1)
1671                 zh->errCode = 114;
1672             else
1673                 zh->errCode = 121;
1674         }
1675         if (zebraExplain_curDatabase (zh->zei, basenames[base_no]))
1676         {
1677             zh->errString = basenames[base_no];
1678             zh->errCode = 109; /* Database unavailable */
1679             return;
1680         }
1681         for (local_attr = attp.local_attributes; local_attr && ord_no < 32;
1682              local_attr = local_attr->next)
1683         {
1684             int ord;
1685
1686             ord = zebraExplain_lookupSU (zh->zei, attp.attset_ordinal,
1687                                          local_attr->local);
1688             if (ord > 0)
1689                 ords[ord_no++] = ord;
1690         }
1691     }
1692     if (ord_no == 0)
1693     {
1694         zh->errCode = 113;
1695         return;
1696     }
1697     before = pos-1;
1698     after = 1+num-pos;
1699     scan_info_array = odr_malloc (stream, ord_no * sizeof(*scan_info_array));
1700     for (i = 0; i < ord_no; i++)
1701     {
1702         int j, prefix_len = 0;
1703         int before_tmp = before, after_tmp = after;
1704         struct scan_info *scan_info = scan_info_array + i;
1705         struct rpn_char_map_info rcmi;
1706
1707         rpn_char_map_prepare (zh, reg_id, &rcmi);
1708
1709         scan_info->before = before;
1710         scan_info->after = after;
1711         scan_info->odr = stream;
1712
1713         scan_info->list = odr_malloc (stream, (before+after)*
1714                                       sizeof(*scan_info->list));
1715         for (j = 0; j<before+after; j++)
1716             scan_info->list[j].term = NULL;
1717         termz[prefix_len++] = ords[i];
1718         termz[prefix_len++] = reg_id;
1719         termz[prefix_len] = 0;
1720         strcpy (scan_info->prefix, termz);
1721
1722         trans_scan_term (zh, zapt, termz+prefix_len, reg_id);
1723
1724         dict_scan (zh->dict, termz, &before_tmp, &after_tmp, scan_info,
1725                    scan_handle);
1726     }
1727     glist = odr_malloc (stream, (before+after)*sizeof(*glist));
1728     for (i = 0; i < ord_no; i++)
1729         ptr[i] = before;
1730
1731     *is_partial = 0;
1732     for (i = 0; i<after; i++)
1733     {
1734         int j, j0 = -1;
1735         const char *mterm = NULL;
1736         const char *tst;
1737         RSET rset;
1738
1739         for (j = 0; j < ord_no; j++)
1740         {
1741             if (ptr[j] < before+after &&
1742                 (tst=scan_info_array[j].list[ptr[j]].term) &&
1743                 (!mterm || strcmp (tst, mterm) < 0))
1744             {
1745                 j0 = j;
1746                 mterm = tst;
1747             }
1748         }
1749         if (j0 == -1)
1750             break;
1751         scan_term_untrans (zh, stream, reg_id,
1752                            &glist[i+before].term, mterm);
1753         rset = rset_trunc (zh, &scan_info_array[j0].list[ptr[j0]].isam_p, 1,
1754                            glist[i+before].term, strlen(glist[i+before].term),
1755                            NULL);
1756
1757         ptr[j0]++;
1758         for (j = j0+1; j<ord_no; j++)
1759         {
1760             if (ptr[j] < before+after &&
1761                 (tst=scan_info_array[j].list[ptr[j]].term) &&
1762                 !strcmp (tst, mterm))
1763             {
1764                 rset_bool_parms bool_parms;
1765                 RSET rset2;
1766
1767                 rset2 =
1768                    rset_trunc (zh, &scan_info_array[j].list[ptr[j]].isam_p, 1,
1769                                glist[i+before].term,
1770                                strlen(glist[i+before].term), NULL);
1771
1772                 bool_parms.key_size = sizeof(struct it_key);
1773                 bool_parms.cmp = key_compare_it;
1774                 bool_parms.rset_l = rset;
1775                 bool_parms.rset_r = rset2;
1776
1777                 rset = rset_create (rset_kind_or, &bool_parms);
1778
1779                 ptr[j]++;
1780             }
1781         }
1782         count_set (rset, &glist[i+before].occurrences);
1783         rset_delete (rset);
1784     }
1785     if (i < after)
1786     {
1787         *num_entries -= (after-i);
1788         *is_partial = 1;
1789     }
1790
1791     for (i = 0; i<ord_no; i++)
1792         ptr[i] = 0;
1793
1794     for (i = 0; i<before; i++)
1795     {
1796         int j, j0 = -1;
1797         const char *mterm = NULL;
1798         const char *tst;
1799         RSET rset;
1800
1801         for (j = 0; j <ord_no; j++)
1802         {
1803             if (ptr[j] < before &&
1804                 (tst=scan_info_array[j].list[before-1-ptr[j]].term) &&
1805                 (!mterm || strcmp (tst, mterm) > 0))
1806             {
1807                 j0 = j;
1808                 mterm = tst;
1809             }
1810         }
1811         if (j0 == -1)
1812             break;
1813
1814         scan_term_untrans (zh, stream, reg_id,
1815                            &glist[before-1-i].term, mterm);
1816
1817         rset = rset_trunc
1818                (zh, &scan_info_array[j0].list[before-1-ptr[j0]].isam_p, 1,
1819                 glist[before-1-i].term, strlen(glist[before-1-i].term),
1820                 NULL);
1821
1822         ptr[j0]++;
1823
1824         for (j = j0+1; j<ord_no; j++)
1825         {
1826             if (ptr[j] < before &&
1827                 (tst=scan_info_array[j].list[before-1-ptr[j]].term) &&
1828                 !strcmp (tst, mterm))
1829             {
1830                 rset_bool_parms bool_parms;
1831                 RSET rset2;
1832
1833                 rset2 = rset_trunc (zh,
1834                          &scan_info_array[j].list[before-1-ptr[j]].isam_p, 1,
1835                                     glist[before-1-i].term,
1836                                     strlen(glist[before-1-i].term), NULL);
1837
1838                 bool_parms.key_size = sizeof(struct it_key);
1839                 bool_parms.cmp = key_compare_it;
1840                 bool_parms.rset_l = rset;
1841                 bool_parms.rset_r = rset2;
1842
1843                 rset = rset_create (rset_kind_or, &bool_parms);
1844
1845                 ptr[j]++;
1846             }
1847         }
1848         count_set (rset, &glist[before-1-i].occurrences);
1849         rset_delete (rset);
1850     }
1851     i = before-i;
1852     if (i)
1853     {
1854         *is_partial = 1;
1855         *position -= i;
1856         *num_entries -= i;
1857     }
1858     *list = glist + i;               /* list is set to first 'real' entry */
1859
1860     logf (LOG_DEBUG, "position = %d, num_entries = %d",
1861           *position, *num_entries);
1862     if (zh->errCode)
1863         logf (LOG_DEBUG, "scan error: %d", zh->errCode);
1864 }
1865