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