/* d4data.h   (c)Copyright Sequiter Software Inc., 1988-1996.  All rights reserved. */

extern char v4buffer[257] ;

typedef int S4CALL S4CMP_FUNCTION( S4CMP_PARM, S4CMP_PARM, size_t) ;

/* typedef required to work around VC++ 1.50 bug in definition of Sort4.assignCmp() */
typedef int (S4CALL *S4CMP_FUNCTION_PTR)( S4CMP_PARM, S4CMP_PARM, size_t ) ;

#ifdef __SC__
   typedef void _cdecl C4DTOK( char S4PTR *, const double ) ;
   typedef void _cdecl C4STOK( char S4PTR *, const char S4PTR *, const int ) ;
#else
   typedef void C4DTOK( char S4PTR *, const double ) ;
   typedef void C4STOK( char S4PTR *, const char S4PTR *, const int ) ;
#endif

#ifdef S4FOX
   typedef unsigned char translatedChars[256] ;
   typedef unsigned char compressedChars[2] ;
#endif

struct DATA4St ;
struct FIELD4St ;
struct DATA4FILESt ;
#ifdef S4COMPILE_TEST
   #ifndef S4OFF_MEMO
      struct F4MEMOSt ;
   #endif
   #ifndef S4OFF_INDEX
      struct INDEX4St ;
      struct TAG4St ;
      struct TAG4FILESt ;
      #ifndef N4OTHER
         struct INDEX4FILESt ;
      #endif
      #ifdef S4FOX
         struct T4VFPSt ;
      #endif
   #endif
   #ifndef S4OFF_TRAN
      struct S4CLASS TRAN4FILESt ;
      struct S4CLASS CODE4TRANSSt ;
   #endif
#else
   struct F4MEMOSt ;
   struct INDEX4St ;
   struct TAG4St ;
   struct TAG4FILESt ;
   struct S4CLASS TRAN4FILESt ;
   struct S4CLASS CODE4TRANSSt ;
   #ifndef N4OTHER
      struct INDEX4FILESt ;
   #endif
   #ifdef S4FOX
      struct T4VFPSt ;
   #endif
#endif

#ifdef S4CBPP
   class S4CLASS FILE4 ;
#else
   struct FILE4St ;
#endif
#ifdef S4CBPP
   class S4CLASS CODE4 ;
#else
   struct CODE4St ;
#endif
#ifdef S4SERVER
   struct SERVER4CLIENTSt ;
#endif
#ifndef S4OFF_COMMUNICATIONS
   struct SOCKET4St ;
   #ifdef S4CLIENT
      struct CONNECTION4St ;
   #endif
#endif

#ifdef S4CBPP
   class S4CLASS Code4 ;
   typedef int ERROR4FUNCTION( Code4 S4PTR *, short int, long ) ;
   typedef int ERROR4DESCRIBE_FUNCTION( Code4 S4PTR *, short int, long, const char S4PTR *, const char S4PTR *, const char S4PTR * ) ;
   typedef int ERROR4STACK( Code4 S4PTR *, short int, long ) ;
   typedef int ERROR4SET( Code4 S4PTR *, short int ) ;
#else
   typedef int ERROR4FUNCTION( struct CODE4St S4PTR *, short int, long ) ;
   typedef int ERROR4DESCRIBE_FUNCTION( struct CODE4St S4PTR *, short int, long, const char S4PTR *, const char S4PTR *, const char S4PTR * ) ;
   typedef int ERROR4STACK( struct CODE4St S4PTR *, short int, long ) ;
   typedef int ERROR4SET( struct CODE4St S4PTR *, short int ) ;
#endif

#ifdef __cplusplus
   #ifdef S4WINDOWS
      #ifdef S4WIN32
         #ifdef _MSC_VER
            typedef struct _declspec(dllexport) l4linkSt
         #else
            typedef struct _export l4linkSt
         #endif
      #else
         typedef struct _export l4linkSt
      #endif
   #else
      typedef struct l4linkSt
   #endif
#else
typedef struct l4linkSt
#endif
{
   struct l4linkSt S4PTR *n, S4PTR *p ;
} LINK4 ;

#ifdef S4CBPP
class S4CLASS LIST4
{
public:
#else
typedef struct
{
#endif
   S4CONV( LINK4 S4PTR *lastNode, LINK4 S4PTR *last_node ) ; /* the last Link */
   LINK4 S4PTR *selected ;
   S4CONV( unsigned short int nLink, unsigned short int n_link ) ; /* The number of links in the list */
#ifdef S4CBPP
} ;
#else
} LIST4 ;
#endif

typedef struct
{
   LINK4 link ;
   double  data ;  /* Make sure it is on a boundry good for at least a double  */
} Y4CHUNK ;

typedef struct
{
   LINK4 link ;

   LIST4 chunks ;      /* Chunks of pieces */
   LIST4 pieces ;      /* A list of available memory pieces */

   int unitStart;    /* The starting # of entries for the Memory Type */
   unsigned   unitSize ;   /* The size of each allocated piece */
   int unitExpand ; /* The expansion # of entries for the Memory Type */
   int nRepeat ;    /* The number of times entry returned for 'new' */
                    /* If nRepeat is '-1', it is a temporary entry. */
   int nUsed ;      /* The number of entries used */
   #ifdef S4DOS    /* no memory sharing under DOS, so can use a CODE4 for limited memory */
      #ifdef S4CBPP
         CODE4 S4PTR    *codeBase ;
      #else
         struct CODE4St *codeBase ;
      #endif
   #endif
}  MEM4 ;

#ifndef S4OFF_OPTIMIZE
typedef struct
{
   LIST4 list ;

   unsigned short int minLink ;
   unsigned long maxTime ;
   unsigned long minTime ;
   char currentPrioCount ;    /* should this list be scanned for avail blocks? */
} OPT4LIST ;

typedef struct
{
   LINK4 link ;
   LINK4 lruLink ;
   char changed ;
   unsigned len ;
   void S4PTR *data ;
   unsigned long readTime ;
   unsigned long accessTime ;
   double hitCount ;
   OPT4LIST *optList ;       /* the optimization list the file resides on */

   /* these next 2 elements must match the OPT4CMP structure in o4opt.h */
   #ifdef S4CBPP
      FILE4 S4PTR *file ;
   #else
      struct FILE4St *file ;
   #endif
   long pos ;
} OPT4BLOCK ;

#ifdef S4CBPP
   typedef struct S4CLASS
#else
   typedef struct
#endif
{
   char blockPower ;
   char forceCurrent ;    /* switch forces a read of current contents */
   char numShift ;

   unsigned char oldMode ;
   unsigned char doUpdate ;
   unsigned char checkCount ;
   unsigned char dummyChar ;

   unsigned int minLink ;
   int numBuffers ;

   unsigned maxBlocks ;
   unsigned writeBlockCount ; /* is the buffer full? */

   unsigned long blockSize ;
   unsigned long bufferSize ;
   unsigned long hashTrail ;       /* where last optimized file ended */
   unsigned long mask ;
   unsigned long numBlocks ;
   unsigned long numLists ;
   unsigned long readStartPos ;
   unsigned long writeStartPos ;
   unsigned long writeCurPos ;

   unsigned long readTimeCount ;
   unsigned long accessTimeCount ;
   unsigned int minAccessTimeVariation ;  /* access times of less than this value will not be updated == 1% of blocks */

   char S4PTR *readBuffer ;
   char S4PTR *writeBuffer ;
   char S4PTR *writeBufferActual ;  /* writeBuffer just points to the actual buffer */

   void S4PTR* S4PTR* buffers ;

   OPT4BLOCK S4PTR *blocks ;

   LIST4 S4PTR *lists ;
   OPT4LIST S4PTR *prio[OPT4NUM_LISTS] ;

   LIST4 avail ;
   OPT4LIST dbfLo ;
   OPT4LIST dbfHi ;
   OPT4LIST indexLo ;
   OPT4LIST indexHi ;
   OPT4LIST other ;

   LIST4 optFiles ;

   #ifdef S4WRITE_DELAY
      LIST4 delayAvail ;   /* extra blocks to allow efficient delay-writing */
      char S4PTR *delayWriteBuffer ;
      char S4PTR *delayLargeBuffer ;
      CRITICAL_SECTION critical4optWrite ;
      int delayLargeBufferAvail ;
      int writeBufferActualAvail ;
   #endif

   #ifdef S4ADVANCE_READ
      char S4PTR *advanceLargeBuffer ;
      CRITICAL_SECTION critical4optRead ;
      #ifdef S4CBPP
         FILE4 S4PTR *advanceReadFile ;
      #else
         struct FILE4St S4PTR *advanceReadFile ;
      #endif
      int advanceLargeBufferAvail ;
      long advanceLargePos ;
      unsigned int advanceLargeLen ;
   #endif

   #ifdef S4CBPP
      FILE4 S4PTR    *writeFile ;
      FILE4 S4PTR    *readFile ;
   #else
      struct FILE4St S4PTR *writeFile ;        /* which file has the write buffer? */
      struct FILE4St S4PTR *readFile ;        /* which file has the write buffer? */
   #endif
} OPT4 ;

#endif /* S4OFF_OPTIMIZE */

#ifdef S4CBPP
class S4CLASS FILE4
{
public:
#else
typedef struct FILE4St
{
#endif
   #ifndef S4OFF_OPTIMIZE
      LINK4 link ;           /* set to 0 if file not optimized */
   #else
      LINK4 space2 ;
   #endif
   /* accessMode and isReadOnly both on indicate 'r' attribute on file */
   /* isReadOnly only on indicates user access is limited to read only */
   /* if accessMode, will do full bufferring, if isReadOnly, will avoid */
   /* performing any disk writes */

   char doAllocFree ;
   char isTemp ;             /* True if it is a temporary file */

   int hand ;
   int isReadOnly ;          /* True if file is read only */

   char S4PTR *nameBuf ;

   S4CONST char S4PTR *name ;

   #ifdef S4CBPP
      CODE4 S4PTR *codeBase ;
   #else
      S4CONV( struct CODE4St *codeBase, struct CODE4St *code_base ) ;
   #endif

   #ifndef S4OFF_MULTI
      int lowAccessMode ;       /* open access level */
   #else
      int space25 ;
   #endif

   #ifndef S4OFF_OPTIMIZE
      char fileCreated ;     /* false if the file has not been created yet - i.e. if a memory-only file */
      char  writeBuffer ;    /* buffer writes where possible */
      long  hashInit ;
      long  len ;            /* internal if optimized */
      char  type ;           /* dbf, index, other */
      char  bufferWrites ;   /* are writes being bufferred? */
      int   doBuffer ;       /* is the file bufferring on? */
      long  expectedReadSize ;  /* record length */
      double hitCountAdd ;
      const void *ownerPtr ;        /* points to DATA4/INDEX4 which holds file handle */
   #else
      char  space1 ;
      long  space3 ;
      long  space4 ;
      char  space5 ;
      char  space6 ;
      int   space7 ;
      long  space11 ;
      double space12 ;
      const void *space13 ;
   #endif


   #ifdef S4MULTI_THREAD
      CRITICAL_SECTION critical4file ;
   #endif

   #ifdef S4WRITE_DELAY
      LIST4 delayWriteFileList ;
   #endif

   #ifdef S4READ_ADVANCE
      LIST4 advanceReadFileList ;
      char *advanceReadBuf ;        /* a buffer for advanced-reading */
      int advanceReadBufStatus ;    /* the status of the advance-read buffer */
                                    /* AR4EMPTY, AR4IN_USE, AR4FULL */
      long advanceReadBufPos ;
      unsigned advanceReadBufLen ;
   #endif

   #ifdef E4ANALYZE_ALL
      char dupName[L_tmpnam] ;
      int hasDup ;
      int inUse ;
   #else
      char *space8 ;
      int space9 ;
      int space10 ;
   #endif
#ifdef S4CBPP
} ;
#else
} FILE4 ;
#endif

#ifdef S4WRITE_DELAY
typedef void S4PTR * S4DELAY_PARM ;
typedef void S4CALL S4DELAY_FUNCTION( S4DELAY_PARM ) ;

typedef struct
{
   LINK4 link ;
   LINK4 fileLink ;    /* for the given file, all links on delay-chain */
   FILE4 *file ;
   const char *data ;
   long pos ;
   unsigned int len ;
   int usageFlag ;
   int status ;

   S4DELAY_FUNCTION *completionRoutine ;
   void *completionData ;   /* routine-specific data for use in completion routine */
} FILE4WRITE_DELAY ;
#endif

#ifdef S4READ_ADVANCE
typedef void S4PTR * S4ADVANCE_PARM ;
typedef void S4CALL S4ADVANCE_FUNCTION( S4ADVANCE_PARM ) ;

typedef struct
{
   LINK4 link ;
   LINK4 fileLink ;    /* for the given file, all links on delay-chain */
   FILE4 *file ;
   char *data ;
   long pos ;
   unsigned int len ;
   int usageFlag ;
   unsigned int status ;

   S4ADVANCE_FUNCTION *completionRoutine ;
   void *completionData ;   /* routine-specific data for use in completion routine */
} FILE4ADVANCE_READ ;
#endif

typedef struct S4CLASS
{
   /* structure must remain fixed positions */
   long transId ;
   long clientId ;
   long clientDataId ;
   long serverDataId ;
   short int type ;
   unsigned long dataLen ;
   time_t    time ;
} LOG4HEADER ;

typedef struct S4CLASS TRAN4St
{
   /* transaction capabilities for a client */
   struct CODE4TRANSSt *c4trans ;
   LIST4 *dataList ;        /* A list of open data files. */
   LIST4 localDataList ;
   char dateFormat[LEN4DATE_FORMAT];          /* Longest is September 15, 1990 */

   #ifndef S4OFF_WRITE
      int currentTranStatus ;  /* is there a current transaction? */
   #else
      int space1 ;
   #endif
   #ifndef S4OFF_MULTI
      int unlockAuto ;        /* automatic unlocking on or off? */
      int savedUnlockAuto ;
      LIST4 locks ;           /* list of Lock4's */
   #else
      int space2 ;
      int space3 ;
      LIST4 space4 ;
   #endif

   #ifndef S4OFF_WRITE
      /* given transaction details */
      long       transId ;
      long       pos ;       /* used during examination processing */
      LOG4HEADER header ;
      unsigned   dataPos ;
/*      char      *charId ;*/
   #else
      long       space6 ;
      long       space7 ;    /* used during examination processing */
      LOG4HEADER space8 ;
      char      *space9 ;    /* used during transaction writing and examination processing */
      unsigned   space10 ;
      unsigned   space11 ;
      char      *space12 ;
   #endif

   #ifdef S4STAND_ALONE
      int userIdNo ;    /* used to determine the id of user */
   #endif

   LIST4 closedDataFiles ;  /* during a transaction */
   #ifdef S4CLIENT
      int dataIdCount ;    /* client keeps an id on each data4 */
   #else
      char userId[LEN4USERID+1] ;
      char netId[LEN4NETID+1] ;
   #endif
} TRAN4 ;

typedef struct S4CLASS CODE4TRANSSt
{
   #ifdef S4CBPP
      CODE4 S4PTR *c4 ;
   #else
      struct CODE4St *c4 ;
   #endif

   #ifndef S4OFF_TRAN
      int enabled ;
      #ifndef S4OFF_WRITE
         #ifndef S4CLIENT
            struct TRAN4FILESt *transFile ;
         #else
            struct TRAN4FILESt *space1 ;
         #endif
      #else
         struct TRAN4FILESt *space1 ;
      #endif
   #else
      int space2 ;
      struct TRAN4FILESt *space1 ;
   #endif
   #ifndef S4SERVER
      TRAN4 trans ;
   #else
      TRAN4 space3 ;
   #endif
} CODE4TRANS ;

typedef struct TRAN4FILESt
{
   long   transId ;
   long   validState ;    /* true/false switch */
   unsigned long fileLocks ;   /* bit encoded, bit i == byte TRAN4LOCK_BASE+i locked */
   FILE4  file ;
   int status ;

   CODE4TRANS *c4trans ;
} TRAN4FILE ;

#ifndef S4OFF_CATALOG
typedef struct CATALOG4St
{
   struct DATA4St *data ;
   int valid ;
   int catalogAdd ;
   int catalogStatus ;
   struct FIELD4St *ownerFld, *aliasFld, *pathNameFld, *typeFld, *readOnlyFld,
                    *indexOpenFld, *createFld, *openModeFld, *logFld ;
   struct TAG4St *aliasTag, *pathTag ;
} CATALOG4 ;
#endif

#ifdef S4CBPP
class S4CLASS CODE4
{
public:
#else
typedef struct CODE4St
{
#endif
   /* documented members... (except ifdef'ed ones) */

   S4CONV( int autoOpen, int auto_open ) ;               /* Automatic production index file opening */
   int createTemp ;                                      /* create files as temporary ? */
   S4CONV( int errCreate, int create_error ) ;           /* Do 'file4create' error ? */
   S4CONV( int errDefaultUnique, int default_unique_error ) ; /* e4unique, r4unique, r4uniqueContinue */
   S4CONV( int errExpr, int expr_error ) ;
   S4CONV( int errFieldName, int field_name_error ) ;
   S4CONV( int errOff, int off_error ) ;                 /* Show error messages? */
   S4CONV( int errOpen, int open_error ) ;               /* Do 'file4open' error ? */
   S4CONV( int errorCode, int error_code ) ;
   #ifdef S4WIN32 /* documented member */
      void S4PTR *hWnd;            /* For use under Microsoft Windows */
   #else
      unsigned hWnd ;              /* For use under Microsoft Windows */
   #endif
   int log ;
   S4CONV( int memExpandData, int mem_expand_data ) ;          /* Expanding data allocation */
   S4CONV( unsigned memSizeBuffer, unsigned mem_size_buffer ) ;/* Pack, Zap */
   S4CONV( unsigned memSizeSortBuffer, unsigned mem_size_sort_buffer ) ; /* The default file buffer size when sorting */
   S4CONV( unsigned memSizeSortPool, unsigned mem_size_sort_pool ) ;   /* The default pool size for sorting */
   S4CONV( unsigned memStartData, unsigned mem_start_data ) ;      /* Initial data allocation */
   S4CONV( int readOnly, int read_only ) ;
   int safety ;                                          /* File create with safety ? */
   long timeout ;
   short int compatibility ;                                   /* FoxPro compatibility with... 25, 26, 30 */

   /* undocumented members... */

   int s4cr2 ;                                            /* used by CodeReporter */

   int initialized ;                                      /* only allow a single initUndo */
   long errorCode2 ;
   int numericStrLen ;                                    /* the default length for clipper index files */
   int decimals ;                                         /* the default # decimals for clipper index files */

   int memExpandDataFile ;
   unsigned memStartDataFile ;

   unsigned exprBufLen ;        /* for exprWorkBuf */
   unsigned storedKeyLen ;      /* for storedKeu */
   unsigned bufLen ;            /* for fieldBuffer */

   char S4PTR *exprWorkBuf ;    /* used by expression parsing */
   char S4PTR *storedKey ;      /* used by the expr4key() function */
   char S4PTR *fieldBuffer ;
   char S4PTR *version ;

   char indexExtension[4] ;

   MEM4 S4PTR *bitmapMemory ;
   MEM4 S4PTR *dataMemory ;
   S4CONV( MEM4 S4PTR *calcMemory, MEM4 S4PTR *calc_memory ) ;
   MEM4 S4PTR *data4fileMemory ;
   MEM4 S4PTR *relateDataListMemory ;  /* for R4DATA_LIST */
   MEM4 S4PTR *relateListMemory ;  /* for RELATE4LIST */
   MEM4 S4PTR *relateMemory ;
   MEM4 S4PTR *relationMemory ;
   MEM4 S4PTR *dataListMemory ;  /* for DATA4LIST */

   LIST4 availMessages ;        /* list of available message buffers */
   LIST4 dataFileList ;         /* A list of open data files. */

   FILE4 *errorLog ;             /* log file for error messages */

   int collatingSequence ;   /* the collating sequence to use when creating a VFP tag */
   int codePage ;            /* the codepage to use when creating a database file */

   #ifdef S4COMPILE_TEST
      #ifndef S4OFF_MULTI
         S4CONV( int accessMode, int exclusive ) ;             /* how should files be opened? */
         int memExpandLock ;       /* Expanding lock memory allocation */
         unsigned memStartLock ;   /* Initial lock memory allocation record locks */
         int lockAttemptsSingle ;                               /* How many times to attempt each lock in a group lock */
         unsigned int lockDelay ;
         int fileFlush ;  /* force hard file flush during write */
         S4CONV( int readLock, int read_lock ) ;               /* Do lock when reading database ? */
         S4CONV( int lockAttempts, int lock_attempts ) ;        /* How many times to attempt locks. */
         MEM4 S4PTR *lockMemory ;
         MEM4 S4PTR *lockLinkMemory ;
      #endif
      #ifndef S4OFF_OPTIMIZE
         S4CONV( int optimizeWrite, int optimize_write ) ;
         S4CONV( unsigned memSizeBlock, unsigned mem_size_block ) ;  /* Block size (bytes) for memo and index files */
         int optimize ;            /* should files be automatically bufferred? */
         int memMaxPercent ;
         S4CONV( long memStartMax, long mem_start_max ) ;
      #endif
      #ifndef S4OFF_INDEX
         #ifdef S4OFF_OPTIMIZE
            S4CONV( unsigned memSizeBlock, unsigned mem_size_block ) ;  /* Block size (bytes) for memo and index files */
         #endif
         S4CONV( int errTagName, int tag_name_error ) ;
         S4CONV( int memExpandBlock, int mem_expand_block ) ;        /* Expanding block memory allocation */
         S4CONV( int memExpandIndex, int mem_expand_index ) ;        /* Expanding index allocation */
         S4CONV( int memExpandTag, int mem_expand_tag ) ;            /* Expanding tag allocation */
         S4CONV( unsigned memStartBlock, unsigned mem_start_block ) ;     /* Initial block memory allocation for index files */
         S4CONV( unsigned memStartIndex, unsigned mem_start_index ) ;     /* Initial index file allocation */
         S4CONV( unsigned memStartTag, unsigned mem_start_tag ) ;       /* Initial tag allocation */
         int memExpandTagFile ;
         unsigned memStartTagFile ;
         MEM4 S4PTR *indexMemory ;
         MEM4 S4PTR *index4fileMemory ;
         MEM4 S4PTR *tagMemory ;
         MEM4 S4PTR *tagFileMemory ;
      #endif
      #ifndef S4OFF_MEMO
         S4CONV( unsigned memSizeMemo, unsigned mem_size_memo ) ;
         S4CONV( unsigned memSizeMemoExpr, unsigned mem_size_memo_expr ) ;
      #endif
      #ifndef S4OFF_TRAN
         int doTrans ;                                         /* Maintain a transaction file? */
      #endif
   #else
      S4CONV( int accessMode, int exclusive ) ;             /* how should files be opened? */
      int memExpandLock ;       /* Expanding lock memory allocation */
      unsigned memStartLock ;   /* Initial lock memory allocation record locks */
      int lockAttemptsSingle ;                               /* How many times to attempt each lock in a group lock */
      unsigned int lockDelay ;
      int fileFlush ;  /* force hard file flush during write */
      S4CONV( int readLock, int read_lock ) ;               /* Do lock when reading database ? */
      S4CONV( int lockAttempts, int lock_attempts ) ;        /* How many times to attempt locks. */
      MEM4 S4PTR *lockMemory ;
      MEM4 S4PTR *lockLinkMemory ;
      S4CONV( int optimizeWrite, int optimize_write ) ;
      int optimize ;            /* should files be automatically bufferred? */
      int memMaxPercent ;
      S4CONV( long memStartMax, long mem_start_max ) ;
      S4CONV( unsigned memSizeBlock, unsigned mem_size_block ) ;  /* Block size (bytes) for memo and index files */
      S4CONV( int errTagName, int tag_name_error ) ;
      S4CONV( int memExpandBlock, int mem_expand_block ) ;        /* Expanding block memory allocation */
      S4CONV( int memExpandIndex, int mem_expand_index ) ;        /* Expanding index allocation */
      S4CONV( int memExpandTag, int mem_expand_tag ) ;            /* Expanding tag allocation */
      S4CONV( unsigned memStartBlock, unsigned mem_start_block ) ;     /* Initial block memory allocation for index files */
      S4CONV( unsigned memStartIndex, unsigned mem_start_index ) ;     /* Initial index file allocation */
      S4CONV( unsigned memStartTag, unsigned mem_start_tag ) ;       /* Initial tag allocation */
      int memExpandTagFile ;
      unsigned memStartTagFile ;
      MEM4 S4PTR *indexMemory ;
      MEM4 S4PTR *index4fileMemory ;
      MEM4 S4PTR *tagMemory ;
      MEM4 S4PTR *tagFileMemory ;
      S4CONV( unsigned memSizeMemo, unsigned mem_size_memo ) ;
      S4CONV( unsigned memSizeMemoExpr, unsigned mem_size_memo_expr ) ;
      int doTrans ;                                         /* Maintain a transaction file? */
   #endif

   #ifdef E4ANALYZE
      int debugInt ;               /* used to check structure integrity (set to 0x5281) */
   #else
      #ifdef S4VBASIC
         int debugInt ;
      #else
         int space1 ;
      #endif
   #endif
   #ifndef N4OTHER
      unsigned memStartIndexFile ; /* Initial index file allocation */
      int memExpandIndexFile ;  /* Expanding index file allocation */
   #else
      unsigned space4 ;
      int space5 ;
   #endif
   #ifndef S4DOS
      #ifdef S4WIN32
         void S4PTR *hInst ;
         void S4PTR *hInstLocal ;
      #else
         unsigned hInst ;
         unsigned hInstLocal ;
      #endif
      char protocol[LEN4PROTOCOL+1] ;
   #else
      #ifdef S4WIN32
         void S4PTR *space6 ;
         void S4PTR *space7 ;
      #else
         unsigned space6 ;
         unsigned space7 ;
      #endif
      char space8[LEN4PROTOCOL+1] ;
   #endif

   #ifndef S4OFF_WRITE
      char *transFileName ;
   #else
      char *space47 ;
   #endif
   #ifndef S4OFF_CATALOG
      #ifndef S4CLIENT
         CATALOG4 S4PTR *catalog ;
      #else
         void S4PTR *space48 ;
         int space49 ;
         int space50 ;
      #endif  /* S4CLIENT */
   #else
      void S4PTR *space48 ;
      int space49 ;
      int space50 ;
   #endif  /* S4OFF_CATALOG */

   #ifndef S4OFF_COMMUNICATIONS
      MEM4 S4PTR *messageLinkMemory ;
      MEM4 S4PTR *connectionMemory ;
      MEM4 S4PTR *connectionNetMemory ;
      LIST4 availDataMessages ;
      #ifdef S4DISTRIBUTED
         LIST4 servers ;       /* list of connected servers */
      #else
         LIST4 space51 ;
      #endif
      struct SOCKET4St S4PTR *defaultServer ;
      /* LIST4 passwordList ; */
   #else
      MEM4 S4PTR *space52 ;
      MEM4 S4PTR *space52b ;
      MEM4 S4PTR *space52c ;
      LIST4 space53 ;
      LIST4 space55 ;
      void S4PTR *space56 ;
   #endif

   #ifndef S4OFF_TRAN
      char *tranData ;   /* buffer used to hold transaction entries */
      unsigned int tranDataLen ;  /* length of transaction entry buffer */
   #else
      char *space57 ;
      unsigned int space58 ;
   #endif

   #ifdef S4MNDX
      char *memoUseBuffer ;
   #else
      char S4PTR *space16a ;
   #endif

   #ifndef S4OFF_OPTIMIZE
      OPT4 opt ;
      int hasOpt, doOpt, hadOpt ;
   #endif

   #ifdef S4STAND_ALONE
      #ifndef S4OFF_TRAN
         #ifndef S4OFF_WRITE
            TRAN4FILE transFile ;
            int logOpen ;
         #endif
      #endif
   #endif

   #ifdef S4WRITE_DELAY
      int delayWritesEnabled ;
      CRITICAL_SECTION critical4delayWriteList ;
      LIST4 delayWriteList ;
      MEM4 S4PTR *delayWriteMemory ;
      long uninitializeDelayWrite ;   /* request to uninitialize delay-writes */
      HANDLE initUndoDelayWrite ;    /* event for delay-write thread to notify main
                                       thread that uninitialization is complete */
      HANDLE pendingWriteEvent ;    /* event to notify delay-write thread that
                                       there is an action to perform */
   #endif

   #ifdef S4READ_ADVANCE
      int advanceReadsEnabled ;
      CRITICAL_SECTION critical4advanceReadList ;
      LIST4 advanceReadList ;
      MEM4 S4PTR *advanceReadMemory ;
      HANDLE initUndoAdvanceRead ;
      long uninitializeAdvanceRead ;
      HANDLE pendingReadEvent ;
   #endif

   #ifdef S4SERVER
      int singleClient ;
      int displayErrors ;
      int readOnlyRequest ;
      unsigned memStartClient ;
      unsigned memExpandClient ;
      struct SERVER4CLIENTSt S4PTR *catalogClient ;
      MEM4 S4PTR *clientMemory ;
      struct SERVER4St S4PTR *server ;
      struct SERVER4CLIENTSt S4PTR *currentClient ;

      #ifdef N4OTHER
         int doRemove ;
      #else
         int doRemoveSpace ;
      #endif

      #ifdef S4DEBUG_LOG
         char S4PTR *logFileName ;
         FILE4 logFile ;
         int log ;
      #endif
      #ifndef S4OFF_SECURITY
         int idhandling ;
      #endif
   #else
      /* singleOpen can take 0,1, or 2, but only 0 and 1 are documented -OPEN4 modes */
      int singleOpen ;      /* only one instance of a DATA4 allowed (as opposed to exclusive which is access for client) */
      S4CONV( int errGo, int go_error ) ;                   /* Do 'd4go' error ? */
      S4CONV( int errRelate, int relate_error ) ;         /* do relate4terminate error when no match and relate4terminate selected */
      S4CONV( int errSkip, int skip_error ) ;           /* Do 'DataIndex::skip' error ? */
      int lockEnforce ;         /* are pre-locks required for record modifications? */

      int doRemove ;
      const char *lockedNetId ;
      const char *lockedUserId ;
      const char *lockedFileName ;
      long lockedLockItem ;

      CODE4TRANS c4trans ;
      S4CONV( MEM4 S4PTR *totalMemory, MEM4 S4PTR *total_memory ) ;
      S4CONV( LIST4 calcList, LIST4 calc_list ) ;
      S4CONV( LIST4 totalList, LIST4 total_list ) ;
      S4CONV( int numReports, int num_reports ) ;
      short pageno ;
      long clientDataCount ;
   #endif

   #ifdef S4CLIENT
      int indexFormat ;
      int openForCreate ;
   #else
      int doIndexVerify ;       /* for internal purposes only at this point */
      struct RELATION4St S4PTR *currentRelation ;
      char savedKey[I4MAX_KEY_SIZE + 2 * sizeof(long)] ;       /* used by i4remove.c, i4tag.c and i4addtag.c, i4versionCheck, t4versionCheck */
   #endif

   #ifdef S4OPTIMIZE_STATS
      struct DATA4St *statusDbf ;
      struct FIELD4St *typeFld, *fileNameFld, *offsetFld, *lengthFld ;
   #endif
#ifdef S4CBPP
} ;
#else
} CODE4 ;
#endif

#ifndef S4OFF_MEMO
typedef struct
{
   FILE4     file ;
   short      blockSize ;               /* Bytes */
   struct DATA4FILESt  S4PTR *data ;
   #ifndef S4OFF_MULTI
      int fileLock ;                  /* True if file is locked */
   #else
      int space1 ;
   #endif
} MEMO4FILE ;
#endif /* S4OFF_MEMO */

#ifdef S4CBPP
class S4CLASS FILE4SEQ_READ
{
public:
#else
typedef struct
{
#endif
   FILE4 S4PTR *file ;

   long  pos ;          /* The next position to read from */
   char S4PTR *buffer ;
   unsigned nextReadLen ;
   unsigned total ;     /* Total buffer length */
   unsigned working ;   /* Temporary working buffer length (to help align write) */
   unsigned avail ;     /* # of bytes currently available */
   #ifdef S4ADVANCE_READ
      int doAdvance ;
      char S4PTR *buf1 ;
      char S4PTR *buf2 ;
      unsigned int buf1status, buf2status ;
      int buf1avail ;
      int buf2avail ;
   #endif
#ifdef S4CBPP
} ;
#else
} FILE4SEQ_READ ;
#endif

#ifdef S4CBPP
class S4CLASS FILE4SEQ_WRITE
{
public:
#else
typedef struct
{
#endif
   FILE4 S4PTR *file ;

   long  pos ;          /* The next position to read from */
   char S4PTR *buffer ;
   unsigned total ;     /* Total buffer length */
   unsigned working ;   /* Temporary working buffer length (to help align write) */
   unsigned avail ;     /* # of bytes left in working buffer */
   #ifdef S4WRITE_DELAY
      char S4PTR *buf1 ;
      char S4PTR *buf2 ;
      unsigned buf1len ;
      unsigned buf2len ;
      int buf1avail ;
      int buf2avail ;
   #endif
#ifdef S4CBPP
} ;
#else
} FILE4SEQ_WRITE ;
#endif

typedef struct  /* Data File Format */
{
   char name[11] ;
   char type ;
   S4LONG offset ;    /* field's offset into record buffer (for vfp 3.0) */
   unsigned char len ;
   unsigned char dec ;
   #ifdef S4CLIENT_OR_FOX
      char nullBinary ;    /* for FOX 3.0 0x02 == allows null fields, 0x04 == binary field */
      char filler2[12] ;
   #else
      char filler2[13] ;
   #endif
   char hasTag ;
} FIELD4IMAGE ;

typedef struct
{
   unsigned short int lo[4] ;
/*   signed short int hi ;     significant bit in this field */
} CURRENCY4 ;

typedef struct FIELD4St /* Internal Structure and Field Routines. */
{
   char name[11] ;
   unsigned short int len ;
   unsigned short int dec ;
   short int type ;
   short int offset ;
   struct DATA4St S4PTR *data ;

   #ifdef S4CLIENT_OR_FOX
      char null ;
      unsigned short int nullBit ;   /* bit which indicates whether field contents currently are null */
      char binary ;
   #endif
   #ifndef S4OFF_MEMO
      struct F4MEMOSt S4PTR *memo ;
   #endif
   #ifdef S4VBASIC
      short int debugInt ;         /* used to check structure integrity (set to 0x5281) */
   #else
      short int space1 ;
   #endif
} FIELD4 ;

#ifndef S4OFF_MEMO
typedef struct F4MEMOSt
{
   S4CONV( int isChanged, int is_changed ) ;
   int status ;           /* 0 - Current contents, 1 - Unknown */
   char  S4PTR *contents ;
   unsigned int len ;
   S4CONV( unsigned int lenMax, unsigned int len_max ) ;
   FIELD4  S4PTR *field ;
} F4MEMO ;
#endif

typedef struct  /* Creating Data File */
{
   char S4PTR *name ;
   short int type ;
   unsigned short int len ;
   unsigned short int dec ;
   unsigned short int nulls ;  /* are nulls allowed? */
} FIELD4INFO ;

#ifdef S4SERVER
typedef struct
{
   char append ;
   char delet ;
   char update ;
   char index ;
   char alter ;
   char refer ;
   char compress ;
   char read ;
   char open ;    /* virtual field */
} AUTHORIZE4 ;
#endif

typedef struct
{
   /* Database Header Information */
   char     version ;
   char     yy ;             /* Last Update */
   char     mm ;
   char     dd ;
   S4LONG   numRecs ;
   unsigned short headerLen; /* Header Length, Indicates start of data */
   unsigned short recordLen;
   char     zero[16] ;
   char     hasMdxMemo ;    /* 0x01 for has mdx, in fox 0x02 for has memo */
   char     codePage ;
   char     zero2[2] ;
} DATA4HEADER_FULL ;

typedef struct DATA4FILESt
{
   LINK4 link ;

   S4CONV( unsigned int recWidth, unsigned int record_width ) ;

   unsigned short int infoLen ;

   int nFields ;         /* The number of data fields in the database */
   int nFieldsMemo ;     /* The number of memo fields in the database */

   long minCount ;
   long userCount ;      /* number of DATA4's that are using this DATA4FILE */

   CODE4 S4PTR *c4 ;
   char S4PTR *info ;

   #ifndef S4CLIENT
      char S4PTR *record ;
   #else
      char S4PTR *space1 ;
   #endif

   #ifndef S4OFF_WRITE
      int doDate ;    /* does the date need to be updated on unlock/close? */
   #endif

   /**** the next set of lines must remain in order as they are a file view ****/
   /* Database Header Information */
   char version ;
   #ifndef S4CLIENT
      char     yy ;             /* Last Update */
      char     mm ;
      char     dd ;
   #else
      char space3 ;
      char space4 ;
      char space5 ;
   #endif
   S4LONG   numRecs ;
   unsigned short headerLen ; /* Header Length, Indicates start of data */
   /**** the previous set of lines must remain in order as they are a file view ****/

   #ifdef S4SERVER
      struct SERVER4CLIENTSt S4PTR *singleClient ;   /* only one client has access to the file */
      time_t    nullTime ;   /* The last time the datafile had 0 handles, if any */
   #else
      void S4PTR *space6 ;
      time_t space7 ;
   #endif
   #ifdef S4CLIENT
      struct DATA4St S4PTR *fileLock ;
      struct DATA4St S4PTR *appendLock ;
      struct DATA4St S4PTR *lockTest ;
   #else
      struct DATA4St S4PTR *space9 ;
      struct DATA4St S4PTR *space10 ;
   #endif

   #ifdef S4CLIENT
      char accessName[LEN4PATH+1] ;
      LIST4 lockedRecords ;
      struct CONNECTION4St S4PTR *connection ;
      long serverId ;
      int accessMode ;
   #endif
   #ifndef S4CLIENT
      FILE4    file ;
      char hasMdxMemo ;        /* Has an MDX and/or a memo file attached to it */

      int fileChanged ;   /* True if the file has been changed since */
                                /* the header has been updated. */
      short    blockSize ;
      #ifndef S4OFF_MEMO
         MEMO4FILE   memoFile ;   /* Memo file handle */
      #endif

      int tranStatus ;   /* is this data4file using transactions? */
      char valid ;    /* if valid, a close on a datafile will not low-close it */
      #ifndef S4OFF_MULTI
         #ifdef S4SERVER
            struct DATA4St *exclusiveOpen ;
         #endif
         LIST4    lockedRecords ; /* list of LOCK4's */
         long fileServerLock ;    /* which data holds file lock */
         long fileClientLock ;    /* which data holds file lock */
         long appendClientLock ;  /* True if the file is locked for appending */
         long appendServerLock ;  /* True if the file is locked for appending */

         long tempServerLock ;    /* for lock registering */
         long tempClientLock ;    /* for lock registering */
      #endif
   #endif  /* S4CLIENT */

   #ifndef S4OFF_OPTIMIZE
      int hiPrio ;   /* used to determine which priority lru list to put block data on and advance group-reads */
                     /* '1' if d4seek, -1 if d4skip */
   #endif

   #ifdef S4STAND_ALONE
      char openMdx ;       /* does the datafile have an open production file attatched to it */
   #endif

   #ifdef N4OTHER
      LIST4 tagfiles ;
      unsigned long indexLocked ;
   #else
      LIST4    indexes ;        /* list of INDEX4FILE;s */
      unsigned long space99 ;
   #endif
} DATA4FILE ;

typedef struct DATA4St
{
   LINK4 link ;

   #ifdef S4SERVER
      int accessMode ;              /* in what mode did the client open the data file */
   #endif
   int bofFlag ;
   int eofFlag ;
   int readOnly ;
   S4CONV( int recordChanged, int record_changed ) ; /* T/F */
   S4LONG count ;                /* a fairly current record count on the database */
   S4CONV( S4LONG recNum, S4LONG rec_num ) ;               /* Record number; -1 unknown; 0 for append */
   S4LONG recNumOld ;            /* Record number, -1 none present; 0 for append */

   char S4PTR *groupRecordAlloc ;   /* if the current and old record allocations
                                       allocated at the same time? */
   char S4PTR *record ;          /* Data allocated with 'u4alloc' */
   char S4PTR *recordOld ;       /* Data allocated with 'u4alloc' */
                                 /* Extra byte added for temporary CTRL_Z */
   char alias[LEN4DATA_ALIAS+1] ;

   S4CONV( CODE4 S4PTR *codeBase, CODE4 S4PTR *code_base ) ;

   TRAN4 S4PTR *trans ;

   FIELD4  S4PTR *fields ;       /* An array of field pointers */

   LIST4 indexes ;               /* list of INDEX4's */

   struct TAG4St *tagSelected ;

   int    codePage ;

   DATA4FILE *dataFile ;

   #ifndef S4OFF_MEMO
      S4CONV( F4MEMO S4PTR *fieldsMemo, F4MEMO S4PTR *fields_memo ) ;    /* A list of fields to be flushed */
      #ifndef S4OFF_MULTI
         char memoValidated ; /* Can we be sure memo id #'s are up to date. */
      #endif
   #endif

   #ifndef S4OFF_TRAN
      #ifndef S4CLIENT
         int logVal ;
      #endif
   #endif

   #ifdef S4VBASIC
      int debugInt ;      /* used to check structure integrity (set to 0x5281) */
   #endif

   #ifdef S4SERVER
      long clientId ;
      long serverId ;
      #ifndef S4OFF_SECURITY
         int owner ;     /* set to true if the DATA4 is owner of the table */
         AUTHORIZE4 authorize ;
      #endif
   #else
      long clientId ;
   #endif
} DATA4 ;

typedef void S4OPERATOR(void) ;

/* NOTE: IT IS CRITICAL THAT THE FOLLOWING STRUCTURE'S MEMBERS ARE NOT
   RE-ORDERED. */
typedef struct E4INFOSt
{
   short int fieldNo ;   /* field no in data structure -- since FIELD4 may be transient */
   FIELD4 S4PTR *fieldPtr ;
   int localData ;       /* true if the fieldPtr points to a local data4 */
   char S4PTR *p1 ;
   int len ;         /* Length */
   int numEntries ; /* Number of entries in sub-expression */
   int numParms ;
   int resultPos ;  /* The position in the result array for result. */
   int i1 ;          /* Could be constant position. 'i1' and 'resultPos'
                       and 'functionI' and 'function'
                       must be at last position due to memcmp() in e4isTag() */
   int functionI ;
   S4OPERATOR S4PTR *function ;
} E4INFO ;

typedef struct e4exprSt
{
   E4INFO S4PTR *info ;
   int infoN ;
   S4CONST char S4PTR *source ;
   char S4PTR *constants ;
   int len, type ;
   struct TAG4FILESt S4PTR *tagPtr ;
   #ifdef S4FOX
      struct T4VFPSt S4PTR *vfpInfo ;
   #else
      void S4PTR *space1 ;
   #endif
   DATA4 S4PTR *data ;
   DATA4FILE S4PTR *dataFile ;
   S4CONV( CODE4 S4PTR *codeBase, CODE4 S4PTR *code_base ) ;

   unsigned int lenEval ;     /* This is the length of the buffer needed for evaluation. */
   int numParms ;    /* This is the # of parameter positions used in evaluation. */
   char hasTrim ;    /* special case for key evaluation */
   #ifdef S4CLIPPER
      int keyDec, keyLen ;   /* used for CLIPPER version */
   #endif
} EXPR4 ;

#ifndef S4CLIENT

#ifdef N4OTHER
   typedef struct
   {
      long  pointer ;    /* =0L if record, not pointer */
      long  num ;
      unsigned char  value[1] ;  /* The key size is variable */
   } B4KEY_DATA ;
#else
   typedef struct
   {
      S4LONG num ;
      unsigned char  value[1] ;  /* The key size is variable */
   } B4KEY_DATA ;
#endif

#ifdef S4FOX
/* the following structure is used only on the leaf nodes of the tree structure */
typedef struct
{
   short            freeSpace ;        /* # bytes available in node */
   unsigned char    recNumMask[4] ;      /* record number mask */
   unsigned char    dupByteCnt ;      /* duplicate byte mask count */
   unsigned char    trailByteCnt ;    /* Trailing byte mask count */
   unsigned char    recNumLen ;       /* # bits used for record number */
   unsigned char    dupCntLen ;       /* # bits used for duplicate count */
   unsigned char    trailCntLen ;     /* # bits used for trail count */
   unsigned char    infoLen ;          /* # bytes for holding record number, */
} B4NODE_HEADER ;

typedef struct
{
   short      nodeAttribute ;    /* 0=index, 1=root, 2=leaf */
   short      nKeys ;            /* Block Image starts here */
   S4LONG     leftNode ;         /* -1 if not present */
   S4LONG     rightNode ;        /* -1 if not present */
} B4STD_HEADER ;

typedef struct
{
   LINK4 link ;
   struct TAG4FILESt  S4PTR *tag ;

   int changed ;
   S4LONG  fileBlock ;     /* Identifies block within index file */
   int keyOn ;         /* The current key within the block */
   int curTrailCnt ;  /* current value used for seeking */
   int curDupCnt ;    /* current value used for seeking */
   int dupPos ;        /* bit offset into the info for the duplicate data */
   int trailPos ;      /* bit offset into the info for the trail data */
   int recPos ;        /* bit offset into the info for the record # data */
   char  *curPos ;       /* current position into the data (starts at end) */

   int builtOn ;       /* the 'current' key value (i.e. key really 'on') */
   char  S4PTR *builtPos ;     /* position where built on */
   B4KEY_DATA S4PTR *builtKey ;

   B4STD_HEADER header ;
   B4NODE_HEADER nodeHdr ;    /* only if the block is a leaf */
   char  data[1] ;        /* the remaining data */
} B4BLOCK ;

#endif  /* ifdef S4FOX  */

#ifndef S4FOX

#ifdef S4NDX
   typedef struct
   {
      long     root ;
      long     eof ;
      char     n1dummy ;
      char     type ;
      char     n2dummy[2] ;
      short    keyLen  ;
      short    keysMax ;           /* Maximum # of keys per block;  <= 100 */
      short    intOrDate ;        /* TRUE (1) if Numeric or Date Key */
      short    groupLen ;          /* keyLen plus 8 increased to a multiple of 2 */
      short    dummy ;
      short    unique ;             /* TRUE if Unique */

 /*   char     expression[256] ; */
 /*   long     version ; */
   } I4IND_HEAD_WRITE;
#else
   #ifdef S4CLIPPER
      typedef struct
      {
         short          sign ;
         short          version ;
         long           root ;          /* Root Block */
         long           eof ;           /* First Free Block Pointer */
         short          groupLen ;     /* Key Length + 2*sizeof(long) */
         short          keyLen ;       /* Key Length */
         short          keyDec ;       /* Number of Decimals in Key */
         short          keysMax ;      /* Maximum # of keys per block;  <= 100 */
         short          keysHalf ;     /* Maximum # of keys per half block */

    /*   char           expression[256];   The index expression corresponding to the database. */
    /*   short          unique   ;         TRUE if Unique */
      } I4IND_HEAD_WRITE;
   #endif
#endif

#ifdef S4NDX
typedef struct
{
   S4LONG   oldVersion ;
   int headerOffset ;

   S4LONG   root ;
   S4LONG     eof ;
   char     n1dummy ;
   char     type ;
   char     n2dummy[2] ;
   short    keyLen  ;
   short    keysMax ;           /* Maximum # of keys per block;  <= 100 */
   short    intOrDate ;        /* TRUE (1) if Numeric or Date Key */
   short    groupLen ;          /* keyLen plus 8 increased to a multiple of 2 */
   short    dummy ;
   short    unique ;             /* TRUE if Unique */
/* char     expression[256] ; */
   S4LONG   version ;
}  T4HEADER ;
#else
   #ifdef S4CLIPPER
      typedef struct
      {
         short      oldVersion ;
         int headerOffset ;
         S4LONG     virtualEof ;   /* The next available file block */
         short      sign ;
         short      version ;
         S4LONG     root ;          /* Root Block */
         S4LONG     eof ;           /* First Free Block Pointer */
         short      groupLen ;     /* Key Length + 2*sizeof(long) */
         short      keyLen ;       /* Key Length */
         short      keyDec ;       /* Number of Decimals in Key */
         short      keysMax ;      /* Maximum # of keys per block;  <= 100 */
         short      keysHalf ;     /* Maximum # of keys per half block */
      /* char       expression[256] ;   The index expression corresponding to the database. */
         short      unique   ;      /* TRUE if Unique */
         short      descending ;     /* The descending flag corresponding to the index file */
      /* char       filter[256] ;   The filter(for) expression corresponding to the database. */
      }  T4HEADER ;
   #else
      typedef struct
      {
         char   two ;                /* Version number (currently 2) */
         char   yymmdd[3] ;          /* Date of last reindex */
         char   dataName[12] ;      /* Name of associated data file */
         char   dummy1[4] ;          /* extra 4 bytes for data-names-not used in DOS */
         short  blockChunks ;       /* Block Size 1 to 32 (512 byte chunks) */
         short  blockRw ;           /* Block Read/Write Size in bytes */
         char   isProduction ;      /* 1 if production index, else 0 */
         char   numSlots ;          /* number possible tags (48) */
         short  slotSize ;          /* number bytes/tag slot (32) */
         short  numTags ;
         short  dummy2 ;
         S4LONG eof ;
         S4LONG freeList ;          /* start of the free list */
         char   zero[4] ;
         char   createDate[3];      /* not used by CodeBase */
         char   blank ;
      }  I4HEADER ;
   #endif     /*   ifdef S4CLIPPER  */
#endif     /*   ifdef S4NDX   */
#endif     /*   ifndef S4FOX  */


#ifndef S4FOX
typedef struct
{
   LINK4 link ;
   struct TAG4FILESt  S4PTR *tag ;

   S4LONG  fileBlock ;  /* Identifies block within index file */
   int changed ;
   int keyOn ;      /* The current key within the block */

   short      nKeys ; /* Block Image starts here */
   #ifdef S4NDX
      char       dummy[2] ;
      B4KEY_DATA data ;
   #else
      #ifdef S4CLIPPER
         short pointers[( B4BLOCK_SIZE / 2 - 1 )] ;
         B4KEY_DATA S4PTR *data ;
      #else
         char       dummy[6] ;
         B4KEY_DATA info ;
      #endif
   #endif
} B4BLOCK ;

typedef struct
{
   S4LONG headerPos ;          /* Header position (in 512 byte chunks) */
   char  tag[10] ;
   short x1000 ;               /* used for dBASE/SQL expression type - dBASE only allowed for CBPP 1.0x */
   char  leftChld ;
   char  rightChld ;
   char  parent ;
   char  x2 ;
   char  indexType ;
   char  zeros[11] ;
} T4DESC ;
#endif     /* ifndef  S4FOX  */

#ifndef N4OTHER
typedef struct
{
#ifdef S4FOX
   S4LONG         root ;            /* -1 means unknown */
   S4LONG         freeList ;       /* start of the free list (-1 if none) */
   unsigned S4LONG version ;        /* used multi-user only */
   short          keyLen ;         /* Key Length */
   unsigned char  typeCode;        /* 0x01 Uniq; 0x08 For Clause; 0x32 Compact; 0x80 Compound */
   unsigned char  signature ;       /* unused */

/* char           dummy2[482] ;        unused */

   char           sortSeq[8] ;    /* collating sequence (ie GENERAL) */
   char           dummy3[4] ;
   short          descending   ;    /* 1 = descending, 0 = ascending */
   short          filterPos ;      /* not used, == to exprLen */
   short          filterLen ;      /* length of filter clause */
   short          exprPos ;        /* not used, == to 0  */
   short          exprLen ;        /* length of expression */
/* char           exprPool[512] ;  expression and filter pool */
#else
   S4LONG         root ;            /* -1 means unknown */
   char           dummy1[4] ;
   char           typeCode;        /* 0x10 Normal; 0x58 Uniq,Desc; 0x50 Uniq; 0x18 Desc */
   char           type ;            /* N,D, or C (F is type N)  */
   char           dummy2[2] ;
   short          keyLen ;
   short          keysMax ;        /* Maximum # of keys per block;  <= 100  */
   char           dummy3[2] ;       /* 1 if Numeric or Date Key (NDX only) */
   short          groupLen ;       /* keyLen plus 4 (MDX); plus 8 (NDX) */
   unsigned char  version ;
   char           dummy4 ;
   short          unique   ;        /* 0x4000 (TRUE)if Unique */

   /* Note, 'exprKey[220]' comes after 'unique' and */
   /*       'exprFilter[220]' comes at position 0x2FA */
#endif
}  T4HEADER ;

#ifdef S4FOX   /* info on codepage and collating sequence */
typedef struct T4VFPSt
{
   int              codePage ;    /* codepage of database file */
   int              sortType ;    /* collating seq of tag in index file */
   translatedChars  *tablePtr ;   /* points to translation table */
   compressedChars  *compPtr;     /* points to compressed char table */
   unsigned char    *cpPtr ;      /* points to codepage table */
} T4VFP ;
#endif
#endif   /*  ifndef N4OTHER  */

#endif   /*  ifdef S4CLIENT */

typedef struct TAG4FILESt
{
   LINK4   link ;
   #ifndef N4OTHER
      struct INDEX4FILESt S4PTR *indexFile ;
   #else
      void S4PTR *space1 ;
   #endif
   char    alias[LEN4TAG_ALIAS+1] ;
   CODE4 S4PTR *codeBase ;
   int debugInt ;  /* used to check structure integrity (set to 0x5281) */

   #ifdef N4OTHER
      int userCount ;
   #else
      int space2 ;
   #endif

   #ifdef S4CLIENT
      char S4PTR *exprPtr ;
      char S4PTR *filterPtr ;
      short int errUniqueHold ;
   #else
      EXPR4   S4PTR  *expr ;
      EXPR4   S4PTR  *filter ;
      S4CMP_FUNCTION *cmp ;
      C4STOK S4PTR   *stok ;        /* Conversion for 'seek' */
      C4DTOK S4PTR   *dtok ;        /* Conversion for 'seek' */
      #ifdef S4MDX
         char         hadKeys ;
      #else
         char         space3 ;
      #endif
      char            hasKeys ;

      LIST4           blocks ;
      LIST4           saved ;

      #ifdef S4FOX
         char         pChar ;
         T4VFP     vfpInfo ;
      #else
         char         space4 ;
         char         space5 ;     /* modify appropriately when above workaround is combined */
      #endif

      #ifdef S4CLIPPER
         S4LONG       checkEof ;     /* used for debug purposes to verify eof length */
      #else
         S4LONG       space6 ;
      #endif

      #ifdef N4OTHER
         FILE4 file ;
         S4LONG fileLocked ;
         MEM4 S4PTR *blockMemory ;
         #ifndef S4OFF_OPTIMIZE
            struct TAG4FILESt *readBlockTag ;    /* used for optimization -- is a block-read request occurring? */
         #endif
      #else
         FILE4        space7 ;
         S4LONG       space8 ;
         void S4PTR  *space9 ;
      #endif

      T4HEADER        header ;
      S4LONG          headerOffset ;     /* Offset in file to the tag's header info. */
      int rootWrite ;        /* True if 'header.root' needs to be written */
      int keyDec ;
      #ifdef S4FOX
         MEM4 *builtKeyMemory ;
      #endif
      #ifdef S4MDX
         S4LONG       changed ;
      #endif
      #ifdef S4UNIX
         int keyType ;
      #endif
   #endif
} TAG4FILE ;

typedef struct TAG4St
{
   LINK4   link ;
   struct  INDEX4St S4PTR *index ;
   TAG4FILE *tagFile ;
   /* this uniqueError MUST be 0 if the tag is not unique */
   short int errUnique ; /* Is rewriting a unique key an error ? */
   #ifndef S4OFF_TRAN
      int isValid ;
   #endif
   #ifndef S4CLIENT
      #ifndef S4OFF_TRAN
         LIST4 removedKeys ;     /* list of temporarily removed keys for r4unique and e4unique cases */
      #endif
      int added, removed ;             /* was an entry added, removed */
   #endif
} TAG4 ;

typedef struct
{
   char S4PTR  *name ;
   S4CONST char S4PTR  *expression ;
   S4CONST char S4PTR  *filter ;
   short int unique ;
   unsigned short int descending ;
} TAG4INFO ;

#ifndef N4OTHER
typedef struct INDEX4FILESt
{
   LINK4  link ;

   LIST4  tags ;
   int userCount ;
   CODE4 S4PTR *codeBase ;
   DATA4FILE S4PTR *dataFile ;

   #ifdef S4CLIENT
      char accessName[LEN4PATH+1] ;
      int autoOpened ;
      long clientId, serverId ;
      #ifdef S4VBASIC
         short int debugInt ;         /* used to check structure integrity (set to 0x5281) */
      #else
         short int space1 ;
      #endif
   #else
      FILE4  file ;
      MEM4 S4PTR *blockMemory ;
      long fileLocked ;

      #ifdef S4FOX
         TAG4FILE S4PTR *tagIndex ;    /* the tags are a tag in the index file! */
         long  eof ;
         unsigned long  versionOld ;
      #else
         TAG4FILE S4PTR *space2 ;
         long space3 ;
         unsigned long space4 ;
      #endif

      #ifdef S4MDX
         I4HEADER header ;
         long  changed ;
      #endif

      #ifndef S4OFF_OPTIMIZE
         TAG4FILE *readBlockTag ;    /* used for optimization -- is a block-read request occurring? */
      #endif
   #endif
} INDEX4FILE ;
#endif

typedef struct INDEX4St
{
   LINK4  link ;
   LIST4  tags ;

   DATA4 S4PTR *data ;
   CODE4 S4PTR *codeBase ;

   #ifndef S4OFF_TRAN
      int isValid ;
   #endif
   #ifndef N4OTHER
      INDEX4FILE *indexFile ;
   #endif
   #ifdef S4CLIENT
      char alias[LEN4DATA_ALIAS+1] ;
   #else
      char accessName[LEN4PATH+1] ;
      #ifdef N4OTHER
         FILE4 file ;
/*         char alias[LEN4TAG_ALIAS+1] ;*/
         char S4PTR *path ;
         long  versionOld ;
      #else
         FILE4 space1 ;
         char S4PTR *space2 ;
         long space3 ;
      #endif
   #endif
} INDEX4 ;

#ifndef S4OFF_TRAN
#ifndef S4CLIENT
typedef struct
{
   LINK4 link ;
   long recno ;
   unsigned char key[1] ;   /* of variable length, but marked as '1' for a place holder */
} TAG4KEY_REMOVED ;
#endif
#endif

#ifndef S4CLIENT

/* Memo File Structures */
typedef struct
{
   #ifdef S4MFOX
      S4LONG  nextBlock ;  /* Memo Entry 1,2, ... */
      char  usused[2] ;
      short blockSize ;  /* Bytes */
   #else
      #ifdef S4MNDX
         S4LONG  nextBlock ;  /* Memo Entry 1,2, ... */
      #else
         S4LONG  nextBlock ;  /* Memo Entry 1,2, ... */
         S4LONG  zero ;
         char  fileName[8] ;
         short zero2 ;
         short x102 ;
         short blockSize ;  /* Bytes */
         short zero3 ;
      #endif
   #endif
} MEMO4HEADER ;

#ifndef S4MNDX
#ifndef S4MFOX
typedef struct
{
   S4LONG  next ;     /* The next free block area */
   S4LONG  num ;      /* The number of free blocks in the free block area */
   int toDisk ;    /* TRUE if this information needs to be written to disk */
   S4LONG  blockNo ; /* The current block number */
} MEMO4CHAIN_ENTRY ;
#endif /*  ifndef S4MFOX  */

typedef struct
{
   #ifdef S4MFOX
      S4LONG type ;         /* 0 for picture, 1 for text, 2 for OLE -- picture not supported */
      S4LONG numChars ;    /* Including the 'MemoBlock' */
   #else
      short minusOne ;    /* '-1' for dBASE IV */
      short startPos ;
      S4LONG  numChars ;    /* Including the 'MemoBlock' */
   #endif
} MEMO4BLOCK ;
#endif  /*  ifndef S4MNDX  */
#endif  /*  ifndef S4CLIENT  */

typedef struct
{
   unsigned  char  sigDig ;  /* The number of significant digits; 52 is zero */
   unsigned  char  digitInfo ; /* contains one, len and sign */
   unsigned  char  bcd[10] ;
}  C4BCD ;

#ifndef S4OFF_MULTI
/* for a single lock */
typedef struct
{
   short int type ;
   long recNum ;    /* if appropriate */
   long clientId ;
   long serverId ;
} LOCK4ID ;

typedef struct LOCK4St
{
   LINK4 link ;
   #ifdef S4CLIENT
      DATA4 *data ;
   #else
      DATA4FILE *data ;
   #endif

   LOCK4ID id ;
} LOCK4 ;

#ifndef S4SERVER
typedef struct
{
   LINK4 link ;
   DATA4 *data ;
   long   recNo ;
} LOCK4LINK ;
#endif
#endif

#ifdef S4USE_LOW_MEMORY
typedef union
{
   unsigned long block ;
   struct
   {
      unsigned short protect ;
      unsigned short real ;
   } ptr ;
} FIXED4MEM ;
#else
typedef void * FIXED4MEM ;
#endif

#ifdef S4TESTING
#ifndef S4SERVER
typedef struct
{
   unsigned char T4SUITE[255] ;
   unsigned char T4RECNO[100] ;
} ATS4RECINFO ;
#endif
#endif