/* * $Id$ */ /* * Harbour Project source code: * Header file for the RDD API * * Copyright 1999 {list of individual authors and e-mail addresses} * www - http://www.harbour-project.org * * 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; either version 2 of the License, or * (at your option) any later version, with one exception: * * The exception is that if you link the Harbour Runtime Library (HRL) * and/or the Harbour Virtual Machine (HVM) with other files to produce * an executable, this does not by itself cause the resulting executable * to be covered by the GNU General Public License. Your use of that * executable is in no way restricted on account of linking the HRL * and/or HVM code into it. * * 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., 675 Mass Ave, Cambridge, MA 02139, USA (or visit * their web site at http://www.gnu.org/). * */ #ifndef HB_RDDAPI_H_ #define HB_RDDAPI_H_ #include "filesys.h" /* RDD virtual machine integration functions */ extern int hb_rddGetCurrentWorkAreaNumber( void ); extern ERRCODE hb_rddSelectWorkAreaAlias( char * szAlias ); extern ERRCODE hb_rddSelectWorkAreaNumber( int iArea ); extern ERRCODE hb_rddSelectWorkAreaSymbol( PHB_SYMB pSymAlias ); extern ERRCODE hb_rddGetFieldValue( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol ); extern ERRCODE hb_rddPutFieldValue( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol ); extern ERRCODE hb_rddFieldGet( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol ); extern ERRCODE hb_rddFieldPut( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol ); extern void hb_rddShutDown( void ); /* Flags for DBTRANSINFO */ #define DBTF_MATCH 0x0001 #define DBTF_PUTREC 0x0002 /* Codes for Locking methods */ #define DBLM_EXCLUSIVE 1 #define DBLM_MULTIPLE 2 #define DBLM_FILE 3 /* Codes for SELF_ORDINFO() */ #define DBOI_CONDITION 1 /* Get the order condition */ #define DBOI_EXPRESSION 2 /* Get the order expression */ #define DBOI_POSITION 3 /* Get the order position */ #define DBOI_RECNO 4 /* Get the order record number */ #define DBOI_NAME 5 /* Get the order list name */ #define DBOI_NUMBER 6 /* Get the order list position */ #define DBOI_BAGNAME 7 /* Get the order Bag name */ #define DBOI_BAGEXT 8 /* Get the order Bag Extension */ #define DBOI_INDEXEXT DBOI_BAGEXT #define DBOI_INDEXNAME DBOI_BAGNAME #define DBOI_ORDERCOUNT 9 /* Get the number of orders in the index file */ #define DBOI_FILEHANDLE 10 /* Get the handle of the index file */ #define DBOI_ISCOND 11 /* Get the flag if the order has a for condition */ #define DBOI_ISDESC 12 /* Get the flag if the order is descending */ #define DBOI_UNIQUE 13 /* Get the flag if the order has the unique attribute set */ /* Codes for SELF_INFO() */ #define DBI_ISDBF 1 /* Logical: RDD support DBF file format? */ #define DBI_CANPUTREC 2 /* Logical: RDD support Putting Records? */ #define DBI_GETHEADERSIZE 3 /* Numeric: Get header size of the file */ #define DBI_LASTUPDATE 4 /* Date: Last date RDD file updated */ #define DBI_GETDELIMITER 5 /* String: Get default delimiter */ #define DBI_SETDELIMITER 6 /* String: Set default delimiter */ #define DBI_GETRECSIZE 7 /* Numeric: Get record size of the file */ #define DBI_GETLOCKARRAY 8 /* Array: Get an array of locked records */ #define DBI_TABLEEXT 9 /* String: Get table file extension */ #define DBI_ISFLOCK 20 /* Get file lock status */ #define DBI_CHILDCOUNT 22 /* Number of opened relations */ #define DBI_FILEHANDLE 23 /* Handle of opened file */ #define DBI_BOF 26 /* BOF flag - alternate to bof() */ #define DBI_EOF 27 /* EOF flag - alternate to eof() */ #define DBI_DBFILTER 28 /* Filter expression */ #define DBI_FOUND 29 /* FOUND flag - alternate to found */ #define DBI_FCOUNT 30 /* Number of fields */ #define DBI_LOCKCOUNT 31 /* Get record size of the file */ #define DBI_VALIDBUFFER 32 /* Is the current buffer valid */ #define DBI_ALIAS 33 /* Alias name of workarea */ #define DBI_GETSCOPE 34 /* Locate codeblock */ #define DBI_LOCKOFFSET 35 /* New locking offset */ #define DBI_SHARED 36 /* Gets/Sets the shared flag */ #define DBI_MEMOEXT 37 /* String: Get memo file extension */ #define DBI_MEMOHANDLE 38 /* Dos handle for memo file */ #define DBI_MEMOBLOCKSIZE 39 /* Blocksize in memo files */ #define DBI_DB_VERSION 101 /* HOST driver Version */ #define DBI_RDD_VERSION 102 /* RDD version (current RDD) */ #define DBI_USER 1000 /* Start of user definable DBI_ values */ /* Codes for SELF_RECINFO() */ #define DBRI_DELETED 1 #define DBRI_LOCKED 2 #define DBRI_RECSIZE 3 #define DBRI_RECNO 4 #define DBRI_UPDATED 5 /* Codes for SELF_FIELDINFO() */ #define DBS_NAME 1 #define DBS_TYPE 2 #define DBS_LEN 3 #define DBS_DEC 4 /* Codes for RawLock types */ #define FILE_LOCK 1 #define FILE_UNLOCK 2 #define REC_LOCK 3 #define REC_UNLOCK 4 #define HEADER_LOCK 5 #define HEADER_UNLOCK 6 #define APPEND_LOCK 7 #define APPEND_UNLOCK 8 /* forward declarations */ struct _RDDFUNCS; struct _AREA; typedef struct _FILEINFO { FHANDLE hFile; char * szFileName; /* Name of file */ ULONG * pLocksPos; /* List of records locked */ ULONG lNumLocksPos; /* Number of records locked */ BOOL fFileLocked; /* TRUE if entire file is locked */ BOOL fAppend; /* TRUE if new record is added */ struct _FILEINFO * pNext; /* The next file in the list */ } FILEINFO; typedef FILEINFO * LPFILEINFO; /* * DBFIELDINFO * ----------- * The field structure */ typedef struct { BYTE * atomName; /* FIELD (symbol) name */ USHORT uiType; /* FIELD type */ USHORT typeExtended; /* FIELD type extended */ USHORT uiLen; /* Overall FIELD length */ USHORT uiDec; /* Decimal places of numeric FIELD */ } DBFIELDINFO; typedef DBFIELDINFO * LPDBFIELDINFO; /* * DBOPENINFO * ---------- * The Open Info structure */ typedef struct { USHORT uiArea; /* Work Area number of the data store */ BYTE * abName; /* The qualified name of the data store */ BYTE * atomAlias; /* The logical name of the data store */ BOOL fShared; /* Share mode of the data store */ BOOL fReadonly; /* Readonly mode of the data store */ void * lpdbHeader; /* Pointer to a header of the data store */ } DBOPENINFO; typedef DBOPENINFO * LPDBOPENINFO; /* * DBEXTENDINFO * ------------ * Additional properties */ typedef struct { USHORT uiHeaderLen; /* Size of header */ USHORT uiRecordLen; /* Size of record */ BYTE * bRecord; /* Buffer of the data */ BOOL fHasMemo; /* Work Area with Memo fields */ ULONG lRecNo; /* Current record */ ULONG lNextBlock; /* Next block for memos */ BOOL fExclusive; /* Share the file */ BOOL fReadOnly; /* Read only file */ BYTE bYear; /* Last update */ BYTE bMonth; BYTE bDay; BOOL fRecordChanged; /* Record changed */ } DBEXTENDINFO; typedef DBEXTENDINFO * LPDBEXTENDINFO; /* * DBORDERCONDINFO * --------------- * The Create Order conditional Info structure */ typedef struct _DBORDERCONDINFO { BOOL fActive; BYTE * abFor; PHB_ITEM itmCobFor; PHB_ITEM itmCobWhile; PHB_ITEM itmCobEval; LONG lStep; LONG lStartRecno; LONG lNextCount; LONG lRecno; BOOL fRest; BOOL fDescending; BOOL fScoped; BOOL fAll; BOOL fAdditive; BOOL fUseCurrent; BOOL fCustom; BOOL fNoOptimize; void * lpvCargo; } DBORDERCONDINFO; typedef DBORDERCONDINFO * LPDBORDERCONDINFO; /* * DBORDERCREATE * ------------- * The Create Order Info structure */ typedef struct { LPDBORDERCONDINFO lpdbOrdCondInfo; /* Conditional information */ BYTE * abBagName; /* Name of the Order bag */ BYTE * atomBagName; /* Name of the Order */ PHB_ITEM itmOrder; BOOL fUnique; /* Flag to determine if all keys are unique */ PHB_ITEM itmCobExpr; /* Code block containing the KEY expression */ PHB_ITEM abExpr; /* String containing the KEY expression */ } DBORDERCREATEINFO; typedef DBORDERCREATEINFO * LPDBORDERCREATEINFO; /* * DBORDERINFO * ----------- * The Set Index Info structure */ typedef struct { PHB_ITEM atomBagName; /* Name of the Order Bag */ PHB_ITEM itmOrder; /* Name or Number of the Order */ PHB_ITEM itmCobExpr; /* Code block containing the KEY expression */ PHB_ITEM itmResult; /* Operation result */ BOOL fAllTags; /* Open all tags */ } DBORDERINFO; typedef DBORDERINFO * LPDBORDERINFO; /* * DBSCOPEINFO * ----------- * The Scope Info structure */ typedef struct { PHB_ITEM itmCobFor; /* Code Block representation of a FOR clause */ PHB_ITEM lpstrFor; /* String representation of a FOR clause */ PHB_ITEM itmCobWhile; /* Code Block representation of a WHILE clause */ PHB_ITEM lpstrWhile; /* String representation of a WHILE clause */ PHB_ITEM lNext; /* NEXT record */ PHB_ITEM itmRecID; PHB_ITEM fRest; /* TRUE if start from the current record */ BOOL fIgnoreFilter; BOOL fIncludeDeleted; BOOL fLast; BOOL fIgnoreDuplicates; } DBSCOPEINFO; typedef DBSCOPEINFO * LPDBSCOPEINFO; /* * DBFILTERINFO * ------------ * The Filter Info structure */ typedef struct { PHB_ITEM itmCobExpr; /* Block representation of the FILTER expression */ PHB_ITEM abFilterText; /* String representation of FILTER expression */ BOOL fFilter; } DBFILTERINFO; typedef DBFILTERINFO * LPDBFILTERINFO; /* * DBRELINFO * ------------ * The Relationship Info structure */ typedef struct _DBRELINFO { PHB_ITEM itmCobExpr; /* Block representation of the relational SEEK key */ PHB_ITEM abKey; /* String representation of the relational SEEK key */ struct _AREA *lpaParent; /* The parent of this relation */ struct _AREA *lpaChild; /* The parents children */ struct _DBRELINFO *lpdbriNext; /* Next child or parent */ } DBRELINFO; typedef DBRELINFO * LPDBRELINFO; /* * DBEVALINFO * ------------ * The Evaluation Info structure * * Contains information necessary for a block evaluation * on each record of the workarea */ typedef struct { PHB_ITEM itmBlock; /* The block to be evaluated */ DBSCOPEINFO dbsci; /* Scope info that limits the evaluation */ } DBEVALINFO; typedef DBEVALINFO * LPDBEVALINFO; /* * DBTRANSITEM * ------------ * The Transfer Item structure * * Defines a single transfer item (usually a field) from * one database to another; used by DBTRANSINFO */ typedef struct { USHORT uiSource; /* Field index number from the source */ USHORT uiDest; /* Destination field index number */ } DBTRANSITEM; typedef DBTRANSITEM * LPDBTRANSITEM; /* * DBTRANSINFO * ------------ * The Transfer Info structure * * Defines a global transfer of data items from on workarea * to another */ typedef struct { struct _AREA *lpaSource; /* Pointer to source work area */ struct _AREA *lpaDest; /* Pointer to dest work area */ DBSCOPEINFO dbsci; /* Scope to limit transfer */ USHORT uiFlags; /* Transfer attributes */ USHORT uiItemCount; /* Number of items below */ LPDBTRANSITEM lpTransItems; /* Array of items */ } DBTRANSINFO; typedef DBTRANSINFO * LPDBTRANSINFO; /* * DBSORTITEM * ---------- * The Sort Item Structure * * An array of items that, together, indicate the key value to * use while sorting data. The order of the array determines the * order of the sorting. */ typedef struct { USHORT uiField; /* Index into the workarea->fields structure */ USHORT uiFlags; /* Sort flags */ } DBSORTITEM; typedef DBSORTITEM * LPDBSORTITEM; /* Flags for DBSORTITEM */ #define SF_ASCEND 1 #define SF_CASE 2 #define SF_DESCEND 4 #define SF_NUM 32 #define SF_DOUBLE 64 #define SF_LONG 128 /* * DBSORTINFO * ---------- * The Sort Info Structure * * Information for a physical sort on the workarea */ typedef struct { DBTRANSINFO dbtri; /* Destination workarea transfer information */ LPDBSORTITEM lpdbsItem; /* Fields which compose the key values for the sort */ USHORT uiItemCount; /* The number of fields above */ } DBSORTINFO; typedef DBSORTINFO * LPDBSORTINFO; /* * DBLOCKINFO * ---------- * The Lock Info Structure * * Information for a record or file lock */ typedef struct { ULONG itmRecID; USHORT uiMethod; BOOL fResult; } DBLOCKINFO; typedef DBLOCKINFO * LPDBLOCKINFO; /* * FIELD * ----- * The Field structure * * This is the basic unit of access for a workarea */ typedef struct _FIELD { USHORT uiType; /* Field type */ USHORT uiTypeExtended; /* Field type - extended */ USHORT uiLen; /* Field length */ USHORT uiDec; /* Decimal length */ USHORT uiArea; /* Area this field resides in */ USHORT uiOffset; /* Offset for this field */ void * sym; /* Symbol that represents the field */ void * memo; /* Pointer to memo data */ struct _FIELD *lpfNext; /* The next field in the list */ } FIELD; typedef FIELD * LPFIELD; /*--------------------* WORKAREA structure *----------------------*/ /* * WORKAREA * -------- * The Workarea Structure * * Information to administrate the workarea */ typedef struct _AREA { struct _RDDFUNCS * lprfsHost; /* Virtual method table for this workarea */ USHORT uiArea; /* The number assigned to this workarea */ void * atomAlias; /* Pointer to the alias symbol for this workarea */ USHORT uiFieldExtent; /* Total number of fields allocated */ USHORT uiFieldCount; /* Total number of fields used */ LPFIELD lpFields; /* Pointer to an array of fields */ void * lpFieldExtents; /* Void ptr for additional field properties */ PHB_ITEM valResult; /* All purpose result holder */ BOOL fTop; /* TRUE if "top" */ BOOL fBottom; /* TRUE if "bottom" */ BOOL fBof; /* TRUE if "bof" */ BOOL fEof; /* TRUE if "eof" */ BOOL fFound; /* TRUE if "found" */ DBSCOPEINFO dbsi; /* Info regarding last LOCATE */ DBFILTERINFO dbfi; /* Filter in effect */ LPDBORDERCONDINFO lpdbOrdCondInfo; LPDBRELINFO lpdbRelations; /* Parent/Child relationships used */ USHORT uiParents; /* Number of parents for this area */ USHORT heap; USHORT heapSize; USHORT rddID; LPFILEINFO lpFileInfo; /* Files used by this workarea */ LPDBEXTENDINFO lpExtendInfo; /* Additional properties */ } AREA; typedef AREA * LPAREA; #ifndef AREAP #define AREAP LPAREA #endif /*--------------------* Virtual Method Table *----------------------*/ typedef USHORT ( * DBENTRYP_V )( AREAP area ); typedef USHORT ( * DBENTRYP_BP )( AREAP area, BOOL * param ); typedef USHORT ( * DBENTRYP_B )( AREAP area, BOOL param ); typedef USHORT ( * DBENTRYP_L )( AREAP area, LONG param ); typedef USHORT ( * DBENTRYP_UL )( AREAP area, ULONG param ); typedef USHORT ( * DBENTRYP_I )( AREAP area, PHB_ITEM param ); typedef USHORT ( * DBENTRYP_SI )( AREAP area, USHORT index, PHB_ITEM param ); typedef USHORT ( * DBENTRYP_VP )( AREAP area, LPDBOPENINFO param ); typedef USHORT ( * DBENTRYP_VF )( AREAP area, LPDBFIELDINFO param ); typedef USHORT ( * DBENTRYP_VL )( AREAP area, LPDBLOCKINFO param ); typedef USHORT ( * DBENTRYP_VFI )( AREAP area, LPDBFILTERINFO param ); typedef USHORT ( * DBENTRYP_VLO )( AREAP area, LPDBSCOPEINFO param ); typedef USHORT ( * DBENTRYP_SP )( AREAP area, USHORT * param ); typedef USHORT ( * DBENTRYP_P )( AREAP area, BYTE * param ); typedef USHORT ( * DBENTRYP_PP )( AREAP area, BYTE ** param ); typedef USHORT ( * DBENTRYP_S )( AREAP area, USHORT param ); typedef USHORT ( * DBENTRYP_LP )( AREAP area, LONG * param ); typedef USHORT ( * DBENTRYP_ULP )( AREAP area, ULONG * param ); typedef USHORT ( * DBENTRYP_SVP )( AREAP area, USHORT index, void * param ); typedef USHORT ( * DBENTRYP_VSP )( AREAP area, USHORT action, ULONG lRecord ); typedef USHORT ( * DBENTRYP_SVL )( AREAP area, USHORT index, ULONG * param ); typedef USHORT ( * DBENTRYP_SSI )( AREAP area, USHORT p1, USHORT p2, PHB_ITEM p3 ); typedef USHORT ( * DBENTRYP_ISI )( AREAP area, PHB_ITEM p1, USHORT p2, PHB_ITEM p3 ); #if 0 typedef USHORT ( * DBENTRYP_VPL )( AREAP area, void * p1, LONG p2); typedef USHORT ( * DBENTRYP_VPLP )( AREAP area, void * p1, LONGP p2); typedef USHORT ( * DBENTRYP_LSP )( AREAP area, LONG p1, USHORTP p2); #endif /*--------------------* Virtual Method Table *----------------------*/ typedef struct _RDDFUNCS { /* Movement and positioning methods */ DBENTRYP_BP bof; DBENTRYP_BP eof; DBENTRYP_BP found; DBENTRYP_V goBottom; DBENTRYP_UL go; DBENTRYP_I goToId; DBENTRYP_V goTop; #if 0 DBENTRYP_SI seek; #endif DBENTRYP_L skip; DBENTRYP_L skipFilter; DBENTRYP_L skipRaw; /* Data management */ DBENTRYP_VF addField; DBENTRYP_B append; DBENTRYP_I createFields; DBENTRYP_V deleterec; DBENTRYP_BP deleted; DBENTRYP_SP fieldCount; DBENTRYP_VF fieldDisplay; DBENTRYP_SSI fieldInfo; DBENTRYP_SVP fieldName; DBENTRYP_V flush; DBENTRYP_PP getRec; DBENTRYP_SI getValue; DBENTRYP_SVL getVarLen; DBENTRYP_V goCold; DBENTRYP_V goHot; DBENTRYP_P putRec; DBENTRYP_SI putValue; DBENTRYP_V recall; DBENTRYP_ULP reccount; DBENTRYP_ISI recInfo; DBENTRYP_I recno; DBENTRYP_S setFieldExtent; /* WorkArea/Database management */ DBENTRYP_P alias; DBENTRYP_V close; DBENTRYP_VP create; DBENTRYP_SI info; DBENTRYP_V newarea; DBENTRYP_VP open; DBENTRYP_V release; DBENTRYP_SP structSize; DBENTRYP_P sysName; #if 0 DBENTRYP_VP dbEval; #endif DBENTRYP_V pack; #if 0 DBENTRYP_LSP packRec; DBENTRYP_VP sort; DBENTRYP_VP trans; DBENTRYP_VP transRec; #endif DBENTRYP_V zap; /* Relational Methods */ #if 0 DBENTRYP_VP childEnd; DBENTRYP_VP childStart; DBENTRYP_VP childSync; DBENTRYP_V syncChildren; DBENTRYP_V clearRel; DBENTRYP_V forceRel; DBENTRYP_SVP relArea; DBENTRYP_VP relEval; DBENTRYP_SVP relText; DBENTRYP_VP setRel; /* Order Management */ DBENTRYP_VP orderListAdd; DBENTRYP_V orderListClear; DBENTRYP_VP orderListDelete; DBENTRYP_VP orderListFocus; DBENTRYP_V orderListRebuild; DBENTRYP_VP orderCondition; DBENTRYP_VP orderCreate; DBENTRYP_VP orderDestroy; DBENTRYP_SVP orderInfo; #endif /* Filters and Scope Settings */ DBENTRYP_V clearFilter; DBENTRYP_V clearLocate; #if 0 DBENTRYP_V clearScope; DBENTRYP_VPLP countScope; #endif DBENTRYP_I filterText; #if 0 DBENTRYP_SI scopeInfo; #endif DBENTRYP_VFI setFilter; DBENTRYP_VLO setLocate; #if 0 DBENTRYP_VP setScope; DBENTRYP_VPL skipScope; /* Miscellaneous */ DBENTRYP_VP compile; #endif DBENTRYP_I error; #if 0 DBENTRYP_I evalBlock; #endif /* Network operations */ DBENTRYP_VSP rawlock; DBENTRYP_VL lock; DBENTRYP_UL unlock; /* Memofile functions */ DBENTRYP_V closeMemFile; DBENTRYP_VP createMemFile; DBENTRYP_SVP getValueFile; DBENTRYP_VP openMemFile; DBENTRYP_SVP putValueFile; /* Database file header handling */ DBENTRYP_V readDBHeader; DBENTRYP_V writeDBHeader; /* Special and reserved methods */ DBENTRYP_SVP whoCares; } RDDFUNCS; typedef RDDFUNCS * PRDDFUNCS; #define RDDFUNCSCOUNT ( sizeof( RDDFUNCS ) / sizeof( DBENTRYP_V ) ) /*--------------------* SELF Methods *------------------------*/ /* Movement and positioning methods */ #define SELF_BOF(w, sp) ((*(w)->lprfsHost->bof)(w, sp)) #define SELF_EOF(w, sp) ((*(w)->lprfsHost->eof)(w, sp)) #define SELF_FOUND(w, sp) ((*(w)->lprfsHost->found)(w, sp)) #define SELF_GOTO(w, l) ((*(w)->lprfsHost->go)(w, l)) #define SELF_GOTOID(w, sp) ((*(w)->lprfsHost->goToId)(w, sp)) #define SELF_GOBOTTOM(w) ((*(w)->lprfsHost->goBottom)(w)) #define SELF_GOTOP(w) ((*(w)->lprfsHost->goTop)(w)) #define SELF_SEEK(w, i, v) ((*(w)->lprfsHost->seek)(w, i, v)) #define SELF_SKIP(w, l) ((*(w)->lprfsHost->skip)(w, l)) #define SELF_SKIPFILTER(w, l) ((*(w)->lprfsHost->skipFilter)(w, l)) #define SELF_SKIPRAW(w, l) ((*(w)->lprfsHost->skipRaw)(w, l)) /* Data management */ #define SELF_ADDFIELD(w, ip) ((*(w)->lprfsHost->addField)(w, ip)) #define SELF_APPEND(w,l) ((*(w)->lprfsHost->append)(w,l)) #define SELF_CREATEFIELDS(w, v) ((*(w)->lprfsHost->createFields)(w, v)) #define SELF_DELETE(w) ((*(w)->lprfsHost->deleterec)(w)) #define SELF_DELETED(w, sp) ((*(w)->lprfsHost->deleted)(w, sp)) #define SELF_FIELDCOUNT(w, sp) ((*(w)->lprfsHost->fieldCount)(w, sp)) #define SELF_FIELDDISPLAY(w, sp) ((*(w)->lprfsHost->fieldDisplay)(w, sp)) #define SELF_FIELDINFO(w,s1,s2,v) ((*(w)->lprfsHost->fieldInfo)(w,s1,s2,v)) #define SELF_FIELDNAME(w, i, bp) ((*(w)->lprfsHost->fieldName)(w, i, bp)) #define SELF_FLUSH(w) ((*(w)->lprfsHost->flush)(w)) #define SELF_GETREC(w, bpp) ((*(w)->lprfsHost->getRec)(w, bpp)) #define SELF_GETVALUE(w, i, v) ((*(w)->lprfsHost->getValue)(w, i, v)) #define SELF_GETVARLEN(w, i, lp) ((*(w)->lprfsHost->getVarLen)(w, i, lp)) #define SELF_GOCOLD(w) ((*(w)->lprfsHost->goCold)(w)) #define SELF_GOHOT(w) ((*(w)->lprfsHost->goHot)(w)) #define SELF_PUTVALUE(w, i, v) ((*(w)->lprfsHost->putValue)(w, i, v)) #define SELF_PUTREC(w, bp) ((*(w)->lprfsHost->putRec)(w, bp)) #define SELF_RECALL(w) ((*(w)->lprfsHost->recall)(w)) #define SELF_RECCOUNT(w, sp) ((*(w)->lprfsHost->reccount)(w, sp)) #define SELF_RECINFO(w,v1,i,v2) ((*(w)->lprfsHost->recInfo)(w,v1,i,v2)) #define SELF_RECNO(w, i) ((*(w)->lprfsHost->recno)(w, i)) #define SELF_SETFIELDEXTENT(w, s) ((*(w)->lprfsHost->setFieldExtent)(w, s)) /* WorkArea/Database management */ #define SELF_ALIAS(w, bp) ((*(w)->lprfsHost->alias)(w, bp)) #define SELF_CLOSE(w) ((*(w)->lprfsHost->close)(w)) #define SELF_CREATE(w, ip) ((*(w)->lprfsHost->create)(w, ip)) #define SELF_INFO(w, i, g) ((*(w)->lprfsHost->info)(w, i, g)) #define SELF_NEW(w) ((*(w)->lprfsHost->newarea)(w)) #define SELF_OPEN(w, ip) ((*(w)->lprfsHost->open)(w, ip)) #define SELF_RELEASE(w) ((*(w)->lprfsHost->release)(w)) #define SELF_STRUCTSIZE(w, sp) ((*(w)->lprfsHost->structSize)(w,sp)) #define SELF_SYSNAME(w, bp) ((*(w)->lprfsHost->sysName)(w, bp)) #define SELF_DBEVAL(w, ip) ((*(w)->lprfsHost->dbEval)(w, ip)) #define SELF_PACK(w) ((*(w)->lprfsHost->pack)(w)) #define SELF_PACKREC(w, l, sp) ((*(w)->lprfsHost->packRec)(w, l, sp)) #define SELF_SORT(w, ip) ((*(w)->lprfsHost->sort)(w, ip)) #define SELF_TRANS(w, ip) ((*(w)->lprfsHost->trans)(w, ip)) #define SELF_TRANSREC(w, ip) ((*(w)->lprfsHost->transRec)(w, ip)) #define SELF_ZAP(w) ((*(w)->lprfsHost->zap)(w)) /* Relational Methods */ #define SELF_CHILDEND(w, ip) ((*(w)->lprfsHost->childEnd)(w, ip)) #define SELF_CHILDSTART(w, ip) ((*(w)->lprfsHost->childStart)(w, ip)) #define SELF_CHILDSYNC(w, ip) ((*(w)->lprfsHost->childSync)(w, ip)) #define SELF_SYNCCHILDREN(w) ((*(w)->lprfsHost->syncChildren)(w)) #define SELF_CLEARREL(w) ((*(w)->lprfsHost->clearRel)(w)) #define SELF_FORCEREL(w) ((*(w)->lprfsHost->forceRel)(w)) #define SELF_RELAREA(w, s, sp) ((*(w)->lprfsHost->relArea)(w, s, sp)) #define SELF_RELEVAL(w, ip) ((*(w)->lprfsHost->relEval)(w, ip)) #define SELF_RELTEXT(w, s, bp) ((*(w)->lprfsHost->relText)(w, s, bp)) #define SELF_SETREL(w, ip) ((*(w)->lprfsHost->setRel)(w, ip)) /* Order Management */ #define SELF_ORDLSTADD(w, lp) ((*(w)->lprfsHost->orderListAdd)(w, lp)) #define SELF_ORDLSTDELETE(w, lp) ((*(w)->lprfsHost->orderListDelete)(w, lp)) #define SELF_ORDLSTFOCUS(w, lp) ((*(w)->lprfsHost->orderListFocus)(w,lp)) #define SELF_ORDLSTREBUILD(w) ((*(w)->lprfsHost->orderListRebuild)(w)) #define SELF_ORDLSTCLEAR(w) ((*(w)->lprfsHost->orderListClear)(w)) #define SELF_ORDSETCOND(w, ip) ((*(w)->lprfsHost->orderCondition)(w, ip)) #define SELF_ORDCREATE(w, ip) ((*(w)->lprfsHost->orderCreate)(w, ip)) #define SELF_ORDDESTROY(w, p) ((*(w)->lprfsHost->orderDestroy)(w, p)) #define SELF_ORDINFO(w, i, p) ((*(w)->lprfsHost->orderInfo)(w, i, p)) #define SELF_ORDEXPR(w, p) ((*(w)->lprfsHost->orderInfo)(w, DBOI_EXPRESSION, p)) #define SELF_ORDCOND(w, p) ((*(w)->lprfsHost->orderInfo)(w, DBOI_CONDITION, p)) #define SELF_ORDRECNO(w, p) ((*(w)->lprfsHost->orderInfo)(w, DBOI_RECNO, p)) #define SELF_ORDPOS(w, p) ((*(w)->lprfsHost->orderInfo)(w, DBOI_POSITION, p)) #define SELF_ORDNUMBER(w, p) ((*(w)->lprfsHost->orderInfo)(w, DBOI_NUMBER, p)) #define SELF_ORDNAME(w, p) ((*(w)->lprfsHost->orderInfo)(w, DBOI_NAME, p)) #define SELF_ORDBAGNAME(w, p) ((*(w)->lprfsHost->orderInfo)(w, DBOI_BAGNAME, p)) #define SELF_ORDBAGEXT(w, p) ((*(w)->lprfsHost->orderInfo)(w, DBOI_BAGEXT, p)) /* Filters and Scope Settings */ #define SELF_CLEARFILTER(w) ((*(w)->lprfsHost->clearFilter)(w)) #define SELF_CLEARLOCATE(w) ((*(w)->lprfsHost->clearLocate)(w)) #define SELF_CLEARSCOPE(w) ((*(w)->lprfsHost->clearScope)(w)) #define SELF_COUNTSCOPE(w,ip,lp) ((*(w)->lprfsHost->countScope)(w,ip,lp)) #define SELF_FILTERTEXT(w, bp) ((*(w)->lprfsHost->filterText)(w, bp)) #define SELF_SCOPEINFO(w,i,v) ((*(w)->lprfsHost->scopeInfo)(w,i,v)) #define SELF_SETFILTER(w, ip) ((*(w)->lprfsHost->setFilter)(w, ip)) #define SELF_SETLOCATE(w, ip) ((*(w)->lprfsHost->setLocate)(w, ip)) #define SELF_SETSCOPE(w, ip) ((*(w)->lprfsHost->setScope)(w, ip)) #define SELF_SKIPSCOPE(w, bp, l) ((*(w)->lprfsHost->skipScope)(w, bp, l)) /* Miscellaneous */ #define SELF_COMPILE(w, bp) ((*(w)->lprfsHost->compile)(w, bp)) #define SELF_ERROR(w, ip) ((*(w)->lprfsHost->error)(w, ip)) #define SELF_EVALBLOCK(w, v) ((*(w)->lprfsHost->evalBlock)(w, v)) /* Network operations */ #define SELF_GETLOCKS(w, g) ((*(w)->lprfsHost->info)(w, DBI_GETLOCKARRAY, g)) #define SELF_RAWLOCK(w, i, l) ((*(w)->lprfsHost->rawlock)(w, i, l)) #define SELF_LOCK(w, sp) ((*(w)->lprfsHost->lock)(w, sp)) #define SELF_UNLOCK(w, l) ((*(w)->lprfsHost->unlock)(w, l)) /* Memofile functions */ #define SELF_CLOSEMEMFILE(w) ((*(w)->lprfsHost->closeMemFile)(w)) #define SELF_CREATEMEMFILE(w,bp) ((*(w)->lprfsHost->createMemFile)(w,bp)) #define SELF_GETVALUEFILE(w,i,bp) ((*(w)->lprfsHost->getValueFile)(w,i,bp)) #define SELF_OPENMEMFILE(w,bp) ((*(w)->lprfsHost->openMemFile)(w,bp)) #define SELF_PUTVALUEFILE(w,i,bp) ((*(w)->lprfsHost->putValueFile)(w,i,bp)) /* Database file header handling */ #define SELF_READDBHEADER(w) ((*(w)->lprfsHost->readDBHeader)(w)) #define SELF_WRITEDBHEADER(w) ((*(w)->lprfsHost->writeDBHeader)(w)) /* Info operations */ #define SELF_RECSIZE(w, lp) ((*(w)->lprfsHost->info)(w, DBI_GETRECSIZE, lp)) #define SELF_HEADERSIZE(w, fp) ((*(w)->lprfsHost->info)(w, DBI_GETHEADERSIZE, fp)) #define SELF_LUPDATE(w, fp) ((*(w)->lprfsHost->info)(w, DBI_LASTUPDATE, fp )) #define SELF_SETDELIM(w, fp) ((*(w)->lprfsHost->info)(w, DBI_SETDELIMITER, fp)) #define SELF_GETDELIM(w, fp) ((*(w)->lprfsHost->info)(w, DBI_GETDELIMITER, fp)) #define SELF_TABLEEXT(w, fp) ((*(w)->lprfsHost->info)(w, DBI_TABLEEXT, fp)) /*--------------------* SUPER Methods *------------------------*/ /* Movement and positioning methods */ #define SUPER_BOF(w, sp) ((*(SUPERTABLE)->bof)(w, sp)) #define SUPER_EOF(w, sp) ((*(SUPERTABLE)->eof)(w, sp)) #define SUPER_FOUND(w, sp) ((*(SUPERTABLE)->found)(w, sp)) #define SUPER_GOTO(w, l) ((*(SUPERTABLE)->go)(w, l)) #define SUPER_GOTOID(w, sp) ((*(SUPERTABLE)->goToId)(w, sp)) #define SUPER_GOBOTTOM(w) ((*(SUPERTABLE)->goBottom)(w)) #define SUPER_GOTOP(w) ((*(SUPERTABLE)->goTop)(w)) #define SUPER_SEEK(w, i, v) ((*(SUPERTABLE)->seek)(w, i, v)) #define SUPER_SKIP(w, l) ((*(SUPERTABLE)->skip)(w, l)) #define SUPER_SKIPFILTER(w, l) ((*(SUPERTABLE)->skipFilter)(w, l)) #define SUPER_SKIPRAW(w, l) ((*(SUPERTABLE)->skipRaw)(w, l)) /* Data management */ #define SUPER_ADDFIELD(w, ip) ((*(SUPERTABLE)->addField)(w, ip)) #define SUPER_APPEND(w,l) ((*(SUPERTABLE)->append)(w,l)) #define SUPER_CREATEFIELDS(w, v) ((*(SUPERTABLE)->createFields)(w, v)) #define SUPER_DELETE(w) ((*(SUPERTABLE)->deleterec)(w)) #define SUPER_DELETED(w, sp) ((*(SUPERTABLE)->deleted)(w, sp)) #define SUPER_FIELDCOUNT(w, sp) ((*(SUPERTABLE)->fieldCount)(w, sp)) #define SUPER_FIELDDISPLAY(w, sp) ((*(SUPERTABLE)->fieldDisplay)(w, sp)) #define SUPER_FIELDINFO(w,s1,s2,v) ((*(SUPERTABLE)->fieldInfo)(w,s1,s2,v)) #define SUPER_FIELDNAME(w, i, bp) ((*(SUPERTABLE)->fieldName)(w, i, bp)) #define SUPER_FLUSH(w) ((*(SUPERTABLE)->flush)(w)) #define SUPER_GETREC(w, bpp) ((*(SUPERTABLE)->getRec)(w, bpp)) #define SUPER_GETVALUE(w, i, v) ((*(SUPERTABLE)->getValue)(w, i, v)) #define SUPER_GETVARLEN(w, i, lp) ((*(SUPERTABLE)->getVarLen)(w, i, lp)) #define SUPER_GOCOLD(w) ((*(SUPERTABLE)->goCold)(w)) #define SUPER_GOHOT(w) ((*(SUPERTABLE)->goHot)(w)) #define SUPER_PUTVALUE(w, i, v) ((*(SUPERTABLE)->putValue)(w, i, v)) #define SUPER_PUTREC(w, bp) ((*(SUPERTABLE)->putRec)(w, bp)) #define SUPER_RECALL(w) ((*(SUPERTABLE)->recall)(w)) #define SUPER_RECCOUNT(w, sp) ((*(SUPERTABLE)->reccount)(w, sp)) #define SUPER_RECINFO(w,v1,i,v2) ((*(SUPERTABLE)->recInfo)(w,v1,i,v2)) #define SUPER_RECNO(w, sp) ((*(SUPERTABLE)->recno)(w, sp)) #define SUPER_SETFIELDEXTENT(w, s) ((*(SUPERTABLE)->setFieldExtent)(w, s)) /* WorkArea/Database management */ #define SUPER_ALIAS(w, bp) ((*(SUPERTABLE)->alias)(w, bp)) #define SUPER_CLOSE(w) ((*(SUPERTABLE)->close)(w)) #define SUPER_CREATE(w, ip) ((*(SUPERTABLE)->create)(w, ip)) #define SUPER_INFO(w, i, g) ((*(SUPERTABLE)->info)(w, i, g)) #define SUPER_NEW(w) ((*(SUPERTABLE)->newarea)(w)) #define SUPER_OPEN(w, ip) ((*(SUPERTABLE)->open)(w, ip)) #define SUPER_RELEASE(w) ((*(SUPERTABLE)->release)(w)) #define SUPER_STRUCTSIZE(w, sp) ((*(SUPERTABLE)->structSize)(w, sp)) #define SUPER_SYSNAME(w, bp) ((*(SUPERTABLE)->sysName)(w, bp)) #define SUPER_DBEVAL(w, ip) ((*(SUPERTABLE)->dbEval)(w, ip)) #define SUPER_PACK(w) ((*(SUPERTABLE)->pack)(w)) #define SUPER_PACKREC(w, l, sp) ((*(SUPERTABLE)->packRec)(w, l, sp)) #define SUPER_SORT(w, ip) ((*(SUPERTABLE)->sort)(w, ip)) #define SUPER_TRANS(w, ip) ((*(SUPERTABLE)->trans)(w, ip)) #define SUPER_TRANSREC(w, ip) ((*(SUPERTABLE)->transRec)(w, ip)) #define SUPER_ZAP(w) ((*(SUPERTABLE)->zap)(w)) /* Relational Methods */ #define SUPER_CHILDEND(w, ip) ((*(SUPERTABLE)->childEnd)(w, ip)) #define SUPER_CHILDSTART(w, ip) ((*(SUPERTABLE)->childStart)(w, ip)) #define SUPER_CHILDSYNC(w, ip) ((*(SUPERTABLE)->childSync)(w, ip)) #define SUPER_SYNCCHILDREN(w) ((*(SUPERTABLE)->syncChildren)(w)) #define SUPER_CLEARREL(w) ((*(SUPERTABLE)->clearRel)(w)) #define SUPER_FORCEREL(w) ((*(SUPERTABLE)->forceRel)(w)) #define SUPER_RELAREA(w, s, sp) ((*(SUPERTABLE)->relArea)(w, s, sp)) #define SUPER_RELEVAL(w, ip) ((*(SUPERTABLE)->relEval)(w, ip)) #define SUPER_RELTEXT(w, s, bp) ((*(SUPERTABLE)->relText)(w, s, bp)) #define SUPER_SETREL(w, ip) ((*(SUPERTABLE)->setRel)(w, ip)) /* Order Management */ #define SUPER_ORDLSTADD(w, lp) ((*(SUPERTABLE)->orderListAdd)(w, lp)) #define SUPER_ORDLSTDELETE(w, lp) ((*(SUPERTABLE)->orderListDelete)(w, lp)) #define SUPER_ORDLSTFOCUS(w, lp) ((*(SUPERTABLE)->orderListFocus)(w, lp)) #define SUPER_ORDLSTREBUILD(w) ((*(SUPERTABLE)->orderListRebuild)(w)) #define SUPER_ORDLSTCLEAR(w) ((*(SUPERTABLE)->orderListClear)(w)) #define SUPER_ORDSETCOND(w,ip) ((*(SUPERTABLE)->orderCondition)(w, ip)) #define SUPER_ORDCREATE(w, ip) ((*(SUPERTABLE)->orderCreate)(w, ip)) #define SUPER_ORDDELETE(w, ip) ((*(SUPERTABLE)->orderDelete)(w, ip)) #define SUPER_ORDINFO(w, i, p) ((*(SUPERTABLE)->orderInfo)(w, i, p)) #define SUPER_ORDEXPR(w, p) ((*(SUPERTABLE)->orderInfo)(w, DBOI_EXPRESSION, p)) #define SUPER_ORDCOND(w, p) ((*(SUPERTABLE)->orderInfo)(w, DBOI_CONDITION, p)) #define SUPER_ORDRECNO(w, p) ((*(SUPERTABLE)->orderInfo)(w, DBOI_RECNO, p)) #define SUPER_ORDPOS(w, p) ((*(SUPERTABLE)->orderInfo)(w, DBOI_POSITION, p)) #define SUPER_ORDNUMBER(w, p) ((*(SUPERTABLE)->orderInfo)(w, DBOI_NUMBER, p)) #define SUPER_ORDNAME(w, p) ((*(SUPERTABLE)->orderInfo)(w, DBOI_NAME, p)) #define SUPER_ORDBAGNAME(w, p) ((*(SUPERTABLE)->orderInfo)(w, DBOI_BAGNAME, p)) #define SUPER_ORDBAGEXT(w, p) ((*(SUPERTABLE)->orderInfo)(w, DBOI_BAGEXT, p)) /* Filters and Scope Settings */ #define SUPER_CLEARFILTER(w) ((*(SUPERTABLE)->clearFilter)(w)) #define SUPER_CLEARLOCATE(w) ((*(SUPERTABLE)->clearLocate)(w)) #define SUPER_CLEARSCOPE(w) ((*(SUPERTABLE)->clearScope)(w)) #define SUPER_COUNTSCOPE(w,ip,lp) ((*(SUPERTABLE)->countScope)(w,ip,lp)) #define SUPER_FILTERTEXT(w, bp) ((*(SUPERTABLE)->filterText)(w, bp)) #define SUPER_SCOPEINFO(w,i,v) ((*(SUPERTABLE)->scopeInfo)(w,i,v)) #define SUPER_SETFILTER(w, ip) ((*(SUPERTABLE)->setFilter)(w, ip)) #define SUPER_SETLOCATE(w, ip) ((*(SUPERTABLE)->setLocate)(w, ip)) #define SUPER_SETSCOPE(w, ip) ((*(SUPERTABLE)->setScope)(w, ip)) #define SUPER_SKIPSCOPE(w, bp, l) ((*(SUPERTABLE)->skipScope)(w, bp, l)) /* Miscellaneous */ #define SUPER_COMPILE(w, bp) ((*(SUPERTABLE)->compile)(w, bp)) #define SUPER_ERROR(w, ip) ((*(SUPERTABLE)->error)(w, ip)) #define SUPER_EVALBLOCK(w, v) ((*(SUPERTABLE)->evalBlock)(w, v)) /* Network operations */ #define SUPER_GETLOCKS(w, g) ((*(SUPERTABLE)->info)(w, DBI_GETLOCKARRAY, g)) #define SUPER_RAWLOCK(w, i, l) ((*(SUPERTABLE)->rawlock)(w, i, l)) #define SUPER_LOCK(w, sp) ((*(SUPERTABLE)->lock)(w, sp)) #define SUPER_UNLOCK(w) ((*(SUPERTABLE)->unlock)(w)) /* Memofile functions */ #define SUPER_CLOSEMEMFILE(w) ((*(SUPERTABLE)->closeMemFile)(w)) #define SUPER_CREATEMEMFILE(w,bp) ((*(SUPERTABLE)->createMemFile)(w,bp)) #define SUPER_GETVALUEFILE(w,i,bp) ((*(SUPERTABLE)->getValueFile)(w,i,bp)) #define SUPER_OPENMEMFILE(w,bp) ((*(SUPERTABLE)->openMemFile)(w,bp)) #define SUPER_PUTVALUEFILE(w,i,bp) ((*(SUPERTABLE)->putValueFile)(w,i,bp)) /* Database file header handling */ #define SUPER_READDBHEADER(w) ((*(SUPERTABLE)->readDBHeader)(w)) #define SUPER_WRITEDBHEADER(w) ((*(SUPERTABLE)->writeDBHeader)(w)) /* Info operations */ #define SUPER_RECSIZE(w, lp) ((*(SUPERTABLE)->info)(w, DBI_GETRECSIZE, lp)) #define SUPER_HEADERSIZE(w, fp) ((*(SUPERTABLE)->info)(w, DBI_GETHEADERSIZE, fp)) #define SUPER_LUPDATE(w, fp) ((*(SUPERTABLE)->info)(w, DBI_LASTUPDATE, fp )) #define SUPER_SETDELIM(w, fp) ((*(SUPERTABLE)->info)(w, DBI_SETDELIMITER, fp)) #define SUPER_GETDELIM(w, fp) ((*(SUPERTABLE)->info)(w, DBI_GETDELIMITER, fp)) #define SUPER_TABLEEXT(w, fp) ((*(SUPERTABLE)->info)(w, DBI_TABLEEXT, fp)) /* * PROTOTYPES * ---------- */ extern ERRCODE hb_rddInherit( PRDDFUNCS pTable, PRDDFUNCS pSubTable, PRDDFUNCS pSuperTable, BYTE * szDrvName ); extern ERRCODE hb_rddDisinherit( BYTE * drvName ); extern USHORT hb_rddExtendType( USHORT fieldType ); extern USHORT hb_rddFieldType( USHORT extendType ); #endif /* HB_RDDAPI_H_ */