/*
this file composed by Klaus Ripke from the iAPI files by Robert Janusz.
this is the test app "ix.c" with all the includes slurped in,
see // #include "isomething.c"
you may run this with:
cp iAPI.txt iAPI.c
gcc iAPI.c
./a.out <dbpath>
*/
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
iAPI software: The Example of ISIS (UNIX v.3) Database Handle
Copyright (C) 2000 by Robert Janusz
E-mail: rj@jezuici.krakow.pl
Address: Robert Janusz, ul. Kopernika 26, 31-501 Krakow, Poland
tel: (0048-12) 4294416/432 ; fax: (0048-12) 4295003.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
// Linux gcc Compiler conventions !
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
// Global variables +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
static
char DBpath [71];
char UpCase [256];
#define NFIND 3 // let's keep it for future
#define PACKED __attribute__((packed)) // it shoud work on Linux gcc ;-)
// #include "idef.c"
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
iAPI software: The Type Definitions for Unix-ISIS databases
Copyright (C) 2000 by Robert Janusz
E-mail: rj@jezuici.krakow.pl
Address: Robert Janusz, ul. Kopernika 26, 31-501 Krakow, Poland
tel: (0048-12) 4294416/432 ; fax: (0048-12) 4295003.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
// gcc Linux Compiler conventions !
// *** ONLY UNIX ISIS = the difference between DOS/UNIX structures
// *************************** TYPE DEFINITIONS *****************************
// Cross Reference File XRF structure +++++++++++++++++++++++++++++++++++++++
typedef /* Packed */ struct // /* Packed */ and order are necessary for block reading
{
long int xpos PACKED;
// Block nr: 1, 2...; < 0: last block
long int xrec [127] PACKED;
// References to Master File records...
// xrec [...] = 2048 *xrmfb [21 bit] & xrmfp [11 bit]
// rec. deleted log. < 0 & > 0 (restore: -xrmfb)
// rec. deleted phis. =-1 & = 0 (ref@MST.ctrl)
// rec. does not exist = 0 & = 0
// new rec. to invert bit 1024 = 1
// rec. edited to inv. (add & del post.) bit 512 = 1
}
xrfBlock;
// Master File (MST) record structures... +++++++++++++++++++++++++++++++++++
typedef /* Packed */ struct // The first record in Master File
{
long int ctlmfn PACKED // Always 0
, nxtmfn PACKED // Next Master File Number
, nxtmfb PACKED; // Next block in Master File, the 1st has 1
short int nxtmfp PACKED // Next position in the last block
, mftype PACKED; // 0 for user's bases; 1 for messages
long int reccnt PACKED // Reserved for future
, mfcxx1 PACKED // Reserved for future
, mfcxx2 PACKED // LAN, > 0: inversion, update not possible
, mfcxx3 PACKED; // LAN, = 1: exists exclusive user
}
mstControl;
typedef /* Packed */ struct // Fixed part of record header that must be...
{ // included in the same block;
// the header can begin only on 0, 2, 4...498
long int mfn PACKED; // MFN number
short int mfrl PACKED; // Length of record (allways eaven)...
// LAN: < 0 ==> record blocked
long int mfbwb PACKED; // Block Pointer | If the record waits for inv...
short int mfbwp PACKED; // Position Pointer | ...ref. to old location
// mfbwb, mfbwp: = 0 at creation;
// after modif. = ref to the old record.
// xrmfp bit 1024 = 1 at creation
// (= waits to be inverted);
// xrmfp bit 512 = 1 at edit
// (=waits to be inv. & delete old references)
}
mstHdrFix;
typedef /* Packed */ struct
{
short int base PACKED // Position of data fields in the record
, nvf PACKED // Number of fields in the record
, status PACKED; // 0 = active, 1 = deleted logicaly (- xrfb < 0)
}
mstHdrTxt;
typedef /* Packed */ struct
{
mstHdrFix mhf PACKED; // This header is allways in MST file block
mstHdrTxt mht PACKED;
}
RecHeaders;
typedef /* Packed */ struct // Index for every field in the record
{ // dimension = 6 *nvf; base = 18 + 6 *nvf
short int tag PACKED // Label of the field
, pos PACKED // Position of the first char in data part: 0, 1...
, len PACKED; // Length of the field
}
mstIndex;
// Inverted File structures +++++++++++++++++++++++++++++++++++++++++++++++++
// Control File (CNT) structure..............................................
typedef /* Packed */ struct
{
short int idtype PACKED // B*tree type; 1 = N01/L01, 2 = N02/L02
, ordn PACKED // = 5; a half of size of key-record in N0x
, ordf PACKED // = 5; a half of size of key-record in L0x
, n PACKED // = 15; number of buffers for nodes
, k PACKED // = 5; number of buffers for 1st index level (k < n)
, lev PACKED; // Current number of levels in index; -1: no N0x
long int posrx PACKED // Reference to the root in N0x
, nmaxpos PACKED // Next record in N0x
, fmaxpos PACKED; // Next record in L0x
short int abnormal PACKED; // 0: N0x has only the root
}
cntBlock;
// Index of Dictionary (N0x) structures......................................
typedef /* Packed */ struct
{
long int pos PACKED; // Number of record
short int ock PACKED // Number of active keys in the record: 1, 2, 3...2*ordn
, it PACKED; // B*tree type
}
nodeHeader;
typedef /* Packed */ struct
{
char key [10] PACKED;
long int ref PACKED; // > 0: reference to next node;
// < 0: ref. to leaf: idx [1st].key = key
// = 0: inactive
}
nodeIndex1;
typedef /* Packed */ struct
{
char key [30] PACKED;
long int ref PACKED;
}
nodeIndex2;
typedef /* Packed */ struct
{
nodeHeader hdr PACKED;
nodeIndex1 idx [10] PACKED; // Vector of 2*ordn elements
}
nodeBlock1;
typedef /* Packed */ struct
{
nodeHeader hdr PACKED;
nodeIndex2 idx [10] PACKED; // Vector of 2*ordn elements
}
nodeBlock2;
typedef /* Packed */ union
{
nodeBlock1 nb1 PACKED;
nodeBlock2 nb2 PACKED;
}
nodeBlock;
// Leaf File (L0x) structures (all index terms)..............................
typedef /* Packed */ struct
{
long int pos PACKED; // Number of leaf record: 1, 2...
short int ock PACKED // Number of active keys in the record: 1..2*ordf
, it PACKED; // = 1 for L01; = 2 for L02
long int ps PACKED; // Next record in the order: key [ock] < ps^ idx [1st].key
}
leafHeader;
typedef /* Packed */ struct
{
char key [10] PACKED;
short int xxx PACKED; // *** ONLY UNIX ISIS;
long int infb PACKED // Reference to IFP segment *** != ISIS.MANUAL ***
, infp PACKED;
}
leafKey1;
typedef /* Packed */ struct
{
char key [30] PACKED;
short int xxx PACKED; // *** ONLY UNIX ISIS;
long int infb PACKED // Reference to IFP segment *** != ISIS.MANUAL ***
, infp PACKED;
}
leafKey2;
typedef /* Packed */ struct
{
leafHeader hdr PACKED;
leafKey1 idx [10] PACKED; // 2*ordf keys
}
leafBlock1;
typedef /* Packed */ struct
{
leafHeader hdr PACKED;
leafKey2 idx [10] PACKED; // 2*ordf keys
}
leafBlock2;
typedef /* Packed */ union
{
leafBlock1 lb1 PACKED;
leafBlock2 lb2 PACKED;
}
leafBlock;
// Inverted File Posting structures..........................................
// ordained postings organized in segments: Index --> Master File
typedef /* Packed */ struct
{
long int ifblk PACKED // Number of block
, ifrec [127] PACKED; // Vector of long int *** != ISIS.MANUAL ***
// In 1st block ifrec [1st/2nd] = next pos. in IFP
}
ifpBlock;
typedef /* Packed */ struct // This header and 1st posting - always in IFP block
{
long int ifpnxtb PACKED // Pointer to the next segment: 1, 2... | = 0: last seg.
, ifpnxtp PACKED // 0, 1... | = 0: last seg.
, ifptotp PACKED // Tot. number of postings (o.k. only in the 1st segment)
// = Sum (segment=1, nseg; ifpsegp)
, ifpsegp PACKED // Number of postings in this segment
, ifpsegc PACKED; // Max. number of postings in this segment (<= 32768)
}
ifpHeader;
// ifpHeader & 1st ifpPosting always in the same ifpBlock
// Postings in Segment are always in chain of IFP blocks
typedef /* Packed */ struct // Stored left-->right + 0 --> 8 char
{
long int pmfn PACKED; // First 3 bytes --> Master File
short int ptag PACKED; // Field ident - according to File Selection Table (FST)
char pocc PACKED; // Number of occurence of the field
short int pcnt PACKED; // Counter of the termin inside the field
}
ifpPosting;
typedef struct
{
int opened; // Which files are opened (bit spec.)...
FILE *mst; // 1
FILE *xrf; // 2
FILE *ifp; // 4
FILE *n01; // 8
FILE *l01; // 16
FILE *n02; // 32
FILE *l02; // 64
mstControl mctrl; // MST ctrl record
cntBlock cnt1, cnt2; // Inv. Files ctrl records
long int ibm, ipm; // IFP new Segment Bock/Pos
char name [72]; // Database name
}
BaseCtrl;
typedef struct // This structer must be allways corelated with BaseCtrl
{
char st [31]; // Max. string to find
short int v; // Field to find; 0: all fields
short int it; // Type of B*Tree <== strlen (st)
leafBlock lbl; // Block L0x with index terms
short int ilk; // Position of term in lbl...idx
char *term; // The term in lbl...idx
long int ib, ip; // Number of block/position for IFP
ifpBlock ibl; // Block IFP with posting/s
ifpHeader ihd; // Header for Segment of postings
long int iiseg; // Number of posting in current Segment (index)
long int iitot; // Number of posting in total (index)
long int iall; // Number of posting in all Segments
char *ipst; // Ref. to last posting string [8 chars]
cntBlock *cntr; // BaseCtrl.cntr1/2 <== it
FILE *n0x; // N01 or N02 <== it, = BaseCtrl.n0x
FILE *l0x; // L01 or L02 <== it, = BaseCtrl.l0x
}
TableQuery;
#define RECLENGTH 8192
typedef union
{
char buf [RECLENGTH];
RecHeaders hdrs;
}
RecCtrl;
// *** MAIN DATABASE FILE RELATIONS (MST <--> XRF) ***
// 1 2 3
// MST |-mblk-|-mblk-|-mblk-|-mblk-|-mblk-|-mblk-|-mblk-|-mblk-|...
// ctrl |----record----|
// |--->|
// 1 2 3 | pointer: B/P (P in [0, 2, 4... 498])
// XRF |-xblk-|-xblk-|-xblk-|...
// MFN= 1... 128... 255...
// Record |-->-pos->--|
// |-mhf-mht-|-idx[1]...idx[nvf]-|---text...---|
// |-------------- record buffer --------------|
// *** INVERTED FILE RELATIONS (N0x <--> L0x <-->IFP) ***
// N0x |-nbl-|-nbl-|-nbl-|-nbl-|-nbl-|-nbl-|...
// -->-root->-| |-->--next-->--| |->-->-| r<0
// |
// L0x |--lbl--|--lbl--|--lbl--|--lbl--|--lbl--|--lbl--|...
// |
// |-<--------------<-------------<-| r<0
// *** POSTING *** |
// IFP |---ibl---|---ibl---|---ibl---|---ibl---|---ibl---|---ibl---|...
// |next |-ihd-|---Segment---| |-ihd-|---Segment---|
// |Seg. |-->------>------>-next->--| |||...
// MFN...
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// #include "idef.c"
// Let's specify non int header ;-) just to keep order
void ShowRec (RecCtrl *rc);
void setQuery (BaseCtrl *bc, TableQuery *tq, char *sx, short int fld);
void isis ();
// #include "iutil.c"
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
iAPI software: The UTIL procedures for Unix-ISIS databases
Copyright (C) 2000 by Robert Janusz
E-mail: rj@jezuici.krakow.pl
Address: Robert Janusz, ul. Kopernika 26, 31-501 Krakow, Poland
tel: (0048-12) 4294416/432 ; fax: (0048-12) 4295003.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
// gcc Linux Compiler conventions !
// *** ONLY UNIX ISIS = the difference between DOS/UNIX structures
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int ReadMem (void *ptr, FILE *f, long int nr, long int size)
{ // Read "nr"'s block of size "size" from file "f" into "ptr"...
if (fseek (f, nr * size, SEEK_SET) != 0) return (-1);
if (fread (ptr, size, 1, f) == 0) return (-2);
return (0); // O.K.
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void doUpcase (char *s, char *st, int slen)
{ int i;
for (i = 0; i < slen; i++)
{ if (i < strlen (st)) s [i] = UpCase [(int) st [i]]; else s [i] = ' '; }
s [slen] = 0;
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int sComp (char *s1, char *s2, int len)
{ int i;
for (i = 0; i < len; i++)
{ if (s1 [i] > s2 [i]) return (1); // .gt.
if (s1 [i] < s2 [i]) return (-1); // .lt.
}
return (0); // .eq.
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int bfOpen (FILE **f, BaseCtrl *bc, char *ext, char *opt)
{ char st [81];
if (strlen (bc->name) + strlen (ext) > 80) return (-2);
strcpy (st, bc->name); strcat (st, ext);
if ((*f = fopen (st, opt)) == NULL) return (-1);
return (0);
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int InitBase (BaseCtrl *bc)
// Error return: -1 base file/s; -2 inv. file/s; -3 mst. ctrl rec/s;
// -4 cnt param/s; -5 ifp param/s
{ ifpBlock ib;
bc->opened = 0;
if (bfOpen (&bc->mst, bc, ".MST", "rb") != 0) return (-1);
bc->opened += 1; // MST opened
if (bfOpen (&bc->xrf, bc, ".XRF", "rb") != 0) return (-1);
bc->opened += 2; // XRF opened
if (bfOpen (&bc->ifp, bc, ".CNT", "rb") != 0) return (-2);
if (fread (&bc->cnt1, sizeof (cntBlock), 1, bc->ifp) == 0 ||
fread (&bc->cnt2, sizeof (cntBlock), 1, bc->ifp) == 0) return (-2);
if (fclose (bc->ifp) != 0) return (-3);
if (bfOpen (&bc->ifp, bc, ".IFP", "rb") != 0) return (-2);
bc->opened += 4; // IFP opened
if (bfOpen (&bc->n01, bc, ".N01", "rb") != 0) return (-2);
bc->opened += 8; // N01 opened
if (bfOpen (&bc->l01, bc, ".L01", "rb") != 0) return (-2);
bc->opened += 16; // L01 opened
if (bfOpen (&bc->n02, bc, ".N02", "rb") != 0) return (-2);
bc->opened += 32; // N02 opened
if (bfOpen (&bc->l02, bc, ".L02", "rb") != 0) return (-2);
bc->opened += 64; // L02 opened
if (fread (&bc->mctrl, sizeof (mstControl), 1, bc->mst) == 0) return (-3);
if (bc->cnt1.ordn != 5 || bc->cnt1.ordf != 5 || bc->cnt1.n != 15 ||
bc->cnt1.k != 5 || bc->cnt2.ordn != 5 || bc->cnt2.ordf != 5 ||
bc->cnt2.n != 15 || bc->cnt2.k != 5) return (-4);
if (fread (&ib, sizeof (ifpBlock), 1, bc->ifp) == 0) return (-5);
if (ib.ifblk != 1) return (-5);
bc->ibm = ib.ifrec [0]; bc->ipm = ib.ifrec [1];
return (0);
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void Done (BaseCtrl *bc) // Close the database files
{
if (bc->opened && 1) fclose (bc->mst);
if (bc->opened && 2) fclose (bc->xrf);
if (bc->opened && 4) fclose (bc->ifp);
if (bc->opened && 8) fclose (bc->n01);
if (bc->opened && 16) fclose (bc->l01);
if (bc->opened && 32) fclose (bc->n02);
if (bc->opened && 64) fclose (bc->l02);
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
char UpMe (char c) // ^A = ^a etc.
{
if (c > 96) c = c - 32;
return (c);
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void outS (char *st)
{ char i;
if (st == NULL) return;
for (i = 0; i < strlen (st); i++)
// c = tblconvert [st [i]];
if (st [i] == (char) 145) printf ("<"); // This is HTML <
else if (st [i] == (char) 146) printf (">"); // and that is >
else printf ("%c", st [i]);
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void outC (char ch)
{ char st [2];
st [0] = ch; st [1] = 0; outS (st);
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void outD (double x, int n)
{ char s [80];
gcvt (x, n, s);
outS (s);
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void outN (long int x) // long int -> sting @ base=10
{
// char st [33];
// ltoa (x, st, 10); outS (st);
printf ("%li", x);
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// #include "imasterf.c"
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
iAPI software: The Master File access to Unix-ISIS databases
Copyright (C) 2000 by Robert Janusz
E-mail: rj@jezuici.krakow.pl
Address: Robert Janusz, ul. Kopernika 26, 31-501 Krakow, Poland
tel: (0048-12) 4294416/432 ; fax: (0048-12) 4295003.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
// gcc Linux Compiler conventions !
// *** ONLY UNIX ISIS = the difference between DOS/UNIX structures
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int GetRec (BaseCtrl *bc, long int mfnr, RecCtrl *rc, int bufvol)
{ char mblk [512]; // Master File block;
long int xmfb, xmfp; // Pointer to Master File (last read) record
// xMfB < 0 : record deleted (status = 1), -xMfB --> block;
// xMfP = 0: deleted phisicaly
// = 0 & = 0: does not exist
// 1st block: xMfB = 1, xMfP = 0; pointer = xMfB * 2048 + xMfP
// ==> mst < 500 MBy;
long int xn, xb;
int ret, nch;
xrfBlock xblk;
mstHdrFix *hf = &rc->hdrs.mhf;
mstHdrTxt *ht = &rc->hdrs.mht;
char *b = rc->buf;
if ((mfnr < 1) || (mfnr >= bc->mctrl.nxtmfn)) return (-2); // No record
// Find the address in XRF...
xn = mfnr - 1; xb = xn / 127;
if (ReadMem (&xblk, bc->xrf, xb, sizeof (xrfBlock)) != 0) return (-1);
xn = xblk.xrec [xn % 127]; // = address in MST
xmfb = xn / 2048; // Master File Block
xmfp = xn % 512; // Master File Position
// Find the record in MST...
if (xmfb < 1) return (1); // Record deleted
ret = 0; // Record o.k.
if (ReadMem (&mblk, bc->mst, xmfb - 1, sizeof (mblk)) != 0) return (-1);
// Copy headers into record buffer...
memcpy (b, &mblk [xmfp], sizeof (mstHdrFix));
if (hf->mfn != mfnr) return (-2); // Database corrupted
if (hf->mfrl >= bufvol) return (-3); // Buffer too small
// Get the rest of the record
xmfp += sizeof (mstHdrFix); // Posinion in block
xb = sizeof (mstHdrFix); // Position in buf
xn = labs (hf->mfrl) - xb; // Number of chars to read
if (xn <= 0) return (4); // No fields ??
for ( ; ; ) // We have some chars
{ // Find number of chars to copy from this block
if (xn <= (nch = sizeof (mblk) - xmfp)) nch = xn;
memcpy (b + xb, &mblk [xmfp], nch);
xb += nch; xn -= nch; xmfp = 0;
if (xn <= 0) break; // Nothing more to read
if (fread (&mblk, sizeof (mblk), 1, bc->mst) == 0) return (-1);
}
if (ht->status != 0) ret = 1; // Record deleted logicaly
if (hf->mfbwb != 0 || hf->mfbwp != 0) ret = 2; // Record not inv.
if (hf->mfrl < 0) ret = 3; // Record blocked
return (ret);
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int IsF (RecCtrl *rc, short int v, char ch, char *st)
{ short int n, k, kk, flag;
char *b = rc->buf;
mstHdrTxt *mht = &rc->hdrs.mht;
mstIndex *ind = (mstIndex *) &rc->buf [sizeof (RecHeaders)];
flag = 0;
for (n = 0; n < mht->nvf; n++)
{
if (ind->tag == v) // there is a tag
{
if (ch == ' ') // field found
{ flag = 1; break; }
else // there is sub-field
{ flag = 1;
kk = 0; k = mht->base + ind->pos;
while (b [k] != '^' || b [k + 1] != ch) // convention ;-)
{ k += 1; kk += 1;
if (kk >= ind->len) // out of field
return (0);
}
break;
}
}
ind += 1; // next index ref.
}
if (flag == 0) return (0); // false
if (st == NULL) return (1); // true
else
if (sComp (&b [mht->base + ind->pos], st, ind->len) == 0)
return (1);
else return (0);
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void RepF (RecCtrl *rc, char nf, ...)
// Repeated "nf" fields in record "rc", the left label appears only if:
// - begins with "\n", - there was another field and there is defined
// filed; the right label appears only if ther was defined field.
{ va_list pinfo; // for ... parameter list
int i, c, flag, n, k, kk, v;
int hit = 0;
char *sl, *sr;
char *b = rc->buf;
mstHdrTxt *mht = &rc->hdrs.mht;
mstIndex *ind = (mstIndex *) &rc->buf [sizeof (RecHeaders)];
for (n = 0; n < mht->nvf; n++)
{
va_start (pinfo, nf);
for (i = 0; i < nf; i++)
{
kk = 0;
k = mht->base + ind->pos;
sl = va_arg (pinfo, char *); // left
v = va_arg (pinfo, short int); // field
c = va_arg (pinfo, char); // sub-field
c = UpMe (c);
sr = va_arg (pinfo, char *); // right
if (v != ind->tag) // another Tag
break;
if (c != ' ') // sub-field
{ flag = 1;
while (b [k] != '^' || UpMe (b [k + 1]) != c) // convention ;-)
{ k += 1; kk += 1;
if (kk >= ind->len)
{ flag = 0; break; }
}
if (flag) { k += 2; kk += 2; }
}
else flag = 1;
if (flag)
{ // Reference to NULL = NW error !!!
if (sl == NULL) flag = 0;
else if (*sl == '\n') flag = 1; else flag = 0;
if (hit != 0 || flag) outS (sl);
hit += 1;
if (c == ' ')
while (kk < ind->len)
{
if (b [k] != '<' && b [k] != '>') // HTML special ;-)
outC (b [k]);
k += 1; kk += 1;
}
else
while (kk < ind->len && b [k] != '^') // convention ;-)
{
if (b [k] != '<' && b [k] != '>') // HTML special ;-)
outC (b [k]);
k += 1; kk += 1;
}
outS (sr);
}
}
va_end (pinfo);
ind += 1;
}
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// #include "iinvterm.c"
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
iAPI software: The Inv. File Terms access for Unix-ISIS databases
Copyright (C) 2000 by Robert Janusz
E-mail: rj@jezuici.krakow.pl
Address: Robert Janusz, ul. Kopernika 26, 31-501 Krakow, Poland
tel: (0048-12) 4294416/432 ; fax: (0048-12) 4295003.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
// gcc Linux Compiler conventions !
// *** ONLY UNIX ISIS = the difference between DOS/UNIX structures
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int FindFirst (TableQuery *tq)
{
short int i, j // Indexes for idx []
, srec, klen, sidx; // Size (rec), key length, size (idx)
long int r; // Reference (record number); < 0: --> L0x --> IFP
char *ref;
leafHeader *lhdr = &tq->lbl.lb1.hdr; // = ...lb2.hdr
nodeBlock nbl;
nodeHeader *nhdr = &nbl.nb1.hdr; // = ...nb2.hdr
if (tq->it == 1)
{ klen = 10; srec = sizeof (nodeBlock1); sidx = sizeof (nodeIndex1); }
else
{ klen = 30; srec = sizeof (nodeBlock2); sidx = sizeof (nodeIndex2); }
r = tq->cntr->posrx; // Root in N0x
while (r > 0L)
{
if (ReadMem (&nbl, tq->n0x, r - 1, srec) != 0) return (-1);
j = nhdr->ock;
if (nhdr->pos != r || nhdr->it != tq->it ||
j < 1 || j > 10) return (-3); // 10 = 2*ordn
ref = (char *) &nbl.nb1.idx; // Reference to first elem. of index
ref += sidx; // The first key is allways <= st, skip it
for (i = 1; i < j; i++)
if (sComp (ref, tq->st, klen) > 0) break;
else ref += sidx;
ref -= sidx; // Correct value
r = *(long int *) (ref + klen); // We have the "ref" value
if (r > tq->cntr->nmaxpos) return (-3); // Out of N0x
}
// Now find the term in L0x index
if (tq->it == 1)
{ srec = sizeof (leafBlock1); sidx = sizeof(leafKey1); }
else
{ srec = sizeof(leafBlock2); sidx = sizeof(leafKey2); }
r = - r;
if (ReadMem (&tq->lbl, tq->l0x, r - 1, srec) != 0) return (-1);
j = lhdr->ock;
if (lhdr->pos != r || lhdr->it != tq->it ||
j < 1 || j > 10) return (-2); // 10 = 2*ordf
tq->ilk = 0;
ref = (char *) &tq->lbl.lb1.idx; // Reference to first elem. of index
ref += sidx; // The first key is allways <= s, skip it
for (i = 1; i < j; i++)
if (sComp (ref, tq->st, klen) > 0) break;
else { ref += sidx; tq->ilk += 1; }
ref -= sidx;
tq->term = ref; // We have the term address
if (tq->it == 1)
ref += 12; // += 10; *** NOT UNIX
else ref += 32; // += 30; *** NOT UNIX
tq->ib = *(long int *) ref; // = infb
ref += sizeof (long int);
tq->ip = *(long int *) ref; // = infp
return (0); // O.K.
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int FindNext (TableQuery *tq)
{ int srec; // Block size
long int r; // Reference (record number); < 0: --> L0x --> IFP
leafHeader *lhdr = &tq->lbl.lb1.hdr; // = ...lb2.hdr
if (tq->it == 1) srec = sizeof (leafBlock1);
else srec = sizeof (leafBlock2);
tq->ilk += 1; // Next key in the index
if (tq->ilk >= lhdr->ock) // Out of index
{ r = lhdr->ps; // Next L0x record in order
if (r <= 0)
{ tq->ilk -= 1; return (1); } // Nothing more, end of index
if (ReadMem (&tq->lbl, tq->l0x, r - 1, srec) != 0) return (-1);
if (lhdr->pos != r || lhdr->it != tq->it ||
lhdr->ock < 1 || lhdr->ock > 10) return (-2); // 10 = 2*ordf
tq->ilk = 0;
}
srec = tq->ilk;
if (tq->it == 1)
{ tq->term = tq->lbl.lb1.idx [srec].key;
tq->ib = tq->lbl.lb1.idx [srec].infb;
tq->ip = tq->lbl.lb1.idx [srec].infp;
}
else
{ tq->term = tq->lbl.lb2.idx [srec].key;
tq->ib = tq->lbl.lb2.idx [srec].infb;
tq->ip = tq->lbl.lb2.idx [srec].infp;
}
return (0); // We have the new key
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int Find (BaseCtrl *bc, TableQuery tabq [], int ifind, long int *npg
, RecCtrl *rc, long int recvol)
{ int i;
if (ifind <= 0 || ifind > NFIND) return (-1);
for (i = 0; i < ifind; i++)
if (FindFirst (&tabq [i]) < 0) return (-1);
i = Postings (bc, tabq, ifind, npg, rc, recvol);
return (i);
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int IndexPrep (BaseCtrl *bc, TableQuery *tq1, TableQuery *tq2, char *st)
{ char sx [31]; // tqx->v contains the status of L0x index
int i;
if (st == NULL)
for (i = 0; i < 30; i++) sx [i] = ' ';
else
for (i = 0; i < 30; i++)
if (i < strlen (st)) sx [i] = st [i]; else sx [i] = ' ';
sx [30] = 0;
setQuery (bc, tq2, sx, 0); // We have a long term in tq2; v := 0
if (FindFirst (tq2) < 0) return (-1);
sx [10] = 0;
setQuery (bc, tq1, sx, 0); // We have a short term in tq1; v := 0
if (FindFirst (tq1) < 0) return (-1);
while (sComp (tq1->term, tq1->st, 10) < 0)
if ((tq1->v = FindNext (tq1)) != 0) break; // At the end or error
if (tq1->v < 0) return (-1);
while (sComp (tq2->term, tq2->st, 30) < 0)
if ((tq2->v = FindNext (tq2)) != 0) break; // At the end or error
if (tq2->v < 0) return (-1);
return (IndexTest (tq1, tq2));
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int IndexTest (TableQuery *tq1, TableQuery *tq2)
{
if (tq1->v == 1) // At the end of 1st
if (tq2->v == 1) // At the end of 2nd
return (0); // All done
else return (2); // We have only 2nd
else
if (tq2->v == 1) return (1); // We have only 1st
else if (sComp (tq1->term, tq2->term, 10) <= 0) return (1);
else return (2);
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int IndexTerm (int i, TableQuery *tq1, TableQuery *tq2)
{
if (i == 1) tq1->v = FindNext (tq1); // The term was in 1st
else if (i == 2) tq2->v = FindNext (tq2); // The term was in 2nd
else return (-1);
return (IndexTest (tq1, tq2));
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void setQuery (BaseCtrl *bc, TableQuery *tq, char *sx, short int fld)
{ // Must be activated AFTER the initialization of database
tq->v = fld;
if (strlen (sx) <= 10)
{ tq->it = 1; doUpcase (tq->st, sx, 10);
tq->cntr = &bc->cnt1; tq->n0x = bc->n01; tq->l0x = bc->l01;
}
else
{ tq->it = 2; doUpcase (tq->st, sx, 30);
tq->cntr = &bc->cnt2; tq->n0x = bc->n02; tq->l0x = bc->l02;
}
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// #include "ipost.c"
/* ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
iAPI software: The Inv. File Postings access for Unix-ISIS databases
Copyright (C) 2000 by Robert Janusz
E-mail: rj@jezuici.krakow.pl
Address: Robert Janusz, ul. Kopernika 26, 31-501 Krakow, Poland
tel: (0048-12) 4294416/432 ; fax: (0048-12) 4295003.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ */
// gcc Linux Compiler conventions !
// *** ONLY UNIX ISIS = the difference between DOS/UNIX structures
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int PostSeg (BaseCtrl *bc, TableQuery *tq)
{
if (ReadMem (&tq->ibl, bc->ifp, tq->ib - 1, sizeof (ifpBlock)) != 0)
return (-1);
if (labs (tq->ibl.ifblk) - tq->ib != 0) return (-2);
memcpy (&tq->ihd, &tq->ibl.ifrec [tq->ip], sizeof (ifpHeader));
tq->ip += 3; // = long int.s / (header - posting) ***!= ISIS.MANUAL ***
tq->iiseg = 0;
return (0);
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int PostNext (BaseCtrl *bc, TableQuery *tq)
{
if (tq->iitot >= tq->iall) return (1); // No more postings
if (tq->iiseg >= tq->ihd.ifpsegp) // No more postings in this seg.
{ // Get next Segment...
tq->ib = tq->ihd.ifpnxtb; tq->ip = tq->ihd.ifpnxtp;
if (PostSeg (bc, tq) != 0) return (-2);
}
tq->iiseg += 1; tq->iitot += 1;
tq->ip += 2; // = Number of long int / posting ***!= ISIS.MANUAL ***
if (tq->ip > 125) // ***!= ISIS.MANUAL ***
{ // Get next block for this segment; we HAVE TO find the right block!
tq->ib += 1; tq->ip = 0;
if (ReadMem (&tq->ibl, bc->ifp, tq->ib - 1, sizeof (ifpBlock)) != 0)
return (-1);
if (labs (tq->ibl.ifblk) != tq->ib) return (-3);
}
tq->ipst = (char *) &tq->ibl.ifrec [tq->ip];
return (0);
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void PostMake (long int mfn, short int tag, char occ, short int pcnt
, char *s, char *slen)
{ ifpPosting rnp;
char *p = (char *) &rnp;
rnp.pmfn = mfn; rnp.ptag = tag; rnp.pocc = occ; rnp.pcnt = pcnt;
if (tag == 0) *slen = 3; // Only MFN
else *slen = 5; // MFN and TAG
s [2] = p [0]; s [1] = p [1]; s [0] = p [2]; // = pmfn
s [4] = p [4]; s [3] = p [5]; s [5] = p [6]; s [7] = p [7]; s [6] = p [8];
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void PostInv (ifpPosting *ifpp, void *ps)
{ char *p = (char *) ifpp;
char *s = (char *) ps;
// Posting string: |0 a |1 b |2 c |3 d |4 e |5 f |6 g |7 h | ps *s
// ifpPosting: |0 c|1 b |2 a |3 0 |4 e |5 d |6 f |7 h |8 g | ifpp *p
// |pmfn |ptag |pocc|pcnt |
p [0] = s [2]; p [1] = s [1]; p [2] = s [0]; p [3] = 0; // = pmfn
p [4] = s [4]; p [5] = s [3]; p [6] = s [5]; p [7] = s [7]; p [8] = s [6];
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
int main (int argc, char **argv) // char *argv []
{ char c;
printf ("ix <database>\n");
printf ("<database> ::= UNIX-ISIS (v.3) MF without .MST\n");
printf ("ix ver. 0.3, Copyright (C) 2000 by Robert Janusz\n");
printf ("ix comes with ABSOLUTELY NO WARRANTY\n");
printf ("License: GPL; see http://www.gnu.org/ for details\n");
for (c = 'A'; c <= 'z'; c++) // Let's prepare it, we use API, not an example
UpCase [c] = UpMe (c);
if (argv [1] != NULL) {
strcpy (DBpath, argv [1]); // Database; no test ! ;-) it's only an example
isis ();
}
return (0);
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void isis ()
{
int j, v, k;
long int nrc;
BaseCtrl bc;
RecCtrl rc;
char st [31];
TableQuery tabq [NFIND];
strcpy (bc.name, DBpath);
InitBase (&bc);
// ShowRec but not all...
printf ("\n*** ShowRec ***\n\n");
//for (nrc = 1L; nrc < bc.mctrl.nxtmfn; nrc++) {
for (nrc = 10L; nrc < 20L; nrc++) {
if ((j = GetRec (&bc, nrc, &rc, RECLENGTH)) == 0) {
ShowRec (&rc);
}
}
// ShowIndex
printf ("\n*** ShowIndex: %s ***\n\n", st);
strcpy (st, "TEST"); // just an Inv. File term
v = 0; // term counter
k = IndexPrep (&bc, &tabq [0], &tabq [1], st); // prepare indexes
while (k > 0) {
j = 20 * k - 10; // We have the term length ;-)
memcpy (&st, &tabq [k - 1].term [0], j); // keep it in st
st [j] = 0;
if ((v += 1) > 12) // we want 12 terms in a list
{
printf ("->%s\n", st); // the next term
break;
}
printf ("%s\n", st);
k = IndexTerm (k, &tabq [0], &tabq [1]); // Next term
}
// Find a term & show records
printf ("\n*** Search for: %s ***\n\n", st); // Let's use the last term
setQuery (&bc, &tabq [0], st, 0); // String to search in a filed 0 = any
j = Find (&bc, tabq, 1, &nrc, &rc, RECLENGTH); // 1 term to search for
// Clean all
printf ("\nO.K.\n");
Done (&bc);
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
void ShowRec (RecCtrl *rc)
{ long int nr;
short int n, k, kk;
char st [256];
char *b = rc->buf;
mstHdrTxt *mht = &rc->hdrs.mht;
mstIndex *ind = (mstIndex *) &rc->buf [sizeof (RecHeaders)];
nr = rc->hdrs.mhf.mfn; // Record header
printf ("=== %li\n", nr);
for (n = 0; n < mht->nvf; n++)
{ // Show fileds without formating
printf ("*** [%li] ", (long int) ind->tag);
k = mht->base + ind->pos;
for (kk = 0; kk < ind->len; kk++)
printf ("%c", b [k++]);
printf ("\n");
ind += 1; // Next index
}
printf ("___\n");
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// This procedure is prepared to do a simple AND operator after some
// extensions, so it can be localy a little strange ;-)
int Postings (BaseCtrl *bc, TableQuery tabq [], int ifind, long int *npg
, RecCtrl *rc, long int recvol)
{ int j, state;
long int ipg, rn;
ifpPosting ip;
TableQuery *tq;
if (ifind < 1) goto finish; // nothing to do
ipg = 1L; // Index for page break
{ tq = &tabq [0]; // Let's think only about one term to handle (example)
if (PostSeg (bc, tq) != 0) return (-1);
tq->iall = tq->ihd.ifptotp; // Only 1st Segment has tot. post. number
tq->iitot = 0;
if (PostNext (bc, tq) != 0) return (-1);
PostInv (&ip, tq->ipst);
if (sComp (tq->st, tq->term, 20 * tq->it - 10) != 0)
ipg = 0L; // the term not found
}
if (ipg != 1L) goto finish;
for ( ; ; ) // Global loop...
{
// Is there a field
{ tq = &tabq [0];
if (tq->v != 0)
while (ip.ptag != tq->v)
{
if (PostNext (bc, tq) > 0) goto finish; // No more postings
PostInv (&ip, tq->ipst);
}
}
rn = ip.pmfn;
state = 1;
if (ip.pmfn != rn)
state = 0;
if (state) // We have a record to show
{
if ((j = GetRec (bc, rn, rc, recvol)) == 0)
ShowRec (rc);
else
printf ("Record state = %li\n", j);
do // Shift all postings
{ tq = &tabq [0];
if (PostNext (bc, tq) > 0) goto finish; // No more postings
PostInv (&ip, tq->ipst);
}
while (ip.pmfn <= rn); // MFN equals
}
else // state == 0, Shift all postings
while (ip.pmfn < rn) // The last is to examin
{ tq = &tabq [0];
if (PostNext (bc, tq) > 0) goto finish; // No more postings
PostInv (&ip, tq->ipst);
}
}
finish:
return (0); // The output is finished
}
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
RSS Feed