index/kcompare.c

   1 /* $Id: kcompare.c,v 1.41 2003-06-23 15:35:25 adam Exp $
   2    Copyright (C) 1995,1996,1997,1998,1999,2000,2001,2002,2003
   3    Index Data Aps
   4
   5 This file is part of the Zebra server.
   6
   7 Zebra is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with Zebra; see the file LICENSE.zebra.  If not, write to the
  19 Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.
  21 */
  22
  23
  24
  25
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <stdio.h>
  29 #include <assert.h>
  30
  31 #include "index.h"
  32
  33 void key_logdump (int logmask, const void *p)
  34 {
  35     struct it_key key;
  36
  37     memcpy (&key, p, sizeof(key));
  38     logf (logmask, "%7d s=%-4d", key.sysno, key.seqno);
  39 }
  40
  41 int key_compare_it (const void *p1, const void *p2)
  42 {
  43     if (((struct it_key *) p1)->sysno != ((struct it_key *) p2)->sysno)
  44     {
  45         if (((struct it_key *) p1)->sysno > ((struct it_key *) p2)->sysno)
  46             return 2;
  47         else
  48             return -2;
  49     }
  50     if (((struct it_key *) p1)->seqno != ((struct it_key *) p2)->seqno)
  51     {
  52         if (((struct it_key *) p1)->seqno > ((struct it_key *) p2)->seqno)
  53             return 1;
  54         else
  55             return -1;
  56     }
  57     return 0;
  58 }
  59
  60 char *key_print_it (const void *p, char *buf)
  61 {
  62     const struct it_key *i = p;
  63     sprintf (buf, "%d:%d", i->sysno, i->seqno);
  64     return buf;
  65 }
  66
  67 int key_compare (const void *p1, const void *p2)
  68 {
  69     struct it_key i1, i2;
  70     memcpy (&i1, p1, sizeof(i1));
  71     memcpy (&i2, p2, sizeof(i2));
  72     if (i1.sysno != i2.sysno)
  73     {
  74         if (i1.sysno > i2.sysno)
  75             return 2;
  76         else
  77             return -2;
  78     }
  79     if (i1.seqno != i2.seqno)
  80     {
  81         if (i1.seqno > i2.seqno)
  82             return 1;
  83         else
  84             return -1;
  85     }
  86     return 0;
  87 }
  88
  89 int key_qsort_compare (const void *p1, const void *p2)
  90 {
  91     int r;
  92     size_t l;
  93     char *cp1 = *(char **) p1;
  94     char *cp2 = *(char **) p2;
  95
  96     if ((r = strcmp (cp1, cp2)))
  97         return r;
  98     l = strlen(cp1)+1;
  99     if ((r = key_compare (cp1+l+1, cp2+l+1)))
 100         return r;
 101     return cp1[l] - cp2[l];
 102 }
 103
 104 int key_get_pos (const void *p)
 105 {
 106     struct it_key key;
 107     memcpy (&key, p, sizeof(key));
 108     return key.seqno;
 109 }
 110
 111 struct iscz1_code_info {
 112     struct it_key key;
 113 };
 114
 115 static void *iscz1_code_start (int mode)
 116 {
 117     struct iscz1_code_info *p = (struct iscz1_code_info *)
 118         xmalloc (sizeof(*p));
 119     p->key.sysno = 0;
 120     p->key.seqno = 0;
 121     return p;
 122 }
 123
 124 static void iscz1_code_reset (void *vp)
 125 {
 126     struct iscz1_code_info *p = (struct iscz1_code_info *) vp;
 127     p->key.sysno = 0;
 128     p->key.seqno = 0;
 129 }
 130
 131 static void iscz1_code_stop (int mode, void *p)
 132 {
 133     xfree (p);
 134 }
 135
 136 void iscz1_encode_int (unsigned d, char **dst)
 137 {
 138     unsigned char *bp = (unsigned char*) *dst;
 139
 140     if (d <= 63)
 141         *bp++ = d;
 142     else if (d <= 16383)
 143     {
 144         *bp++ = 64 | (d>>8);
 145        *bp++ = d & 255;
 146     }
 147     else if (d <= 4194303)
 148     {
 149         *bp++ = 128 | (d>>16);
 150         *bp++ = (d>>8) & 255;
 151         *bp++ = d & 255;
 152     }
 153     else
 154     {
 155         *bp++ = 192 | (d>>24);
 156         *bp++ = (d>>16) & 255;
 157         *bp++ = (d>>8) & 255;
 158         *bp++ = d & 255;
 159     }
 160     *dst = (char *) bp;
 161 }
 162
 163 int iscz1_decode_int (unsigned char **src)
 164 {
 165     unsigned c = *(*src)++;
 166     switch (c & 192)
 167     {
 168     case 0:
 169         return c;
 170     case 64:
 171         return ((c & 63) << 8) + *(*src)++;
 172     case 128:
 173         c = ((c & 63) << 8) + *(*src)++;
 174         c = (c << 8) + *(*src)++;
 175         return c;
 176     }
 177     if (c&32) /* expand sign bit to high bits */
 178        c = ((c | 63) << 8) + *(*src)++;
 179     else
 180        c = ((c & 63) << 8) + *(*src)++;
 181     c = (c << 8) + *(*src)++;
 182     c = (c << 8) + *(*src)++;
 183
 184     return c;
 185 }
 186
 187 static void iscz1_code_item (int mode, void *vp, char **dst, char **src)
 188 {
 189     struct iscz1_code_info *p = (struct iscz1_code_info *) vp;
 190     struct it_key tkey;
 191     int d;
 192
 193     if (mode == ISAMC_ENCODE)
 194     {
 195         memcpy (&tkey, *src, sizeof(struct it_key));
 196         d = tkey.sysno - p->key.sysno;
 197         if (d)
 198         {
 199             iscz1_encode_int (2*tkey.seqno + 1, dst);
 200             iscz1_encode_int (d, dst);
 201             p->key.sysno += d;
 202             p->key.seqno = tkey.seqno;
 203         }
 204         else
 205         {
 206             iscz1_encode_int (2*(tkey.seqno - p->key.seqno), dst);
 207             p->key.seqno = tkey.seqno;
 208         }
 209         (*src) += sizeof(struct it_key);
 210     }
 211     else
 212     {
 213         d = iscz1_decode_int ((unsigned char **) src);
 214         if (d & 1)
 215         {
 216             p->key.seqno = d>>1;
 217             p->key.sysno += iscz1_decode_int ((unsigned char **) src);
 218         }
 219         else
 220             p->key.seqno += d>>1;
 221         memcpy (*dst, &p->key, sizeof(struct it_key));
 222         (*dst) += sizeof(struct it_key);
 223     }
 224 }
 225
 226 ISAMS_M *key_isams_m (Res res, ISAMS_M *me)
 227 {
 228     isams_getmethod (me);
 229
 230     me->compare_item = key_compare;
 231
 232     me->code_start = iscz1_code_start;
 233     me->code_item = iscz1_code_item;
 234     me->code_stop = iscz1_code_stop;
 235
 236     me->debug = atoi(res_get_def (res, "isamsDebug", "0"));
 237
 238     return me;
 239 }
 240
 241 ISAMC_M *key_isamc_m (Res res, ISAMC_M *me)
 242 {
 243     isc_getmethod (me);
 244
 245     me->compare_item = key_compare;
 246
 247     me->code_start = iscz1_code_start;
 248     me->code_item = iscz1_code_item;
 249     me->code_stop = iscz1_code_stop;
 250     me->code_reset = iscz1_code_reset;
 251
 252     me->debug = atoi(res_get_def (res, "isamcDebug", "0"));
 253
 254     return me;
 255 }
 256
 257 ISAMD_M *key_isamd_m (Res res, ISAMD_M *me)
 258 {
 259     me = isamd_getmethod (me);
 260
 261     me->compare_item = key_compare;
 262
 263     me->code_start = iscz1_code_start;
 264     me->code_item = iscz1_code_item;
 265     me->code_stop = iscz1_code_stop;
 266     me->code_reset = iscz1_code_reset;
 267
 268     me->debug = atoi(res_get_def (res, "isamdDebug", "0"));
 269
 270     return me;
 271 }
 272
 273 int key_SU_encode (int ch, char *out)
 274 {
 275     int i;
 276     for (i = 0; ch; i++)
 277     {
 278         if (ch >= 64)
 279             out[i] = 65 + (ch & 63);
 280         else
 281             out[i] = 1 + ch;
 282         ch = ch >> 6;
 283     }
 284     return i;
 285     /* in   out
 286        0     1
 287        1     2
 288        63    64
 289        64    65, 2
 290        65    66, 2
 291        127   128, 2
 292        128   65, 3
 293        191   128, 3
 294        192   65, 4
 295     */
 296 }
 297
 298 int key_SU_decode (int *ch, const unsigned char *out)
 299 {
 300     int len = 1;
 301     int fact = 1;
 302     *ch = 0;
 303     for (len = 1; *out >= 65; len++, out++)
 304     {
 305         *ch += (*out - 65) * fact;
 306         fact <<= 6;
 307     }
 308     *ch += (*out - 1) * fact;
 309     return len;
 310 }
 311