rset/rsbetween.c

   1 /*
   2  * Copyright (C) 1994-2002, Index Data
   3  * All rights reserved.
   4  * Heikki Levanto
   5  *
   6  * $Id: rsbetween.c,v 1.5 2002-04-12 15:25:03 heikki Exp $
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12 #include <assert.h>
  13
  14 #include <rsbetween.h>
  15 #include <zebrautl.h>
  16
  17 static void *r_create_between(RSET ct, const struct rset_control *sel, void *parms);
  18 static RSFD r_open_between (RSET ct, int flag);
  19 static void r_close_between (RSFD rfd);
  20 static void r_delete_between (RSET ct);
  21 static void r_rewind_between (RSFD rfd);
  22 static int r_count_between (RSET ct);
  23 static int r_read_between (RSFD rfd, void *buf, int *term_index);
  24 static int r_write_between (RSFD rfd, const void *buf);
  25
  26 static const struct rset_control control_between =
  27 {
  28     "between",
  29     r_create_between,
  30     r_open_between,
  31     r_close_between,
  32     r_delete_between,
  33     r_rewind_between,
  34     r_count_between,
  35     r_read_between,
  36     r_write_between,
  37 };
  38
  39
  40 const struct rset_control *rset_kind_between = &control_between;
  41
  42 struct rset_between_info {
  43     int key_size;
  44     RSET rset_l;
  45     RSET rset_m;
  46     RSET rset_r;
  47     int term_index_s;
  48     int (*cmp)(const void *p1, const void *p2);
  49     char *(*printer)(const void *p1, char *buf);
  50     struct rset_between_rfd *rfd_list;
  51 };
  52
  53 struct rset_between_rfd {
  54     RSFD rfd_l;
  55     RSFD rfd_m;
  56     RSFD rfd_r;
  57     int  more_l;
  58     int  more_m;
  59     int  more_r;
  60     int term_index_l;
  61     int term_index_m;
  62     int term_index_r;
  63     void *buf_l;
  64     void *buf_m;
  65     void *buf_r;
  66     int level;
  67     struct rset_between_rfd *next;
  68     struct rset_between_info *info;
  69 };
  70
  71 static void *r_create_between (RSET ct, const struct rset_control *sel, void *parms)
  72 {
  73     rset_between_parms *between_parms = (rset_between_parms *) parms;
  74     struct rset_between_info *info;
  75
  76     info = (struct rset_between_info *) xmalloc (sizeof(*info));
  77     info->key_size = between_parms->key_size;
  78     info->rset_l = between_parms->rset_l;
  79     info->rset_m = between_parms->rset_m;
  80     info->rset_r = between_parms->rset_r;
  81     if (rset_is_volatile(info->rset_l) ||
  82         rset_is_volatile(info->rset_m) ||
  83         rset_is_volatile(info->rset_r))
  84         ct->flags |= RSET_FLAG_VOLATILE;
  85     info->cmp = between_parms->cmp;
  86     info->printer = between_parms->printer;
  87     info->rfd_list = NULL;
  88
  89     info->term_index_s = info->rset_l->no_rset_terms;
  90     ct->no_rset_terms =
  91         info->rset_l->no_rset_terms +
  92         info->rset_m->no_rset_terms +
  93         info->rset_r->no_rset_terms;
  94     ct->rset_terms = (RSET_TERM *)
  95         xmalloc (sizeof (*ct->rset_terms) * ct->no_rset_terms);
  96
  97     memcpy (ct->rset_terms, info->rset_l->rset_terms,
  98             info->rset_l->no_rset_terms * sizeof(*ct->rset_terms));
  99     memcpy (ct->rset_terms + info->rset_l->no_rset_terms,
 100             info->rset_m->rset_terms,
 101             info->rset_m->no_rset_terms * sizeof(*ct->rset_terms));
 102     memcpy (ct->rset_terms + info->rset_l->no_rset_terms +
 103                              info->rset_m->no_rset_terms,
 104             info->rset_r->rset_terms,
 105             info->rset_r->no_rset_terms * sizeof(*ct->rset_terms));
 106     return info;
 107 }
 108
 109 static RSFD r_open_between (RSET ct, int flag)
 110 {
 111     struct rset_between_info *info = (struct rset_between_info *) ct->buf;
 112     struct rset_between_rfd *rfd;
 113
 114     if (flag & RSETF_WRITE)
 115     {
 116         logf (LOG_FATAL, "between set type is read-only");
 117         return NULL;
 118     }
 119     rfd = (struct rset_between_rfd *) xmalloc (sizeof(*rfd));
 120     rfd->next = info->rfd_list;
 121     info->rfd_list = rfd;
 122     rfd->info = info;
 123
 124     rfd->buf_l = xmalloc (info->key_size);
 125     rfd->buf_m = xmalloc (info->key_size);
 126     rfd->buf_r = xmalloc (info->key_size);
 127     rfd->rfd_l = rset_open (info->rset_l, RSETF_READ);
 128     rfd->rfd_m = rset_open (info->rset_m, RSETF_READ);
 129     rfd->rfd_r = rset_open (info->rset_r, RSETF_READ);
 130     rfd->more_l = rset_read (info->rset_l, rfd->rfd_l, rfd->buf_l,
 131                              &rfd->term_index_l);
 132     rfd->more_m = rset_read (info->rset_m, rfd->rfd_m, rfd->buf_m,
 133                              &rfd->term_index_m);
 134     rfd->more_r = rset_read (info->rset_r, rfd->rfd_r, rfd->buf_r,
 135                              &rfd->term_index_r);
 136     rfd->level=0;
 137     return rfd;
 138 }
 139
 140 static void r_close_between (RSFD rfd)
 141 {
 142     struct rset_between_info *info = ((struct rset_between_rfd*)rfd)->info;
 143     struct rset_between_rfd **rfdp;
 144
 145     for (rfdp = &info->rfd_list; *rfdp; rfdp = &(*rfdp)->next)
 146         if (*rfdp == rfd)
 147         {
 148             xfree ((*rfdp)->buf_l);
 149             xfree ((*rfdp)->buf_m);
 150             xfree ((*rfdp)->buf_r);
 151             rset_close (info->rset_l, (*rfdp)->rfd_l);
 152             rset_close (info->rset_m, (*rfdp)->rfd_m);
 153             rset_close (info->rset_r, (*rfdp)->rfd_r);
 154             *rfdp = (*rfdp)->next;
 155             xfree (rfd);
 156             return;
 157         }
 158     logf (LOG_FATAL, "r_close_between but no rfd match!");
 159     assert (0);
 160 }
 161
 162 static void r_delete_between (RSET ct)
 163 {
 164     struct rset_between_info *info = (struct rset_between_info *) ct->buf;
 165
 166     assert (info->rfd_list == NULL);
 167     xfree (ct->rset_terms);
 168     rset_delete (info->rset_l);
 169     rset_delete (info->rset_m);
 170     rset_delete (info->rset_r);
 171     xfree (info);
 172 }
 173
 174 static void r_rewind_between (RSFD rfd)
 175 {
 176     struct rset_between_info *info = ((struct rset_between_rfd*)rfd)->info;
 177     struct rset_between_rfd *p = (struct rset_between_rfd *) rfd;
 178
 179     logf (LOG_DEBUG, "rsbetween_rewind");
 180     rset_rewind (info->rset_l, p->rfd_l);
 181     rset_rewind (info->rset_m, p->rfd_m);
 182     rset_rewind (info->rset_r, p->rfd_r);
 183     p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l, &p->term_index_l);
 184     p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m, &p->term_index_m);
 185     p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r, &p->term_index_r);
 186     p->level=0;
 187 }
 188
 189 static int r_count_between (RSET ct)
 190 {
 191     return 0;
 192 }
 193
 194 static void logit( struct rset_between_info *info, char *prefix, void *l, void *m, void *r)
 195 {
 196     char buf_l[32];
 197     char buf_m[32];
 198     char buf_r[32];
 199     logf(LOG_DEBUG,"btw: %s l=%s m=%s r=%s",
 200       prefix,
 201       (*info->printer)(l, buf_l),
 202       (*info->printer)(m, buf_m),
 203       (*info->printer)(r, buf_r) );
 204 }
 205
 206 static int r_read_between (RSFD rfd, void *buf, int *term_index)
 207 {
 208     struct rset_between_rfd *p = (struct rset_between_rfd *) rfd;
 209     struct rset_between_info *info = p->info;
 210     int cmp_l;
 211     int cmp_r;
 212
 213     while (p->more_m)
 214     {
 215         logit( info, "start of loop", p->buf_l, p->buf_m, p->buf_r);
 216
 217         /* forward L until past m, count levels, note rec boundaries */
 218         if (p->more_l)
 219             cmp_l= (*info->cmp)(p->buf_l, p->buf_m);
 220         else
 221             cmp_l=2; /* past this record */
 222         logf(LOG_DEBUG, "cmp_l=%d", cmp_l);
 223
 224         while (cmp_l < 0)   /* l before m */
 225         {
 226             if (cmp_l == -2)
 227                 p->level=0; /* earlier record */
 228             if (cmp_l == -1)
 229                 p->level++; /* relevant start tag */
 230             if (p->more_l)
 231             {
 232                 p->more_l = rset_read (info->rset_l, p->rfd_l, p->buf_l,
 233                                    &p->term_index_l);
 234                 cmp_l= (*info->cmp)(p->buf_l, p->buf_m);
 235                 logit( info, "forwarded L", p->buf_l, p->buf_m, p->buf_r);
 236                 logf(LOG_DEBUG, "  cmp_l=%d", cmp_l);
 237             }
 238             else
 239                 cmp_l=2;
 240         } /* forward L */
 241
 242         /* forward R until past m, count levels */
 243         if (p->more_r)
 244             cmp_r= (*info->cmp)(p->buf_r, p->buf_m);
 245         else
 246             cmp_r=2;
 247         logf(LOG_DEBUG, "cmp_r=%d", cmp_r);
 248         while (cmp_r < 0)   /* r before m */
 249         {
 250             /* -2, earlier record, doesn't matter */
 251             if (cmp_r == -1)
 252                 p->level--; /* relevant end tag */
 253             if (p->more_r)
 254             {
 255                 p->more_r = rset_read (info->rset_r, p->rfd_r, p->buf_r,
 256                                    &p->term_index_r);
 257                 cmp_r= (*info->cmp)(p->buf_r, p->buf_m);
 258                 logit( info, "forwarded R", p->buf_l, p->buf_m, p->buf_r);
 259                 logf(LOG_DEBUG, "  cmp_r=%d", cmp_r);
 260             }
 261             else
 262                 cmp_r=2;
 263         } /* forward R */
 264
 265         if ( ( p->level <= 0 ) && ! p->more_l)
 266             return 0; /* no more start tags, nothing more to find */
 267
 268         if ( p->level > 0)  /* within a tag pair (or deeper) */
 269         {
 270             memcpy (buf, p->buf_m, info->key_size);
 271             *term_index = p->term_index_m;
 272             logit( info, "Returning a hit (m)", p->buf_l, p->buf_m, p->buf_r);
 273             p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m,
 274                                    &p->term_index_m);
 275             return 1;
 276         }
 277         else
 278             if ( ! p->more_l )  /* not in data, no more starts */
 279                 return 0;  /* ergo, nothing can be found. stop scanning */
 280
 281         p->more_m = rset_read (info->rset_m, p->rfd_m, p->buf_m,
 282                                &p->term_index_m);
 283     } /* while more_m */
 284
 285     logf(LOG_DEBUG,"Exiting, no more stuff in m");
 286     return 0;  /* no more data possible */
 287
 288
 289 }  /* r_read */
 290
 291
 292 static int r_write_between (RSFD rfd, const void *buf)
 293 {
 294     logf (LOG_FATAL, "between set type is read-only");
 295     return -1;
 296 }
 297