/*
- * Copyright (C) 1994-1998, Index Data
+ * Copyright (C) 1994-1999, Index Data
* All rights reserved.
* Sebastian Hammer, Adam Dickmeiss
*
* $Log: extract.c,v $
- * Revision 1.89 1998-10-28 10:54:38 adam
+ * Revision 1.97 1999-07-06 12:28:04 adam
+ * Updated record index structure. Format includes version ID. Compression
+ * algorithm ID is stored for each record block.
+ *
+ * Revision 1.96 1999/05/26 07:49:13 adam
+ * C++ compilation.
+ *
+ * Revision 1.95 1999/05/21 12:00:17 adam
+ * Better diagnostics for extraction process.
+ *
+ * Revision 1.94 1999/05/20 12:57:18 adam
+ * Implemented TCL filter. Updated recctrl system.
+ *
+ * Revision 1.93 1999/05/15 14:36:38 adam
+ * Updated dictionary. Implemented "compression" of dictionary.
+ *
+ * Revision 1.92 1999/03/09 16:27:49 adam
+ * More work on SDRKit integration.
+ *
+ * Revision 1.91 1999/02/12 13:29:22 adam
+ * Implemented position-flag for registers.
+ *
+ * Revision 1.90 1999/02/02 14:50:52 adam
+ * Updated WIN32 code specific sections. Changed header.
+ *
+ * Revision 1.89 1998/10/28 10:54:38 adam
* SDRKit integration.
*
* Revision 1.88 1998/10/16 08:14:29 adam
*/
#include <stdio.h>
#include <assert.h>
-#ifdef WINDOWS
+#ifdef WIN32
#include <io.h>
#else
#include <unistd.h>
BFiles bfs = rGroup->bfs;
int rw = rGroup->flagRw;
data1_handle dh = rGroup->dh;
+ char *recordCompression;
+ int record_compression = REC_COMPRESS_NONE;
if (!mem)
mem = atoi(res_get_def (common_resource, "memMax", "4"))*1024*1024;
if (mem < 50000)
mem = 50000;
- key_buf = xmalloc (mem);
+ key_buf = (char **) xmalloc (mem);
ptr_top = mem/sizeof(char*);
ptr_i = 0;
key_buf_used = 0;
key_file_no = 0;
- if (!(matchDict = dict_open (bfs, GMATCH_DICT, 50, rw)))
+ if (!(matchDict = dict_open (bfs, GMATCH_DICT, 50, rw, 0)))
{
logf (LOG_FATAL, "dict_open fail of %s", GMATCH_DICT);
return -1;
}
assert (!records);
- records = rec_open (bfs, rw);
+ recordCompression = res_get_def (common_resource,
+ "recordCompression", "none");
+ if (!strcmp (recordCompression, "none"))
+ record_compression = REC_COMPRESS_NONE;
+ if (!strcmp (recordCompression, "bzip2"))
+ record_compression = REC_COMPRESS_BZIP2;
+ records = rec_open (bfs, rw, record_compression);
if (!records)
{
dict_close (matchDict);
struct encode_info {
int sysno;
int seqno;
+ int cmd;
char buf[768];
};
{
i->sysno = 0;
i->seqno = 0;
+ i->cmd = -1;
}
char *encode_key_int (int d, char *bp)
i->sysno = key.sysno;
i->seqno = 0;
}
+ else if (!i->seqno && !key.seqno && i->cmd == *k)
+ return;
bp = encode_key_int (key.seqno - i->seqno, bp);
i->seqno = key.seqno;
+ i->cmd = *k;
if (fwrite (i->buf, bp - i->buf, 1, outf) != 1)
{
logf (LOG_FATAL|LOG_ERRNO, "fwrite");
{
char *b;
- b = xmalloc (reckeys.buf_max += 128000);
+ b = (char *) xmalloc (reckeys.buf_max += 128000);
if (reckeys.buf_used > 0)
memcpy (b, reckeys.buf, reckeys.buf_used);
xfree (reckeys.buf);
dst += sizeof(*pseqno);
}
reckeys.buf_used = dst - reckeys.buf;
- (*pseqno)++;
+ if (*pseqno)
+ (*pseqno)++;
}
static void addSortString (RecWord *p, const char *string, int length)
if (sk->attrSet == p->attrSet && sk->attrUse == p->attrUse)
return;
- sk = xmalloc (sizeof(*sk));
+ sk = (struct sortKey *) xmalloc (sizeof(*sk));
sk->next = sortKeys;
sortKeys = sk;
- sk->string = xmalloc (length);
+ sk->string = (char *) xmalloc (length);
sk->length = length;
memcpy (sk->string, string, length);
static struct file_read_info *file_read_start (int fd)
{
- struct file_read_info *fi = xmalloc (sizeof(*fi));
+ struct file_read_info *fi = (struct file_read_info *)
+ xmalloc (sizeof(*fi));
fi->fd = fd;
fi->file_max = 0;
static off_t file_seek (void *handle, off_t offset)
{
- struct file_read_info *p = handle;
+ struct file_read_info *p = (struct file_read_info *) handle;
p->file_offset = offset;
if (p->sdrbuf)
return offset;
static off_t file_tell (void *handle)
{
- struct file_read_info *p = handle;
+ struct file_read_info *p = (struct file_read_info *) handle;
return p->file_offset;
}
static int file_read (void *handle, char *buf, size_t count)
{
- struct file_read_info *p = handle;
+ struct file_read_info *p = (struct file_read_info *) handle;
int fd = p->fd;
int r;
if (p->sdrbuf)
static void file_begin (void *handle)
{
- struct file_read_info *p = handle;
+ struct file_read_info *p = (struct file_read_info *) handle;
p->file_offset = p->file_moffset;
if (!p->sdrbuf && p->file_moffset)
static void file_end (void *handle, off_t offset)
{
- struct file_read_info *p = handle;
+ struct file_read_info *p = (struct file_read_info *) handle;
assert (p->file_more == 0);
p->file_more = 1;
static void recordLogPreamble (int level, const char *msg, void *info)
{
- struct recordLogInfo *p = info;
+ struct recordLogInfo *p = (struct recordLogInfo *) info;
FILE *outf = log_file ();
if (level & LOG_LOG)
static int recordExtract (SYSNO *sysno, const char *fname,
struct recordGroup *rGroup, int deleteFlag,
struct file_read_info *fi,
- RecType recType, char *subType)
+ RecType recType, char *subType, void *clientData)
{
RecordAttr *recordAttr;
int r;
extractCtrl.addSchema = addSchema;
extractCtrl.dh = rGroup->dh;
for (i = 0; i<256; i++)
- extractCtrl.seqno[i] = 0;
+ {
+ if (zebra_maps_is_positioned(rGroup->zebra_maps, i))
+ extractCtrl.seqno[i] = 1;
+ else
+ extractCtrl.seqno[i] = 0;
+ }
extractCtrl.zebra_maps = rGroup->zebra_maps;
extractCtrl.flagShowRecords = !rGroup->flagRw;
logInfo.rGroup = rGroup;
log_event_start (recordLogPreamble, &logInfo);
- r = (*recType->extract)(&extractCtrl);
+ r = (*recType->extract)(clientData, &extractCtrl);
log_event_start (NULL, NULL);
- if (r)
- {
+ if (r == RECCTRL_EXTRACT_EOF)
+ return 0;
+ else if (r == RECCTRL_EXTRACT_ERROR)
+ {
/* error occured during extraction ... */
if (rGroup->flagRw &&
records_processed < rGroup->fileVerboseLimit)
{
- logf (LOG_WARN, "fail %s %s %ld code = %d", rGroup->recordType,
- fname, (long) recordOffset, r);
+ logf (LOG_WARN, "fail %s %s %ld", rGroup->recordType,
+ fname, (long) recordOffset);
}
return 0;
}
if (rGroup->flagStoreData == 1)
{
rec->size[recInfo_storeData] = recordAttr->recordSize;
- rec->info[recInfo_storeData] = xmalloc (recordAttr->recordSize);
+ rec->info[recInfo_storeData] = (char *)
+ xmalloc (recordAttr->recordSize);
if (lseek (fi->fd, recordOffset, SEEK_SET) < 0)
{
logf (LOG_ERRNO|LOG_FATAL, "seek to %ld in %s",
struct recordGroup rGroupM;
struct recordGroup *rGroup = &rGroupM;
struct file_read_info *fi;
+ void *clientData;
memcpy (rGroup, rGroupP, sizeof(*rGroupP));
if (!*rGroup->recordType)
return 0;
if (!(recType =
- recType_byName (rGroup->recTypes, rGroup->recordType, subType)))
+ recType_byName (rGroup->recTypes, rGroup->recordType, subType,
+ &clientData)))
{
logf (LOG_WARN, "No such record type: %s", rGroup->recordType);
return 0;
rGroup->flagStoreKeys = 0;
#if ZEBRASDR
- if (1)
+ if (rGroup->useSDR)
{
ZebraSdrHandle h;
char xname[128], *xp;
strncpy (xname, fname, 127);
- if ((xp = strchr (xname, '.')))
- *xp = '\0';
+ if (!(xp = strchr (xname, '.')))
+ return 0;
+ *xp = '\0';
+ if (strcmp (xp+1, "sdr.bits"))
+ return 0;
h = zebraSdr_open (xname);
if (!h)
segmentno = zebraSdr_segment (h, 0);
sprintf (sdr_name, "%%%s.%d", xname, segmentno);
- logf (LOG_LOG, "SDR: %s", sdr_name);
-#if 1
+#if 0
if (segmentno > 20)
break;
#endif
{
file_begin (fi);
r = recordExtract (sysno, fname, rGroup, deleteFlag, fi,
- recType, subType);
+ recType, subType, clientData);
} while (r && !sysno && fi->file_more);
file_read_stop (fi);
if (fd != -1)