IsisReader: contrib/openisis/openisis.h Source File

00001 /*
00002         openisis - an open implementation of the CDS/ISIS database
00003         Version 0.8.x (patchlevel see file Version)
00004         Copyright (C) 2001-2003 by Erik Grziwotz, erik@openisis.org
00005 
00006         This library is free software; you can redistribute it and/or
00007         modify it under the terms of the GNU Lesser General Public
00008         License as published by the Free Software Foundation; either
00009         version 2.1 of the License, or (at your option) any later version.
00010 
00011         This library is distributed in the hope that it will be useful,
00012         but WITHOUT ANY WARRANTY; without even the implied warranty of
00013         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014         Lesser General Public License for more details.
00015 
00016         You should have received a copy of the GNU Lesser General Public
00017         License along with this library; if not, write to the Free Software
00018         Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00019 
00020         see README for more information
00021 EOH */
00022 #ifndef OPENISIS_H
00023 
00024 /*
00025         $Id: openisis.h,v 1.95 2003/11/23 10:25:38 kripke Exp $
00026         public interface of the openisis lib.
00027         usage samples of most calls are found in openisis.c
00028 */
00029 
00030 #define OPENISIS_VERSION "0.9.1"
00031 
00032 #ifndef __STDC__
00033 #       ifndef const
00034 #               define const
00035 #       endif
00036 #endif
00037 
00038 #ifdef __cplusplus
00039 extern "C" {
00040 #endif
00041 
00042 /* ************************************************************
00043         record structure
00044 */
00045 
00049 typedef struct OpenIsisField {
00050         int         tag;
00051         const char *val;
00052         int         len;
00053 } OpenIsisField;
00054 
00055 
00058 typedef struct OpenIsisRec {
00059         int           dbid;
00060         int           rowid;
00061         int           bytes; /* total avail bytes */
00062         int           used; /* total used bytes (originally BWB) */
00063         int           fields;  /* avail number of fields (originally BWP) */
00064         int           base; /* byte offset of contents area (after fields) */
00065         int           len;      /* used number of fields */
00066         int           state;
00067         OpenIsisField field[1];
00068 } OpenIsisRec;
00069 
00070 /* compute base from fields (for both raw and cooked record) */
00071 #define OPENISIS_BASESZ( nfields ) ((int)sizeof(int)*(8 + 3*(nfields)))
00072 
00073 /* initialise record of f fields, n bytes */
00074 #define OPENISIS_INITREC( r, n, f ) \
00075         do { \
00076                 memset( r, 0, n ); \
00077                 (r)->bytes = (n); \
00078                 (r)->fields = (f); \
00079                 (r)->used = (r)->base = OPENISIS_BASESZ( (r)->fields ); \
00080         }       while (0)
00081 
00082 /* init with std 1 field per 100 bytes */
00083 #define OPENISIS_INITSTD( r, n ) OPENISIS_INITREC( r, n, (n)/100 )
00084 /* init a buffer structure which has a member r */
00085 #define OPENISIS_INITBUF( x ) OPENISIS_INITSTD( &x.r, sizeof(x) )
00086 #define OPENISIS_CLRREC( r ) \
00087         do { \
00088                 (r)->len = (r)->state = 0; \
00089                 (r)->used = (r)->base = OPENISIS_BASESZ( (r)->fields ); \
00090         }       while (0)
00091 
00092 /* check some invariants (for both raw and cooked record) */
00093 #define OPENISIS_RECOK( r ) \
00094         ( (r)->base <= (r)->used \
00095         && (r)->used <= (r)->bytes \
00096         && (r)->len <= (r)->fields \
00097         && (r)->base == OPENISIS_BASESZ( (r)->fields ) )
00098 
00099 
00102 enum { /* field types */
00103         OPENISIS_FTX =  0, /* alphanum */
00104         OPENISIS_FTA =  1, /* STRICTLY alpha */
00105         OPENISIS_FTN =  2, /* numeric */
00106         OPENISIS_FTP =  3, /* pattern */
00107         OPENISIS_FTB =  4, /* bool (old: 13) */
00108         OPENISIS_FTE =  5, /* enum (old: 12) */
00109         OPENISIS_FTI =  8, /* ISO (unused) */
00110         OPENISIS_FTT =  9, /* table (unused) */
00111         OPENISIS_FTO = 13, /* structure: operator */
00112         OPENISIS_FTR = 14, /* structure: record */
00113         OPENISIS_FTS = 15, /* structure: sequence */
00114         OPENISIS_FTV = 16, /* enum value (old: 31) */
00115         OPENISIS_FTF = 16  /* subfield (unused) */
00116 };
00117 
00118 #define OPENISIS_FD_NAMELEN  32
00119 typedef struct OpenIsisFd {
00120         int   id; /* tag */
00121         char  subf; /* subfield char or 0 */
00122         char  type; /* type */
00123         char  rep; /* !0 for repeated */
00124         char  slen; /* length of childs */
00125         short len; /* max length or enum value */
00126         char  name[OPENISIS_FD_NAMELEN]; /* name, 0 terminated, max 30 */
00127         char  desc[OPENISIS_FD_NAMELEN]; /* 0 terminated description */
00128         char *pat; /* 0 terminated pattern */
00129         char *dflt; /* 0 terminated default value */
00130         OpenIsisRec *info; /* additional application dependent attributes */
00131         struct OpenIsisFd **subs; /* subfield childs */
00132 }       OpenIsisFd;
00133 
00134 
00137 typedef struct {
00138         int          len;
00139         OpenIsisFd  *fd;
00140         OpenIsisRec *rec; /* additional fields like formats, worksheets ... */
00141         /* additional internal data like a hash might follow */
00142 }       OpenIsisFdt;
00143 
00144 
00145 typedef struct { /* where a key has a hit */
00146 
00147         unsigned       mfn;
00148         unsigned short tag;
00149         unsigned short occ; /* hit is in occ'th occurence of field tag in row mfn */
00150         unsigned short pos; /* ... as the pos'th word */
00151         unsigned short dbn; /* for multi-db index; ignored by now */
00152 }       OpenIsisHit;
00153 
00154 typedef struct {
00155         unsigned char len;
00156         unsigned char byt[23];
00157 }       OpenIsisVal;
00158 
00159 typedef struct {
00160         OpenIsisVal   val;
00161         unsigned char len;
00162         unsigned char byt[255];
00163 }       OpenIsisKey;
00164 
00165 
00170 enum {
00171         OPENISIS_XCTL = -1, /* the "index" control field */
00172         OPENISIS_XFST = -2, /* fst view line */
00173         OPENISIS_XHIT = -3, /* dotted decimal hit plus val */
00174         OPENISIS_XADD = -4, /* (prefix of) binary OpenIsisKey to add */
00175         OPENISIS_XDEL = -5  /* (prefix of) binary OpenIsisKey to del */
00176 };
00177 
00178 
00186 extern OpenIsisField *openIsisRGet ( OpenIsisRec *r, int tag, int *pos );
00187 
00188 extern OpenIsisField *openIsisROccurence ( OpenIsisRec *r, int tag, int occ );
00189 
00194 extern int openIsisA2i ( const char *p, int l );
00199 extern int openIsisA2il ( const char *p, int l, int *res );
00203 extern int openIsisA2id ( const char *p, int l, int dflt );
00208 extern int openIsisI2a ( char *p, int i );
00209 extern int openIsisU2a ( char *p, unsigned u );
00210 
00216 extern int openIsisRInt ( OpenIsisRec *r, int tag, int def, int *pos );
00217 
00223 extern int openIsisRInt2 (OpenIsisRec *rec,
00224         OpenIsisRec *dflt, int tag, int def);
00225 
00230 extern int openIsisREnum ( OpenIsisFdt *fdt,
00231         OpenIsisRec *r, int tag, int def, int *pos );
00232 
00237 extern char* openIsisRString (OpenIsisRec *r,
00238         int tag, int *pos, char *buf, int len);
00239 
00243 extern char* openIsisRString2 (OpenIsisRec *rec,
00244         OpenIsisRec *dflt, int tag, char *buf, int len);
00245 
00256 extern int openIsisRSerialize ( char *buf, OpenIsisRec *rec );
00261 extern int openIsisRSerializeBin ( char *buf, OpenIsisRec *rec );
00262 
00270 extern char* openIsisRSerializeAlloc (OpenIsisRec *rec, char *buf, int *len);
00271 
00277 /* ************************************************************
00278         fdt
00279 */
00280 
00283 extern OpenIsisFd* openIsisFById ( const OpenIsisFdt *fdt, int id, int subf );
00284 
00287 extern OpenIsisFd* openIsisFByName (const OpenIsisFdt *fdt, const char *name);
00288 
00289 enum {
00290         OPENISIS_NOENUM = 0x10000 /* enum NOENUM :) -- not a short */
00291 };
00292 
00297 extern int openIsisFEnum ( OpenIsisFdt *fdt, int id, const char *name );
00298 
00302 extern OpenIsisFdt* openIsisFFree (OpenIsisFdt *fdt);
00303 
00311 extern OpenIsisRec* openIsisFFdt2Rec (
00312         const OpenIsisFdt *fdt, OpenIsisRec *rec, int embchld);
00313 
00318 extern OpenIsisFdt* openIsisFRec2Fdt (OpenIsisRec *rec);
00319 
00320 
00321 /* ************************************************************
00322         session type and utilities
00323 */
00324 
00325 typedef struct OpenIsisSes *OpenIsisSession;
00326 
00327 extern void *openIsisMAlloc ( int size );
00328 extern void  openIsisMFree ( void *mem );
00329 extern void *openIsisMDup ( const void *str, int size );
00330 
00338 extern char *openIsisToHtml ( const char *str, int len );
00339 extern int openIsisUtf8Chk ( void *mem, int len, int *tof );
00340 
00341 
00342 /* ************************************************************
00343         stream IO
00344 */
00345 
00346 typedef struct OpenIsisIos *OpenIsisStream;
00347 typedef int OpenIsisSFunc ( OpenIsisStream s, int op );
00348 
00349 extern int openIsisSOpen ( const char *name, int flags, OpenIsisSFunc *type );
00350 
00354 enum { /* our very own errno */
00355         OPENISIS_ERR_OK    = 0, /* 0 is no error, also read(2)'s EINTR, EAGAIN */
00356         /* errors logged at level VERBOSE */
00357         OPENISIS_ERR_EOF   = 0x10000, /* end of file */
00358         /* errors logged at level ERROR */
00359         OPENISIS_ERR_FAULT = 0x20000, /* NULL pointer or bad sized buffer given */
00360         OPENISIS_ERR_INVAL = 0x30000, /* general invalid parameters, any EINVAL errno */
00361         OPENISIS_ERR_BADF  = 0x40000, /* bad file, also read(2)'s EINVAL, some of open(2) */
00362         /* errors logged at level SYSERR */
00363         OPENISIS_ERR_IO    = 0x50000, /* real IO error, also write(2)'s ENOSPC, EPIPE */
00364         OPENISIS_ERR_NOMEM = 0x60000, /* out of memory, also open(2)'s EMFILE, ENFILE */
00365         OPENISIS_ERR_BUSY  = 0x70000, /* object is busy */
00366         /* errors logged at level FATAL */
00367         OPENISIS_ERR_TRASH = 0x80000, /* database internal consistency */
00368         OPENISIS_ERR_IDIOT = 0x90000 /* caught programming error */
00369 };
00370 
00371 typedef enum {
00372         OPENISIS_LOG_OFF = 0, /* don't log anything */
00373         OPENISIS_LOG_FATAL   = 0x100000, /* fatal internal errors: we can't go on */
00374         OPENISIS_LOG_SYSERR  = 0x200000, /* problem with system ressources: bad file, no mem */
00375         OPENISIS_LOG_IOERR   = 0x300000, /* problem on IO */
00376         OPENISIS_LOG_ERROR   = 0x400000, /* unusable input, database or query */
00377         OPENISIS_LOG_WARN    = 0x500000, /* bad input */
00378         OPENISIS_LOG_INFO    = 0x600000, /* some major event like opening a db */
00379         OPENISIS_LOG_VERBOSE = 0x700000, /* any event like reading a record */
00380         OPENISIS_LOG_TRACE   = 0x800000, /* database content (log_str) */
00381         /* highest levels only with debug built */
00382         OPENISIS_LOG_DEBUG   = 0x900000, /* lots of processing details */
00383         OPENISIS_LOG_ALL     = 0xa00000  /* just everything, even built-in content */
00384 } OpenIsisLogLevel;
00385 
00386 enum {
00387         OPENISIS_ERR_ERRORS = 10,
00388         OPENISIS_ERR_MASK  = 0xf0000, /* mask for filtering error code */
00389         OPENISIS_ERR_SHIFT = 16, /* shift to make codes 0,1...ERR_ERRORS */
00390         OPENISIS_LOG_NOCHANGE = -1, /* leave as is when initialising log */
00391         OPENISIS_LOG_LEVELS  = 11,
00392         OPENISIS_LOG_MASK    = 0xf00000, /* mask for filtering log levels */
00393         OPENISIS_LOG_SHIFT   = 20, /* shift to make codes 0,1...LOG_LEVELS */
00394         /*
00395                 the following ids are provided just in case
00396                 you don't feel comfortable assuming that in,out,err are always 0,1,2 ;)
00397                 typically, you don't need any of these, 0 will work ...
00398         */
00399         OPENISIS_SIN  = 0, /* stream id of stdin */
00400         OPENISIS_SOUT = 1, /* stdout */
00401         OPENISIS_SERR = 2, /* stderr */
00402         OPENISIS_SMASK = 0xffff, /* mask of stream id part of to */
00403         OPENISIS_MSG_VA = 0x1000000 /* 1st parameter after fmt IS a va_list */
00404 };
00405 
00425 extern int openIsisSMsg ( int to, const char *fmt, ... );
00426 
00436 extern int openIsisSGets ( int fd, char **ptr, char delim );
00437 #define openIsisSReadln( p ) openIsisSGets( 0, p, '\n' )
00438 
00439 typedef struct OpenIsisRecStream {
00440         OpenIsisStream  in; /* input stream to read from */
00441         int             flg; /* flags */
00442         OpenIsisRec    *buf; /* original buffer */
00443         OpenIsisRec    *rec; /* record read */
00444         OpenIsisRec    *dict; /* dictionary of field names */
00445 } OpenIsisRecStream;
00446 
00447 /*
00448         stream in records in some free-style format suitable for
00449         mails, properties, syspar ...
00450         fields are delimited by CR or NL or CR-NL
00451         within a field, tag stops at blank,TAB,= or :
00452         after a TAB, val starts immediately
00453         after a = or :, val starts at 1st character not a blank
00454         after a blank, val starts at 1st char not one of the above separators
00455 
00456         processing
00457 -       a field or record separator is recognized anywhere
00458 - within each field, the tag is read up to the first separator
00459         (any "special" char, all controls, whitespace and most punctuation).
00460         upon reaching a separator, the tag is identified.
00461         if it is empty, and the record has a field, now new field is created.
00462         else, if the tag cannot be identified,
00463         a tag of -1 is used and the tag string appended as value.
00464 - the separator consists of any number of leading blanks,
00465   some separator char, and, unless the sepchar is TAB, trailing blanks.
00466         if the current field is not empty, the separator is appended as value.
00467 - the rest of the field is appended as value
00468 
00469 - a field with empty tag and value (blank line)
00470         terminates the record in most modes
00471 - a field with empty tag (continuation line)
00472         has it's separator AND value appended to the previous field
00473 - if either a tag or a separator extend over more than 4k,
00474         the stream is considered over limit.
00475 
00476 */
00477 enum {
00478         OPENISIS_STOPONEMPTY =   0x10, /* stop at empty line */
00479         OPENISIS_AUTOCLONE   =   0x20, /* clone the record even if not needed */
00480         OPENISIS_TRANSPARENT =   0x40, /* do not convert vtabs to newlines */
00481         OPENISIS_MAIL        =  0x100, /* process mail body */
00482         OPENISIS_MBOX        =  0x200, /* input stream is mbox format */
00483         OPENISIS_DETACH      =  0x400, /* detach body */
00484         OPENISIS_CONVERT     =  0x800  /* fix body parts */
00485 };
00486 
00487 extern int openIsisSGetr ( OpenIsisRecStream *stream );
00488 
00489 
00490 
00491 /* ************************************************************
00492         record utilities requiring a session
00493 */
00494 
00505 extern OpenIsisRec* openIsisRDup (
00506         OpenIsisRec *r, int room, int discard );
00507 
00508 
00512 extern OpenIsisRec* openIsisRMsg (
00513         OpenIsisRec *r, int discard, int tag, const char *fmt, ... );
00514 
00521 #define OPENISIS_RSPACE( recp, room, disc ) \
00522         do { if ( ! (recp) \
00523                 || (recp)->len >= (recp)->fields \
00524                 || (recp)->bytes < (recp)->used + (room) \
00525         ) (recp) = openIsisRDup( (recp), (room), (disc) ); } while (0)
00526 
00534 #define OPENISIS_RADD( recp, ntag, s, n, disc ) \
00535         do { \
00536                 int _ll = (n); \
00537                 OPENISIS_RSPACE( recp, _ll, disc ); \
00538                 if ( (recp) ) { \
00539                         OpenIsisField *_ff = (recp)->field + (recp)->len++; \
00540                         _ff->tag = (ntag); \
00541                         _ff->val = ((char*)recp)+(recp)->used; \
00542                         if ( ! s ) \
00543                                 _ff->len = 0; \
00544                         else \
00545                                 memcpy( (char*)_ff->val, s, _ff->len = _ll ); \
00546                         (recp)->used += _ff->len; \
00547                 } \
00548         } while(0)
00549 
00556 #define OPENISIS_RCAT( recp, s, n, disc ) \
00557         do { \
00558                 OpenIsisField *_ff; \
00559                 int _ll = (n); \
00560                 assert ( (recp) ); \
00561                 assert ( (recp)->len ); \
00562                 if ( (recp)->bytes < (recp)->used + _ll ) \
00563                         (recp) = openIsisRDup( (recp), _ll, (disc) ); \
00564                 _ff = (recp)->field + (recp)->len - 1; \
00565                 memcpy( (char*)(_ff->val+_ff->len), s, _ll ); \
00566                 _ff->len += _ll; \
00567                 (recp)->used += _ll; \
00568         } while(0)
00569 
00570 /* like OPENISIS_RADD, but based on strlen */
00571 #define OPENISIS_RADDS( recp, ntag, s, disc ) \
00572         OPENISIS_RADD( recp, ntag, s, strlen(s), disc )
00573 /* like OPENISIS_RADD, but based on field */
00574 #define OPENISIS_RADDF( recp, f, disc ) \
00575         OPENISIS_RADD( recp, (f)->tag, (f)->val, (f)->len, disc )
00576 /* like OPENISIS_RCAT, but based on strlen */
00577 #define OPENISIS_RCATS( recp, s, disc ) \
00578         OPENISIS_RCAT( recp, s, strlen(s), disc )
00579 
00595 extern OpenIsisRec *openIsisRSplitf (
00596         OpenIsisRec *rec, const OpenIsisField* field );
00597 
00598 
00599 enum { /* RSet flags */
00600         OPENISIS_RARGC = 0xffff, /* argc mask */
00601         OPENISIS_RFDT = 0x0010000, /* first vararg is the Fdt to use */
00602         OPENISIS_RARGV= 0x0020000, /* next vararg is a char **argv */
00603         OPENISIS_RDIS = 0x0040000, /* discard original record on change */
00604         OPENISIS_RNOC = 0x0080000, /* do not recompact after CHG/DEL op */
00605         OPENISIS_RIGN = 0x0100000, /* ignore unknown fields */
00606         /* default op is to append fields at the end */
00607         OPENISIS_RCHG = 0x1000000, /* change mode: overwrite previous field values */
00608         OPENISIS_RDEL = 0x2000000, /* args is a list of tags to delete */
00609         OPENISIS_RDFLT= 0x4000000, /* default mode: set field value only if not already present */
00610         OPENISIS_ROP  = 0xf000000  /* op mask */
00611 };
00612 
00629 extern OpenIsisRec *openIsisRSet ( OpenIsisRec *rec, int mode, ... );
00630 
00636 extern int openIsisRDeserialize (
00637         OpenIsisRec **rec, const char *buf, int len, int flg );
00638 
00639 
00643 extern OpenIsisRec *openIsisRAddI (
00644         OpenIsisRec *rec, int tag, int value, int discard);
00645 
00646 enum {
00647         OPENISIS_FMT_SHARP = 32,        /* # */
00648         OPENISIS_FMT_SLASH,     /* / */
00649         OPENISIS_FMT_PERCENT,   /* % */
00650         OPENISIS_FMT_OPEN,      /* { */
00651         OPENISIS_FMT_CLOSE,     /* } */
00652         OPENISIS_FMT_ESC,       /* ! */
00653         OPENISIS_FMT_B, /* bold */
00654         OPENISIS_FMT_BOX,       /* draw a box (0i) */
00655         OPENISIS_FMT_BPICT,     /* draw background pict (1sn) */
00656         OPENISIS_FMT_C, /* column (1i) */
00657         OPENISIS_FMT_CL,        /* colour (1i) */
00658         OPENISIS_FMT_COLS,      /* colour table (s_) - emits a string of hex vals */
00659         OPENISIS_FMT_FONTS,     /* font table (s_) */
00660         OPENISIS_FMT_FS,        /* font size (1i) */
00661         OPENISIS_FMT_F, /* font (1i) */
00662         OPENISIS_FMT_I, /* italic */
00663         OPENISIS_FMT_LINK,      /* link (2s_) */
00664         OPENISIS_FMT_LW,        /* line width (1i) */
00665         OPENISIS_FMT_M, /* indentation in twips(1in) */
00666         OPENISIS_FMT_NC,        /* new column (0i) */
00667         OPENISIS_FMT_NEWLINE,   /* set newline (1s) */
00668         OPENISIS_FMT_NP,        /* newpage (0i) */
00669         OPENISIS_FMT_PICT,      /* draw pict (1s) */
00670         OPENISIS_FMT_QC,        /* center */
00671         OPENISIS_FMT_QJ,        /* justify */
00672         OPENISIS_FMT_TAB,       /* tab (0i) */
00673         OPENISIS_FMT_UL,        /* underline */
00674         OPENISIS_FMT_X  /* blanks (1i) */
00675 };
00676 
00677 extern OpenIsisRec* openIsisRFmt (
00678         OpenIsisRec *buf, const char *fmt, OpenIsisRec *r );
00679 
00680 
00681 
00682 /* ************************************************************
00683         db access
00684 */
00685 
00691 extern int openIsisDMaxId ( int dbid );
00692 
00700 extern OpenIsisRec *openIsisDRead ( int db, int rowid );
00701 
00705 extern OpenIsisRec *openIsisDFmt (
00706         OpenIsisRec *buf, const char *fmt, int db, int rowid );
00707 
00708 
00717 extern int openIsisDWritex ( int dbid, OpenIsisRec *rec,
00718         OpenIsisRec *idx );
00719 
00724 extern int openIsisDWrite ( int dbid, OpenIsisRec *rec );
00725 #define OPENISIS_DWRITE( rec ) openIsisDWrite( (rec)->dbid, rec )
00726 
00727 
00738 extern OpenIsisRec *openIsisDScan (
00739         int db, int rowid, int tag, const char *key );
00740 
00752 extern OpenIsisRec* openIsisDTerm (
00753         OpenIsisRec *rec, int db, const char *key );
00754 
00755 
00756 #ifndef OPENISIS_SETLEN
00757 #define OPENISIS_SETLEN 1000
00758 #endif
00759 
00765 typedef struct {
00766         int len;
00767         int id[OPENISIS_SETLEN];
00768 } OpenIsisSet;
00769 
00770 
00771 /* query mode */
00772 enum {
00773         /* search given string using index */
00774         OPENISIS_QRY_KEYEQ, /* index scan key equal */
00775         OPENISIS_QRY_KEYPF, /* index scan key prefix */
00776         OPENISIS_QRY_KEYAT, /* index scan key auto (checks for '$') */
00777         /* fulltext scan for given string */
00778         OPENISIS_QRY_SCANE=64, /* fulltext scan for equal */
00779         OPENISIS_QRY_SCANC, /* fulltext scan for contains */
00780         /* parse string as query expression */
00781         OPENISIS_QRY_SIMPLE=128, /* simple left-to-right binding */
00782         OPENISIS_QRY_PROPER /* proper binding using precedence, () */
00783 };
00784 
00785 
00798 extern int openIsisDQuery ( OpenIsisSet *set, int db,
00799         const char *key, int mode, int skip );
00800 
00801 
00805 typedef int OpenIsisDXCb ( void *me, OpenIsisKey *key, OpenIsisHit *hit );
00806 
00807 typedef struct {
00808         int            flg;
00809         void          *me; /* commonly the session */
00810         OpenIsisDXCb  *cb;
00811         OpenIsisKey    key;
00812         OpenIsisKey    to;
00813 }       OpenIsisDXLoop;
00814 
00815 enum { /* flags */
00816         OPENISIS_IDXPF   = 0, /* loop where from is prefix of key */
00817         OPENISIS_IDXEQ   = 1, /* loop from == key */
00818         OPENISIS_IDXUPTO = 2, /* loop from <= key < to */
00819         OPENISIS_IDXINCL = 3, /* loop from <= key <= to */
00820         OPENISIS_IDXMODE = 0x03, /* mask for match mode */
00821         OPENISIS_IDXTRAD = 0x10000  /* use traditional index */
00822 };
00823 
00826 extern int openIsisDXLoop ( int dbid, OpenIsisDXLoop *l );
00827 
00828 
00829 
00830 /* ************************************************************
00831         system control -- session 0 only
00832 */
00833 
00834 enum {
00835         /* search hit result record */
00836         OPENISIS_SEA_KEY   = 1, /* key value */
00837         OPENISIS_SEA_NHITS = 2, /* number of hits */
00838         OPENISIS_SEA_HIT   = 3, /* hit: <mfn tag occ pos dbn> */
00839         /* system (schema 0) parameters */
00840         OPENISIS_SPATH   = 5, /* db dir */
00841         OPENISIS_SLOGF   = 700, /* logfile */
00842         OPENISIS_SLOGV   = 701, /* verbosity */
00843         /* schema parameters */
00844         OPENISIS_SC_NAME   = 710, /* schema n name */
00845         OPENISIS_SC_HOST   = 711, /* schema n host */
00846         OPENISIS_SC_PORT   = 712, /* schema n port */
00847         OPENISIS_SC_DFLTDB = 721, /* schema default db */
00848         /* database parameters */
00849         OPENISIS_DNAME = 800,
00850         OPENISIS_DTYPE = 801,
00851         OPENISIS_DRO   = 802,
00852         OPENISIS_DPATH = 803,
00853         OPENISIS_DDUMP = 804,
00854         OPENISIS_DENC  = 810, /* encoding */
00855         OPENISIS_DFDT  = 811, /* path to serialized fdt */
00856         OPENISIS_DFMT  = 850, /* worksheets */
00857         OPENISIS_DPFT  = 851, /* printformats */
00858         OPENISIS_DFST  = 852, /* field selections */
00859         /* fdt entries */
00860         OPENISIS_FDID    = 860, /* tag */
00861         OPENISIS_FDSUB   = 861, /* subfield char */
00862         OPENISIS_FDTYPE  = 862, /* field type */
00863         OPENISIS_FDREP   = 863, /* repeatable flag */
00864         OPENISIS_FDNUMC  = 864,
00865         OPENISIS_FDLEN   = 865, /* length: 0 variable, >0 maxlen, <0 fixed len */
00866         OPENISIS_FDNAME  = 866, /* field name */
00867         OPENISIS_FDDESC  = 867, /* field description */
00868         OPENISIS_FDPAT   = 868, /* pattern */
00869         OPENISIS_FDDFLT  = 869, /* default value */
00870         OPENISIS_FDINFO  = 870, /* application specific addons */
00871         OPENISIS_FDCHLD  = 871,
00872         OPENISIS_FDT_LEN = 880, /* fdt: number of fd's */
00873         OPENISIS_FDT_FD  = 881, /* fdt: embedded fd */
00874         OPENISIS_FDT_REC = 882, /* fdt: application specific addons */
00875         /* communication parameters */
00876         OPENISIS_COM_SID    = 900,  /* session id */
00877         OPENISIS_COM_SER    = 901,  /* serial no of request */
00878         OPENISIS_COM_DBN    = 902,  /* db name */
00879         OPENISIS_COM_TMS    = 903,  /* server timestamp */
00880         OPENISIS_COM_ROW    = 904,  /* rowid */
00881         OPENISIS_COM_CFG    = 907,  /* embedded cfg */
00882         OPENISIS_COM_REC    = 908,  /* embedded data record */
00883         /* communication parameters: request */
00884         OPENISIS_RQS_TYPE   = 920,  /* request type */
00885         OPENISIS_RQS_FLG    = 921,  /* flags */
00886         OPENISIS_RQS_QMOD   = 922,  /* mode (query) */
00887         OPENISIS_RQS_SKIP   = 923,  /* skip (query) */
00888         OPENISIS_RQS_SIZE   = 924,  /* output size (query, search) */
00889         OPENISIS_RQS_KEY    = 925,  /* key value (query, search) */
00890         OPENISIS_RQS_IDX    = 926,  /* index record (insert, update) */
00891         OPENISIS_RQS_KUP    = 927,  /* upper key value (search) */
00892         OPENISIS_RQS_TAG    = 928,  /* tag restrictions (search) */
00894         OPENISIS_RSP_DBID   = 940,  /* local db id */
00895         OPENISIS_RSP_ERR    = 941,  /* error code */
00896         OPENISIS_RSP_MSG    = 942,  /* error message */
00897         OPENISIS_RSP_NUMT   = 943,  /* total number of records (query, read) */
00898         OPENISIS_RSP_NUMR   = 944,  /* number in this response (query, read) */
00899         OPENISIS_RSP_CERR   = 945   /* client side error */
00900 };
00901 
00902 extern const OpenIsisFdt *openIsisFdtSyspar; /* schema 0 */
00903 extern const OpenIsisFdt *openIsisFdtScheme; /* schema n */
00904 extern const OpenIsisFdt *openIsisFdtDbpar;  /* db cfg */
00905 extern const OpenIsisFdt *openIsisFdtFd;     /* fd rec */
00906 extern const OpenIsisFdt *openIsisFdtFdt;    /* fdt rec */
00907 extern const OpenIsisFdt *openIsisFdtRqs;    /* request rec */
00908 extern const OpenIsisFdt *openIsisFdtRsp;    /* response rec */
00909 extern const OpenIsisFdt *openIsisFdtHit;    /* search hit result record */
00910 
00912 enum {
00913         OPENISIS_RQST_OPEN     =  1, /* open db */
00914         OPENISIS_RQST_CLOS     =  3, /* close db */
00915         OPENISIS_RQST_MNT      =  4, /* mount db */
00916         OPENISIS_RQST_LSDB     =  6, /* list available dbs */
00917         OPENISIS_RQST_MROW     = 10, /* get maxrowid of db */
00918         OPENISIS_RQST_QRY      = 11, /* exec query on db */
00919         OPENISIS_RQST_READ     = 12, /* get rec for rowid */
00920         OPENISIS_RQST_SEA      = 15, /* search index of db */
00921         OPENISIS_RQST_INS      = 20, /* insert rec */
00922         OPENISIS_RQST_UPD      = 21, /* update rec */
00923         OPENISIS_RQST_DEL      = 22, /* delete row */
00924         OPENISIS_RQST_EVAL     = 30  /* command evaluation */
00925 };
00926 
00928 enum {
00929         OPENISIS_RQSF_MNT   = 0x0001, /* mount db */
00930         OPENISIS_RQSF_QRR   = 0x0002, /* fetch records on query */
00931         OPENISIS_RQSF_SENH  = 0x0004  /* sort search result by nhits */
00932 };
00933 
00935 #define OPENISIS_QRY_KEYLEN 1024
00936 
00937 #define OPENISIS_ERRMSGLEN  1024
00938 
00939 enum {
00940         OPENISIS_RELE = 0x0000000, /* release, unlock */
00941         OPENISIS_LOCK = 0x1000000,
00942         OPENISIS_WAKE = 0x2000000, /* broadcast signal, notifyall */
00943         OPENISIS_WAIT = 0x3000000,
00944         OPENISIS_COND = 0x0ffffff  /* condition mask */
00945 };
00967 typedef int OpenIsisCLockFunc ( int lock );
00968 
00972 extern int openIsisCInit ( int argc, const char **argv,
00973         OpenIsisCLockFunc lock );
00974 
00984 extern void openIsisCLog ( int level, const char *filename );
00985 
00986 
00991 extern OpenIsisSession openIsisCOpen ( OpenIsisRec *args );
00992 
00997 extern OpenIsisSession openIsisCSession ( OpenIsisRec *args );
00998 
00999 
01000 /* ************************************************************
01001         schema
01002 */
01003 
01004 #define OPENISIS_SC_NAMELEN  32 /* max length of schema identification */
01005 #define OPENISIS_DB_NAMELEN  32 /* max length of db id relative to schema */
01006 
01007 #define OPENISIS_SCIDMSK  0x0ff00  /* schema part of id */
01008 #define OPENISIS_DBIDMSK  0x000ff  /* db part of id */
01009 
01010 typedef struct {
01011         char           name[OPENISIS_DB_NAMELEN];
01012         int            dbid;
01013         int            mntcnt; /* number of sessions currently using this */
01014         int            tms;    /* last (re)opening timestamp */
01015         OpenIsisRec   *cfg;
01016         OpenIsisFdt   *fdt;
01017 } OpenIsisDb;
01018 
01019 typedef struct {
01020         char           name[OPENISIS_SC_NAMELEN];
01021         int            scid;
01022         int            mntcnt;
01023         OpenIsisRec   *cfg;
01024         int            ndbs;
01025         OpenIsisDb   **dbs;
01026 } OpenIsisSchema;
01027 
01028 /* ************************************************************
01029         client side
01030 */
01031 
01032 typedef struct OpenIsisStb *OpenIsisStub;
01033 
01036 typedef int OpenIsisStbRqsProc (OpenIsisStub stb, OpenIsisRec *rqs);
01037 
01041 typedef void OpenIsisStbDelProc (OpenIsisStub stb, void *client_data);
01042 
01045 typedef int OpenIsisRspCb (void *client_data,
01046         OpenIsisStub stub, OpenIsisRec *response, OpenIsisDb *db);
01047 
01048 typedef struct {
01049         /*      function for request sending.
01050                 if 0, defaults to internal blocking sender
01051         */
01052         int (*sendproc) (OpenIsisStub stub, OpenIsisRec *rqs);
01053         /*      default response callback */
01054         OpenIsisRspCb  *dfltcb;
01055         /*      delete callback: cleanup client data cbd that is no longer
01056                 used. if 0==cbd, session is going to be deleted.
01057         */
01058         void (*delcb) (void *cld, OpenIsisStub session, void *cbd);
01059         /*      client data for dfltcb */
01060         void *dfltcld; 
01061         /*      client data for delcb */
01062         void *delcld; 
01063 } OpenIsisStubCbData;
01064 
01065 extern OpenIsisStub openisis_stub0;
01066 
01069 extern OpenIsisStub openIsisNInit (
01070         int argc, const char **argv, OpenIsisStubCbData *dta
01071 );
01072 
01075 extern void openIsisNDeinit ();
01076 
01079 extern OpenIsisStub openIsisNOpen (
01080         const char *name, int argc, const char **argv, OpenIsisStubCbData *dta
01081 );
01082 
01085 extern void openIsisNClose (OpenIsisStub stub);
01086 
01089 extern OpenIsisSchema* openIsisNSchema (OpenIsisStub stub);
01090 
01102 extern int openIsisNSend (
01103         OpenIsisStub stub, OpenIsisRec *rqs,
01104         OpenIsisRspCb *actcb, void *actcld, int rdup
01105 );
01106 
01110 extern OpenIsisRec *openIsisNRecv (OpenIsisStub stub, OpenIsisDb **db);
01111 
01114 extern void openIsisNClean (OpenIsisStub stub);
01115 
01118 extern int openIsisNGetResult (OpenIsisStub stub,
01119         int **rowids, OpenIsisRec ***recs, int *total,
01120         OpenIsisDb **db, OpenIsisRec **rqs);
01121 
01127 extern void openIsisNNotifyResponse (OpenIsisStub stub, OpenIsisRec **rsp);
01128 
01134 extern void openIsisNNotifyError (OpenIsisStub stub, int errcode);
01135 
01138 extern struct CliChnl* openIsisNGetChannel (OpenIsisStub stub);
01139 
01142 extern OpenIsisDb *openIsisNDbByName (OpenIsisStub stub, const char *dbname);
01143 
01146 extern OpenIsisDb *openIsisNDbById (int dbid);
01147 
01148 
01149 /* ************************************************************
01150         db control
01151 */
01152 
01187 extern OpenIsisDb* openIsisCDOpen ( const char *dbname,
01188         OpenIsisRec *dbpar, OpenIsisRec *syspar, OpenIsisFdt *fdt );
01196 extern int openIsisCDOpenv ( const char *dbname, const char **argv, int argc );
01197 
01198 enum {
01199         OPENISIS_CHK_ONLY = 0x01,       /* check only, do not fix */
01200         OPENISIS_CHK_XRF  = 0x02,       /* check the xrf */
01201         OPENISIS_CHK_FIX  = 0xfe,       /* check all and fix */
01202         OPENISIS_CHK_ALL  = 0xff        /* check all, no fix */
01203 };
01206 extern int openIsisCDCheck ( int dbid, int flags );
01207 
01208 
01209 
01215 extern int openIsisCDClose ( int dbid );
01216 
01217 
01218 /* ************************************************************
01219         low level index access
01220 
01221         DO NOT USE unless you know what you're doing !!!!!!!!!
01222 
01223 */
01224 
01225 typedef struct OpenIsisIdx *OpenIsisIndex;
01226 
01232 extern OpenIsisIndex openIsisCXOpen ( int dbid, int mode );
01233 
01239 extern int openIsisCXAdd ( OpenIsisIndex idx,
01240         OpenIsisKey *key, OpenIsisHit *hit );
01241 
01242 #define openIsisCXClose( idx ) openIsisCXAdd( idx, 0, 0 )
01243 
01244 #ifdef _REENTRANT
01245 extern int openisis_threaded;
01246 #endif
01247 
01248 /* ************************************************************
01249         single session and legacy mode pre 0.9
01250 */
01251 
01256 typedef struct {
01257         /*
01258         although isis-1 dbs have only 2 bytes for field tags (numbers),
01259         we use ints with the lower 3 bytes for the tag.
01260         The highest byte may have special usage in some context.
01261         */
01262         int tag;
01263         int off;
01264         int len;
01265 } OpenIsisFld;
01266 
01269 typedef struct {
01270         int         dbid;
01271         int         rowid;
01272         int         bytes; /* total avail bytes */
01273         int         used; /* total used bytes (originally BWB) */
01274         int         fields;  /* avail number of fields (originally BWP) */
01275         int         base; /* byte offset of contents area (after fields) */
01276         int         len;        /* used number of fields */
01277         int         state;
01278         OpenIsisFld field[1];
01279 } OpenIsisRaw;
01280 
01282 extern OpenIsisRaw *openIsisDRaw ( int db, int rowid );
01283 
01284 #ifndef OPENISIS_NOPRE09
01285 
01286 
01287 /* utilities */
01288 #define openIsis2Html( str, len ) \
01289         openIsisToHtml ( str, len )
01290 #define openIsisValidUTF8( mem, len, tof ) \
01291         openIsisUtf8Chk ( mem, len, tof )
01292 
01293 /* record tools */
01294 #define openIsisClone( r, ro, d ) \
01295         openIsisRDup( r, ro, d )
01296 /* GNUC only, and waaarns ...
01297 #define openIsisPrintf( r, d, t, f, a... ) \
01298         openIsisRMsg( r, d, t, f, ## a )
01299 */
01300 #define OPENISIS_CHKFREE( recp, room, disc ) \
01301         OPENISIS_RSPACE( recp, room, disc )
01302 #define OPENISIS_ADD( recp, ntag, s, n, disc ) \
01303         OPENISIS_RADD( recp, ntag, s, n, disc )
01304 #define OPENISIS_CAT( recp, s, n, disc ) \
01305         OPENISIS_RCAT( recp, s, n, disc )
01306 #define OPENISIS_SADD( recp, ntag, s, disc ) \
01307         OPENISIS_RADDS( recp, ntag, s, disc )
01308 #define OPENISIS_SCAT( recp, s, disc ) \
01309         OPENISIS_RCATS( recp, s, disc )
01310 #define openIsisReadField( rec, f ) \
01311         openIsisRSplitf( rec, f )
01312 #define openIsisFmt( buf, fmt, r ) \
01313         openIsisRFmt( buf, fmt, r )
01314 #define openIsisReadStream( stream ) \
01315         openIsisSGetr( stream )
01316 
01317 /* database */
01318 #define openIsisMaxRowid( db ) \
01319         openIsisDMaxId( db )
01320 #define openIsisReadRow( db, rowid ) \
01321         openIsisDRead( db, rowid )
01322 #define openIsisReadRaw( db, rowid ) \
01323         openIsisDRaw( db, rowid )
01324 #define openIsisRead( buf, fmt, db, rowid ) \
01325         openIsisDFmt( buf, fmt, db, rowid )
01326 #define openIsisWrite( db, r ) \
01327         openIsisDWrite( db, r )
01328 #define openIsisWritex( db, r, i ) \
01329         openIsisDWritex( db, r, i )
01330 #define openIsisScan( db, rowid, tag, key ) \
01331         openIsisDScan( db, rowid, tag, key )
01332 #define openIsisTerm( rec, db, key ) \
01333         openIsisDTerm( rec, db, key )
01334 #define openIsisQuery( set, db, key, mode, skip ) \
01335         openIsisDQuery( set, db, key, mode, skip )
01336 /* database index */
01337 #define OpenIsisIdxCb OpenIsisDXCb
01338 #define OpenIsisIdxLoop OpenIsisDXLoop
01339 #define openIsisIdxLoop( dbis, cb ) \
01340         openIsisDXLoop( dbis, cb )
01341 
01342 /* system control (main session only) */
01343 #define openIsisLog openIsisCLog
01344 #define OpenIsisLockFunc OpenIsisCLockFunc
01345 #define openIsisInit( argc, argv, lock ) \
01346         openIsisCInit( argc, argv, lock )
01347 #define openIsisSesGet( id, args ) \
01348         (id) ? openIsisCSession( args ) : openIsisCOpen( args )
01349 /* database control (main session only) */
01350 #define openIsisOpen openIsisCDOpenv
01351 #define openIsisCheck openIsisCDCheck
01352 #define openIsisClose openIsisCDClose
01353 /* database index control (main session only) */
01354 #define openIsisIdxOpen openIsisCXOpen
01355 #define openIsisIdxAdd openIsisCXAdd
01356 #define openIsisIdxDone( idx ) openIsisCXClose( idx )
01357 
01358 #endif  /* OPENISIS_NOPRE09 */
01359 
01360 #ifdef __cplusplus
01361 }
01362 #endif /* extern "C" */
01363 #define OPENISIS_H
01364 #endif /* OPENISIS_H */