Imported Upstream version 3.1.2upstream/3.1.2

1 files changed, 533 insertions, 0 deletions

diff --git a/xbase64/xbdbf.h b/xbase64/xbdbf.h
new file mode 100755
index 0000000..ce28e9a
--- /dev/null
+++ b/xbase64/xbdbf.h
@@ -0,0 +1,533 @@
+/*  xbdbf.h
+
+    Xbase64 project source code
+
+    This file contains the Class definition for a xbDBF object.
+
+    Copyright (C) 1997,2003  Gary A Kunkel
+    
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU Lesser General Public License as published by
+    the Free Software Foundation; either version 2 of the License, 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 Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+
+
+    Contact:
+    
+     Email:
+    
+      xdb-devel@lists.sourceforge.net
+      xdb-users@lists.sourceforge.net
+      
+      
+     Regular Mail:
+     
+       XBase Support
+       149C South Main St
+       Keller Texas, 76248     
+       USA
+
+*/
+
+#ifndef __XB_DBF_H__
+#define __XB_DBF_H__
+
+#ifdef __GNU LesserG__
+#pragma interface
+#endif
+
+#ifdef __WIN32__
+#include <xbase64/xbwincfg.h>
+#else
+#include <xbase64/xbconfig.h>
+#endif
+
+#include <xbase64/xbtypes.h>
+#include <xbase64/xbdate.h>
+#include <xbase64/xbfile.h>
+
+#include <iostream>
+#include <stdio.h>
+
+/*! \file xbdbf.h
+*/
+
+#if defined(XB_INDEX_ANY)
+   class XBDLLEXPORT xbIndex;
+   class XBDLLEXPORT xbNdx;
+   class XBDLLEXPORT xbNtx;
+#endif
+
+/*****************************/
+/* Field Types               */
+
+#define XB_CHAR_FLD      'C'
+#define XB_LOGICAL_FLD   'L'
+#define XB_NUMERIC_FLD   'N'
+#define XB_DATE_FLD      'D'
+#define XB_MEMO_FLD      'M'
+#define XB_FLOAT_FLD     'F'
+
+/*****************************/
+/* File Status Codes         */
+
+#define XB_CLOSED  0
+#define XB_OPEN    1
+#define XB_UPDATED 2
+
+/*****************************/
+/* Other defines             */
+
+#define XB_OVERLAY     1
+#define XB_DONTOVERLAY 0
+
+#define XB_CHAREOF  '\x1A'         /* end of DBF        */
+#define XB_CHARHDR  '\x0D'         /* header terminator */
+
+//! Used to define the fields in a database (DBF file).
+/*!
+  Generally one would define an xbSchema array to be passed
+  to xbDbf::CreateDatabase() to define the fields in the database.
+
+  For example, one might create a declaration as follows:
+  
+  \code  
+  xbSchema MyRecord[] = 
+  {
+    { "FIRSTNAME", XB_CHAR_FLD,     15, 0 },
+    { "LASTNAME",  XB_CHAR_FLD,     20, 0 },
+    { "BIRTHDATE", XB_DATE_FLD,      8, 0 },
+    { "AMOUNT",    XB_NUMERIC_FLD,   9, 2 },
+    { "SWITCH",    XB_LOGICAL_FLD,   1, 0 },
+    { "FLOAT1",    XB_FLOAT_FLD,     9, 2 },
+    { "FLOAT2",    XB_FLOAT_FLD,     9, 1 },
+    { "FLOAT3",    XB_FLOAT_FLD,     9, 2 },
+    { "FLOAT4",    XB_FLOAT_FLD,     9, 3 },
+    { "MEMO1",     XB_MEMO_FLD,     10, 0 },
+    { "ZIPCODE",   XB_NUMERIC_FLD,   5, 0 },      
+    { "",0,0,0 }
+  };
+  \endcode
+  
+  Note that the last xbSchema in an array must be a "null" entry like the 
+  one above:
+  
+  \code
+    { "",0,0,0 }
+  \endcode
+  
+  To indicate the end of the array.
+*/
+struct XBDLLEXPORT xbSchema {
+  char      FieldName[11];
+  char      Type;
+// xbUShort  FieldLen;       /* does not work */
+// xbUShort  NoOfDecs;       /* does not work */
+  unsigned  char FieldLen;  /* fields are stored as one byte on record*/
+  unsigned  char NoOfDecs;
+};
+
+//! Defines a field in an XBase file header (DBF file header)
+/*!
+  This structure is only used internally by the xbDbf class.
+*/
+struct XBDLLEXPORT xbSchemaRec {
+  char     FieldName[11];
+  char     Type;            /* field type */
+  char     *Address;        /* pointer to field in record buffer 1 */
+// xbUShort FieldLen;        /* does not work */
+// xbUShort NoOfDecs;        /* does not work */
+  unsigned char FieldLen;   /* fields are stored as one byte on record */
+  unsigned char NoOfDecs;
+  char     *Address2;       /* pointer to field in record buffer 2 */
+  char     *fp;             /* pointer to null terminated buffer for field */
+                             /* see method GetString */
+  xbShort  LongFieldLen;    /* to handle long field lengths */
+};
+
+//! xbIxList struct
+/*!
+  Internal use only.
+*/
+struct XBDLLEXPORT xbIxList {
+  xbIxList * NextIx;
+  xbString IxName;
+#if defined(XB_INDEX_ANY)
+  xbIndex  * index;
+  xbShort  Unique;
+  xbShort  KeyUpdated;
+#endif
+};
+
+//! xbMH struct
+/*!
+  Internal use only.
+*/
+
+#ifdef XB_MEMO_FIELDS
+struct XBDLLEXPORT xbMH{                      /* memo header                    */
+  xbLong  NextBlock;             /* pointer to next block to write */
+  char    FileName[8];           /* name of dbt file               */
+  char    Version;               /* not sure                       */
+  xbShort BlockSize;             /* memo file block size           */
+};
+#endif
+
+//! xbDbf class
+/*!
+  The xbDbf class encapsulates an xbase DBF database file.  It includes
+  all dbf access, field access, and locking methods.
+*/
+class XBDLLEXPORT xbDbf : protected xbFile{
+
+public:
+  xbDbf( xbXBase * );
+  virtual ~xbDbf();
+
+  xbXBase  *xbase;               /* linkage to main base class */
+
+/* datafile methods */
+#if defined(XB_INDEX_ANY)
+  xbShort   AddIndexToIxList(xbIndex *, const char *IndexName);
+  xbShort   RemoveIndexFromIxList( xbIndex * );
+#endif
+  xbShort   AppendRecord();
+  xbShort   BlankRecord();
+  xbShort   CloseDatabase( xbBool deleteIndexes = 0 );
+  xbShort   CopyDbfStructure( const char *, xbShort );
+  xbShort   CreateDatabase( const char * Name, xbSchema *, xbShort Overlay );
+  //! Delete all records
+  /*!
+  */
+  xbShort   DeleteAllRecords() { return DeleteAll(0); }
+  xbShort   DeleteRecord();
+#ifdef XBASE_DEBUG
+  xbShort   DumpHeader( xbShort );
+#endif
+  xbShort   DumpRecord( xbULong );
+  //! Return number of fields
+  /*!
+  */
+  xbLong    FieldCount() { return NoOfFields; }
+  //! Return Dbf name
+  /*!
+  */
+  const xbString& GetDbfName() { return GetFileName(); }
+  //! Return status
+  /*!
+  */
+  xbShort   GetDbfStatus() { return DbfStatus; }
+  xbShort   GetFirstRecord();
+  xbShort   GetLastRecord();
+  xbShort   GetNextRecord();
+  xbShort   GetPrevRecord();
+  //! Return current record number
+  /*!
+  */
+  xbLong    GetCurRecNo() { return CurRec; }
+  xbShort   GetRecord( xbULong );
+  //! Return a pointer to the record buffer
+  /*!
+  */
+  char *    GetRecordBuf() { return RecBuf; }
+  //! Return record length
+  /*!
+  */
+  xbShort   GetRecordLen() { return RecordLen; }
+  xbShort   NameSuffixMissing( xbShort, const char * );
+  xbLong    GetRecCnt() { return NoOfRecords(); }
+  xbLong    NoOfRecords();
+  xbLong    PhysicalNoOfRecords();
+  xbShort   OpenDatabase( const char * );
+  xbShort   PackDatabase(xbShort LockWaitOption,
+        void (*packStatusFunc)(xbLong itemNum, xbLong numItems) = 0,
+        void (*indexStatusFunc)(xbLong itemNum, xbLong numItems) = 0);
+  xbShort   PutRecord(); // Put record to current position
+  xbShort   PutRecord(xbULong);
+  xbShort   RebuildAllIndices(
+      void (*statusFunc)(xbLong itemNum, xbLong numItems) = 0);
+  xbShort   RecordDeleted();
+  //! Set number of records to zero????
+  /*!
+  */
+  void      ResetNoOfRecs() { NoOfRecs = 0L; }
+  xbShort   SetVersion( xbShort );
+  //! Undelete all records
+  /*!
+  */
+  xbShort   UndeleteAllRecords() { return DeleteAll(1); }
+  xbShort   UndeleteRecord();
+  xbShort   Zap( xbShort );
+
+/* field methods */
+  const char *GetField(xbShort FieldNo) const; // Using internal static buffer
+  const char *GetField(const char *Name) const;
+  xbShort   GetField( xbShort FieldNo, char *Buf) const;
+  xbShort   GetRawField( xbShort FieldNo, char *Buf) const;
+  xbShort   GetField( xbShort FieldNo, char *Buf, xbShort RecBufSw) const;
+  xbShort   GetField( const char *Name, char *Buf) const;
+  xbShort   GetRawField(const char *Name, char *Buf) const;
+  xbShort   GetField( const char *Name, char *Buf, xbShort RecBufSw) const;
+  xbShort   GetField(xbShort FieldNo, xbString&, xbShort RecBufSw ) const;
+  xbShort   GetFieldDecimal( xbShort );
+  xbShort   GetFieldLen( xbShort );
+  char *    GetFieldName( xbShort );
+  xbShort   GetFieldNo( const char * FieldName ) const;
+  char      GetFieldType( xbShort FieldNo ) const;
+  xbShort   GetLogicalField( xbShort FieldNo );
+  xbShort   GetLogicalField( const char * FieldName );
+  char *    GetStringField( xbShort FieldNo );
+  char *    GetStringField( const char * FieldName );
+  xbShort   PutField( xbShort, const char * );
+  xbShort   PutRawField( xbShort FieldNo, const char *buf );
+  xbShort   PutField( const char *Name, const char *buf);
+  xbShort   PutRawField( const char *Name, const char *buf );
+  xbShort   ValidLogicalData( const char * );
+  xbShort   ValidNumericData( const char * );
+
+  xbLong    GetLongField( const char *FieldName) const;
+  xbLong    GetLongField( const xbShort FieldNo) const;
+  xbShort   PutLongField( const xbShort, const xbLong );
+  xbShort   PutLongField( const char *, const xbLong);
+
+  xbFloat   GetFloatField( const char * FieldName );
+  xbFloat   GetFloatField( xbShort FieldNo );
+  xbShort   PutFloatField( const char *, const xbFloat);
+  xbShort   PutFloatField( const xbShort, const xbFloat);
+
+  xbDouble  GetDoubleField( const char *);
+  xbDouble  GetDoubleField( xbShort, xbShort RecBufSw = 0);
+  xbShort   PutDoubleField( const char *, xbDouble);
+  xbShort   PutDoubleField( const xbShort, xbDouble);
+
+#ifdef XB_LOCKING_ON
+  xbShort   GetLockMode() { return LockMode; }
+  xbShort   SetLockMode( xbShort );
+//  xbShort   OpenXbLockFile();
+//  xbShort   GetTableLockCnt() { return TableLockCnt; }
+//  xbShort   LockIndex( xbShort LockType );    /* for XB_XBASE_LOCK_MODE */
+  int       GetDbfFileNo() { return fileno( fp ); }
+  int       GetMemoFileNo() { return fileno( mfp ); }
+
+#ifdef XB_MEMO_FIELDS
+//  xbShort   GetMemoLockCnt() { return MemoLockCnt; }
+#endif
+  
+/*
+  xbShort   LockTable( xbShort LockType );
+  xbShort   LockXbaseTable( xbShort LockType );
+  xbShort   LockClipperTable( xbShort LockType );
+  xbShort   LockFoxproTable( xbShort LockType );
+  xbShort   LockDbaseTable( xbShort LockType );
+  
+  xbShort   LockRecord( xbShort LockType, xbULong RecNo, xbULong RecCnt );
+  xbShort   LockXbaseRecord( xbShort LockType, xbULong RecNo, xbULong RecCnt );
+  xbShort   LockClipperRecord( 
+               xbShort LockType, xbULong RecNo, xbULong RecCnt );
+  xbShort   LockFoxproRecord( xbShort LockType, xbULong RecNo, xbULong RecCnt );
+  xbShort   LockDbaseRecord( xbShort LockType, xbULong RecNo, xbULong RecCnt );
+
+  xbShort   LockDatabase( xbShort, xbShort, xbULong );
+  xbShort   ExclusiveLock( xbShort );
+  xbShort   ExclusiveUnlock();
+  xbShort   LockDatabase( xbShort cmd, xbULong recNo ) { return 0; }
+*/
+
+#ifndef HAVE_FCNTL
+  xbShort   UnixToDosLockCommand( xbShort WaitOption,
+              xbShort LockType ) const;
+#endif
+
+#else
+  xbShort   LockDatabase( xbShort, xbShort, xbLong )
+     { return XB_NO_ERROR; }
+  xbShort   ExclusiveLock( xbShort ) { return XB_NO_ERROR; };
+  xbShort   ExclusiveUnlock()      { return XB_NO_ERROR; };
+#endif
+
+   //! Turn autolock on
+   /*!
+   */
+   void    AutoLockOn()  { AutoLock = 1; }
+   //! Turn autolock off
+   /*!
+   */
+   void    AutoLockOff() { AutoLock = 0; }
+   //! Return whether or not autolocking is on or off
+   /*!
+   */
+  xbShort GetAutoLock() { return AutoLock; }
+
+#ifdef XB_MEMO_FIELDS
+  xbShort   GetMemoField( xbShort FieldNo, xbLong len,
+             char * Buf, xbShort LockOption );
+  xbLong    GetMemoFieldLen( xbShort FieldNo );
+  xbShort   GetFPTField( xbShort FieldNo, xbLong len,
+              char * Buf, xbShort LockOption );
+  xbLong    GetFPTFieldLen( xbShort FieldNo );
+  xbShort   UpdateMemoData( xbShort FieldNo, xbLong len,
+              const char * Buf, xbShort LockOption );
+  xbShort   MemoFieldExists( xbShort FieldNo ) const;
+  xbShort   LockMemoFile( xbShort WaitOption, xbShort LockType );
+
+  xbShort   MemoFieldsPresent() const;
+  xbLong    CalcLastDataBlock();
+  xbShort   FindBlockSetInChain( xbLong BlocksNeeded, xbLong
+               LastDataBlock, xbLong & Location, xbLong &PreviousNode );
+  xbShort   GetBlockSetFromChain( xbLong BlocksNeeded, xbLong
+               Location, xbLong PreviousNode );
+  xbString & GetDbtName() { return MemofileName; }
+
+#ifdef XBASE_DEBUG
+  xbShort   DumpMemoFreeChain();
+  void      DumpMemoHeader() const;
+  void      DumpMemoBlock() const;
+#endif
+#endif
+
+  //! Turn on "real" deletes
+  /*!
+     This should be done before creating a database (with 
+    xbDbf::CreateDatatabase()) and thereafter before opening
+    a database with xbDbfCreateDatabase().
+    
+    You cannot "turn on" real deletes once a database has been created
+    and records added.
+  */
+  void      RealDeleteOn() { RealDelete = 1; if(fp) ReadHeader(1); }
+  /*! Turn off "real" deletes
+  */
+  void      RealDeleteOff() { RealDelete = 0; if(fp) ReadHeader(1); }
+  //! Return whether "real" deletes are on or off
+  /*!
+ Use this to determine if "real deletes" are being used with
+the database.
+  */
+  xbShort   GetRealDelete() { return RealDelete; }
+
+#if defined(XB_INDEX_ANY)
+  xbShort   IndexCount();
+  xbIndex   *GetIndex(xbShort indexNum);
+#endif
+
+  void      Flush();
+  virtual const char* GetExtWithDot( bool lower );
+
+ private:
+
+  xbShort   DeleteAll( xbShort );
+  void      InitVars();
+  xbShort   PackDatafiles(void (*statusFunc)(xbLong itemNum, xbLong numItems) = 0);
+  xbShort   ReadHeader( xbShort );
+  xbShort   WriteHeader( xbShort );
+  
+#ifdef XB_MEMO_FIELDS
+  xbShort   AddMemoData( xbShort FieldNo, xbLong Len, const char * Buf );
+  xbShort   CreateMemoFile();
+  xbShort   DeleteMemoField( xbShort FieldNo );
+  xbShort   GetDbtHeader( xbShort Option );
+  xbShort   GetMemoBlockSize() { return MemoHeader.BlockSize; }
+  xbShort   OpenMemoFile();
+  xbShort   OpenFPTFile();
+  xbShort   PutMemoData( xbLong StartBlock, xbLong BlocksNeeded,
+          xbLong Len, const char * Buf );
+  xbShort   ReadMemoBlock( xbLong BlockNo, xbShort Option);
+  xbShort   SetMemoBlockSize( xbShort );
+  xbShort   UpdateHeadNextNode() const;
+  xbShort   WriteMemoBlock( xbLong BlockNo, xbShort Option );
+  xbShort   IsType3Dbt() const { return( Version==(char)0x83 ? 1:0 ); }
+  xbShort   IsType4Dbt() const
+        {return (( Version==(char)0x8B || Version==(char)0x8E ) ? 1:0 );}
+  xbShort   CreateUniqueDbfName( xbString &, xbString & );
+#endif
+
+
+//  xbString DatabaseName;
+  xbShort  XFV;                  /* xBASE file version            */
+  xbShort  NoOfFields;
+  char     DbfStatus;            /* 0 = closed
+                                    1 = open
+                                    2 = updates pending           */
+  FILE   *fp;                    /* file pointer                  */
+  xbSchemaRec *SchemaPtr;        /* Pointer to field data         */
+  char   *RecBuf;                /* Pointer to record buffer      */
+  char   *RecBuf2;               /* Pointer to original rec buf   */
+
+#ifdef XB_MEMO_FIELDS
+  xbString MemofileName;         /* memo file name                */
+  FILE    *mfp;                  /* memo file pointer             */
+  void    *mbb;                  /* memo block buffer             */
+  xbMH     MemoHeader;           /* memo header structure         */
+  xbShort  mfield1;              /* memo block field one FF       */
+  xbShort  MStartPos;            /* memo start pos of data        */
+  xbLong   MFieldLen;            /* memo length of data           */
+  xbLong   NextFreeBlock;        /* next free block in free chain */
+  xbLong   FreeBlockCnt;         /* count of free blocks this set */
+  xbLong   MNextBlockNo;         /* free block chain              */
+  xbLong   MNoOfFreeBlocks;      /* free block chain              */
+  xbLong   CurMemoBlockNo;       /* Current block no loaded       */
+#endif
+
+/* Next seven variables are read directly off the database header */
+/* Don't change the order of the following seven items            */
+  char   Version;
+  char   UpdateYY;
+  char   UpdateMM;
+  char   UpdateDD;
+//   xbLong   NoOfRecs;
+//   xbShort  HeaderLen;
+//   xbShort  RecordLen;
+
+  xbULong  NoOfRecs;
+  xbUShort HeaderLen;
+  xbUShort RecordLen;
+
+//#ifdef XB_REAL_DELETE
+  xbULong  FirstFreeRec;
+  xbULong  RealNumRecs;
+//#endif
+
+//  xbIxList * MdxList;
+  xbIxList * NdxList;
+  xbIxList * FreeIxList;
+  xbULong  CurRec;               /* Current record or zero   */
+  xbShort  AutoLock;             /* Auto update option 0 = off  */
+
+//#ifdef XB_REAL_DELETE
+  xbShort  RealDelete;           /* real delete option 0 = off */
+//#endif
+
+#ifdef XB_LOCKING_ON
+  FILE     *xblfh;                /* xbase lock file pointer for xbase locking */
+  xbShort  LockMode;              /* lock mode for this table */  
+  xbString lfn;                   /* xbase lock file name for xbase locking */
+  xbShort  TableLockCnt;          /* number of table locks  */
+  xbShort  IndexLockCnt;          /* no of index locks XB_XBASE_LOCK_MODE only */
+
+#ifdef XB_MEMO_FIELDS
+  xbShort  MemoLockCnt;           /* number of memo file locks */
+#endif
+  
+  /* old locking stuff */
+  xbShort  CurLockType;           /* current type of file lock */
+  xbShort  CurLockCount;          /* number of current file locks */
+  xbULong  CurLockedRecNo;        /* currently locked record no */
+  xbShort  CurRecLockType;        /* current type of rec lock held (F_RDLOCK or F_WRLCK) */
+  xbShort  CurRecLockCount;       /* number of current record locks */
+  xbShort  CurMemoLockType;       /* current type of memo lock */
+  xbShort  CurMemoLockCount;      /* number of current memo locks */
+#endif
+
+};
+#endif      // __XB_DBF_H__
+
+