index/kdump.c

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