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