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