+/*
+ * attr_print: log attributes
+ */
+static void attr_print (Z_AttributesPlusTerm *t)
+{
+ int of, i;
+ for (of = 0; of < t->num_attributes; of++)
+ {
+ Z_AttributeElement *element;
+ element = t->attributeList[of];
+
+ switch (element->which)
+ {
+ case Z_AttributeValue_numeric:
+ logf (LOG_DEBUG, "attributeType=%d value=%d",
+ *element->attributeType,
+ *element->value.numeric);
+ break;
+ case Z_AttributeValue_complex:
+ logf (LOG_DEBUG, "attributeType=%d complex",
+ *element->attributeType);
+ for (i = 0; i<element->value.complex->num_list; i++)
+ {
+ if (element->value.complex->list[i]->which ==
+ Z_StringOrNumeric_string)
+ logf (LOG_DEBUG, " string: '%s'",
+ element->value.complex->list[i]->u.string);
+ else if (element->value.complex->list[i]->which ==
+ Z_StringOrNumeric_numeric)
+ logf (LOG_DEBUG, " numeric: '%d'",
+ *element->value.complex->list[i]->u.numeric);
+ }
+ break;
+ default:
+ assert (0);
+ }
+ }
+}
+
+typedef struct {
+ int type;
+ int major;
+ int minor;
+ Z_AttributesPlusTerm *zapt;
+} AttrType;
+
+static int attr_find (AttrType *src)
+{
+ while (src->major < src->zapt->num_attributes)
+ {
+ Z_AttributeElement *element;
+ element = src->zapt->attributeList[src->major];
+
+ if (src->type == *element->attributeType)
+ {
+ switch (element->which)
+ {
+ case Z_AttributeValue_numeric:
+ ++(src->major);
+ return *element->value.numeric;
+ break;
+ case Z_AttributeValue_complex:
+ if (src->minor >= element->value.complex->num_list ||
+ element->value.complex->list[src->minor]->which !=
+ Z_StringOrNumeric_numeric)
+ break;
+ ++(src->minor);
+ return *element->value.complex->list[src->minor-1]->u.numeric;
+ default:
+ assert (0);
+ }
+ }
+ ++(src->major);
+ }
+ return -1;
+}
+
+static void attr_init (AttrType *src, Z_AttributesPlusTerm *zapt,
+ int type)
+{
+ src->zapt = zapt;
+ src->type = type;
+ src->major = 0;
+ src->minor = 0;
+}
+
+struct trunc_info {
+ int *indx;
+ char **heap;
+ int heapnum;
+ int (*cmp)(const void *p1, const void *p2);
+ int keysize;
+ char *swapbuf;
+ char *tmpbuf;
+ char *buf;
+};
+
+static void heap_swap (struct trunc_info *ti, int i1, int i2)
+{
+ int swap;
+
+ memcpy (ti->swapbuf, ti->heap[i1], ti->keysize);
+ memcpy (ti->heap[i1], ti->heap[i2], ti->keysize);
+ memcpy (ti->heap[i2], ti->swapbuf, ti->keysize);
+
+ swap = ti->indx[i1];
+ ti->indx[i1] = ti->indx[i2];
+ ti->indx[i2] = swap;
+}
+
+static void heap_delete (struct trunc_info *ti)
+{
+ int cur = 1, child = 2;
+
+ assert (ti->heapnum > 0);
+ memcpy (ti->heap[1], ti->heap[ti->heapnum], ti->keysize);
+ ti->indx[1] = ti->indx[ti->heapnum--];
+ while (child <= ti->heapnum) {
+ if (child < ti->heapnum &&
+ (*ti->cmp)(ti->heap[child], ti->heap[1+child]) > 0)
+ child++;
+ if ((*ti->cmp)(ti->heap[cur], ti->heap[child]) > 0)
+ {
+ heap_swap (ti, cur, child);
+ cur = child;
+ child = 2*cur;
+ }
+ else
+ break;
+ }
+}
+
+static void heap_insert (struct trunc_info *ti, const char *buf, int indx)
+{
+ int cur, parent;
+
+ cur = ++(ti->heapnum);
+ memcpy (ti->heap[cur], buf, ti->keysize);
+ ti->indx[cur] = indx;
+ parent = cur/2;
+ while (parent && (*ti->cmp)(ti->heap[parent], ti->heap[cur]) > 0)
+ {
+ heap_swap (ti, cur, parent);
+ cur = parent;
+ parent = cur/2;
+ }
+}
+
+static
+struct trunc_info *heap_init (int size, int key_size,
+ int (*cmp)(const void *p1, const void *p2))
+{
+ struct trunc_info *ti = xmalloc (sizeof(*ti));
+ int i;
+
+ ++size;
+ ti->heapnum = 0;
+ ti->keysize = key_size;
+ ti->cmp = cmp;
+ ti->indx = xmalloc (size * sizeof(*ti->indx));
+ ti->heap = xmalloc (size * sizeof(*ti->heap));
+ ti->swapbuf = xmalloc (ti->keysize);
+ ti->tmpbuf = xmalloc (ti->keysize);
+ ti->buf = xmalloc (size * ti->keysize);
+ for (i = size; --i >= 0; )
+ ti->heap[i] = ti->buf + ti->keysize * i;
+ return ti;
+}
+
+static void heap_close (struct trunc_info *ti)
+{
+ xfree (ti->indx);
+ xfree (ti->heap);
+ xfree (ti->swapbuf);
+ xfree (ti->tmpbuf);
+ xfree (ti);
+}
+
+static RSET rset_trunc (ISAM isam, ISAM_P *isam_p, int from, int to,
+ int merge_chunk)
+{
+ logf (LOG_DEBUG, "rset_trunc, range=%d-%d", from, to-1);
+ if (to - from > merge_chunk)
+ {
+ return NULL;
+ }
+ else
+ {
+ ISPT *ispt;
+ int i;
+ struct trunc_info *ti;
+ RSET result;
+ RSFD rsfd;
+ rset_temp_parms parms;
+
+ ispt = xmalloc (sizeof(*ispt) * (to-from));
+ parms.key_size = sizeof (struct it_key);
+ result = rset_create (rset_kind_temp, &parms);
+ rsfd = rset_open (result, 1);
+
+ ti = heap_init (to-from, sizeof(struct it_key),
+ key_compare);
+ for (i = to-from; --i >= 0; )
+ {
+ ispt[i] = is_position (isam, isam_p[from+i]);
+ if (is_readkey (ispt[i], ti->tmpbuf))
+ heap_insert (ti, ti->tmpbuf, i);
+ }
+ while (ti->heapnum)
+ {
+ int n = ti->indx[1];
+
+ rset_write (result, rsfd, ti->heap[1]);
+ heap_delete (ti);
+ if (is_readkey (ispt[n], ti->tmpbuf))
+ heap_insert (ti, ti->tmpbuf, n);
+ }
+ for (i = to-from; --i >= 0; )
+ is_pt_free (ispt[i]);
+ rset_close (result, rsfd);
+ heap_close (ti);
+ xfree (ispt);
+ return result;
+ }
+}
+
+static ISAM_P *isam_p_buf = NULL;
+static int isam_p_size = 0;
+static int isam_p_indx;
+
+static void add_isam_p (const char *info)
+{
+ if (isam_p_indx == isam_p_size)
+ {
+ ISAM_P *new_isam_p_buf;
+
+ isam_p_size = 2*isam_p_size + 100;
+ new_isam_p_buf = xmalloc (sizeof(*new_isam_p_buf) *
+ isam_p_size);
+ if (isam_p_buf)
+ {
+ memcpy (new_isam_p_buf, isam_p_buf,
+ isam_p_indx * sizeof(*isam_p_buf));
+ xfree (isam_p_buf);
+ }
+ isam_p_buf = new_isam_p_buf;
+ }
+ assert (*info == sizeof(*isam_p_buf));
+ memcpy (isam_p_buf + isam_p_indx, info+1, sizeof(*isam_p_buf));
+ isam_p_indx++;
+}
+
+static int grep_handle (Dict_char *name, const char *info)
+{
+ logf (LOG_DEBUG, "dict name: %s", name);
+ add_isam_p (info);
+ return 0;
+}
+
+static int trunc_term (ZServerInfo *zi, Z_AttributesPlusTerm *zapt,
+ const char *term_sub, ISAM_P **isam_ps)