Imported Upstream version 3.1.2upstream/3.1.2

1 files changed, 2671 insertions, 0 deletions

diff --git a/xbase64/xbdbf.cpp b/xbase64/xbdbf.cpp
new file mode 100755
index 0000000..d3790cb
--- /dev/null
+++ b/xbase64/xbdbf.cpp
@@ -0,0 +1,2671 @@
+/*  xbdbf.cpp
+ 
+    Xbase64 project source code
+   
+    This file contains the basic Xbase routines for reading and writing
+    Xbase .DBF files.
+
+    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
+
+*/
+
+#ifdef __GNU LesserG__
+  #pragma implementation "xbdbf.h"
+#endif
+
+#ifdef __WIN32__
+#include <xbase64/xbwincfg.h>
+#else
+#include <xbase64/xbconfig.h>
+#endif
+
+#include <xbase64/xbase64.h>
+
+#ifdef HAVE_IO_H
+#include <io.h>
+#endif
+#include <errno.h>
+
+/*! \file xbdbf.cpp
+*/
+
+/************************************************************************/
+//! Constructor
+/*!
+  \param x pointer to the global xbXbase class
+*/
+xbDbf::xbDbf( xbXBase * x )
+{
+  xbase = x;
+  InitVars();
+}
+/************************************************************************/
+//! Destructor
+/*!
+*/
+xbDbf::~xbDbf()
+{
+  CloseDatabase(true);
+}
+/************************************************************************/
+//! Initialize private data members.
+/*!
+  Internal use only.
+*/
+void xbDbf::InitVars()
+{
+  SetFileName(NULL);
+  NoOfFields   = 0;
+  DbfStatus    = XB_CLOSED;
+  fp           = NULL;
+  CurRec       = 0L;
+  SchemaPtr    = NULL;
+  RecBuf       = NULL;
+  RecBuf2      = NULL;
+  Version      = 0x00;
+  UpdateYY     = 0x00;
+  UpdateMM     = 0x00;
+  UpdateDD     = 0x00;
+  NoOfRecs     = 0L;
+  HeaderLen    = 0x00;
+  RecordLen    = 0x00;
+  NdxList      = NULL;
+  FreeIxList   = NULL;
+  XFV          = 3;            /* Xbase file version */
+
+#ifdef XB_LOCKING_ON
+  xblfh        = NULL;         /* lock file for XB_XBASE_LOCK_MODE */
+  LockMode     = xbase->GetLockMode();
+  TableLockCnt = 0;
+  IndexLockCnt = 0;
+#ifdef XB_MEMO_FIELDS
+  MemoLockCnt  = 0;
+#endif
+  
+  AutoLock         = 1;
+  CurLockType      = -1;
+  CurLockCount     = 0;
+  CurLockedRecNo   = 0L;
+  CurRecLockType   = -1;
+  CurRecLockCount  = 0;
+  CurMemoLockType  = -1;
+  CurMemoLockCount = 0;
+#else
+  AutoLock         = 0;
+#endif
+
+#ifdef XB_MEMO_FIELDS
+  MemofileName          = "";
+  MemoHeader.BlockSize  = XB_DBT_BLOCK_SIZE;
+  MemoHeader.Version    = 0x03;
+  mfp                   = NULL;
+  mbb                   = NULL;
+  CurMemoBlockNo        = -1;
+  mfield1               = 0;
+  MStartPos             = 0;
+  MFieldLen             = 0;
+  NextFreeBlock         = 0L;
+  FreeBlockCnt          = 0L;
+  MNextBlockNo          = 0L;
+  MNoOfFreeBlocks       = 0L;
+#endif
+
+//#ifdef XB_REAL_DELETE
+  RealDelete = 0;
+  FirstFreeRec = 0L;
+  RealNumRecs = 0L;
+//#endif
+}
+/************************************************************************/
+//! Set dbase version for the dbf file.
+/*!
+  Set dbase version.  Should only be used before creating a database with
+  xbDbf::CreateDatabase().
+  
+  \param v version, either 3 or 4.
+*/
+xbShort xbDbf::SetVersion(xbShort v) {
+  if (v == 0)
+    return XFV;
+  else
+    if(v == 3) {
+      XFV = 3;
+#ifdef XB_MEMO_FIELDS
+      MemoHeader.Version = 0x03;
+#endif
+      return XFV;
+   } else
+     if (v == 4) {
+       XFV = 4;
+#ifdef XB_MEMO_FIELDS
+       MemoHeader.Version = 0x00;
+#endif
+       return XFV;
+   }
+
+  return XB_INVALID_OPTION;
+}
+/************************************************************************/
+//! Write the dbf header
+/*!
+  Internal use only.
+
+  \param PositionOption flag that indicates whether file postition should
+  be moved.  non-zero if so, zero if not.
+*/
+xbShort xbDbf::WriteHeader( xbShort PositionOption )
+{
+   char buf[32];
+   memset(buf, 0, 32);
+   if(PositionOption)
+     rewind(fp);
+
+   memcpy(&buf[0], &Version, 4);
+   xbase->PutLong(&buf[4], NoOfRecs);
+   xbase->PutShort(&buf[8], HeaderLen );
+   xbase->PutShort(&buf[10], RecordLen );
+
+#ifdef XB_REAL_DELETE
+   if(RealDelete){
+     xbase->PutULong(&buf[12], FirstFreeRec);
+     xbase->PutULong(&buf[16], RealNumRecs);
+   }
+#endif
+   if(fwrite(buf, 32, 1, fp) != 1)
+     return XB_WRITE_ERROR;
+
+   return XB_NO_ERROR;
+}
+/************************************************************************/
+//! Read the dbf header.
+/*!
+  Internal use only.
+
+  \param PositionOption
+*/
+xbShort xbDbf::ReadHeader( xbShort PositionOption )
+{
+#if 0
+   char buf[4];
+   if (PositionOption)
+       rewind(fp);
+   if (fread(&Version, 4, 1, fp) != 1)
+     xb_error(XB_READ_ERROR);
+
+   if (fread(buf, 4, 1, fp ) != 1)
+     xb_error(XB_READ_ERROR);
+
+   NoOfRecs = xbase->GetLong( buf );
+   if(fread(buf, 2, 1, fp) != 1)
+     xb_error(XB_READ_ERROR);
+
+   HeaderLen = xbase->GetShort( buf );
+   if(fread(buf, 2, 1, fp) != 1)
+     xb_error(XB_READ_ERROR);
+
+   RecordLen = xbase->GetShort(buf);
+
+#ifdef XB_REAL_DELETE
+   if(RealDelete)
+   {
+     if (fread(buf, 4, 1, fp ) != 1)
+       xb_error(XB_READ_ERROR);
+     FirstFreeRec = xbase->GetULong( buf );
+     
+     if (fread(buf, 4, 1, fp ) != 1)
+       xb_error(XB_READ_ERROR);
+     RealNumRecs = xbase->GetULong( buf );
+   }
+#endif
+#else
+   char buf[32];
+
+   if(PositionOption)
+     rewind(fp);
+
+   if(fread(buf, 32, 1, fp) != 1)
+     return XB_READ_ERROR;
+
+   memcpy(&Version, buf, 4);
+   NoOfRecs = xbase->GetLong(&buf[4]);
+   HeaderLen = xbase->GetShort(&buf[8]);
+   RecordLen = xbase->GetShort(&buf[10]);
+
+#ifdef XB_REAL_DELETE
+   if(RealDelete)
+   {
+     FirstFreeRec = xbase->GetULong(&buf[12]);
+     RealNumRecs = xbase->GetULong(&buf[16]);
+   }
+#endif
+#endif
+
+   return XB_NO_ERROR;
+}
+/************************************************************************/
+//! Determine if file name suffix is missing
+/*!
+  Internal use only.
+*/
+xbShort xbDbf::NameSuffixMissing( xbShort type, const char * name )
+{
+  /*  type 1 is DBF check
+      type 2 is NDX check
+      type 3 is MDX check
+      type 4 is NTX check
+
+      Returns 0 if suffix found
+              1 if suffix not found, lower case
+              2 is suffix not found, upper, case
+*/
+
+  xbShort len;
+
+  len = strlen( name );
+  if( len <= 4 )
+    if( name[len-1] >= 'A' && name[len-1] <= 'Z' )
+      return 2;
+    else
+      return 1;
+
+  if( type == 1          && name[len-4] == '.' &&
+     ( name[len-3] == 'd' || name[len-3] == 'D' ) && 
+     ( name[len-2] == 'b' || name[len-2] == 'B' ) && 
+     ( name[len-1] == 'f' || name[len-1] == 'F' )
+    )
+      return 0;
+
+  if(  type == 2          && name[len-4] == '.' &&
+     ( name[len-3] == 'n' || name[len-3] == 'N' ) && 
+     ( name[len-2] == 'd' || name[len-2] == 'D' ) && 
+     ( name[len-1] == 'x' || name[len-1] == 'X' )
+     )
+      return 0; 
+
+  if(  type == 4          && name[len-4] == '.' &&
+     ( name[len-3] == 'n' || name[len-3] == 'N' ) && 
+     ( name[len-2] == 't' || name[len-2] == 'T' ) && 
+     ( name[len-1] == 'x' || name[len-1] == 'X' )
+    )
+     return 0;
+
+  if( name[len-5] >= 'A' && name[len-5] <= 'Z' )
+    return 2;
+  else
+    return 1;
+}
+/************************************************************************/
+//! Create the dbf file.
+/*!
+  This method attempts to create the DBF file with the specified
+  name (TableName) and schema (xbSchema s).  The OverLay switch is used to determine
+  if an existing file should be overwritten or an error flagged if the
+  file already exists.  The  record buffer is blanked (set to spaces).
+  
+  \param TableName name of the table
+  \param s xbSchema
+  \param Overlay One of the following:
+    \htmlonly
+      <p>
+      <table border=2><tr><th>OverLay</th><th>Description</th></tr>
+        <tr><td>XB_OVERLAY</td><td>Overwrite existing file if it exists</td></tr>
+        <tr><td>XB_DONTOVERLAY</td><td>Report an error if file exists</td></tr>
+      </table>
+    \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{OverLay} & \textbf{Description} \\ \hline \hline
+        XB\_OVERLAY      & Overwrite existing file if it exists \\ \hline
+        XB\_DONTOVERLAY  & Report an error if file exists \\ \hline
+      \end{tabular}
+    \endlatexonly
+  \returns One of the following return codes:
+    \htmlonly
+      <p>
+      <table border=2><tr><th>Return Code</th><th>Description</th></tr>
+        <tr><td>XB_NO_ERROR</td><td>No error</td></tr>
+        <tr><td>XB_FILE_EXISTS</td><td>If the file exists and OverLay is XB_DONTOVERLAY</td></tr>
+        <tr><td>XB_OPEN_ERROR</td><td>Couldn't open the file</td></tr>            <tr><td>XB_NO_MEMORY</td><td>Memory allocation error</td></tr>
+        <tr><td>XB_WRITE_ERROR</td><td>Couldn't write to disk</td><tr>
+      </table>
+    \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{Return Code} & \textbf{Description} \\ \hline \hline
+        XB\_NO\_ERROR & No Error \\ \hline
+        XB\_FILE\_EXISTS & If the file exists and OverLay is XB\_DONTOVERAY \\ \hline
+        XB\_OPEN\_ERROR & Couldn't open the file \\ \hline
+        XB\_WRITE\_ERROR & Couldn't write to disk \\ \hline
+      \end{tabular}
+    \endlatexonly
+*/
+xbShort xbDbf::CreateDatabase( const char * TableName, xbSchema * s,
+    const xbShort Overlay )
+{
+  xbShort    i, j, k, k2, rc;  /* , count; */
+
+#ifdef XB_MEMO_FIELDS
+  xbShort MemoSw = 0;
+#endif
+
+  DbfStatus = XB_CLOSED;                 
+  SetFileName( TableName );
+
+  /* check if the file already exists */
+  if((( fp = fopen( GetFileName(), "r" )) != NULL ) && !Overlay ){
+    fclose( fp );
+    return XB_FILE_EXISTS;
+  }
+  else if( fp ) fclose( fp );
+
+  if(( fp = fopen( GetFileName(), "w+b" )) == NULL )
+    return XB_OPEN_ERROR;
+
+#ifdef XB_LOCKING_ON
+  /* no buffering in multi user mode */
+  setbuf( fp, NULL );
+    
+  /* open the lock file if XB_XBASE_LOCK_FLAVOR */
+//  if( LockMode == XB_XBASE_LOCK_MODE )
+//    if(( rc = OpenXbLockFile()) != XB_NO_ERROR )
+//      return rc;
+#endif
+
+  /* count the number of fields and check paramaters */
+  i = 0;
+  while( s[i].Type != 0 ){
+    NoOfFields++;
+
+#ifdef XB_MEMO_FIELDS
+    if(s[i].Type == 'M'){
+      s[i].FieldLen = 10;
+      s[i].NoOfDecs = 0;
+    }
+#endif /* XB_MEMO_FIELDS */
+
+    if(s[i].Type == 'D'){
+      s[i].FieldLen = 8;
+      s[i].NoOfDecs = 0;
+    }
+
+    if(s[i].Type == 'C')
+      s[i].NoOfDecs = 0;
+
+    RecordLen += s[i].FieldLen;
+
+    if( s[i].Type != 'C' &&
+        s[i].Type != 'N' &&
+        s[i].Type != 'F' &&
+        s[i].Type != 'D' &&
+#ifdef XB_MEMO_FIELDS
+        s[i].Type != 'M' &&
+#endif /* XB_MEMO_FIELDS */
+        s[i].Type != 'L' )
+    {
+      fclose( fp );
+      InitVars();
+      return XB_UNKNOWN_FIELD_TYPE;
+    }
+
+#ifdef XB_MEMO_FIELDS
+//  8/18/03 types B and O dont exist yet - gkunkel
+//      if( !MemoSw && ( s[i].Type=='M' || s[i].Type=='B' || s[i].Type=='O'))
+    if( !MemoSw && ( s[i].Type=='M' ))
+       MemoSw++;
+#endif
+
+// check for numeric fields which are too long
+    if((s[i].Type == 'N' || s[i].Type == 'F') && s[i].FieldLen > 19 ){
+      fclose( fp );
+      InitVars();
+      return XB_INVALID_FIELD_LEN;
+    }
+    i++;
+  }
+  RecordLen++;                  /* add one byte for 0x0D    */
+
+  if(( RecBuf = (char *) malloc( RecordLen )) == NULL ){
+    fclose( fp );
+    InitVars();
+    return XB_NO_MEMORY;
+  }
+
+  if(( RecBuf2 = (char *) malloc( RecordLen )) == NULL ){
+    free( RecBuf );
+    fclose( fp );
+    InitVars();
+    return XB_NO_MEMORY;
+  }
+
+  /* BlankRecord(); */
+  memset( RecBuf, 0x20, RecordLen );
+  memset( RecBuf2, 0x20, RecordLen );
+
+  /* set class variables */
+  Version = XFV & 0x7;            // file version - bit 0-2
+#ifdef XB_MEMO_FIELDS
+  if(MemoSw){
+    if((XFV & 0x7) == 3)
+      Version |= 0x80;    // memo presence - bit 7
+    else
+      Version = (char) 0x8b;
+  }
+#endif
+
+  CurRec  = 0L;
+  HeaderLen = 33 + NoOfFields * 32;
+  xbDate d;
+  UpdateYY = (d.YearOf() - 1900);
+  if((XFV & 0x7) == 3)
+    UpdateYY %= 100;   // dBASE III seems to do this, but IV does not.  DTB
+
+  UpdateMM = d.MonthOf();
+  UpdateDD = d.DayOf( XB_FMT_MONTH );
+
+  /* write the header prolog */
+  if(( rc = WriteHeader( 0 )) != XB_NO_ERROR ){
+    free( RecBuf );
+    free( RecBuf2 );
+    fclose( fp );
+    InitVars();
+    return XB_WRITE_ERROR;
+  }
+
+  if((SchemaPtr=(xbSchemaRec *)malloc(NoOfFields*sizeof(xbSchemaRec)))==NULL){
+    free( RecBuf );
+    free( RecBuf2 );
+    fclose( fp );
+    InitVars();
+    return XB_NO_MEMORY;
+  }
+  memset( SchemaPtr, 0x00, ( NoOfFields * sizeof(xbSchemaRec)));
+
+  /* write the field information into the header */
+  for( i = 0, k = 1; i < NoOfFields; i++ ){
+    memset( SchemaPtr[i].FieldName, 0x00, 11 );
+    strncpy( SchemaPtr[i].FieldName, s[i].FieldName, 10 );
+
+    SchemaPtr[i].Type = s[i].Type;
+    SchemaPtr[i].FieldLen = s[i].FieldLen; 
+    SchemaPtr[i].NoOfDecs = s[i].NoOfDecs;
+    
+    if( SchemaPtr[i].NoOfDecs > SchemaPtr[i].FieldLen ) {
+      fclose( fp );
+      free( SchemaPtr );
+      free( RecBuf );
+      free( RecBuf2 );
+      InitVars(); 
+      return XB_INVALID_SCHEMA;
+    }
+
+    k2 = k;
+    k += SchemaPtr[i].FieldLen;
+
+    if(( fwrite( &SchemaPtr[i], 1, 18, fp )) != 18 ) {
+      fclose( fp );
+      free( SchemaPtr );
+      free( RecBuf );
+      free( RecBuf2 );
+      InitVars(); 
+      return XB_WRITE_ERROR;
+    }
+
+    for( j = 0; j < 14; j++ ) {
+      if(( fwrite( "\x00", 1, 1, fp )) != 1 ) {
+        free( SchemaPtr );
+        free( RecBuf );
+        free( RecBuf2 );
+        fclose( fp );
+        InitVars(); 
+        return XB_WRITE_ERROR;
+      }
+    }
+    SchemaPtr[i].Address  = RecBuf  + k2;
+    SchemaPtr[i].Address2 = RecBuf2 + k2;
+  }
+
+  /* write the header terminator */
+  if(( fputc( XB_CHARHDR, fp )) != XB_CHARHDR ){
+    fclose( fp );
+    free( SchemaPtr );
+    free( RecBuf );
+    free( RecBuf2 );
+    InitVars(); 
+    return XB_WRITE_ERROR;
+  }
+
+#ifdef XB_MEMO_FIELDS
+  if( MemoSw )
+    if((rc = CreateMemoFile()) != XB_NO_ERROR){
+      fclose(fp);
+      free(RecBuf);
+      free(RecBuf2);
+      InitVars();
+      return rc;
+    }
+#endif
+
+  DbfStatus = XB_OPEN;
+  return xbase->AddDbfToDbfList(this, GetFileName());
+}
+/************************************************************************/
+//! Close the dbf file.
+/*!
+  This method attempts to close the DBF file which was previously
+  opened with either CreateDatabase() or OpenDatabase().  Deletes any
+  memory allocated.  Automatically closes any open indexes associated
+  with this data file.
+  
+  \param deleteIndexes if TRUE, the indexes (xbIndex instances) will also 
+    be deleted (index files will not be deleted)
+  \returns One of the following:
+    \htmlonly
+      <p>
+      <table border=2><tr><th>Return Code</th><th>Description</th></tr>
+        <tr><td>XB_NO_ERROR</td><td>No error</td></tr>
+        <tr><td>XB_NOT_OPEN</td><td>File was not open</td></tr>
+      </table>
+    \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{Return Code} & \textbf{Description} \\ \hline \hline
+        XB\_NO\_ERROR & No Error \\ \hline
+        XB\_NOT\_OPEN\_ERROR & File was not open \\ \hline
+      \end{tabular}
+    \endlatexonly
+*/
+xbShort xbDbf::CloseDatabase( xbBool deleteIndexes )
+{
+#if defined(XB_INDEX_ANY)
+  xbIxList *i, *ti;
+#endif
+
+  if(DbfStatus == XB_CLOSED)
+    return XB_NO_ERROR;
+
+
+#if defined(XB_INDEX_ANY)
+  i = NdxList;
+  while (i){
+    i->index->CloseIndex();
+    if(deleteIndexes)
+      delete i->index;
+    i = NdxList;
+  }
+/* free up unused nodes */
+  i = FreeIxList;
+  while( i ) {
+    ti = i;
+    i = i->NextIx;
+    free(ti);
+  }
+#endif
+
+  if(SchemaPtr){
+    for( int j = 0; j < NoOfFields; j++ )
+      if( SchemaPtr[j].fp ) delete SchemaPtr[j].fp;
+    free( SchemaPtr );
+  }
+  if(RecBuf)
+    free( RecBuf );
+  if(RecBuf2)
+    free( RecBuf2 );
+
+#ifdef XB_MEMO_FIELDS
+  if( mbb )
+    free( mbb );         /* memo block buffer */
+  if( mfp )
+    fclose( mfp );       /* memo file pointer */
+#endif
+
+#ifdef XB_LOCKING_ON
+  if( xblfh ){
+    fclose( xblfh );
+    xblfh = NULL;
+  }
+#endif
+
+  xbase->RemoveDbfFromDbfList( this );
+  if(fp)
+    fclose( fp );
+  InitVars();
+  return XB_NO_ERROR;
+}
+/************************************************************************/
+/* options  1 = Print header only
+            2 = Field data only
+            3 = Header and Field data */
+
+//! Dump header information.
+/*!
+  \param Option One of the following:
+     \htmlonly
+       <p>
+       <table border=2><tr><th>Option</th><th>Description</th></tr>
+         <tr><td>1</td><td>Print header only</td></tr>
+         <tr><td>2</td><td>Field data only</td></tr>
+         <tr><td>3</td><td>Header and field data</td></tr>
+       </table>
+     \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{Option} & \textbf{Description} \\ \hline \hline
+        1 & Header only \\ \hline
+        2 & Field data only \\ \hline
+        3 & Header and field data \\ \hline
+      \end{tabular}
+    \endlatexonly
+*/
+#ifdef XBASE_DEBUG
+xbShort xbDbf::DumpHeader( xbShort Option )
+{
+  int i;
+
+  if( Option < 1 || Option > 3 )
+    return XB_INVALID_OPTION;
+
+  if( DbfStatus == XB_CLOSED )
+    return XB_NOT_OPEN;
+
+  std::cout << "\nDatabase file " << GetFileName() << std::endl << std::endl;
+
+  if( Option != 2 ){
+    std::cout << "File header data:" << std::endl;
+    if( Version == 3 )
+      std::cout << "Dbase III file" << std::endl;
+    else if ( Version == 83 )
+      std::cout << "Dbase III file with memo fields" << std::endl << std::endl;
+
+    std::cout << "Last update date = " 
+      << (int) UpdateMM << "/" << (int) UpdateDD << "/" << (int) UpdateYY % 100 << std::endl;  
+
+    std::cout << "Header length    = " << HeaderLen << std::endl;
+    std::cout << "Record length    = " << RecordLen << std::endl;
+    std::cout << "Records in file  = " << NoOfRecs << std::endl << std::endl;
+#ifdef XB_REAL_DELETE
+    std::cout << "First Free Rec   = " << FirstFreeRec << std::endl << std::endl;
+#endif      
+  }
+  if( Option != 1 ){
+    std::cout << "Field Name   Type  Length  Decimals" << std::endl;
+    std::cout << "----------   ----  ------  --------" << std::endl;
+    for( i = 0; i <NoOfFields; i++ ){
+      if( SchemaPtr[i].Type == 'C' && SchemaPtr[i].NoOfDecs > 0 )
+        printf( "%10s    %1c     %4d    %4d\n", SchemaPtr[i].FieldName,
+               SchemaPtr[i].Type, SchemaPtr[i].FieldLen, 0 );
+      else    
+        printf( "%10s    %1c     %4d    %4d\n", SchemaPtr[i].FieldName,
+               SchemaPtr[i].Type, SchemaPtr[i].FieldLen, SchemaPtr[i].NoOfDecs );
+    }
+  }
+  std::cout << std::endl;
+  return XB_NO_ERROR;
+}
+#endif
+/************************************************************************/
+//! Open the DBF file.
+/*!
+  This method attempts to open the DBF file with the specified
+  name (TableName).  This method does not position to any particular
+  record in the file.  The record buffer is blanked (set to spaces).
+
+  \param TableName Name of table to open
+  \returns One of the following:  
+    \htmlonly
+      <p>
+      <table border=2><tr><th>Return Code</th><th>Description</th></tr>
+        <tr><td>XB_NO_ERROR</td><td>No error</td></tr>
+        <tr><td>XB_OPEN_ERROR</td><td>Couldn't open file</td></tr>
+        <tr><td>XB_NO_MEMORY</td><td>Memory allocation error</td></tr>
+        <tr><td>XB_NOT_XBASE</td><td>Not an DBF file</td></tr>
+      </table>
+    \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{Return Code} & \textbf{Description} \\ \hline \hline
+        XB\_NO\_ERROR & No error \\ \hline
+        XB\_OPEN\_ERROR & Couldn't open file \\ \hline
+        XB\_NO\_MEMORY & Memory allocation error \\ \hline
+        XB\_NOT\_XBASE & Not an DBF file \\ \hline
+      \end{tabular}
+    \endlatexonly
+*/
+xbShort xbDbf::OpenDatabase( const char * TableName )
+{
+  xbShort i, j, rc;
+  char buf[33];
+  char *p;
+
+#ifdef XB_MEMO_FIELDS
+  xbShort MemoSw = 0;
+#endif
+
+  /* verify the file is not already open */
+  if( DbfStatus != XB_CLOSED )
+    return XB_ALREADY_OPEN;
+
+  /* copy the file name to the class variable */
+  SetFileName( TableName );
+
+  /* open the file */
+  if(( fp = fopen(GetFileName(), "r+b")) == NULL ){
+    //
+    //  Try to open read only if failed to open read/write
+    //
+    if(( fp = fopen(GetFileName(), "rb")) == NULL )
+      return XB_OPEN_ERROR;
+  }
+
+#ifdef XB_LOCKING_ON
+  /* no buffering in multi user mode - may not see what others have updated */
+  setbuf( fp, NULL );
+  
+  /* open the lock file if XB_XBASE_LOCK_MODE */
+//  if( LockMode == XB_XBASE_LOCK_MODE )
+//    if(( rc = OpenXbLockFile()) != XB_NO_ERROR )
+//      return rc;
+#endif
+
+#ifdef XB_LOCKING_ON
+//  if( AutoLock )
+//    if(( rc = LockDatabase( XB_LOCK, 0L )) != XB_NO_ERROR)
+//      return rc;
+#endif
+
+  /* copy the header into memory */
+  if(( rc = ReadHeader( 1 )) != XB_NO_ERROR ){
+    InitVars();
+    return rc;
+  }
+
+  /* check the version */
+  if( Version == 3 || Version == (char)0x83 ){ /* dBASE III+ */
+    XFV = 3;
+#ifdef XB_MEMO_FIELDS
+    MemoHeader.Version = 0x03;
+#endif
+  }
+  else if( Version == 4 || Version == (char)0x8B ){     /* dBASE IV */
+    XFV = 4;
+#ifdef XB_MEMO_FIELDS
+    MemoHeader.Version = 0x00;
+#endif
+  }
+  else if( Version == (char)0xf5 ){    /* FoxPro */
+    XFV = 4;
+#ifdef XB_MEMO_FIELDS
+    MemoHeader.Version = 0x00;
+#endif
+  }
+  else if( Version == (char)0x30 ){  /* Visual Foxpro */
+    XFV = 4;
+#ifdef XB_MEMO_FIELDS
+    MemoHeader.Version = 0x00;
+#endif
+  } else {
+    InitVars();
+    return XB_NOT_XBASE;
+  }
+
+  // it would seem that dBASE III+ generates an UpdateYY value
+  // of 0 for 2000 and dBASE IV uses 100, so I have removed the
+  // check for UpdateYY being 0 (which might be valid).  DTB
+
+  // Not all flavors of database tools use these fields
+  // Found a month set to 0 in  valid dbf file 
+  // Commented out this check 2/11/06 - GAK
+
+  //  if( UpdateMM == 0 || UpdateDD == 0 ){
+  //    InitVars();
+  //    return XB_NOT_XBASE;
+  //  }
+
+  /* calculate the number of fields */
+  if( Version == (char)0x30 ) {
+    NoOfFields = ( HeaderLen - 296 ) / 32 ;
+  } else {
+    NoOfFields = ( HeaderLen - 33 ) / 32;
+  }
+
+  if(( RecBuf = (char *) malloc( RecordLen )) == NULL ) {
+    fclose( fp );
+    InitVars();
+    return XB_NO_MEMORY;
+  }
+  if(( RecBuf2 = (char *) malloc( RecordLen )) == NULL ) {
+    fclose( fp );
+    free( RecBuf );
+    InitVars();
+    return XB_NO_MEMORY;
+  }
+
+  if((SchemaPtr=(xbSchemaRec *)malloc(NoOfFields*sizeof(xbSchemaRec)))==NULL){
+    free( RecBuf );
+    free( RecBuf2 );
+    fclose( fp );
+    InitVars();
+    return XB_NO_MEMORY;
+  }
+  memset( SchemaPtr, 0x00, ( NoOfFields * sizeof(xbSchemaRec)));
+
+  /* copy field info into memory */
+  for( i = 0, j = 1; i < NoOfFields; i++ ){
+    _fseek( fp,((xbOffT)i*32+32), 0 );
+    fread( &buf, 1, 32, fp );
+    p = buf;
+    strncpy( SchemaPtr[i].FieldName, p, 10 );
+    p += 11;
+    SchemaPtr[i].Type = *p++;
+
+    SchemaPtr[i].Address  = RecBuf + j;
+    SchemaPtr[i].Address2 = RecBuf2 + j;
+
+    SchemaPtr[i].FieldLen = *( p + 4 );
+    SchemaPtr[i].NoOfDecs = *( p + 5 );
+
+    if( SchemaPtr[i].Type == 'C' && SchemaPtr[i].NoOfDecs > 0 ){
+      SchemaPtr[i].LongFieldLen = xbase->GetShort( p + 4 );
+      j += SchemaPtr[i].LongFieldLen;
+    }
+    else
+      j += SchemaPtr[i].FieldLen;
+#ifdef XB_MEMO_FIELDS
+      if( !MemoSw && (SchemaPtr[i].Type == 'M' || 
+        SchemaPtr[i].Type == 'B' || SchemaPtr[i].Type == 'O' ))
+        MemoSw++;
+#endif
+  } 
+  CurRec = 0L;
+  BlankRecord();
+  DbfStatus = XB_OPEN;
+
+#ifdef XB_MEMO_FIELDS
+  if( MemoSw )   /* does this table have memo fields ? */
+    if(( rc = OpenMemoFile()) != XB_NO_ERROR ){
+      free( RecBuf );
+      free( RecBuf2 );
+      free( SchemaPtr );
+      fclose( fp );
+      InitVars(); 
+      return rc;
+    }
+#endif
+
+#ifdef XB_LOCKING_ON
+//  if( AutoLock )
+//    LockDatabase( XB_UNLOCK, 0L );
+#endif               /* XB_LOCKING_ON */
+
+  return xbase->AddDbfToDbfList( this, GetFileName() );
+}
+/************************************************************************/
+//! Blank the record buffer.
+/*!
+  Sets the record to spaces.
+*/
+xbShort xbDbf::BlankRecord()
+{
+  if( DbfStatus == XB_CLOSED ) 
+    return XB_NOT_OPEN;
+
+  if( DbfStatus != XB_UPDATED ){
+    DbfStatus = XB_UPDATED;
+    memcpy( RecBuf2, RecBuf, RecordLen );
+  }
+  
+  memset( RecBuf, 0x20, RecordLen );
+  return XB_NO_ERROR;
+}
+/************************************************************************/
+//! Append the current record to the data file
+/*!
+  This method attempts to append the contents of the current record buffer
+  to the end of the DBF file and updates the file date and number of
+  records in the file.  Also updates any open indices associated with
+  this data file.
+  
+  \returns One of the following:
+    \htmlonly
+      <p>
+      <table border=2><tr><th>Return Code</th><th>Description</th></tr>
+        <tr><td>XB_NO_ERROR</td><td>No error</td></tr>
+        <tr><td>XB_LOCK_FAILED</td><td>Couldn't lock file</td></tr>
+        <tr><td>XB_WRITE_ERROR</td><td>Error writing to file</td></tr>
+      </table>
+    \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{Return Code} & \textbf{Description} \\ \hline \hline
+        XB\_NO\_ERROR & No error \\ \hline
+   XB\_LOCK\_FAILED & Couldn't lock file \\ \hline
+   XB\_WRITE\_ERROR & Error writing to file \\ \hline
+      \end{tabular}
+    \endlatexonly
+*/
+xbShort xbDbf::AppendRecord()
+{
+  xbShort rc;      
+  xbULong nextRecNo;
+
+#if defined(XB_INDEX_ANY)
+  xbIxList *i;
+#endif
+
+/* lock the database */
+#ifdef XB_LOCKING_ON
+//  if( AutoLock )
+//    if(( rc = LockDatabase( XB_LOCK, 0L )) != XB_NO_ERROR) 
+//      return rc;
+
+  rc = ReadHeader(1);
+
+//  if(AutoLock)
+//    LockDatabase( XB_UNLOCK, 0L );
+
+  if( rc )
+    return rc;
+
+#endif
+
+/* lock any indexes */
+#if defined(XB_INDEX_ANY)
+#ifdef XB_LOCKING_ON
+  i = NdxList;
+  while( i && AutoLock ){
+//    if(( rc = i->index->LockIndex( XB_LOCK )) != XB_NO_ERROR ) 
+//      return rc;
+    i = i->NextIx;
+  }
+#endif               /* XB_LOCKING_ON */
+#endif
+
+// if there are no duplicates, and no records set the CurRec to the
+// last record + 1.  This is for EXP::RECNO()
+
+/* check for any duplicate keys */
+#if defined(XB_INDEX_ANY)
+  i = NdxList;
+  while( i ){
+    if( i->index->UniqueIndex() ){
+      i->index->CreateKey( 0, 0 );
+      if( i->index->FindKey() == XB_FOUND )
+      return XB_KEY_NOT_UNIQUE;
+    }
+    i = i->NextIx;
+  }
+#endif
+
+#ifdef XB_REAL_DELETE
+  if(RealDelete && FirstFreeRec)
+    nextRecNo = FirstFreeRec;
+  else
+    nextRecNo = NoOfRecs + 1;
+#else
+  nextRecNo = NoOfRecs + 1;
+#endif
+
+  CurRec = NoOfRecs + 1;
+
+#if defined(XB_INDEX_ANY)
+/* update the indexes */
+  i = NdxList;
+  while( i ){
+    if( !i->index->UniqueIndex() )          /* if we didn't prepare the key */
+      if(( rc = i->index->CreateKey( 0, 0 )) != XB_NO_ERROR ) /* then do it before the add    */
+        return rc;
+    if(( rc =  i->index->AddKey(nextRecNo)) != XB_NO_ERROR )
+      return rc;
+    i->index->TouchIndex();
+    i = i->NextIx;
+  }
+#endif              /* XB_INDEX_ANY */
+
+#ifdef XB_REAL_DELETE
+  char buf[4];
+
+  if(RealDelete && FirstFreeRec){
+    /*
+    **  Grab the next free rec no and put it in FirstFreeRec
+    */
+    if(_fseek(fp, (HeaderLen+(((xbOffT)FirstFreeRec-1)*RecordLen)+1), 0) != 0)
+      return XB_SEEK_ERROR;
+       
+    if(fread(buf, 4, 1, fp) != 1)
+      return XB_READ_ERROR;
+       
+    FirstFreeRec = xbase->GetULong(buf);
+  }
+   
+  /*
+  **  Okay, seek and write the record out
+  */
+  if(_fseek(fp, (HeaderLen+(((xbOffT)nextRecNo-1)*RecordLen)), 0) != 0)
+    return XB_SEEK_ERROR;
+     
+  if(fwrite( RecBuf, RecordLen, 1, fp) != 1)
+    return XB_WRITE_ERROR;
+
+  /*
+  **  If we just appended the record to the file, then write the EOF char
+  */
+  if(nextRecNo == NoOfRecs + 1){
+    if( fputc( XB_CHAREOF, fp ) != XB_CHAREOF )
+      return XB_WRITE_ERROR;
+  }
+#else
+  /* write the last record */
+  if( _fseek( fp,(HeaderLen+((xbOffT)NoOfRecs*RecordLen)), 0 ) != 0 )
+    return XB_SEEK_ERROR;
+
+  if( fwrite( RecBuf, RecordLen, 1, fp ) != 1 )
+    return XB_WRITE_ERROR;
+
+   /* write the end of file marker */
+  if( fputc( XB_CHAREOF, fp ) != XB_CHAREOF )
+    return XB_WRITE_ERROR;
+#endif
+
+  /* calculate the latest header information */
+  xbDate d; 
+  UpdateYY = d.YearOf() - 1900;
+  if(XFV == 3)
+    UpdateYY %= 100;  // dBASE III seems to do this, IV does not.  DTB
+  UpdateMM = d.MonthOf();
+  UpdateDD = d.DayOf( XB_FMT_MONTH );
+#ifndef XB_REAL_DELETE
+  NoOfRecs++;
+#else
+  if(RealDelete){
+    if(nextRecNo == NoOfRecs + 1)
+      NoOfRecs++;
+    RealNumRecs++;
+  }
+  else
+    NoOfRecs++;
+#endif
+  CurRec = nextRecNo;
+
+  /* rewrite the header record */
+  if(( rc = WriteHeader( 1 )) != XB_NO_ERROR )
+     return rc;
+
+#ifdef XB_LOCKING_ON
+//  if( AutoLock )
+//    LockDatabase( XB_UNLOCK, 0L );
+
+#if defined(XB_INDEX_ANY)
+  i = NdxList;
+  while( i && AutoLock ){
+//    i->index->LockIndex( XB_UNLOCK );
+    i = i->NextIx;
+  }
+#endif               /* XB_INDEX_ANY  */
+#endif               /* XB_LOCKING_ON */
+
+  DbfStatus = XB_OPEN;
+  return XB_NO_ERROR;
+}
+/************************************************************************/
+//! Get a record from the data file
+/*!
+  This method attempts to retrieve the record specified by RecNo from the
+  data file into the record buffer.  
+  
+  \param RecNo Record number to retrieve
+  \returns One of the following:
+    \htmlonly
+      <p>
+      <table border=2><tr><th>Return Code</th><th>Description</th></tr>
+        <tr><td>XB_NO_ERROR</td><td>No error</td></tr>
+        <tr><td>XB_LOCK_FAILED</td><td>Couldn't lock file</td></tr>
+        <tr><td>XB_NOT_OPEN</td><td>File is not open</td></tr>
+        <tr><td>XB_INVALID_RECORD</td><td>Invalid record number</td></tr>
+        <tr><td>XB_WRITE_ERROR</td><td>Error writing to file</td></tr>
+      </table>
+    \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{Return Code} & \textbf{Description} \\ \hline \hline
+        XB\_NO\_ERROR & No error \\ \hline
+   XB\_LOCK\_FAILED & Couldn't lock file \\ \hline
+   XB\_NOT\_OPEN & File is not open \\ \hline
+   XB\_INVALID\_RECORD & Invalid record number \\ \hline
+   XB\_WRITE\_ERROR & Error writing to file \\ \hline
+      \end{tabular}
+    \endlatexonly
+*/
+xbShort xbDbf::GetRecord( xbULong RecNo )
+{
+  xbShort rc;
+  if( DbfStatus == XB_CLOSED )
+    return XB_NOT_OPEN;
+
+#ifdef XB_LOCKING_ON
+//  if( AutoLock )
+//    if(( rc = LockDatabase( XB_LOCK, RecNo )) != 0 ) return rc;
+
+  rc = ReadHeader(1);
+
+//  if(AutoLock)
+//    LockDatabase( XB_UNLOCK, RecNo );
+
+  if( rc )
+    return rc;
+
+#endif
+
+  if( RecNo > NoOfRecs || RecNo == 0L )
+    return XB_INVALID_RECORD;
+
+  if( _fseek( fp, (HeaderLen+(((xbOffT)RecNo-1L)*RecordLen)), SEEK_SET )){
+#ifdef XB_LOCKING_ON
+//    LockDatabase( XB_UNLOCK, RecNo );
+#endif
+    return XB_SEEK_ERROR;
+  }
+
+  if( fread( RecBuf, RecordLen, 1, fp ) != 1 ){
+#ifdef XB_LOCKING_ON
+//    LockDatabase( XB_UNLOCK, RecNo );
+#endif
+    return XB_READ_ERROR;
+  }
+
+#ifdef XB_LOCKING_ON
+//  if( AutoLock )
+//    LockDatabase( XB_LOCK, RecNo );
+#endif
+
+  DbfStatus = XB_OPEN;
+  CurRec = RecNo;
+  return XB_NO_ERROR;
+}
+/************************************************************************/
+//! Get the first physical record in the data file
+/*!
+  Attempts to retrieve the first physical record from the data file into
+  the record buffer.
+  
+  \returns One of the following:
+    \htmlonly
+      <p>
+      <table border=2><tr><th>Return Code</th><th>Description</th></tr>
+        <tr><td>XB_NO_ERROR</td><td>No error</td></tr>
+        <tr><td>XB_LOCK_FAILED</td><td>Couldn't lock file</td></tr>
+        <tr><td>XB_NOT_OPEN</td><td>File is not open</td></tr>
+        <tr><td>XB_INVALID_RECORD</td><td>Invalid record number</td></tr>
+        <tr><td>XB_SEEK_ERROR</td><td>Error seeking file</td></tr>
+        <tr><td>XB_WRITE_ERROR</td><td>Error writing to file</td></tr>
+      </table>
+    \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{Return Code} & \textbf{Description} \\ \hline \hline
+        XB\_NO\_ERROR & No error \\ \hline
+   XB\_LOCK\_FAILED & Couldn't lock file \\ \hline
+   XB\_NOT\_OPEN & File is not open \\ \hline
+   XB\_INVALID\_RECORD & Invalid record number \\ \hline
+   XB\_SEEK\_ERROR & Error seeking file \\ \hline
+   XB\_WRITE\_ERROR & Error writing to file \\ \hline
+      \end{tabular}
+    \endlatexonly
+*/
+xbShort xbDbf::GetFirstRecord()
+{
+  xbShort rc;
+  if( NoOfRecs == 0 )
+    return XB_INVALID_RECORD;
+
+  rc = GetRecord( 1L );
+#ifdef XB_REAL_DELETE
+  if(!rc && RealDelete && RecordDeleted())
+    rc = GetNextRecord();
+#endif
+
+  return rc;
+}
+/************************************************************************/
+//! Get the last phyiscal record in the data file
+/*!
+  Attempts to retrieve the last physical record from the data file into
+  the record buffer.
+  
+  \returns One of the following:
+    \htmlonly
+      <p>
+      <table border=2><tr><th>Return Code</th><th>Description</th></tr>
+        <tr><td>XB_NO_ERROR</td><td>No error</td></tr>
+        <tr><td>XB_LOCK_FAILED</td><td>Couldn't lock file</td></tr>
+        <tr><td>XB_EOF</td><td>At end of file</td></tr>
+        <tr><td>XB_NOT_OPEN</td><td>File is not open</td></tr>
+        <tr><td>XB_INVALID_RECORD</td><td>Invalid record number</td></tr>
+        <tr><td>XB_SEEK_ERROR</td><td>Error seeking file</td></tr>
+        <tr><td>XB_WRITE_ERROR</td><td>Error writing to file</td></tr>
+      </table>
+    \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{Return Code} & \textbf{Description} \\ \hline \hline
+        XB\_NO\_ERROR & No error \\ \hline
+   XB\_LOCK\_FAILED & Couldn't lock file \\ \hline
+   XB\_EOF & At end of file \\ \hline
+   XB\_NOT\_OPEN & File is not open \\ \hline
+   XB\_INVALID\_RECORD & Invalid record number \\ \hline
+   XB\_SEEK\_ERROR & Error seeking file \\ \hline
+   XB\_WRITE\_ERROR & Error writing to file \\ \hline
+      \end{tabular}
+    \endlatexonly
+*/
+xbShort xbDbf::GetLastRecord()
+{
+  xbShort rc;
+  if( NoOfRecs == 0 )
+    return XB_INVALID_RECORD;
+
+  rc = GetRecord( NoOfRecs );
+#ifdef XB_REAL_DELETE
+  if(!rc && RealDelete && RecordDeleted())
+    rc = GetPrevRecord();
+#endif
+
+  return rc;
+}
+/************************************************************************/
+//! Get the next physical record in the data file
+/*!
+  Attempts to retrieve the next physical record from the data file into
+  the record buffer.
+
+  \returns One of the following:
+    \htmlonly
+      <p>
+      <table border=2><tr><th>Return Code</th><th>Description</th></tr>
+        <tr><td>XB_NO_ERROR</td><td>No error</td></tr>
+        <tr><td>XB_LOCK_FAILED</td><td>Couldn't lock file</td></tr>
+        <tr><td>XB_EOF</td><td>At end of file</td></tr>
+        <tr><td>XB_NOT_OPEN</td><td>File is not open</td></tr>
+        <tr><td>XB_INVALID_RECORD</td><td>Invalid record number</td></tr>
+        <tr><td>XB_SEEK_ERROR</td><td>Error seeking file</td></tr>
+        <tr><td>XB_WRITE_ERROR</td><td>Error writing to file</td></tr>
+      </table>
+    \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{Return Code} & \textbf{Description} \\ \hline \hline
+        XB\_NO\_ERROR & No error \\ \hline
+   XB\_LOCK\_FAILED & Couldn't lock file \\ \hline
+   XB\_EOF & At end of file \\ \hline
+   XB\_NOT\_OPEN & File is not open \\ \hline
+   XB\_INVALID\_RECORD & Invalid record number \\ \hline
+   XB\_SEEK\_ERROR & Error seeking file \\ \hline
+   XB\_WRITE\_ERROR & Error writing to file \\ \hline
+      \end{tabular}
+    \endlatexonly
+*/
+xbShort xbDbf::GetNextRecord()
+{
+  xbShort rc;
+  if( NoOfRecs == 0 ) 
+    return XB_INVALID_RECORD;
+  else if( CurRec >= NoOfRecs ) 
+    return XB_EOF;
+  
+  rc = GetRecord( ++CurRec );
+
+#ifdef XB_REAL_DELETE
+  while(!rc && RealDelete && RecordDeleted())
+    rc = GetRecord(++CurRec);
+#endif
+  
+  return rc;
+}
+/************************************************************************/
+//! Get the previous physical record in the data file
+/*!
+  Attempts to retrieve the previous physical record from the data file into
+  the record buffer.
+  
+  \returns One of the following:
+    \htmlonly
+      <p>
+      <table border=2><tr><th>Return Code</th><th>Description</th></tr>
+        <tr><td>XB_NO_ERROR</td><td>No error</td></tr>
+        <tr><td>XB_LOCK_FAILED</td><td>Couldn't lock file</td></tr>
+        <tr><td>XB_BOF</td><td>At beginning of file</td></tr>
+        <tr><td>XB_NOT_OPEN</td><td>File is not open</td></tr>
+        <tr><td>XB_INVALID_RECORD</td><td>Invalid record number</td></tr>
+        <tr><td>XB_SEEK_ERROR</td><td>Error seeking file</td></tr>
+        <tr><td>XB_WRITE_ERROR</td><td>Error writing to file</td></tr>
+      </table>
+    \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{Return Code} & \textbf{Description} \\ \hline \hline
+        XB\_NO\_ERROR & No error \\ \hline
+   XB\_LOCK\_FAILED & Couldn't lock file \\ \hline
+   XB\_BOF & At beginning of file \\ \hline
+   XB\_NOT\_OPEN & File is not open \\ \hline
+   XB\_INVALID\_RECORD & Invalid record number \\ \hline
+   XB\_SEEK\_ERROR & Error seeking file \\ \hline
+   XB\_WRITE\_ERROR & Error writing to file \\ \hline
+      \end{tabular}
+    \endlatexonly
+*/
+xbShort xbDbf::GetPrevRecord()
+{
+  xbShort rc;
+  if( NoOfRecs == 0 ) 
+    return XB_INVALID_RECORD;
+  else if( CurRec <= 1L ) 
+    return XB_EOF;
+  
+  rc = GetRecord( --CurRec );
+
+#ifdef XB_REAL_DELETE
+  while(!rc && RealDelete && RecordDeleted())
+    rc = GetRecord(--CurRec);
+#endif
+
+  return rc;
+}
+/************************************************************************/
+//! Dump record
+/*!
+  Dump the contents of the specified record to stdout.
+
+  \param RecNo Record number of record to be dumped.
+  \returns An error code (same as GetRecord()).
+*/
+xbShort xbDbf::DumpRecord( xbULong RecNo )
+{
+  int i, rc;
+  char buf[4096];
+
+  if( RecNo == 0 || RecNo > NoOfRecs )
+    return XB_INVALID_RECORD;
+
+  rc = GetRecord( RecNo );
+  if( rc != XB_NO_ERROR )
+    return rc;
+
+  std::cout << "\nREC NUMBER " << RecNo << "\n";
+
+  if( RecordDeleted() )
+    std::cout << "\nRecord deleted...\n";
+
+  for( i = 0; i < NoOfFields; i++ ){
+#ifdef XB_MEMO_FIELDS
+    if(SchemaPtr[i].Type == 'M'){
+      if( MemoFieldExists( i )){
+        std::cout << SchemaPtr[i].Type << " " << SchemaPtr[i].FieldName 
+                  << " len = " << GetMemoFieldLen( i ) << std::endl;
+        memset( buf, 0x00, 4095 );
+        rc = GetMemoField(i, 4095, buf, 0);
+        if(rc != XB_NO_ERROR)
+          return rc;
+      } else {
+         buf[0] = 0x00;
+      }    
+    }
+    else
+      GetField( i, buf );
+    std::cout << SchemaPtr[i].Type << " " << SchemaPtr[i].FieldName << " = '" << buf << "'\n";
+#else
+    GetField( i, buf );
+    std::cout << SchemaPtr[i].FieldName << " = '" << buf << "'\n";
+#endif
+  }
+  std::cout << std::endl;
+  return XB_NO_ERROR;
+}
+/************************************************************************/
+//! Write the current record buffer to the current record in the data file.
+/*!
+  Attempts to write the contents of the record buffer to the current
+  record in the data file.  Updates any open indexes.
+
+  \sa PutRecord(xbULong RecNo)
+  \returns One of the following:
+    \htmlonly
+      <p>
+      <table border=2><tr><th>Return Code</th><th>Description</th></tr>
+        <tr><td>XB_NO_ERROR</td><td>No error</td></tr>
+        <tr><td>XB_LOCK_FAILED</td><td>Couldn't lock file</td></tr>
+        <tr><td>XB_NOT_OPEN</td><td>File is not open</td></tr>
+        <tr><td>XB_INVALID_RECORD</td><td>Invalid record number</td></tr>
+        <tr><td>XB_SEEK_ERROR</td><td>Error seeking file</td></tr>
+        <tr><td>XB_WRITE_ERROR</td><td>Error writing to file</td></tr>
+      </table>
+    \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{Return Code} & \textbf{Description} \\ \hline \hline
+        XB\_NO\_ERROR & No error \\ \hline
+   XB\_LOCK\_FAILED & Couldn't lock file \\ \hline
+   XB\_NOT\_OPEN & File is not open \\ \hline
+   XB\_INVALID\_RECORD & Invalid record number \\ \hline
+   XB\_SEEK\_ERROR & Error seeking file \\ \hline
+   XB\_WRITE\_ERROR & Error writing to file \\ \hline
+      \end{tabular}
+    \endlatexonly
+*/
+
+/************************************************************************/
+xbShort xbDbf::PutRecord() {
+   return PutRecord(CurRec);
+}
+
+//! Write the current record buffer to the specified record in the data file.
+/*!
+  Attempts to write the contents of the record buffer to the record specified
+  by RecNo.  Updates any open indexes.
+  
+  \param RecNo Record number to which data should be written
+  \returns One of the following:
+    \htmlonly
+      <p>
+      <table border=2><tr><th>Return Code</th><th>Description</th></tr>
+        <tr><td>XB_NO_ERROR</td><td>No error</td></tr>
+        <tr><td>XB_LOCK_FAILED</td><td>Couldn't lock file</td></tr>
+        <tr><td>XB_NOT_OPEN</td><td>File is not open</td></tr>
+        <tr><td>XB_INVALID_RECORD</td><td>Invalid record number</td></tr>
+        <tr><td>XB_SEEK_ERROR</td><td>Error seeking file</td></tr>
+        <tr><td>XB_WRITE_ERROR</td><td>Error writing to file</td></tr>
+      </table>
+    \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{Return Code} & \textbf{Description} \\ \hline \hline
+        XB\_NO\_ERROR & No error \\ \hline
+   XB\_LOCK\_FAILED & Couldn't lock file \\ \hline
+   XB\_NOT\_OPEN & File is not open \\ \hline
+   XB\_INVALID\_RECORD & Invalid record number \\ \hline
+   XB\_SEEK\_ERROR & Error seeking file \\ \hline
+   XB\_WRITE\_ERROR & Error writing to file \\ \hline
+      \end{tabular}
+    \endlatexonly
+*/
+xbShort xbDbf::PutRecord(xbULong RecNo) 
+{
+  xbShort  rc;
+
+#if defined(XB_INDEX_ANY)
+  xbIxList *i;
+#endif
+
+  if( DbfStatus == XB_CLOSED )
+    return XB_NOT_OPEN;
+
+/* lock the database */
+#ifdef XB_LOCKING_ON
+  if( AutoLock ){
+//    if(( rc = LockDatabase( XB_LOCK, RecNo )) != XB_NO_ERROR ) 
+//      return rc;
+//    if(( rc = LockDatabase( XB_LOCK, 0L )) != XB_NO_ERROR ){
+//      LockDatabase( XB_UNLOCK, RecNo );
+//      return rc;
+//    }
+     
+    if((rc = ReadHeader(1)) != XB_NO_ERROR){
+//      if(AutoLock){
+//        LockDatabase( XB_UNLOCK, RecNo );
+//        LockDatabase( XB_UNLOCK, 0L );
+//      }
+      return rc;
+    }
+  }
+#endif
+
+  if( RecNo > NoOfRecs || RecNo == 0L )
+    return XB_INVALID_RECORD;
+
+/* lock the indexes */
+#if defined(XB_INDEX_ANY)
+#ifdef XB_LOCKING_ON
+  i = NdxList;
+  while( i && AutoLock ){
+//    if(( rc = i->index->LockIndex( XB_LOCK )) != XB_NO_ERROR ) 
+//      return rc;
+    i = i->NextIx;
+  }
+#endif               /* XB_LOCKING_ON */
+#endif
+
+#if defined(XB_INDEX_ANY)
+  /* for any unique indexes that were updated, verify no unique keys exist */
+  i = NdxList;
+  while( i ){
+    if( i->index->UniqueIndex() ){
+      if(( i->KeyUpdated = i->index->KeyWasChanged()) == 1 ){
+        i->index->CreateKey(0, 0);
+         if( i->index->FindKey() == XB_FOUND && i->index->GetCurDbfRec() != RecNo)
+           return XB_KEY_NOT_UNIQUE;
+      }
+    }
+    i = i->NextIx;
+  }
+#endif
+
+#if defined(XB_INDEX_ANY)
+   /* loop through deleting old index keys and adding new index keys */
+  i = NdxList;
+  while( i ){
+    if( !i->index->UniqueIndex() )
+      i->KeyUpdated = i->index->KeyWasChanged();
+    if( i->KeyUpdated ){
+      i->index->CreateKey( 1, 0 );      /* load key buf w/ old values */
+      if((rc = i->index->DeleteKey( CurRec )) != XB_NO_ERROR){
+#ifdef XB_LOCKING_ON
+//        if( AutoLock ){
+//          LockDatabase( XB_UNLOCK, RecNo );
+//          LockDatabase( XB_UNLOCK, 0L );
+//        }
+#if defined(XB_INDEX_ANY)
+        i = NdxList;
+        while( i && AutoLock ){
+//          i->index->LockIndex( XB_UNLOCK );
+          i = i->NextIx;
+        }
+#endif               /* XB_INDEX_ANY  */
+#endif               /* XB_LOCKING_ON */
+      return rc;
+    }
+
+    i->index->CreateKey( 0, 0 );
+    if(( rc = i->index->AddKey(CurRec)) != XB_NO_ERROR ){
+#ifdef XB_LOCKING_ON
+//      if( AutoLock ){
+//        LockDatabase( XB_UNLOCK, RecNo );
+//        LockDatabase( XB_UNLOCK, 0L );
+//      }
+#if defined(XB_INDEX_ANY)
+      i = NdxList;
+      while( i && AutoLock ){
+//        i->index->LockIndex( XB_UNLOCK );
+        i = i->NextIx;
+      }
+#endif               /* XB_INDEX_ANY  */
+#endif               /* XB_LOCKING_ON */
+      return rc;
+    }
+    i->index->TouchIndex();
+   }
+   i = i->NextIx;
+ }
+#endif                        /* XB_INDEX_ANY */
+
+ if( _fseek( fp, (HeaderLen+(((xbOffT)RecNo-1L)*RecordLen)),0 ))
+   return XB_SEEK_ERROR;
+
+ if( fwrite( RecBuf, RecordLen, 1, fp ) != 1 )
+   return XB_WRITE_ERROR;
+
+ /* calculate the latest header information */
+ xbDate d;
+ UpdateYY = d.YearOf() - 1900;
+ if(XFV == 3)
+    UpdateYY %= 100;  // dBASE III seems to do this, IV does not.  DTB
+ UpdateMM = d.MonthOf();
+ UpdateDD = d.DayOf( XB_FMT_MONTH );
+
+ /* rewrite the header record */
+ if(( rc = WriteHeader( 1 )) != XB_NO_ERROR )
+   return rc;
+
+#ifdef XB_LOCKING_ON
+//  if( AutoLock ){
+//    LockDatabase( XB_UNLOCK, RecNo );
+//    LockDatabase( XB_UNLOCK, 0L );
+//  }
+
+#if defined(XB_INDEX_ANY)
+  i = NdxList;
+  while( i && AutoLock ){
+//    i->index->LockIndex( XB_UNLOCK );
+    i = i->NextIx;
+  }
+#endif               /* XB_INDEX_ANY  */
+#endif               /* XB_LOCKING_ON */
+
+  CurRec = RecNo;
+  DbfStatus = XB_OPEN;
+  return XB_NO_ERROR;
+}
+/************************************************************************/
+//! Delete the current record
+/*!
+  Marks the current record as deleted or if "real" deletes are turned
+  on (xbDbf::RealDeleteOn()) will delete the record and add it to the
+  free record list.  Normal dBase behavior is to simply mark the record
+  as deleted; the record will actually be deleted when the the DBF file 
+  "packed" (xbDbf::PackDatabase()).  If "real" deletes are not on, a 
+  record may be undeleted using xbDbf::UndeleteRecord().
+  
+  \returns One of the following:
+    \htmlonly
+      <p>
+      <table border=2><tr><th>Return Code</th><th>Description</th></tr>
+        <tr><td>XB_NO_ERROR</td><td>No error</td></tr>
+        <tr><td>XB_INVALID_RECORD</td><td>Invalid record number</td></tr>
+      </table>
+    \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{Return Code} & \textbf{Description} \\ \hline \hline
+        XB\_NO\_ERROR & No error \\ \hline
+   XB\_INVALID\_RECORD & Invalid record number \\ \hline
+      \end{tabular}
+    \endlatexonly
+*/
+xbShort xbDbf::DeleteRecord()
+{
+  xbULong newCurRec = 0;
+  xbShort rc = XB_NO_ERROR;
+
+#if defined(XB_INDEX_ANY)
+  xbIxList *i;
+#endif
+
+  if(!RecBuf)   
+    return XB_INVALID_RECORD;
+     
+  if(CurRec < 1 || CurRec > NoOfRecs)
+    return XB_INVALID_RECORD;
+          
+/* lock the database */
+#ifdef XB_LOCKING_ON
+
+  if( AutoLock ){
+/*
+    if(( rc = LockDatabase( XB_LOCK, CurRec )) != XB_NO_ERROR ) 
+      return rc;
+    if(( rc = LockDatabase( XB_LOCK, 0L )) != XB_NO_ERROR ){
+      LockDatabase( XB_UNLOCK, CurRec );
+      return rc;
+    }
+ */
+    if((rc = ReadHeader(1)) != XB_NO_ERROR){
+//      if(AutoLock){
+//        LockDatabase( XB_UNLOCK, CurRec );
+//        LockDatabase( XB_UNLOCK, 0L );
+//      }
+      return rc;
+    }
+  }
+#endif
+
+/* lock the indexes */
+#if defined(XB_INDEX_ANY) && defined(XB_LOCKING_ON) && defined(XB_REAL_DELETE)
+  i = NdxList;
+  while( i && AutoLock ){
+//    if(( rc = i->index->LockIndex( XB_LOCK )) != XB_NO_ERROR )
+//       return rc;
+    i = i->NextIx;
+  }
+#endif
+
+/* remove keys from indexes */
+#if defined(XB_REAL_DELETE) && defined(XB_INDEX_ANY)
+
+  if(RealDelete){
+    i = NdxList;
+    while(i){
+      i->index->CreateKey(0, 0);      /* load key buf */
+      if(i->index->GetCurDbfRec() == (xbULong)CurRec){
+        i->index->DeleteKey(CurRec);
+        newCurRec = i->index->GetCurDbfRec();
+      }
+      else
+        i->index->DeleteKey(CurRec);
+      i->index->TouchIndex();
+      i = i->NextIx;
+    }
+  }
+
+#endif
+
+  RecBuf[0] = 0x2a;
+
+
+#ifdef XB_REAL_DELETE
+  if(RealDelete){
+#ifdef XB_MEMO_FIELDS
+    //
+    //  Delete memo data for memo fields.
+    //
+    for(int f = 0; f < NoOfFields; f++ )
+      if(GetFieldType(f) == 'M' && MemoFieldExists(f))
+        UpdateMemoData(f, 0, 0, XB_LOCK);
+#endif
+    xbase->PutULong(&RecBuf[1], FirstFreeRec);
+    FirstFreeRec = CurRec;
+    RealNumRecs--;
+    WriteHeader(1);
+ }
+#endif
+
+ if(!RealDelete){
+   if( DbfStatus != XB_UPDATED ){
+     DbfStatus = XB_UPDATED;
+     memcpy( RecBuf2, RecBuf, RecordLen );
+   }
+   rc = PutRecord( CurRec );
+ }
+ else
+ {
+   if(_fseek( fp, (HeaderLen+(((xbOffT)CurRec-1L)*RecordLen)), 0))
+     return XB_SEEK_ERROR;
+   if(fwrite( RecBuf, RecordLen, 1, fp ) != 1 )
+     return XB_WRITE_ERROR;
+
+   //
+   //  Attempt to read in the record for the current location
+   //  in the active index.
+   //
+   CurRec = newCurRec;
+   if(CurRec)
+     rc = GetRecord(CurRec);
+   else
+     BlankRecord();
+ }
+      
+#ifdef XB_LOCKING_ON
+//  if(AutoLock){
+//    LockDatabase( XB_UNLOCK, CurRec );
+//    LockDatabase( XB_UNLOCK, 0L );
+//  }
+
+#if defined(XB_INDEX_ANY) && defined(XB_REAL_DELETE)
+  i = NdxList;
+  while( i && AutoLock ){
+//    i->index->LockIndex( XB_UNLOCK );
+    i = i->NextIx;
+  }
+#endif               /* XB_INDEX_ANY  */
+#endif               /* XB_LOCKING_ON */
+
+  return rc;
+}
+/************************************************************************/
+//! Undelete the current record
+/*!
+  Marks the currect record as not deleted (i.e. removes the flag indicating
+  the record is deleted).  This method may not be used (and will return
+  an error code) if "real" deletes are on.
+  
+  \returns One of the following:
+    \htmlonly
+      <p>
+      <table border=2><tr><th>Return Code</th><th>Description</th></tr>
+        <tr><td>XB_NO_ERROR</td><td>No error</td></tr>
+        <tr><td>XB_INVALID_RECORD</td><td>Invalid record number</td></tr>
+      </table>
+    \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{Return Code} & \textbf{Description} \\ \hline \hline
+        XB\_NO\_ERROR & No error \\ \hline
+   XB\_INVALID\_RECORD & Invalid record number \\ \hline
+      \end{tabular}
+    \endlatexonly
+*/
+xbShort xbDbf::UndeleteRecord()
+{
+  xbShort rc;
+   
+#ifdef XB_REAL_DELETE
+  if(RealDelete)
+    return XB_INVALID_RECORD;
+#endif
+  if( RecBuf ){
+    if( DbfStatus != XB_UPDATED ){
+      DbfStatus = XB_UPDATED;
+      memcpy( RecBuf2, RecBuf, RecordLen );
+    }
+  
+    RecBuf[0] = 0x20;
+    if(( rc = PutRecord( CurRec )) != 0 )
+      return rc;
+  }
+  else
+    return XB_INVALID_RECORD;
+
+  return 0;
+}
+/************************************************************************/
+//! Determine if current record is deleted
+/*!
+  \returns TRUE (1) if the current record is marked as deleted or FALSE
+    (0) if not.
+*/
+xbShort xbDbf::RecordDeleted()
+{
+  if( RecBuf && RecBuf[0] == 0x2a )
+    return 1;
+  else
+    return 0;
+}
+/************************************************************************/
+//! Create a unique file name 
+/*!
+*/
+xbShort xbDbf::CreateUniqueDbfName( xbString & sDbfn, xbString & sDbtn )
+{
+  xbShort dnf;    /* directory in name flag */
+  xbShort unique = 0;
+  xbLong l = 1;
+  char dbfn[13];
+  char dbtn[13];
+  
+  dnf = xbase->DirectoryExistsInName( GetFileName() );
+  sprintf( dbfn, "xb%06d.dbf", l );
+  sprintf( dbtn, "xb%06d.dbt", l++ );
+  
+  if( dnf ){
+    sDbfn.assign( GetFileName(), 0, dnf );
+    sDbfn += dbfn;
+    sDbtn.assign( GetFileName(), 0, dnf );
+    sDbtn += dbtn;
+  } else  {
+    sDbfn  = dbfn;
+    sDbtn  = dbtn;
+  }
+    
+  while( !unique ){
+    if( access( sDbfn.getData(), 0 ) == -1 &&
+        access( sDbtn.getData(), 0 ) == -1 )
+      unique++;
+    else{
+      sprintf( dbfn, "xb%06d.dbf", l );
+      sprintf( dbtn, "xb%06d.dbt", l++ );
+    
+      if( dnf ){
+        sDbfn.assign( GetFileName(), 0, dnf );
+        sDbfn += dbfn;
+        sDbtn.assign( GetFileName(), 0, dnf );
+        sDbtn += dbtn;
+      } else  {
+        sDbfn  = dbfn;
+        sDbtn  = dbtn;
+      }
+    }
+  }
+  return 0;
+}
+
+/************************************************************************/
+//! Pack data file
+/*!
+*/
+xbShort xbDbf::PackDatafiles(void (*statusFunc)(xbLong itemNum, xbLong numItems))
+{
+  xbShort rc, i;
+  FILE *t;
+  xbLong l;
+  char *target, *source;
+  xbString TempDbfName;
+  xbString TempDbtName;
+  char   * Buf = 0; 
+
+#ifdef XB_MEMO_FIELDS
+  char tbuf[4];
+#endif
+
+#ifdef XB_MEMO_FIELDS
+  xbLong   len, BufSize;
+  xbShort  MemoFields;
+#endif  /* XB_MEMO_FIELDS */
+
+  xbDbf Temp( xbase );
+  CreateUniqueDbfName( TempDbfName, TempDbtName );
+
+  if(( t = fopen( TempDbfName, "w+b" )) == NULL )
+    return XB_OPEN_ERROR;
+
+  /* copy file header */
+  if(( rc = _fseek( fp, 0, SEEK_SET )) != 0 )
+    return XB_SEEK_ERROR;
+
+  for( i = 0; i < HeaderLen; i++ )
+    fputc( fgetc( fp ), t );
+  fputc( 0x1a, t );
+
+  if( fclose( t ) != 0 )
+    return XB_CLOSE_ERROR;
+
+#ifdef XB_MEMO_FIELDS
+  if(( MemoFields = MemoFieldsPresent()) > 0 ){
+
+    if((t = fopen( TempDbtName, "w+b" )) == NULL)
+       return XB_OPEN_ERROR;
+
+    l = 1L;
+    memset( tbuf, 0x00, 4 );
+    xbase->PutLong( tbuf, l );
+
+    if((fwrite(&tbuf, 4, 1, t)) != 1)
+      return XB_WRITE_ERROR;
+
+    if( MemoHeader.Version == 0x03 ){
+      for( i = 0; i < 12; i++ ) fputc( 0x00, t );
+        fputc( 0x03, t );
+      for( i = 0; i < 495; i++ ) fputc( 0x00, t );
+    } else {
+      for( i = 0; i < 4; i++ ) fputc( 0x00, t );
+      if ((fwrite(&MemoHeader.FileName, 8, 1, t)) != 1)
+        return XB_WRITE_ERROR;
+      for( i = 0; i < 4; i++ ) fputc( 0x00, t );
+        memset( tbuf, 0x00, 2 );
+      xbase->PutShort( tbuf, MemoHeader.BlockSize );
+      if ((fwrite(&tbuf, 2, 1, t)) != 1)
+        return XB_WRITE_ERROR;
+
+      for( i = 22; i < MemoHeader.BlockSize; i++ ) fputc( 0x00, t );
+    }
+
+    if( fclose( t ) != 0 )
+      return XB_CLOSE_ERROR;
+   }
+#endif   /* XB_MEMO_FIELDS */
+
+   /* reopen as database */
+   if(( rc = Temp.OpenDatabase( TempDbfName )) != XB_NO_ERROR )
+     return rc;
+
+#ifdef XB_REAL_DELETE
+   if(RealDelete)
+     Temp.RealDeleteOn();
+   Temp.FirstFreeRec = 0;
+   Temp.RealNumRecs = 0;
+#endif   
+   Temp.ResetNoOfRecs();
+   Temp.WriteHeader(2);          // flush NoOfRecs=0 to disk
+   target = Temp.GetRecordBuf();
+   source = GetRecordBuf();
+
+   for( l = 1; l <= PhysicalNoOfRecords(); l++ ){
+     if(statusFunc && (l == 1 || !(l % 100) || l == PhysicalNoOfRecords()))
+       statusFunc(l, PhysicalNoOfRecords());
+
+     if(( rc = GetRecord( l )) != XB_NO_ERROR )
+       return rc;
+
+     if( !RecordDeleted() ){
+       memcpy( target, source, GetRecordLen());
+
+#ifdef XB_MEMO_FIELDS
+       BufSize = 0L;
+//     Buf = NULL;   Already set to 0, this statement flags as memory leak
+
+       for( i = 0; i < NoOfFields; i++ ){
+         if( GetFieldType( i ) == 'M' && MemoFieldExists( i )){
+           Temp.PutLongField(i, 0L);
+           len = GetMemoFieldLen( i );
+           if( len > BufSize ){
+             if( Buf )
+               free( Buf );
+             if((Buf = (char *)malloc(len)) == NULL)
+               return XB_NO_MEMORY;
+             BufSize = len;
+           }
+           GetMemoField( i, len, Buf, -1 );
+           Temp.UpdateMemoData( i, len, Buf, -1 );
+         }
+       }
+#endif
+       if(( rc = Temp.AppendRecord()) != XB_NO_ERROR ){
+         if(Buf) free(Buf);
+         return rc;
+       }
+     }
+   }
+   if( Buf ) free( Buf );
+   Temp.CloseDatabase();
+
+   if(fclose(fp) != 0)
+     return XB_CLOSE_ERROR;
+
+   if(remove(GetFileName()) != 0)
+     return XB_WRITE_ERROR;
+
+   if(rename(TempDbfName, GetFileName()) != 0)
+     return XB_WRITE_ERROR;
+
+#ifdef XB_MEMO_FIELDS
+   if( MemoFields ){
+     if(fclose(mfp) != 0)       
+       return XB_CLOSE_ERROR;
+
+     if(remove(MemofileName) != 0)
+       return XB_WRITE_ERROR;     
+     if( rename( TempDbtName, MemofileName ) != 0 )
+       return XB_WRITE_ERROR;
+     if(( mfp = fopen( MemofileName, "r+b" )) == NULL )
+       return XB_OPEN_ERROR;
+     if(( rc = GetDbtHeader(1)) != 0 ){
+       fclose( mfp );
+       return rc;
+     }
+#ifdef XB_LOCKING_ON
+     /* no buffering in multi user mode */
+     setbuf( mfp, NULL );
+#endif
+  }
+
+#endif /* XB_MEMO_FIELDS */
+
+  if(( fp = fopen( GetFileName(), "r+b" )) == NULL )
+    return XB_OPEN_ERROR;
+
+#ifdef XB_LOCKING_ON
+  /* no buffering in multi user mode */
+  setbuf( fp, NULL );
+#endif
+
+  return XB_NO_ERROR;
+}
+/************************************************************************/
+//! Pack the database
+/*!
+  This method removes all records marked for deletion from an Xbase (.DBF)
+  file, reindexes any open index files, and also reorganizes any memo fields
+  stored in a .DBT memo file.
+
+  \param packStatusFunc status function
+  \param indexStatusFunc index status function
+
+  \param LockWaitOption One of the following:
+    \htmlonly
+      <p>
+      <table border=2><tr><th>LockWaitOption</th><th>Description</th></tr>
+        <tr><td>F_SETLK</td><td>Return immediately if the DBF file cannot be locked</td></tr>
+        <tr><td>XB_LOCK</td><td>Wait for lock on DBF file to succeed</td></tr>
+      </table>
+    \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{LockWaitOption} & \textbf{Description} \\ \hline \hline
+        F\_SETLK & Return immediately if DBF file cannot be locked \\ \hline
+        F\_SETLKW  & Wait for lock on DBF file to succeed \\ \hline
+      \end{tabular}
+    \endlatexonly
+    
+  \returns One of the following return codes:
+    \htmlonly
+      <p>
+      <table border=2><tr><th>Return Code</th><th>Description</th></tr>
+        <tr><td>XB_NO_ERROR</td><td>No error</td></tr>
+   <tr><td>XB_CLOSE_ERROR</td><td>Unable to close intermediate work file</td></tr>
+   <tr><td>XB_OPEN_ERROR</td><td>Could not open file</td></tr>
+   <tr><td>XB_NO_MEMORY</td><td>Memory allocation error</td></tr>
+        <tr><td>XB_WRITE_ERROR</td><td>Couldn't write to disk</td></tr>
+   <tr><td>XB_SEEK_ERROR</td><td>Error seeking file</td></tr>
+   <tr><td>XB_LOCK_FAILED</td><td>Unable to lock file or index</td></tr>
+      </table>
+    \endhtmlonly
+    \latexonly
+      \\
+      \\
+      \begin{tabular}{|l|l|} \hline
+        \textbf{Return Code} & \textbf{Description} \\ \hline \hline
+        XB\_NO\_ERROR & No Error \\ \hline
+   XB\_CLOSE\_ERROR & Unable to close intermediate work file \\ \hline
+        XB\_OPEN\_ERROR & Couldn't open the file \\ \hline
+   XB\_NO\_MEMORY & Memory allocation error \\ \hline
+        XB\_WRITE\_ERROR & Couldn't write to disk \\ \hline
+   XB\_SEEK\_ERROR & Error seeking file \\ \hline
+   XB\_LOCK\_FAILED & Unable to lock file or index \\ \hline
+      \end{tabular}
+    \endlatexonly
+*/
+xbShort xbDbf::PackDatabase(xbShort LockWaitOption,
+            void (*packStatusFunc)(xbLong itemNum, xbLong numItems),
+            void (*indexStatusFunc)(xbLong itemNum, xbLong numItems))
+{
+  xbShort rc;
+
+  /* lock all open files and indexes */
+//  if(( rc = ExclusiveLock( LockWaitOption )) != XB_NO_ERROR ) return rc;
+
+  if(( rc = PackDatafiles(packStatusFunc)) != XB_NO_ERROR ){
+//    ExclusiveUnlock();
+    return rc;
+  }
+
+  /* refresh file header */
+  if(( rc = ReadHeader(1)) != XB_NO_ERROR )
+    return rc;
+
+  if(( rc = RebuildAllIndices(indexStatusFunc)) != XB_NO_ERROR ) 
+    return rc;
+
+//  ExclusiveUnlock();
+  return XB_NO_ERROR;
+}
+/************************************************************************/
+//! Copy DBF structure
+/*!
+*/
+xbShort xbDbf::CopyDbfStructure(const char *NewFileName, xbShort Overlay) {
+
+  xbShort rc, i;
+  xbString ndfn;       /* new dbf file name */
+  char  ch;
+
+#ifdef XB_MEMO_FIELDS
+  char buf[9];
+  xbShort ct, NameLen;
+  xbString MemoName;
+#endif
+  FILE  *t;
+
+  /* build the new file name */
+  rc = NameSuffixMissing( 1, NewFileName );
+  ndfn = NewFileName;
+  if( rc == 1 )
+    ndfn += ".dbf";
+  else if( rc == 2 )
+    ndfn += ".DBF";
+
+  /* check if the file exists and Overlay is on */
+  if(((t = fopen( ndfn, "r" )) != NULL ) && !Overlay) {
+    fclose(t);
+    return XB_FILE_EXISTS;
+  }
+
+  /* open new file */
+  if((t = fopen(ndfn, "w+b")) == NULL)
+    return XB_OPEN_ERROR;
+
+  /* copy the file header */
+  if(( rc = _fseek( fp, 0, SEEK_SET )) != 0 )
+    return XB_SEEK_ERROR;
+
+  fputc( fgetc( fp ), t );
+
+  /* do the date */
+  xbDate d;
+  ch = d.YearOf() - 1900;
+  if(XFV == 3)
+    ch %= 100;          // dBASE III+ does this, dBASE IV does not.
+  fputc( ch, t );
+  ch = d.MonthOf();
+  fputc( ch, t );
+  ch = d.DayOf( XB_FMT_MONTH );
+  fputc( ch, t );
+
+  /* record count */
+  for( i = 0; i < 4; i++ ) fputc( 0x00, t );
+
+  if((rc = _fseek(fp, 7, SEEK_CUR)) != 0) {
+    fclose( t );
+    return XB_SEEK_ERROR;
+  }
+  for( i = 0; i < 4; i++ )
+    fputc( fgetc( fp ), t );
+
+  for( i = 0; i < 17; i++ )
+    fputc( 0x00, t );
+
+  if((rc = _fseek( fp, 17, SEEK_CUR )) != 0) {
+    fclose( t );
+    return XB_SEEK_ERROR;
+  }
+
+  for( i = 29; i < HeaderLen; i++ )
+    fputc( fgetc( fp ), t );
+
+  fputc( 0x1a, t );
+  fclose( t );
+
+#ifdef XB_MEMO_FIELDS
+  if( MemoFieldsPresent()){
+     MemoName = ndfn;
+
+     NameLen = MemoName.len();
+     NameLen--;
+     if( MemoName.getCharacter( NameLen ) == 'F' )
+       MemoName.putAt(NameLen, 'T');
+     else
+       MemoName.putAt(NameLen, 't');
+
+     if(( t = fopen( MemoName, "w+b" )) == NULL )
+       return XB_OPEN_ERROR;
+
+     memset( buf, 0x00, 4 );
+     xbase->PutLong( buf, 1L );
+     if(( fwrite( &buf, 4, 1, t )) != 1 ){
+       fclose( t );
+       return XB_WRITE_ERROR;
+     }
+     if( MemoHeader.Version == 0x03 ){
+       for( i = 0; i < 12; i++ ) fputc( 0x00, t );
+       fputc( 0x03, t );
+       for( i = 0; i < 495; i++ ) fputc( 0x00, t );
+     }
+     else
+     {
+       for( i = 0; i < 4; i++ ) fputc( 0x00, t );  // put 4 bytes 0x00
+       memset( buf, 0x00, 9 );
+       NameLen = ndfn.len();
+       for( i = 0, ct = 0; i < NameLen; i++ )
+         if( ndfn.getCharacter( i ) == PATH_SEPARATOR ){
+           ct = i;
+           ct++;
+         }
+
+       for( i = 0; i < 8 && ndfn[i+ct] != '.'; i++ )
+         buf[i] = ndfn[i+ct];
+
+       fwrite( &buf, 8, 1, t );
+       for( i = 0; i < 4; i++ ) fputc( 0x00, t );
+       memset( buf, 0x00, 2 );
+       xbase->PutShort( buf, MemoHeader.BlockSize );
+       if(( fwrite( &buf, 2, 1, t )) != 1 ){
+         fclose(t);
+         return XB_WRITE_ERROR;
+       }
+       for( i = 22; i < MemoHeader.BlockSize; i++ ) fputc( 0x00, t );
+     }
+   }
+   fclose( t );
+#endif   // XB_MEMO_FIELDS
+   return XB_NO_ERROR;
+}
+/************************************************************************/
+//! Add index to list
+/*!
+  Adds the specified index to the list of indexes maintained by the 
+  dbf.
+  
+  \param n index to add
+  \param IndexName name of index
+*/
+#if defined(XB_INDEX_ANY)
+xbShort xbDbf::AddIndexToIxList(xbIndex * n, const char *IndexName)
+{
+  xbIxList *i, *s, *t;
+
+  if( !FreeIxList ){
+    if((i = (xbIxList *) malloc(sizeof(xbIxList))) == NULL) 
+      return XB_NO_MEMORY;
+  }
+  else
+  {
+    i = FreeIxList;
+    FreeIxList = i->NextIx;
+  } 
+  memset(i, 0x00, sizeof(xbIxList));
+
+  i->IxName  = IndexName;
+  i->index   = n;
+
+  s = NULL;
+  t = NdxList;
+  while( t && strcmp( t->IxName, IndexName ) < 0 ){
+    s = t;
+    t = t->NextIx;
+  }
+  i->NextIx = t;
+  if( s == NULL )
+    NdxList = i;
+  else
+    s->NextIx = i;
+  return 0;
+}
+#endif
+/************************************************************************/
+//! Rebuild all index files
+/*!
+*/
+xbShort xbDbf::RebuildAllIndices(void (*statusFunc)(xbLong itemNum, xbLong numItems))
+{
+#if defined(XB_INDEX_ANY)
+  xbShort rc;
+  xbIxList *n;
+
+  n = NdxList;
+  while( n ){
+    if(( rc = n->index->ReIndex(statusFunc)) != XB_NO_ERROR ){
+//      ExclusiveUnlock();
+      return rc;
+    }
+    n = n->NextIx;
+  }
+#endif
+  return XB_NO_ERROR;
+}
+/************************************************************************/
+//! Delete all records
+/*!
+*/
+xbShort xbDbf::DeleteAll( xbShort Option )
+{
+  xbShort rc;
+
+  if(( NoOfRecords()) == 0 ) 
+    return XB_NO_ERROR;
+  if(( rc = GetFirstRecord()) != XB_NO_ERROR )
+    return rc;
+
+  if( Option == 0 ){   /* delete all option */
+    while( 1 ){
+      if( !RecordDeleted())
+        if(( rc = DeleteRecord()) != XB_NO_ERROR )
+          return rc;
+      if(( rc = GetNextRecord()) != XB_NO_ERROR )
+        break;
+    }
+  }
+  else   /* undelete all option */
+  {
+    while( 1 ){
+      if( RecordDeleted())
+        if(( rc = UndeleteRecord()) != XB_NO_ERROR )
+          return rc;
+        if(( rc = GetNextRecord()) != XB_NO_ERROR )
+          break;
+    }
+  }
+  if( rc == XB_EOF )
+    return XB_NO_ERROR;
+  else
+    return rc;
+}
+/************************************************************************/
+//! Delete all records and pack data file
+/*!
+*/
+xbShort xbDbf::Zap( xbShort WaitOption )
+{
+  xbShort rc;
+  xbString TempDbfName, TempDbtName;
+  
+  CreateUniqueDbfName( TempDbfName, TempDbtName );
+  if(( rc = CopyDbfStructure( TempDbfName, 1 )) != XB_NO_ERROR) {
+    return rc;
+  }
+
+  if( fp ){
+    fclose( fp );
+    fp = 0;
+  }
+
+  if(( rc = remove( GetFileName() )) != 0 )
+    return XB_WRITE_ERROR;
+
+  if(( rc = rename( TempDbfName, GetFileName() )) != 0 ) 
+    return XB_WRITE_ERROR;
+  
+  if((fp = fopen( GetFileName(), "r+b" )) == NULL)
+    return XB_OPEN_ERROR;
+
+#ifdef XB_LOCKING_ON
+  setbuf( fp, NULL );
+#endif
+  ReadHeader( 1 );
+
+#ifdef XB_MEMO_FIELDS
+  if( MemoFieldsPresent() ){
+    fclose( mfp );
+
+  if(( rc = remove( MemofileName )) != 0 )
+    return XB_WRITE_ERROR;
+
+  if(( rc = rename( TempDbtName, MemofileName )) != 0 ) 
+    return XB_WRITE_ERROR;
+  
+  if(( mfp = fopen( MemofileName, "r+b" )) == NULL)
+    return XB_OPEN_ERROR;
+
+  }
+#endif   // XB_MEMO_FIELDS
+
+  if(( rc = RebuildAllIndices()) != XB_NO_ERROR )
+    return rc;
+  
+  return XB_NO_ERROR;
+}
+/************************************************************************/
+//! Remove an index from the list
+/*!
+*/
+#if defined(XB_INDEX_ANY)
+xbShort xbDbf::RemoveIndexFromIxList(xbIndex * n) {
+  xbIxList *i, *s;
+
+  i = NdxList;
+  s = NULL;
+  while( i ){
+    if( i->index == n ){
+      /* remove it from current chain */
+      if( s )
+        s->NextIx = i->NextIx;
+      else
+        NdxList = i->NextIx;
+
+      /* add i to the current free chain */
+      i->NextIx = FreeIxList;
+      FreeIxList = i;
+      FreeIxList->IxName = (const char *)NULL;
+      FreeIxList->index = NULL;
+      break;
+    }
+    else
+    {
+      s = i;
+      i = i->NextIx;
+    }
+  }
+  return XB_NO_ERROR;
+} 
+#endif
+
+/************************************************************************/
+//! Gets the number of records in the data file
+/*!
+*/
+xbLong xbDbf::NoOfRecords()
+{
+  xbLong numRecs;
+
+/* lock the database */
+#ifdef XB_LOCKING_ON
+  xbShort rc;
+
+  if( AutoLock ){
+//    if(( rc = LockDatabase( XB_LOCK, 0L )) != XB_NO_ERROR )
+//      return rc;
+
+    if((rc = ReadHeader(1)) != XB_NO_ERROR){
+//      if(AutoLock)
+//        LockDatabase( XB_UNLOCK, 0L );
+      return rc;
+    }
+  }
+#endif
+
+#ifndef XB_REAL_DELETE
+  numRecs = NoOfRecs;
+#else
+  numRecs = RealDelete ? RealNumRecs : NoOfRecs;
+#endif
+
+#ifdef XB_LOCKING_ON
+//  if(AutoLock)
+//    LockDatabase( XB_UNLOCK, 0L );
+#endif
+
+  return numRecs;
+}
+/************************************************************************/
+//! Get the physical number of records in the data file
+/*!
+*/
+xbLong xbDbf::PhysicalNoOfRecords()
+{
+  xbShort rc;
+    
+/* lock the database */
+#ifdef XB_LOCKING_ON
+//  if( AutoLock )
+//    if(( rc = LockDatabase( XB_LOCK, 0L )) != XB_NO_ERROR )
+//       return rc;
+#endif
+
+  rc = ReadHeader(1);
+
+#ifdef XB_LOCKING_ON
+//  if(AutoLock)
+//    if(( rc = LockDatabase( XB_UNLOCK, 0L )) != XB_NO_ERROR )
+//      return rc;
+#endif
+
+  if( rc )
+    return rc;
+ 
+  return NoOfRecs;
+}
+
+/************************************************************************/
+#if defined(XB_INDEX_ANY)
+//! Get the number of currently open indexes for data file
+/*!
+*/
+xbShort xbDbf::IndexCount()
+{
+  xbShort count;
+  xbIxList *i;
+
+  for(count = 0, i = NdxList; i; i = i->NextIx, count++) ;
+
+  return count;
+}
+/************************************************************************/
+//! Get a specific index
+/*!
+*/
+xbIndex * xbDbf::GetIndex(xbShort indexNum)
+{
+  xbIxList *i;
+
+  i = NdxList;
+  while(indexNum && i){
+    indexNum--;
+    i = i->NextIx;
+  }
+
+  if(i)
+    return i->index;
+
+  return 0;
+}
+
+#endif // XB_INDEX_ANY
+/************************************************************************/
+void xbDbf::Flush()
+{
+  if(fp)
+    fflush(fp);
+
+#ifdef XB_MEMO_FIELDS
+  if(mfp)
+    fflush(mfp);
+#endif
+
+#if defined(XB_INDEX_ANY)
+  xbIxList
+    *i;
+
+  i = NdxList;
+  while(i) {
+    i->index->Flush();
+    i = i->NextIx;
+  }
+#endif
+}
+/************************************************************************/
+#ifdef XB_LOCKING_ON
+xbShort xbDbf::SetLockMode( xbShort nlm )
+{
+/*
+  xbShort rc;
+  if( LockMode != XB_XBASE_LOCK_MODE &&
+      nlm == XB_XBASE_LOCK_MODE      &&
+      !xblfh ){
+    rc = OpenXbLockFile();
+    if( rc )
+      return rc;
+  }
+*/  
+  LockMode = nlm;
+  return XB_NO_ERROR;   
+}
+#endif
+/************************************************************************/
+const char  * xbDbf::GetExtWithDot( bool lower )
+{
+  return lower ? ".dbf" : ".DBF";
+}