index/extract.c

   1 /*
   2  * Copyright (C) 1994-1995, Index Data I/S
   3  * All rights reserved.
   4  * Sebastian Hammer, Adam Dickmeiss
   5  *
   6  * $Log: extract.c,v $
   7  * Revision 1.6  1995-09-08 14:52:27  adam
   8  * Minor changes. Dictionary is lower case now.
   9  *
  10  * Revision 1.5  1995/09/06  16:11:16  adam
  11  * Option: only one word key per file.
  12  *
  13  * Revision 1.4  1995/09/05  15:28:39  adam
  14  * More work on search engine.
  15  *
  16  * Revision 1.3  1995/09/04  12:33:41  adam
  17  * Various cleanup. YAZ util used instead.
  18  *
  19  * Revision 1.2  1995/09/04  09:10:34  adam
  20  * More work on index add/del/update.
  21  * Merge sort implemented.
  22  * Initial work on z39 server.
  23  *
  24  * Revision 1.1  1995/09/01  14:06:35  adam
  25  * Split of work into more files.
  26  *
  27  */
  28 #include <stdio.h>
  29 #include <assert.h>
  30 #include <unistd.h>
  31 #include <fcntl.h>
  32 #include <ctype.h>
  33
  34 #include <alexutil.h>
  35 #include "index.h"
  36
  37 #define KEY_BUF_SIZE 100000
  38
  39 static Dict file_idx;
  40 static SYSNO sysno_next;
  41 static int key_fd = -1;
  42 static int sys_idx_fd = -1;
  43 static char *key_buf;
  44 static int key_offset;
  45
  46 void key_open (const char *fname)
  47 {
  48     void *file_key;
  49     if (key_fd != -1)
  50         return;
  51     if ((key_fd = open (fname, O_RDWR|O_CREAT, 0666)) == -1)
  52     {
  53         logf (LOG_FATAL|LOG_ERRNO, "open %s", fname);
  54         exit (1);
  55     }
  56     logf (LOG_DEBUG, "key_open of %s", fname);
  57     if (!(key_buf = malloc (KEY_BUF_SIZE)))
  58     {
  59         logf (LOG_FATAL|LOG_ERRNO, "malloc");
  60         exit (1);
  61     }
  62     key_offset = 0;
  63     if (!(file_idx = dict_open (FNAME_FILE_DICT, 40, 1)))
  64     {
  65         logf (LOG_FATAL, "dict_open fail of %s", "fileidx");
  66         exit (1);
  67     }
  68     file_key = dict_lookup (file_idx, ".");
  69     if (file_key)
  70         memcpy (&sysno_next, (char*)file_key+1, sizeof(sysno_next));
  71     else
  72         sysno_next = 1;
  73     if ((sys_idx_fd = open (FNAME_SYS_IDX, O_RDWR|O_CREAT, 0666)) == -1)
  74     {
  75         logf (LOG_FATAL|LOG_ERRNO, "open %s", FNAME_SYS_IDX);
  76         exit (1);
  77     }
  78 }
  79
  80 int key_close (void)
  81 {
  82     if (key_fd == -1)
  83     {
  84         logf (LOG_DEBUG, "key_close - but no file");
  85         return 0;
  86     }
  87     close (key_fd);
  88     close (sys_idx_fd);
  89     dict_insert (file_idx, ".", sizeof(sysno_next), &sysno_next);
  90     dict_close (file_idx);
  91     key_fd = -1;
  92     logf (LOG_DEBUG, "key close - key file exist");
  93     return 1;
  94 }
  95
  96 void key_flush (void)
  97 {
  98     size_t i = 0;
  99     int w;
 100
 101     if (key_fd == -1)
 102         return;
 103     while (i < key_offset)
 104     {
 105         w = write (key_fd, key_buf + i, key_offset - i);
 106         if (w == -1)
 107         {
 108             logf (LOG_FATAL|LOG_ERRNO, "Write key fail");
 109             exit (1);
 110         }
 111         i += w;
 112     }
 113     key_offset = 0;
 114 }
 115
 116 void key_write (int cmd, struct it_key *k, const char *str)
 117 {
 118     char x;
 119     size_t slen = strlen(str);
 120
 121     if (key_offset + sizeof(*k) + slen >= KEY_BUF_SIZE - 2)
 122         key_flush ();
 123     x = (cmd == 'a') ? 1 : 0;
 124     memcpy (key_buf + key_offset, str, slen+1);
 125     key_offset += slen+1;
 126     memcpy (key_buf + key_offset, &x, 1);
 127     key_offset++;
 128     memcpy (key_buf + key_offset, k, sizeof(*k));
 129     key_offset += sizeof(*k);
 130 }
 131
 132 void key_write_x (struct strtab *t, int cmd, struct it_key *k, const char *str)
 133 {
 134     void **oldinfo;
 135
 136     if (strtab_src (t, str, &oldinfo))
 137         ((struct it_key *) *oldinfo)->seqno++;
 138     else
 139     {
 140         *oldinfo = xmalloc (sizeof(*k));
 141         memcpy (*oldinfo, k, sizeof(*k));
 142         ((struct it_key *) *oldinfo)->seqno = 1;
 143     }
 144 }
 145
 146 void key_rec_flush (const char *str, void *info, void *data)
 147 {
 148     key_write (*((int*) data), (struct it_key *)info, str);
 149     xfree (info);
 150 }
 151
 152 void text_extract (struct strtab *t, SYSNO sysno, int cmd, const char *fname)
 153 {
 154     FILE *inf;
 155     struct it_key k;
 156     int seqno = 1;
 157     int c;
 158     char w[IT_MAX_WORD];
 159
 160     logf (LOG_DEBUG, "Text extract of %d", sysno);
 161     k.sysno = sysno;
 162     inf = fopen (fname, "r");
 163     if (!inf)
 164     {
 165         logf (LOG_WARN|LOG_ERRNO, "open %s", fname);
 166         return;
 167     }
 168     while ((c=getc (inf)) != EOF)
 169     {
 170         int i = 0;
 171         while (i < 254 && c != EOF && isalnum(c))
 172         {
 173             w[i++] = index_char_cvt (c);
 174             c = getc (inf);
 175         }
 176         if (i)
 177         {
 178             w[i] = 0;
 179
 180             k.seqno = seqno++;
 181 #if IT_KEY_HAVE_FIELD
 182             k.field = 0;
 183 #endif
 184             key_write_x (t, cmd, &k, w);
 185         }
 186         if (c == EOF)
 187             break;
 188     }
 189     fclose (inf);
 190 }
 191
 192 void file_extract (int cmd, const char *fname, const char *kname)
 193 {
 194     int i;
 195     char ext[128];
 196     SYSNO sysno;
 197     char ext_res[128];
 198     const char *file_type;
 199     void *file_info;
 200     struct strtab *t;
 201
 202     logf (LOG_DEBUG, "%c %s k=%s", cmd, fname, kname);
 203     for (i = strlen(fname); --i >= 0; )
 204         if (fname[i] == '/')
 205         {
 206             strcpy (ext, "");
 207             break;
 208         }
 209         else if (fname[i] == '.')
 210         {
 211             strcpy (ext, fname+i+1);
 212             break;
 213         }
 214     sprintf (ext_res, "fileExtension.%s", ext);
 215     if (!(file_type = res_get (common_resource, ext_res)))
 216         return;
 217
 218     file_info = dict_lookup (file_idx, kname);
 219     if (!file_info)
 220     {
 221         sysno = sysno_next++;
 222         dict_insert (file_idx, kname, sizeof(sysno), &sysno);
 223         lseek (sys_idx_fd, sysno * SYS_IDX_ENTRY_LEN, SEEK_SET);
 224         write (sys_idx_fd, kname, strlen(kname)+1);
 225     }
 226     else
 227         memcpy (&sysno, (char*) file_info+1, sizeof(sysno));
 228     t = strtab_mk ();
 229     if (!strcmp (file_type, "text"))
 230         text_extract (t, sysno, cmd, fname);
 231     strtab_del (t, key_rec_flush, &cmd);
 232 }
 233
 234