fivedev/harbour-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ab4e415682efd7f3030eb93e4bbf030d5c054631
harbour-core/harbour/include/hbapirdd.h

1173 lines
43 KiB
C
Raw Blame History

/*
* $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, or (at your option)
* any later version.
*
* 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 software; see the file COPYING. If not, write to
* the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307 USA (or visit the web site http://www.gnu.org/).
*
* As a special exception, the Harbour Project gives permission for
* additional uses of the text contained in its release of Harbour.
*
* The exception is that, if you link the Harbour libraries 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 Harbour library code into it.
*
* This exception does not however invalidate any other reasons why
* the executable file might be covered by the GNU General Public License.
*
* This exception applies only to the code released by the Harbour
* Project under the name Harbour. If you copy code from other
* Harbour Project or Free Software Foundation releases into a copy of
* Harbour, as the General Public License permits, the exception does
* not apply to the code that you add in this way. To avoid misleading
* anyone as to the status of such modified files, you must delete
* this exception notice from them.
*
* If you write modifications of your own for Harbour, it is your choice
* whether to permit this exception to apply to your modifications.
* If you do not wish that, delete this exception notice.
*
*/
#ifndef HB_APIRDD_H_
#define HB_APIRDD_H_
#include "hbapifs.h"
//#include "ord.ch"
#if defined(HB_EXTERN_C)
extern "C" {
#endif
#define HARBOUR_MAX_RDD_DRIVERNAME_LENGTH 32
#define HARBOUR_MAX_RDD_ALIAS_LENGTH 32
#define HARBOUR_MAX_RDD_FIELDNAME_LENGTH 32
/* RDD virtual machine integration functions */
extern USHORT hb_rddInsertAreaNode( char *szDriver );
extern int hb_rddGetCurrentWorkAreaNumber( void );
void * hb_rddGetCurrentWorkAreaPointer( 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 );
/* DBCMD errors */
#define EDBCMD_SEEK_BADPARAMETER 1001
#define EDBCMD_NOALIAS 1002
#define EDBCMD_NOVAR 1003
#define EDBCMD_USE_BADPARAMETER 1005
#define EDBCMD_REL_BADPARAMETER 1006
#define EDBCMD_FIELDNAME_BADPARAMETER 1009
#define EDBCMD_DUPALIAS 1011
#define EDBCMD_DBCMDBADPARAMETER 1014
#define EDBCMD_BADPARAMETER 1015
#define EDBCMD_INFOBADPARAMETER 1032
#define EDBCMD_DBINFOBADPARAMETER 1034
#define EDBCMD_DBFILEPUTBADPARAMETER 1041
#define EDBCMD_DBFILEGETBADPARAMETER 1042
#define EDBCMD_NOTABLE 2001
#define EDBCMD_EVAL_BADPARAMETER 2019
/* 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
/* Constants for SELF_ORDINFO()
Be sure these stay in sync with the same ones in ord.ch
*/
#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 */
/* 53-level constants */
#define DBOI_FULLPATH 20 /* Get the order Bag Full Path */
#define DBOI_KEYTYPE 24 /* Get the keytype of order */
#define DBOI_KEYSIZE 25 /* Get the keysize of order */
#define DBOI_KEYCOUNT 26 /* Get the number of keys */
#define DBOI_SETCODEBLOCK 27 /* Set codeblock for order key */
#define DBOI_KEYDEC 28 /* Get decimals of order key */
#define DBOI_HPLOCKING 29 /* High performance index locking */
#define DBOI_LOCKOFFSET 35 /* New locking offset */
#define DBOI_KEYADD 36 /* Gets/Sets the Key to be added */
#define DBOI_KEYDELETE 37 /* Gets/Sets the Key to be deleted */
#define DBOI_KEYVAL 38 /* Get current key value */
#define DBOI_SCOPETOP 39 /* Gets/Sets top of scope */
#define DBOI_SCOPEBOTTOM 40 /* Gets/Sets bottom of scope */
#define DBOI_SCOPETOPCLEAR 41 /* Clears top scope setting */
#define DBOI_SCOPEBOTTOMCLEAR 42 /* Clears bottom scope setting */
#define DBOI_CUSTOM 45 /* Custom created order */
#define DBOI_SKIPUNIQUE 46 /* Flag for skip unique */
#define DBOI_KEYSINCLUDED 50 /* # of keys included while indexing */
/* keyno */
#define DBOI_KEYGOTO DBOI_POSITION
#define DBOI_KEYNORAW 51 /* keyno ignoring any filter */
#define DBOI_KEYCOUNTRAW 52 /* keycount ignoring any filter */
#define DBOI_OPTLEVEL 53 /* Optimization achieved for last query */
// Ideally shoud be an entry point that doesn't require an open table
#define DBOI_STRICTREAD 60 /* Get/set read thru RDD when indexing */
#define DBOI_OPTIMIZE 61 /* Get/set use of query optimization */
#define DBOI_AUTOOPEN 62 /* Get/set auto open of production index */
#define DBOI_AUTOORDER 63 /* Get/set default order: production index */
#define DBOI_AUTOSHARE 64 /* Get/set automatic sharing control */
/* Return values for DBOI_OPTLEVEL */
#define DBOI_OPTIMIZED_NONE 0
#define DBOI_OPTIMIZED_PART 1
#define DBOI_OPTIMIZED_FULL 2
/* 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_FULLPATH 10 /* String: Full path name of opened file */
#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 /* Locked records */
#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;
struct _RDDNODE;
/*
* DBFIELDINFO
* -----------
* The field structure
*/
typedef struct
{
BYTE * atomName; /* FIELD (symbol) name */
USHORT uiType; /* FIELD type */
USHORT uiTypeExtended; /* 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;
/*
* 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 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;
/*
* DBORDSCOPEINFO
* --------------
* The Order Scope Info structure
*/
typedef struct
{
USHORT nScope; /* scope operation: TOPSCOPE/ENDSCOPE */
PHB_ITEM scopeValue;
} DBORDSCOPEINFO;
typedef DBORDSCOPEINFO * LPDBORDSCOPEINFO;
/*
* 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 */
BOOL isScoped; /* Is this relation scoped */
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
{
PHB_ITEM 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 */
void * sym; /* Symbol that represents the field */
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;
} 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_VT )( AREAP area, LPDBTRANSINFO param );
typedef USHORT ( * DBENTRYP_VF )( AREAP area, LPDBFIELDINFO param );
typedef USHORT ( * DBENTRYP_VL )( AREAP area, LPDBLOCKINFO param );
typedef USHORT ( * DBENTRYP_VR )( AREAP area, LPDBRELINFO param );
typedef USHORT ( * DBENTRYP_VS )( AREAP area, LPDBSORTINFO param );
typedef USHORT ( * DBENTRYP_VFI )( AREAP area, LPDBFILTERINFO param );
typedef USHORT ( * DBENTRYP_VEI )( AREAP area, LPDBEVALINFO param );
typedef USHORT ( * DBENTRYP_VLO )( AREAP area, LPDBSCOPEINFO param );
typedef USHORT ( * DBENTRYP_VOC )( AREAP area, LPDBORDERCREATEINFO param );
typedef USHORT ( * DBENTRYP_VOI )( AREAP area, LPDBORDERCONDINFO param );
typedef USHORT ( * DBENTRYP_VOS )( AREAP area, LPDBORDSCOPEINFO param );
typedef USHORT ( * DBENTRYP_OI )( AREAP area, LPDBORDERINFO param );
typedef USHORT ( * DBENTRYP_OII )( AREAP area, USHORT index, LPDBORDERINFO 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_SVPB )( AREAP area, USHORT index, void * param, BOOL p3 );
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 );
typedef USHORT ( * DBENTRYP_BIB )( AREAP area, BOOL p1, PHB_ITEM p2, BOOL p3 );
typedef USHORT ( * DBENTRYP_VPL )( AREAP area, void * p1, LONG p2);
typedef USHORT ( * DBENTRYP_VPLP )( AREAP area, void * p1, LONG * p2);
typedef USHORT ( * DBENTRYP_LSP )( AREAP area, LONG p1, USHORT * p2);
/* this methods DO USE take a Workarea but an RDDNODE */
typedef USHORT ( * DBENTRYP_I0 )( void );
typedef USHORT ( * DBENTRYP_I1 )( PHB_ITEM p1);
typedef USHORT ( * DBENTRYP_I2 )( PHB_ITEM p1, PHB_ITEM p2);
/*--------------------* 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;
DBENTRYP_BIB seek;
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;
DBENTRYP_VEI dbEval;
DBENTRYP_V pack;
DBENTRYP_LSP packRec;
DBENTRYP_VS sort;
DBENTRYP_VT trans;
DBENTRYP_VT transRec;
DBENTRYP_V zap;
/* Relational Methods */
DBENTRYP_VR childEnd;
DBENTRYP_VR childStart;
DBENTRYP_VR childSync;
DBENTRYP_V syncChildren;
DBENTRYP_V clearRel;
DBENTRYP_V forceRel;
DBENTRYP_SVP relArea;
DBENTRYP_VR relEval;
DBENTRYP_SVP relText;
DBENTRYP_VR setRel;
/* Order Management */
DBENTRYP_OI orderListAdd;
DBENTRYP_V orderListClear;
DBENTRYP_VP orderListDelete;
DBENTRYP_OI orderListFocus;
DBENTRYP_V orderListRebuild;
DBENTRYP_VOI orderCondition;
DBENTRYP_VOC orderCreate;
DBENTRYP_OI orderDestroy;
DBENTRYP_OII orderInfo;
/* Filters and Scope Settings */
DBENTRYP_V clearFilter;
DBENTRYP_V clearLocate;
DBENTRYP_V clearScope;
DBENTRYP_VPLP countScope;
DBENTRYP_I filterText;
DBENTRYP_SI scopeInfo;
DBENTRYP_VFI setFilter;
DBENTRYP_VLO setLocate;
DBENTRYP_VOS setScope;
DBENTRYP_VPL skipScope;
/* Miscellaneous */
DBENTRYP_P compile;
DBENTRYP_I error;
DBENTRYP_I evalBlock;
/* Network operations */
DBENTRYP_VSP rawlock;
DBENTRYP_VL lock;
DBENTRYP_UL unlock;
/* Memofile functions */
DBENTRYP_V closeMemFile;
DBENTRYP_VP createMemFile;
DBENTRYP_SVPB getValueFile;
DBENTRYP_VP openMemFile;
DBENTRYP_SVP putValueFile;
/* Database file header handling */
DBENTRYP_V readDBHeader;
DBENTRYP_V writeDBHeader;
/* non WorkArea functions */
DBENTRYP_I0 exit;
DBENTRYP_I1 drop;
DBENTRYP_I2 exists;
/* Special and reserved methods */
DBENTRYP_SVP whoCares;
} RDDFUNCS;
typedef RDDFUNCS * PRDDFUNCS;
#define RDDFUNCSCOUNT ( sizeof( RDDFUNCS ) / sizeof( DBENTRYP_V ) )
/* RDD Node structure */
typedef struct _RDDNODE
{
char szName[ HARBOUR_MAX_RDD_DRIVERNAME_LENGTH + 1 ]; /* Name of RDD */
USHORT uiType; /* Type of RDD */
RDDFUNCS pTable; /* Table of functions */
USHORT uiAreaSize; /* Size of the WorkArea */
struct _RDDNODE * pNext; /* Next RDD in the list */
} RDDNODE;
typedef RDDNODE * LPRDDNODE;
/*--------------------* 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, i1, v, i2) ((*(w)->lprfsHost->seek)(w, i1, v, i2))
#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,b) ((*(w)->lprfsHost->getValueFile)(w,i,bp,b))
#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))
/* non WorkArea functions */
#define SELF_EXIT(r) ((*(r)->pTable.exit)())
#define SELF_DROP(r, i) ((*(r)->pTable.drop)(i))
#define SELF_EXISTS(r, it, ii) ((*(r)->pTable.exists)(it,ii))
/*--------------------* 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, i1, v, i2) ((*(SUPERTABLE)->seek)(w, i1, v, i2))
#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,l) ((*(SUPERTABLE)->unlock)(w,l))
/* Memofile functions */
#define SUPER_CLOSEMEMFILE(w) ((*(SUPERTABLE)->closeMemFile)(w))
#define SUPER_CREATEMEMFILE(w,bp) ((*(SUPERTABLE)->createMemFile)(w,bp))
#define SUPER_GETVALUEFILE(w,i,bp,b) ((*(SUPERTABLE)->getValueFile)(w,i,bp,b))
#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))
/* non WorkArea functions */
#define SUPER_EXIT() ((*(SUPERTABLE)->exit)())
#define SUPER_DROP(i) ((*(SUPERTABLE)->drop)(i))
#define SUPER_EXISTS(it, ii) ((*(SUPERTABLE)->exists)(it, ii))
/*
* 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 );
#if defined(HB_EXTERN_C)
}
#endif
#endif /* HB_APIRDD_H_ */
Reference in New Issue View Git Blame Copy Permalink