index/kdump.c

   1 /*
   2  * Copyright (C) 1994-1995, Index Data I/S
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: kdump.c,v $
   7  * Revision 1.7  1995-10-10 12:24:38  adam
   8  * Temporary sort files are compressed.
   9  *
  10  * Revision 1.6  1995/09/29  14:01:42  adam
  11  * Bug fixes.
  12  *
  13  * Revision 1.5  1995/09/11  13:09:35  adam
  14  * More work on relevance feedback.
  15  *
  16  * Revision 1.4  1995/09/08  14:52:27  adam
  17  * Minor changes. Dictionary is lower case now.
  18  *
  19  * Revision 1.3  1995/09/06  16:11:17  adam
  20  * Option: only one word key per file.
  21  *
  22  * Revision 1.2  1995/09/04  12:33:42  adam
  23  * Various cleanup. YAZ util used instead.
  24  *
  25  * Revision 1.1  1995/09/04  09:10:36  adam
  26  * More work on index add/del/update.
  27  * Merge sort implemented.
  28  * Initial work on z39 server.
  29  *
  30  */
  31 #include <stdio.h>
  32 #include <assert.h>
  33 #include <unistd.h>
  34 #include <assert.h>
  35
  36 #include <alexutil.h>
  37 #include "index.h"
  38
  39 char *prog;
  40
  41
  42 int key_file_decode (FILE *f)
  43 {
  44     int c, d;
  45
  46     c = getc (f);
  47     switch (c & 192)
  48     {
  49     case 0:
  50         d = c;
  51         break;
  52     case 64:
  53         d = ((c&63) << 8) + (getc (f) & 0xff);
  54         break;
  55     case 128:
  56         d = ((c&63) << 8) + (getc (f) & 0xff);
  57         d = (d << 8) + (getc (f) & 0xff);
  58         break;
  59     case 192:
  60         d = ((c&63) << 8) + (getc (f) & 0xff);
  61         d = (d << 8) + (getc (f) & 0xff);
  62         d = (d << 8) + (getc (f) & 0xff);
  63         break;
  64     }
  65     return d;
  66 }
  67
  68
  69 static int read_one (FILE *inf, char *name, char *key, struct it_key *prevk)
  70 {
  71     int c;
  72     int i = 0;
  73     struct it_key itkey;
  74     do
  75     {
  76         if ((c=getc(inf)) == EOF)
  77             return 0;
  78         name[i++] = c;
  79     } while (c);
  80     if (i > 1)
  81         prevk->sysno = 0;
  82     c = key_file_decode (inf);
  83     key[0] = c & 1;
  84     c = c >> 1;
  85     itkey.sysno = c + prevk->sysno;
  86     if (c)
  87     {
  88         prevk->sysno = itkey.sysno;
  89         prevk->seqno = 0;
  90     }
  91     c = key_file_decode (inf);
  92     itkey.seqno = c + prevk->seqno;
  93     prevk->seqno = itkey.seqno;
  94
  95     memcpy (key+1, &itkey, sizeof(itkey));
  96     return 1;
  97 }
  98
  99 int main (int argc, char **argv)
 100 {
 101     int ret;
 102     char *arg;
 103     char *key_fname = NULL;
 104     char key_string[IT_MAX_WORD];
 105     char key_info[256];
 106     FILE *inf;
 107     struct it_key prevk;
 108
 109     prevk.sysno = 0;
 110     prevk.seqno = 0;
 111
 112     prog = *argv;
 113     while ((ret = options ("v:", argv, argc, &arg)) != -2)
 114     {
 115         if (ret == 0)
 116         {
 117             key_fname = arg;
 118         }
 119         else if (ret == 'v')
 120         {
 121             log_init (log_mask_str(arg), prog, NULL);
 122         }
 123         else
 124         {
 125             logf (LOG_FATAL, "Unknown option '-%s'", arg);
 126             exit (1);
 127         }
 128     }
 129     if (!key_fname)
 130     {
 131         fprintf (stderr, "kdump [-v log] file\n");
 132         exit (1);
 133     }
 134     if (!(inf = fopen (key_fname, "r")))
 135     {
 136         logf (LOG_FATAL|LOG_ERRNO, "fopen %s", key_fname);
 137         exit (1);
 138     }
 139     while (read_one (inf, key_string, key_info, &prevk))
 140     {
 141         struct it_key k;
 142         int op;
 143
 144         op = key_info[0];
 145         memcpy (&k, 1+key_info, sizeof(k));
 146         printf ("%7d op=%d s=%-5d %s\n", k.sysno, op, k.seqno,
 147                 key_string);
 148     }
 149     if (fclose (inf))
 150     {
 151         logf (LOG_FATAL|LOG_ERRNO, "fclose %s", key_fname);
 152         exit (1);
 153     }
 154
 155     exit (0);
 156 }