+static int scan_save_set(ZebraHandle zh, ODR stream, NMEM nmem,
+ struct rset_key_control *kc,
+ Z_AttributesPlusTerm *zapt,
+ RSET limit_set,
+ const char *term,
+ const char *index_type,
+ struct scan2_info_entry *ar, int ord_no,
+ ZebraScanEntry *glist, int pos)
+{
+ int i;
+ RSET rset = 0;
+ zint approx_limit = zh->approx_limit;
+ AttrType global_hits_limit_attr;
+ int l;
+ attr_init_APT(&global_hits_limit_attr, zapt, 12);
+
+ l = attr_find(&global_hits_limit_attr, NULL);
+ if (l != -1)
+ approx_limit = l;
+
+ for (i = 0; i < ord_no; i++)
+ {
+ if (ar[i].isam_p && strcmp(wrbuf_cstr(ar[i].term), term) == 0)
+ {
+ struct ord_list *ol = ord_list_create(nmem);
+ RSET rset_t;
+
+ ol = ord_list_append(nmem, ol, ar[i].ord);
+
+ assert(ol);
+ rset_t = rset_trunc(
+ zh, &ar[i].isam_p, 1,
+ wrbuf_buf(ar[i].term), wrbuf_len(ar[i].term),
+ NULL, 1, zapt->term->which, nmem,
+ kc, kc->scope, ol, index_type,
+ 0 /* hits_limit_value */,
+ 0 /* term_ref_id_str */);
+ if (!rset)
+ rset = rset_t;
+ else
+ {
+ RSET rsets[2];
+
+ rsets[0] = rset;
+ rsets[1] = rset_t;
+ rset = rset_create_or(nmem, kc, kc->scope, 0 /* termid */,
+ 2, rsets);
+ }
+ ar[i].isam_p = 0;
+ }
+ }
+ if (rset)
+ {
+ zint count;
+ /* merge with limit_set if given */
+ if (limit_set)
+ {
+ RSET rsets[2];
+ rsets[0] = rset;
+ rsets[1] = rset_dup(limit_set);
+
+ rset = rset_create_and(nmem, kc, kc->scope, 2, rsets);
+ }
+ /* count it */
+ zebra_count_set(zh, rset, &count, approx_limit);
+
+ if (pos != -1)
+ {
+ zint sysno;
+ zebra_snippets *hit_snippets = zebra_snippets_create();
+
+ glist[pos].term = 0;
+ glist[pos].display_term = 0;
+
+ get_first_snippet_from_rset(zh, rset, hit_snippets, &sysno);
+ if (sysno)
+ {
+ zebra_snippets *rec_snippets = zebra_snippets_create();
+ int code = zebra_get_rec_snippets(zh, sysno, rec_snippets);
+ if (code == 0)
+ {
+ const struct zebra_snippet_word *w =
+ zebra_snippets_lookup(rec_snippets, hit_snippets);
+ if (w)
+ {
+ glist[pos].display_term = odr_strdup(stream, w->term);
+ }
+ else
+ {
+ yaz_log(YLOG_WARN, "zebra_snippets_lookup failed for pos=%d", pos);
+ }
+ }
+ zebra_snippets_destroy(rec_snippets);
+ }
+ if (zebra_term_untrans_iconv(zh, stream->mem, index_type,
+ &glist[pos].term, term))
+ {
+ /* failed.. use display_term instead (which could be 0) */
+ glist[pos].term = glist[pos].display_term;
+ }
+
+ if (!glist[pos].term)
+ {
+ yaz_log(YLOG_WARN, "Could not generate scan term for pos=%d",
+ pos);
+ glist[pos].term = "None";
+ }
+ glist[pos].occurrences = count;
+ zebra_snippets_destroy(hit_snippets);
+ }
+ rset_delete(rset);
+ if (count > 0)
+ return 1;
+ else
+ return 0;
+ }
+ return 0;
+}
+
+static ZEBRA_RES rpn_scan_norm(ZebraHandle zh, ODR stream, NMEM nmem,
+ struct rset_key_control *kc,
+ Z_AttributesPlusTerm *zapt,
+ int *position, int *num_entries,
+ ZebraScanEntry **list,
+ int *is_partial, RSET limit_set,
+ const char *index_type,
+ int ord_no, int *ords)
+{
+ struct scan2_info_entry *ar = nmem_malloc(nmem, sizeof(*ar) * ord_no);
+ struct rpn_char_map_info rcmi;
+ zebra_map_t zm = zebra_map_get_or_add(zh->reg->zebra_maps, index_type);
+ int i, dif;
+ int after_pos;
+ int pos = 0;
+
+ ZebraScanEntry *glist = (ZebraScanEntry *)
+ odr_malloc(stream, *num_entries * sizeof(*glist));
+
+ *is_partial = 0;
+ if (*position > *num_entries+1)
+ {
+ *is_partial = 1;
+ *position = 1;
+ *num_entries = 0;
+ return ZEBRA_OK;
+ }
+ rpn_char_map_prepare(zh->reg, zm, &rcmi);
+
+ for (i = 0; i < ord_no; i++)
+ ar[i].term = wrbuf_alloc();
+
+ for (i = 0; i < ord_no; i++)
+ {
+ char termz[IT_MAX_WORD+20];
+ int prefix_len = 0;
+
+ prefix_len = key_SU_encode(ords[i], termz);
+ termz[prefix_len] = 0;
+ strcpy(ar[i].prefix, termz);
+
+ if (trans_scan_term(zh, zapt, termz+prefix_len, zm) ==
+ ZEBRA_FAIL)
+ {
+ for (i = 0; i < ord_no; i++)
+ wrbuf_destroy(ar[i].term);
+ return ZEBRA_FAIL;
+ }
+ wrbuf_rewind(ar[i].term);
+ wrbuf_puts(ar[i].term, termz + prefix_len);
+ ar[i].isam_p = 0;
+ ar[i].ord = ords[i];
+ }
+ /** deal with terms before position .. */
+ /* the glist index starts at zero (unlike scan positions */
+ for (pos = *position-2; pos >= 0; )
+ {
+ const char *hi = 0;
+
+ /* scan on all maximum terms */
+ for (i = 0; i < ord_no; i++)
+ {
+ if (ar[i].isam_p == 0)
+ {
+ char termz[IT_MAX_WORD+20];
+ int before = 1;
+ int after = 0;
+
+ ar[i].pos_to_save = -1;
+
+ strcpy(termz, ar[i].prefix);
+ strcat(termz, wrbuf_cstr(ar[i].term));
+ dict_scan(zh->reg->dict, termz, &before, &after,
+ ar+i, scan_handle2);
+ }
+ }
+ /* get maximum after scan */
+ for (i = 0; i < ord_no; i++)
+ {
+ if (ar[i].isam_p
+ && (hi == 0 || strcmp(wrbuf_cstr(ar[i].term), hi) > 0))
+ hi = wrbuf_cstr(ar[i].term);
+ }
+ if (!hi)
+ break;
+ if (scan_save_set(zh, stream, nmem, kc, zapt, limit_set, hi,
+ index_type, ar, ord_no, glist,
+ (pos >= 0 && pos < *num_entries) ? pos : -1))
+ --pos;
+ }
+ /* see if we got all terms before.. */
+ dif = 1 + pos;
+ if (dif > 0)
+ {
+ /* did not get all terms; adjust the real position and reduce
+ number of entries */
+ yaz_log(YLOG_LOG, "before terms dif=%d", dif);
+ glist = glist + dif;
+ *num_entries -= dif;
+ *position -= dif;
+ *is_partial = 1;
+ }
+ for (i = 0; i < ord_no; i++)
+ {
+ char termz[IT_MAX_WORD+20];
+ int prefix_len = 0;
+
+ prefix_len = key_SU_encode(ords[i], termz);
+ termz[prefix_len] = 0;
+ strcpy(ar[i].prefix, termz);
+
+ if (trans_scan_term(zh, zapt, termz+prefix_len, zm) ==
+ ZEBRA_FAIL)
+ return ZEBRA_FAIL;
+ wrbuf_rewind(ar[i].term);
+ wrbuf_puts(ar[i].term, termz + prefix_len);
+ ar[i].isam_p = 0;
+ ar[i].ord = ords[i];
+ }
+
+ after_pos = 1; /* immediate term first.. */
+ for (pos = *position-1; pos < *num_entries; )
+ {
+ const char *lo = 0;
+
+ /* scan on all minimum terms */
+ for (i = 0; i < ord_no; i++)
+ {
+ if (ar[i].isam_p == 0)
+ {
+ char termz[IT_MAX_WORD+20];
+ int before = 0;
+ int after = after_pos;
+
+ ar[i].pos_to_save = 1;
+
+ strcpy(termz, ar[i].prefix);
+ strcat(termz, wrbuf_cstr(ar[i].term));
+ dict_scan(zh->reg->dict, termz, &before, &after,
+ ar+i, scan_handle2);
+ }
+ }
+ after_pos = 2; /* next round we grab following term */
+
+ /* get minimum after scan */
+ for (i = 0; i < ord_no; i++)
+ {
+ if (ar[i].isam_p
+ && (lo == 0 || strcmp(wrbuf_cstr(ar[i].term), lo) < 0))
+ lo = wrbuf_cstr(ar[i].term);
+ }
+ if (!lo)
+ break;
+ if (scan_save_set(zh, stream, nmem, kc, zapt, limit_set, lo,
+ index_type, ar, ord_no, glist,
+ (pos >= 0 && pos < *num_entries) ? pos : -1))
+ pos++;
+
+ }
+ if (pos != *num_entries)
+ {
+ if (pos >= 0)
+ *num_entries = pos;
+ else
+ *num_entries = 0;
+ *is_partial = 1;
+ }
+
+ *list = glist;
+
+ for (i = 0; i < ord_no; i++)
+ wrbuf_destroy(ar[i].term);
+
+ return ZEBRA_OK;
+}
+
+struct scan1_info_entry {
+ char *term;
+ ISAM_P isam_p;
+};
+
+struct scan_info {
+ struct scan1_info_entry *list;
+ ODR odr;
+ int before, after;
+ char prefix[20];
+};