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