index/kdump.c

   1 /* This file is part of the Zebra server.
   2    Copyright (C) 1994-2009 Index Data
   3
   4 Zebra is free software; you can redistribute it and/or modify it under
   5 the terms of the GNU General Public License as published by the Free
   6 Software Foundation; either version 2, or (at your option) any later
   7 version.
   8
   9 Zebra is distributed in the hope that it will be useful, but WITHOUT ANY
  10 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12 for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17
  18 */
  19
  20 #include <stdio.h>
  21 #include <string.h>
  22 #include <assert.h>
  23 #include <stdlib.h>
  24 #ifdef WIN32
  25 #include <io.h>
  26 #endif
  27 #if HAVE_UNISTD_H
  28 #include <unistd.h>
  29 #endif
  30 #include <assert.h>
  31
  32 #include <charmap.h>
  33 #include "index.h"
  34
  35 char *prog;
  36
  37 int main(int argc, char **argv)
  38 {
  39     exit(0);
  40 }
  41
  42 #if 0
  43 /* old kdumper.. must be updated to use new codec .. */
  44 int key_file_decode (FILE *f)
  45 {
  46     int c, d;
  47
  48     c = getc (f);
  49     switch (c & 192)
  50     {
  51     case 0:
  52         d = c;
  53         break;
  54     case 64:
  55         d = ((c&63) << 8) + (getc (f) & 0xff);
  56         break;
  57     case 128:
  58         d = ((c&63) << 8) + (getc (f) & 0xff);
  59         d = (d << 8) + (getc (f) & 0xff);
  60         break;
  61     case 192:
  62         d = ((c&63) << 8) + (getc (f) & 0xff);
  63         d = (d << 8) + (getc (f) & 0xff);
  64         d = (d << 8) + (getc (f) & 0xff);
  65         break;
  66     default:
  67         d = 0;
  68         assert (0);
  69     }
  70     return d;
  71 }
  72
  73
  74 static int read_one (FILE *inf, char *name, char *key, struct it_key *prevk)
  75 {
  76     int c;
  77     int i = 0;
  78     struct it_key itkey;
  79     do
  80     {
  81         if ((c=getc(inf)) == EOF)
  82             return 0;
  83         name[i++] = c;
  84     } while (c);
  85     if (i > 1)
  86         prevk->sysno = 0;
  87     c = key_file_decode (inf);
  88     key[0] = c & 1;
  89     c = c >> 1;
  90     itkey.sysno = c + prevk->sysno;
  91     if (c)
  92     {
  93         prevk->sysno = itkey.sysno;
  94         prevk->seqno = 0;
  95     }
  96     c = key_file_decode (inf);
  97     itkey.seqno = c + prevk->seqno;
  98     prevk->seqno = itkey.seqno;
  99
 100     memcpy (key+1, &itkey, sizeof(itkey));
 101     return 1;
 102 }
 103
 104
 105 int main (int argc, char **argv)
 106 {
 107     int ret;
 108     char *arg;
 109     char *key_fname = NULL;
 110     char key_string[IT_MAX_WORD];
 111     char key_info[256];
 112     ZebraMaps zm;
 113     FILE *inf;
 114     Res res = NULL;
 115     struct it_key prevk;
 116
 117     prevk.sysno = 0;
 118     prevk.seqno = 0;
 119
 120     prog = *argv;
 121     while ((ret = options ("c:v:", argv, argc, &arg)) != -2)
 122     {
 123         if (ret == 0)
 124         {
 125             key_fname = arg;
 126         }
 127         else if (ret == 'v')
 128         {
 129             yaz_log_init (yaz_log_mask_str(arg), prog, NULL);
 130         }
 131         else if (ret == 'c')
 132         {
 133             if (!(res = res_open (arg, 0, 0)))
 134             {
 135                 yaz_log(YLOG_FATAL, "Failed to open resource file %s", arg);
 136                 exit (1);
 137             }
 138         }
 139         else
 140         {
 141             yaz_log (YLOG_FATAL, "Unknown option '-%s'", arg);
 142             exit (1);
 143         }
 144     }
 145     if (!key_fname)
 146     {
 147         fprintf (stderr, "kdump [-c config] [-v log] file\n");
 148         exit (1);
 149     }
 150     if (!res)
 151         res = res_open ("zebra.cfg", 0, 0);
 152     zm = zebra_maps_open (res, 0);
 153     if (!(inf = fopen (key_fname, "r")))
 154     {
 155         yaz_log (YLOG_FATAL|YLOG_ERRNO, "fopen %s", key_fname);
 156         exit (1);
 157     }
 158     printf ("t  rg op  sysno seqno txt\n");
 159     while (read_one (inf, key_string, key_info, &prevk))
 160     {
 161         struct it_key k;
 162         int op;
 163         char keybuf[IT_MAX_WORD+1];
 164         char *to = keybuf;
 165         const char *from = key_string;
 166         int usedb_type = from[0];
 167         int reg_type = from[1];
 168
 169         op = key_info[0];
 170         memcpy (&k, 1+key_info, sizeof(k));
 171
 172         from += 2;
 173         while (*from)
 174         {
 175             const char *res = zebra_maps_output (zm, reg_type, &from);
 176             if (!res)
 177                 *to++ = *from++;
 178             else
 179                 while (*res)
 180                     *to++ = *res++;
 181         }
 182         *to = '\0';
 183         printf ("%c %3d %c %7d %5d %s\n", reg_type, usedb_type, op ? 'i':'d',
 184                 k.sysno, k.seqno, keybuf);
 185     }
 186     zebra_maps_close (zm);
 187     if (fclose (inf))
 188     {
 189         yaz_log (YLOG_FATAL|YLOG_ERRNO, "fclose %s", key_fname);
 190         exit (1);
 191     }
 192     exit (0);
 193 }
 194 #endif
 195 /*
 196  * Local variables:
 197  * c-basic-offset: 4
 198  * indent-tabs-mode: nil
 199  * End:
 200  * vim: shiftwidth=4 tabstop=8 expandtab
 201  */
 202