New upstream version 4.1.0upstream/4.1.0

78 files changed, 3476 insertions, 1002 deletions

diff --git a/src/core/xbbcd.cpp b/src/core/xbbcd.cpp
index ff64110..f86e74f 100755
--- a/src/core/xbbcd.cpp
+++ b/src/core/xbbcd.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -268,7 +268,6 @@ xbInt16 xbBcd::Compare( const xbBcd &bcdIn ){
     return -1;
 }
 
-
 /***********************************************************************/
 unsigned char xbBcd::GetEncDigitsNoSign() const {
   unsigned char c = bcd.cEncDigits << 1;
@@ -277,7 +276,7 @@ unsigned char xbBcd::GetEncDigitsNoSign() const {
 /***********************************************************************/
 unsigned xbBcd::GetSign() const {
   //return bcd.Sign;
-  return bcd.cEncDigits >> 7;
+  return (unsigned) bcd.cEncDigits >> 7;
 }
 /***********************************************************************/
 unsigned xbBcd::GetSigDigits() const {
diff --git a/src/core/xbblockread.cpp b/src/core/xbblockread.cpp
new file mode 100755
index 0000000..09076b1
--- /dev/null
+++ b/src/core/xbblockread.cpp
@@ -0,0 +1,271 @@
+/*  xbblockread.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+This module handles block read methods.  Block reading is used for performance improvement
+during sequential access processing.
+
+*/
+
+#include "xbase.h"
+
+#ifdef XB_BLOCKREAD_SUPPORT
+
+namespace xb{
+
+/************************************************************************/
+xbBlockRead::xbBlockRead(  xbDbf * d ) {
+  pBlock        = NULL;
+  ulBlkSize     = 0;
+  ulFirstBlkRec = 0;
+  ulRecCnt      = 0;
+  ulMaxRecs     = 0;
+  bEof          = xbFalse;
+  this->dbf     = d;
+  tFmTime       = 0;
+}
+/************************************************************************/
+xbBlockRead::~xbBlockRead(){
+  if( pBlock ){
+    free( pBlock );
+    pBlock = NULL;
+  }
+}
+
+/************************************************************************/
+//! @brief Dump read block internals to stdout.
+/*!
+  Dump the current read block internals to stdout.
+*/
+
+
+#ifdef XB_DEBUG_SUPPORT
+void xbBlockRead::DumpReadBlockInternals(){
+  std::cout << "------- DumpBlockInternals ---------" << std::endl;
+  std::cout << "Dflt Blk Size    = [" << dbf->GetXbasePtr()->GetDefaultBlockReadSize()
+                                                               << "]" << std::endl;
+  std::cout << "Dbf Record Count = [" << dbf->GetRecordCount() << "]" << std::endl;
+  std::cout << "Dbf Record Len   = [" << dbf->GetRecordLen()   << "]" << std::endl;
+  std::cout << "ulBlkSize        = [" << ulBlkSize             << "]" << std::endl;
+  std::cout << "ulMaxRecs        = [" << ulMaxRecs             << "]" << std::endl;
+  std::cout << "ulFirstBlkRec    = [" << ulFirstBlkRec         << "]" << std::endl;
+  std::cout << "ulRecCnt         = [" << ulRecCnt              << "]" << std::endl;
+  std::cout << "bEof             = [" << bEof                  << "]" << std::endl;
+}
+#endif  // XB_DEBUG_SUPPORT
+/************************************************************************/
+//! @brief Get the first record number in the current block.
+/*!
+  Retrieve the first record numer in the current block.<br>
+
+  \returns First record number in the current block.
+*/
+
+xbUInt32 xbBlockRead::GetBlockFirstRecNo() const{
+  return ulFirstBlkRec;
+}
+/************************************************************************/
+//! @brief Get record for specified record number.
+/*!
+  Retrieve a record from read block buffer and copy it into the record buffer.
+  If the current record is not in the current block, the routine calls 
+  GetBlockForRecNo to load the currect block from disk.<br><br>
+  For performance reasons, this method assumes a valid record number has been 
+  passed.<br><br>
+
+  \param ulRecNo - Record number to retrieve.
+  \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16  xbBlockRead::GetRecord( xbUInt32 ulRecNo ){
+  xbInt16 iRc = 0;
+  xbInt16 iErrorStop = 0;
+
+  // std::cout << "xbBlockRead::GetRecord( " << ulRecNo << ")\n";
+
+  try{
+    if( !( ulRecNo >= ulFirstBlkRec && ulRecNo < (ulFirstBlkRec + ulRecCnt))){
+      if(( iRc = GetBlockForRecNo( ulRecNo )) != XB_NO_ERROR ){
+        iErrorStop = 100;
+        throw iRc;
+      }
+    }
+    char *s = pBlock;
+    s += (ulRecNo - ulFirstBlkRec) * dbf->GetRecordLen();
+    char *t = dbf->RecBuf;
+    xbUInt32 ulRecLen = dbf->GetRecordLen();
+    for( xbUInt32 l = 0; l < ulRecLen; l++ ){
+      *t = *s;
+      t++;
+      s++;
+    }
+    dbf->ulCurRec = ulRecNo;
+  }
+  catch (xbInt16 iRc ){
+    xbString sMsg;
+    sMsg.Sprintf( "xbBlockRead::GetBlockForRecNo() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+    dbf->GetXbasePtr()->WriteLogMessage( sMsg.Str() );
+    dbf->GetXbasePtr()->WriteLogMessage( dbf->GetXbasePtr()->GetErrorMessage( iRc ));
+  }
+  return iRc;
+}
+
+/************************************************************************/
+//! @brief Get record for specified record number.
+/*!
+  Retrieve a block containing specified record.  This routine calculates the
+  correct block in the DBF file, updates the internal block fields and retrieves 
+  the block of records from disk and loads into the block buffer.<br><br>
+
+  \param ulRecNo - Record number to retrieve.
+  \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16  xbBlockRead::GetBlockForRecNo( xbUInt32 ulRecNo ){
+
+  xbInt16 iRc = 0;
+  xbInt16 iErrorStop = 0;
+
+  try{
+    xbUInt32 ulDbfRecCnt = dbf->GetRecordCount();
+
+    // calc to determine block number for the requested record, 0 based offset
+    xbUInt32 ulBlockNo = (xbUInt32)(ulRecNo / ulMaxRecs);
+    if( ulRecNo % ulMaxRecs == 0 ) ulBlockNo--;
+
+    // calc the first record
+    ulFirstBlkRec = (ulBlockNo * ulMaxRecs);
+
+    // calc the record count
+    if(( ulFirstBlkRec + ulMaxRecs) > ulDbfRecCnt ){
+      ulRecCnt = ulDbfRecCnt - ulFirstBlkRec;
+      bEof     = xbTrue;
+    } else {
+      ulRecCnt = ulMaxRecs;
+      bEof     = xbFalse;
+    }
+
+    // position accordingly
+    xbInt64 ulStartPos = dbf->GetHeaderLen() + ((xbInt64) ulFirstBlkRec * dbf->GetRecordLen());
+    if(( dbf->xbFseek( ulStartPos, SEEK_SET )) != XB_NO_ERROR ){
+      iErrorStop = 110;
+      iRc = XB_SEEK_ERROR;
+      throw iRc;
+    }
+
+    if(( dbf->GetFileMtime( tFmTime )) != XB_NO_ERROR ){
+      iErrorStop = 120;
+      throw iRc;
+    }
+    // read it
+    if(( dbf->xbFread( (void *) pBlock, ulRecCnt * dbf->GetRecordLen(), 1 )) != XB_NO_ERROR ){
+      iErrorStop = 130;
+      throw iRc;
+    }
+
+    ulFirstBlkRec++;    // zero offset in the routine, regular record number from ths point forward
+  }
+  catch (xbInt16 iRc ){
+    xbString sMsg;
+    sMsg.Sprintf( "xbBlockRead::GetBlockForRecNo() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+    dbf->GetXbasePtr()->WriteLogMessage( sMsg.Str() );
+    dbf->GetXbasePtr()->WriteLogMessage( dbf->GetXbasePtr()->GetErrorMessage( iRc ));
+  }
+  return iRc;
+}
+
+
+/************************************************************************/
+//! @brief Get the current block size.
+/*!
+  Retrieve the current block size.<br><br>
+
+  \returns Current Block Size.
+*/
+
+xbUInt32 xbBlockRead::GetBlockSize() const{
+  return ulBlkSize;
+}
+
+/************************************************************************/
+//! @brief Get the current block record count.
+/*!
+  Retrieve the current number of records loaded in the block.<br><br>
+
+  \returns Current Block Size.
+*/
+
+xbUInt32 xbBlockRead::GetBlockRecCnt() const {
+  return ulRecCnt;
+}
+
+/************************************************************************/
+//! @brief Init the block processing for a iven DBF file.
+/*!
+  Initialize the settings for a given DBF file.<br>
+  This routine may adjust the block size as needed to eliminate unused
+  memory or adjust it bigger if too small.
+
+  \param ulRecNo - ulBlockSize - Block size to allocate. If 0 or missing, it uses default block size of 32K.
+  \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbBlockRead::Init(xbUInt32 ulBlockSize ){
+
+  xbInt16 iRc = 0;
+  xbInt16 iErrorStop = 0;
+
+  try{
+
+    // calculate the block size
+    if( ulBlockSize == 0 )
+      ulBlkSize = dbf->GetXbasePtr()->GetDefaultBlockReadSize();
+
+    // if not big enough to handle more than one record, bump it up to something meaningful
+    if( ulBlkSize < (xbUInt32)(dbf->GetRecordLen() * 2 ))
+      ulBlkSize = (xbUInt32) dbf->GetRecordLen() * 10;
+
+    ulMaxRecs = (xbUInt32) ulBlkSize / dbf->GetRecordLen();
+    ulBlkSize = ulMaxRecs * dbf->GetRecordLen();
+
+    // allocate memory for the block
+    if(( pBlock = (char *) calloc( 1, ulBlkSize )) == NULL ){
+      iErrorStop = 100;
+      throw iRc;
+    }
+  }
+  catch (xbInt16 iRc ){
+    xbString sMsg;
+    sMsg.Sprintf( "xbBlockRead::Init() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+    dbf->GetXbasePtr()->WriteLogMessage( sMsg.Str() );
+    dbf->GetXbasePtr()->WriteLogMessage( dbf->GetXbasePtr()->GetErrorMessage( iRc ));
+  }
+  return iRc;
+}
+
+/************************************************************************/
+//! @brief Set the block size.
+/*!
+  St block size for this DBF file.<br>.
+
+  \param ulBlkSize - Block Size.
+  \returns XB_NO_ERROR
+*/
+
+xbInt16 xbBlockRead::SetBlockSize( xbUInt32 ulBlkSize ){
+  this->ulBlkSize = ulBlkSize;
+  return XB_NO_ERROR;
+}
+
+/************************************************************************/
+}   /* namespace */ 
+#endif         /*  XB_BLOCKREAD_SUPPORT */
\ No newline at end of file
diff --git a/src/core/xbdbf.cpp b/src/core/xbdbf.cpp
index 3d13369..4033ef9 100755
--- a/src/core/xbdbf.cpp
+++ b/src/core/xbdbf.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -24,10 +24,16 @@ namespace xb{
   \param x Pointer to xbXbase
 */
 xbDbf::xbDbf( xbXBase * x ) : xbFile( x ){
-  xbase         = x;
-  SchemaPtr     = NULL;
-  RecBuf        = NULL;
-  RecBuf2       = NULL;
+  xbase             = x;
+  SchemaPtr         = NULL;
+  RecBuf            = NULL;
+  RecBuf2           = NULL;
+
+  #ifdef XB_BLOCKREAD_SUPPORT
+  pRb               = NULL;
+  bBlockReadEnabled = xbFalse;              // batch read switch, if xbTrue, then ON
+  #endif // XB_BLOCKREAD_SUPPORT
+
   InitVars();
 }
 /************************************************************************/
@@ -77,7 +83,7 @@ void xbDbf::InitVars()
 
   #ifdef XB_INF_SUPPORT
   llInfData.Clear();
-  #endif // XB_INF_SUPPORT
+  #endif   // XB_INF_SUPPORT
 }
 
 /************************************************************************/
@@ -104,6 +110,16 @@ xbDbf::~xbDbf(){
     free( RecBuf2 );
     RecBuf2 = NULL;
   }
+  if( RecBuf ){
+    free( RecBuf );
+    RecBuf = NULL;
+  }
+
+  #ifdef XB_BLOCKREAD_SUPPORT
+  if( bBlockReadEnabled )
+    DisableBlockReadProcessing();
+  #endif   // XB_BLOCKREAD_SUPPORT
+
   Close();
 }
 /************************************************************************/
@@ -1952,6 +1968,18 @@ xbInt16 xbDbf::GetFirstKey(){
 }
 
 /************************************************************************/
+//! @brief GetHeaderLen for dbf
+/*!
+
+  Returns the length of the header portion of the dbf file
+  \returns Length of header protion of dbf file
+
+*/
+xbUInt16 xbDbf::GetHeaderLen() const {
+  return uiHeaderLen;
+}
+
+/************************************************************************/
 //! @brief GetLastKey for tag.
 /*!
 
@@ -2054,6 +2082,32 @@ xbInt16 xbDbf::Find( xbDouble &dKey ){
 #endif // XB_INDEX_SUPPORT
 
 /************************************************************************/
+//! @brief Return true if dbf file empty or positioned to the first record
+/*!
+  \returns Returns true if dbf file is empty or positioned on the first record.
+*/
+xbBool xbDbf::GetBof() {
+/*
+  if( GetRecordCount() == 0 || GetCurRecNo() == 1 )
+    return xbTrue;
+  else
+  */
+    return xbFalse;
+}
+/************************************************************************/
+//! @brief Return true if dbf file empty or positioned to the last record
+/*!
+  \returns Returns true if dbf file is empty or positioned on the last record.
+*/
+xbBool xbDbf::GetEof() {
+  xbUInt32 ulRecCnt = GetRecordCount();
+
+  if( ulRecCnt == 0 || GetCurRecNo() == ulRecCnt )
+    return xbTrue;
+  else
+    return xbFalse;
+}
+/************************************************************************/
 //! @brief Return the current record number. 
 /*!
   \returns Returns the current record number.
@@ -2428,15 +2482,23 @@ xbInt16 xbDbf::GetRecord( xbUInt32 ulRecNo ){
           iErrorStop = 120;
           throw iRc;
         }
-     }
-   }
+      }
+    }
 
+
+    // std::cout << "xbdbf::GetRecord: " << ulRecNo << " " << ulNoOfRecs << "\n";
     if( ulRecNo > ulNoOfRecs || ulRecNo == 0L ){
       iErrorStop = 130;
       iRc = XB_INVALID_RECORD;
       throw iRc;
     }
 
+    #ifdef XB_BLOCKREAD_SUPPORT
+    if( bBlockReadEnabled )
+      return pRb->GetRecord( ulRecNo );
+    #endif // XB_BLOCK_READ_SUPPORT
+
+
     if(( xbFseek( (uiHeaderLen+(( (xbInt64) ulRecNo-1L ) * uiRecordLen )), SEEK_SET )) != XB_NO_ERROR ){
       iErrorStop = 140;
       iRc = XB_SEEK_ERROR;
@@ -2475,9 +2537,6 @@ char * xbDbf::GetRecordBuf( xbInt16 iOpt ) const {
     return RecBuf;
 }
 
-
-
-
 /************************************************************************/
 //! @brief Get the current number of records in the dbf data file.
 /*!
@@ -3211,12 +3270,12 @@ xbInt16 xbDbf::Open( const xbString & sTableName, const xbString & sAlias ){
       xbLinkListNode<xbString> * llN = llInfData.GetHeadNode();
       for( xbUInt32 i = 0; i < llNodeCnt; i++ ){
         s2 = llN->GetKey();
-		#ifdef XB_NDX_SUPPORT
+        #ifdef XB_NDX_SUPPORT
         if(( iRc = OpenIndex( "NDX", s2 )) != XB_NO_ERROR ){
           iErrorStop = 120;
           throw iRc ;
         }
-		#endif  // XB_NDX_SUPPORT
+        #endif  // XB_NDX_SUPPORT
         llN = llN->GetNextNode();
       }
     }
@@ -3270,7 +3329,6 @@ xbInt16 xbDbf::OpenIndex( const xbString &sIxType, const xbString &sFileName ){
 
     #ifdef XB_MDX_SUPPORT
     } else if( sType == "MDX" ){
-
       pIx = new xbIxMdx( this );
       if(( iRc = pIx->Open( sFileName )) != XB_NO_ERROR ){
         iErrorStop = 120;
@@ -4209,4 +4267,72 @@ xbInt16 xbDbf::Zap(){
   return iRc;
 }
 /************************************************************************/
+#ifdef XB_BLOCKREAD_SUPPORT
+// block read processing is designed to provide a way to rapidly retrieve
+// all the records from a .DBF file in sequential order.
+
+// It is not designed for doing any read/write processing or data retrieval based on a tag sort.
+// It is designed for doing a fast sequentil block read out of a table
+
+
+xbInt16 xbDbf::DisableBlockReadProcessing(){
+
+  if( bBlockReadEnabled ){
+    bBlockReadEnabled = xbFalse;
+    delete pRb;
+    pRb = NULL;
+  }
+  return XB_NO_ERROR;
+}
+
+xbBool xbDbf::GetBlockReadStatus() const {
+  return bBlockReadEnabled;
+}
+
+xbInt16 xbDbf::EnableBlockReadProcessing(){
+
+  xbInt16  iRc = 0;
+  xbInt16  iErrorStop = 0;
+
+  try{
+
+    if( !bBlockReadEnabled ){
+      if( iDbfStatus == XB_UPDATED ){
+        if(  GetAutoCommit() == 1 ){
+          if(( iRc = Commit()) != XB_NO_ERROR ){
+            iErrorStop = 100;
+            throw iRc;
+          }
+        } else {
+          if(( iRc = Abort()) != XB_NO_ERROR ){
+            iErrorStop = 110;
+            throw iRc;
+          }
+        }
+      }
+      pRb = new xbBlockRead( this );
+      if( !pRb ){
+        iErrorStop = 120;
+        iRc = XB_NO_MEMORY;
+        throw iRc;
+      }
+      if(( iRc = pRb->Init()) != XB_NO_ERROR ){
+        iErrorStop = 130;
+        throw iRc;
+      }
+
+      bBlockReadEnabled = xbTrue;
+    }
+
+  } catch( xbInt16 iRc ){
+    xbString sMsg;
+    sMsg.Sprintf( "xbdbf::EnableBlockReadProcessing() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+    xbase->WriteLogMessage( sMsg.Str() );
+    xbase->WriteLogMessage( GetErrorMessage( iRc ));
+  }
+  return iRc;
+}
+
+#endif // XB_BLOCKREAD_SUPPORT
+/************************************************************************/
 }   /* namespace */
\ No newline at end of file
diff --git a/src/core/xbdbf3.cpp b/src/core/xbdbf3.cpp
index 504542f..d57be3c 100755
--- a/src/core/xbdbf3.cpp
+++ b/src/core/xbdbf3.cpp
@@ -261,7 +261,7 @@ xbInt16 xbDbf3::CreateTable( const xbString & sTableName, const xbString & sAlia
   catch( xbInt16 rc )
   {
     xbString sMsg;
-    sMsg.Sprintf( "xbdbf3::CreateTable() Exception Caught Error Stop = %d rc = %d", iErrorStop, rc );
+    sMsg.Sprintf( "xbdbf3::CreateTable() Exception Caught Error Stop = [%d] rc = [%d]", iErrorStop, rc );
     xbase->WriteLogMessage( sMsg );
     xbase->WriteLogMessage( GetErrorMessage( rc ));
 
@@ -453,7 +453,7 @@ xbInt16 xbDbf3::Open( const xbString & sTableName, const xbString & sAlias,
   catch ( xbInt16 iRc )
   {
     xbString sMsg;
-    sMsg.Sprintf( "xbdbf3::Open() Exception Caught Error Stop = %d iRc = %d ShareMode = %d OpenMode = %d", iErrorStop, iRc, iShareMode, iOpenMode );
+    sMsg.Sprintf( "xbdbf3::Open() Exception Caught Error Stop = [%d] iRc = [%d] ShareMode = [%d] OpenMode = [%d]", iErrorStop, iRc, iShareMode, iOpenMode );
     xbase->WriteLogMessage( sMsg );
     xbase->WriteLogMessage( GetErrorMessage( iRc ));
     xbFclose();
@@ -623,14 +623,14 @@ xbInt16 xbDbf3::Rename( const xbString sNewName ){
     xbTblList *tle = xbase->GetTblListEntry( this );
     if( tle ){
       // std::cout << "setting [" << GetFqFileName().Str() << "][" << sNewNameWoExt.Str() << "]\n";
-      tle->psTblName->Set( GetFqFileName().Str());
+      tle->psFqTblName->Set( GetFqFileName().Str());
       tle->psTblAlias->Set( sNewNameWoExt.Str());
     }
   }
   catch ( xbInt16 iRc )
   {
     xbString sMsg;
-    sMsg.Sprintf( "xbdbf3::Rename() Exception Caught Error Stop = %d iRc = %d", iErrorStop, iRc );
+    sMsg.Sprintf( "xbdbf3::Rename() Exception Caught Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
     xbase->WriteLogMessage( sMsg );
     xbase->WriteLogMessage( GetErrorMessage( iRc ));
 
diff --git a/src/core/xbdbf4.cpp b/src/core/xbdbf4.cpp
index 2b49be9..59ba39a 100755
--- a/src/core/xbdbf4.cpp
+++ b/src/core/xbdbf4.cpp
@@ -180,10 +180,10 @@ xbInt16 xbDbf4::CreateTable( const xbString &sTableName, const xbString &sAlias,
     ulCurRec  = 0L;
     uiHeaderLen = 33 + iNoOfFields * 32;
     xbDate d;
-    cUpdateYY = (char) (d.YearOf() - 1900);
-    cUpdateMM = (char) d.MonthOf();
-    cUpdateDD = (char) d.DayOf( XB_FMT_MONTH );
-
+    cUpdateYY  = (char) (d.YearOf() - 1900);
+    cUpdateMM  = (char) d.MonthOf();
+    cUpdateDD  = (char) d.DayOf( XB_FMT_MONTH );
+    cIndexFlag = 0;
     // Default language driver to 0x1b
     cLangDriver = 0x1b;
 
@@ -264,7 +264,7 @@ xbInt16 xbDbf4::CreateTable( const xbString &sTableName, const xbString &sAlias,
   catch( xbInt16 rc )
   {
     xbString sMsg;
-    sMsg.Sprintf( "xbdbf4::CreateTable() Exception Caught Error Stop = %d rc = %d", iErrorStop, rc );
+    sMsg.Sprintf( "xbdbf4::CreateTable() Exception Caught Error Stop = [%d] rc = [%d]", iErrorStop, rc );
     xbase->WriteLogMessage( sMsg );
     xbase->WriteLogMessage( GetErrorMessage( rc ));
 
@@ -452,6 +452,9 @@ xbInt16 xbDbf4::Open( const xbString & sTableName, const xbString & sAlias,
     #endif
 
    #ifdef XB_MDX_SUPPORT
+
+//   printf( "cIndexFlag [%x]\n", cIndexFlag );
+
    if( cIndexFlag ){
      // create the file name
      xbString sIxFileName = GetFqFileName();
@@ -471,7 +474,7 @@ xbInt16 xbDbf4::Open( const xbString & sTableName, const xbString & sAlias,
   catch ( xbInt16 iRc )
   {
     xbString sMsg;
-    sMsg.Sprintf( "xbdbf4::Open() Exception Caught Error Stop = %d iRc = %d ShareMode = %d OpenMode = %d", iErrorStop, iRc, iShareMode, iOpenMode );
+    sMsg.Sprintf( "xbdbf4::Open() Exception Caught Error Stop = [%d] iRc = [%d] ShareMode = [%d] OpenMode = [%d]", iErrorStop, iRc, iShareMode, iOpenMode );
     xbase->WriteLogMessage( sMsg );
     xbase->WriteLogMessage( GetErrorMessage( iRc ));
     xbFclose();
@@ -726,7 +729,7 @@ xbInt16 xbDbf4::Rename( const xbString sNewName ){
     // rename the table in the table list
     xbTblList *tle = xbase->GetTblListEntry( this );
     if( tle ){
-      tle->psTblName->Set( GetFqFileName().Str());
+      tle->psFqTblName->Set( GetFqFileName().Str());
       tle->psTblAlias->Set( sNewNameWoExt.Str());
     }
 
@@ -735,7 +738,7 @@ xbInt16 xbDbf4::Rename( const xbString sNewName ){
   catch ( xbInt16 iRc )
   {
     xbString sMsg;
-    sMsg.Sprintf( "xbdbf4::Rename() Exception Caught Error Stop = %d iRc = %d", iErrorStop, iRc );
+    sMsg.Sprintf( "xbdbf4::Rename() Exception Caught Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
     xbase->WriteLogMessage( sMsg );
     xbase->WriteLogMessage( GetErrorMessage( iRc ));
 
diff --git a/src/core/xbexp.cpp b/src/core/xbexp.cpp
index 23bc7c6..deea53d 100755
--- a/src/core/xbexp.cpp
+++ b/src/core/xbexp.cpp
@@ -669,10 +669,22 @@ xbInt16 xbExp::GetTokenDatabaseField( xbExpToken &t ){
   }
 
   // look for ->
-  // remove the field name from before the ->
+  // remove the table name from before the ->
   if( strncmp( s, "->", 2 ) == 0 ){
     ulTokenLen2+=2;
     s+=2;
+
+/*
+  if( strncmp( s, "->", 2 ) == 0 || strncmp( s, ".", 1 ) == 0){
+    if( *s == '.' ){
+      ulTokenLen2+=1;
+      s+=1;
+    } else {
+      ulTokenLen2+=2;
+      s+=2;
+    }
+*/
+
     // go past white space
     while( *s && !IsTokenSeparator( *s ) && IsWhiteSpace( *s )) {
       ulTokenLen2++;
@@ -1489,6 +1501,7 @@ xbInt16 xbExp::ParseExpressionField( xbExpToken &t, xbExpNode *n ){
   try{
 
     xbUInt32 lPos;
+
     if(( lPos = t.sToken.Pos( "->" )) > 0 ){
       //  table name is part of the token
       xbString sTableName = t.sToken;
@@ -1496,6 +1509,22 @@ xbInt16 xbExp::ParseExpressionField( xbExpToken &t, xbExpNode *n ){
       sFieldName = t.sToken;
       sFieldName.Mid( lPos + 2, t.sToken.Len() - lPos - 1 );
       pDbf = (xbDbf *) xbase->GetDbfPtr( sTableName );
+
+
+/*
+    //  updated 1/2/23 to support either table.field or table->field
+    if((( lPos = t.sToken.Pos( "->" )) > 0) || (( lPos = t.sToken.Pos( "." )) > 0) ){
+      //  table name is part of the token
+      xbString sTableName = t.sToken;
+      sTableName.Left( lPos-1 );
+      sFieldName = t.sToken;
+      if( t.sToken[lPos] == '.' )
+        sFieldName.Mid( lPos + 1, t.sToken.Len() - lPos );
+      else  // ->
+        sFieldName.Mid( lPos + 2, t.sToken.Len() - lPos - 1 );
+      pDbf = (xbDbf *) xbase->GetDbfPtr( sTableName );
+*/
+
     } else {
       // table name is not part of the token 
       pDbf = dbf;
diff --git a/src/core/xbfile.cpp b/src/core/xbfile.cpp
index 937c16f..3b798a2 100755
--- a/src/core/xbfile.cpp
+++ b/src/core/xbfile.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -49,6 +49,119 @@ xbFile::~xbFile(){
 }
 
 /************************************************************************/
+//! @brief Create Home Folders.
+/*!
+  Create xbase64 log and data folders in the home directory for current usre.
+
+  \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::SetHomeFolders(){
+
+  xbInt16 iErrorStop = 0;
+  xbInt16 iRc = XB_NO_ERROR;
+  xbString sHomeDir;
+  char cPathSeperator;
+  xbString sDflt;
+
+  try{
+
+    GetHomeDir( sHomeDir );
+    //std::cout << "CreateHomeFolders() home dir = [" << sHomeDir.Str() << "]\n";
+
+    if( FileExists( sHomeDir ) == xbFalse ){
+      iErrorStop = 100;
+      iRc = XB_DIRECTORY_ERROR;
+      throw iRc;
+    }
+
+    #ifdef WIN32
+    cPathSeperator = '\\';
+    #else
+    cPathSeperator = '/';
+    #endif
+    sDflt.Sprintf( ".%c", cPathSeperator );
+    // set the default folders just in case later steps fail
+    xbase->SetDataDirectory( sDflt );
+    #ifdef XB_LOGGING_SUPPORT
+    xbase->SetLogDirectory( sDflt );
+    #endif
+
+    if( sHomeDir[sHomeDir.Len()] != cPathSeperator )
+      sHomeDir += cPathSeperator;
+
+    xbString sWork( sHomeDir );
+    sWork += "xbase64";
+
+    if( FileExists( sWork ) == xbFalse ){
+      #ifdef WIN32
+        if( CreateDirectory( sWork.Str(), NULL ) == 0 ){
+          iErrorStop = 130;
+          iRc = XB_DIRECTORY_ERROR;
+          throw iRc;
+        }
+      #else
+        // 0777 mode is correct, the mode will be modified by the user's umask
+        if( mkdir( sWork.Str(), 0777 ) == -1 ){
+          iErrorStop = 140;
+          iRc = XB_DIRECTORY_ERROR;
+          throw iRc;
+        }
+      #endif
+    }
+
+    #ifdef XB_LOGGING_SUPPORT
+    sWork.Sprintf( "%sxbase64%clogs", sHomeDir.Str(), cPathSeperator );
+    // std::cout << "logdir = " << sWork.Str() << "\n";
+
+    if( FileExists( sWork ) == xbFalse ){
+      #ifdef WIN32
+        if( CreateDirectory( sWork.Str(), NULL ) == 0 ){
+          iErrorStop = 110;
+          iRc = XB_DIRECTORY_ERROR;
+          throw iRc;
+        }
+      #else
+        if( mkdir( sWork.Str(), 0777 ) == -1 ){
+          iErrorStop = 120;
+          iRc = XB_DIRECTORY_ERROR;
+          throw iRc;
+        }
+      #endif
+    }
+    xbase->SetLogDirectory( sWork );
+    #endif  // XB_LOGGING_SUPPORT
+
+    sWork.Sprintf( "%sxbase64%cdata", sHomeDir.Str(), cPathSeperator );
+    // std::cout << "datadir = " << sWork.Str() << "\n";
+    if( FileExists( sWork ) == xbFalse ){
+      #ifdef WIN32
+        if( CreateDirectory( sWork.Str(), NULL ) == 0 ){
+          iErrorStop = 130;
+          iRc = XB_DIRECTORY_ERROR;
+          throw iRc;
+        }
+      #else
+        if( mkdir( sWork.Str(), 0777 ) == -1 ){
+          iErrorStop = 140;
+          iRc = XB_DIRECTORY_ERROR;
+          throw iRc;
+        }
+      #endif
+    }
+    xbase->SetDataDirectory( sWork );
+
+  }
+  catch (xbInt16 iRc ){
+    xbString sMsg;
+    sMsg.Sprintf( "xbFile::CreateHomeFolders() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+    xbase->WriteLogMessage( sMsg.Str() );
+    xbase->WriteLogMessage( GetErrorMessage( iRc ));
+  }
+  return iRc;
+}
+
+/************************************************************************/
 //! @brief Create a unique file name.
 /*!
   Given a directory and file extension as inputs, create a unique file name.
@@ -1445,7 +1558,7 @@ xbInt16 xbFile::xbFputs( const xbString & s ){
 /*!
   \param p Pointer to data to write
   \param size size of write
-  \param nmemb Number of times to write it
+  \param nmemb Number of times to read it
    \returns <a href="xbretcod_8h.html">Return Codes</a>
 */
 
@@ -1899,69 +2012,39 @@ void xbFile::SetLockRetryCount( xbInt16 iLockRetries ) {
 }
 
 #endif
+
+
 /***********************************************************************/
 #ifdef XB_DEBUG_SUPPORT
-//! @brief Debugging routine - dump a block to the log file.
+//! @brief Debugging routine - dump mem to the log file.
 /*!
-  This routine dumps a block to a file in the log file. This is
+  This routine dumps data from meemory to the log file. This is
   primarily used for debugging and analysis purposes.
 
-  \param ulBlockNo Block number to write
+  \param p Pointer to data to write
   \param lBlxkSize Size of block
   \returns <a href="xbretcod_8h.html">Return Codes</a>
 */
-xbInt16 xbFile::DumpBlockToDisk( xbUInt32 ulBlockNo, size_t lBlkSize ){
+xbInt16 xbFile::DumpMemToDisk( char *p, size_t lSize ){
 
 
   xbInt16 iRc = 0;
   xbInt16 iErrorStop = 0;
-
-  xbUInt32 ulStartBlock;
-  xbUInt32 ulEndBlock;
-
-  char *p = 0x00;
-
   xbString sDir;
   xbString sFn;
-  char *buf = NULL;
-  FILE *fpd = NULL;
-  try{
-    iErrorStop = 100;
 
-  if( ulBlockNo == 0 ){
-    ulStartBlock = 0;
-    xbUInt64 ullFileSizeulBlockNo;
-    if(( iRc = GetFileSize( ullFileSizeulBlockNo )) != XB_NO_ERROR ){
-      iErrorStop = 110;
-      throw iRc;
-    }
-    ulEndBlock = (xbUInt32) (ullFileSizeulBlockNo / lBlkSize);
-  } else {
-    ulStartBlock = ulBlockNo; 
-    ulEndBlock = ulBlockNo;
-  }
-
-  if(( buf = (char *) malloc( lBlkSize )) == NULL ){
-    iErrorStop = 120;
-    iRc = XB_NO_MEMORY;
-    throw iRc;
-  }
-
-  sDir = GetDefaultLogDirectory();
-  char cLastChar = sDir[sDir.Len()];
+  FILE *fpd = NULL;
 
-  for( xbUInt32 l = ulStartBlock; l < ulEndBlock; l++ ){
+  try{
 
-    if(( iRc = ReadBlock( l, lBlkSize, buf )) != XB_NO_ERROR ){
-      iErrorStop = 130;
-      throw iRc;
-    }
+    sDir = GetLogDirectory();
+    char cLastChar = sDir[sDir.Len()];
 
     // build logfile name
     if( cLastChar != '/' && cLastChar != '\\' )
-      sFn.Sprintf( "%s/Blockdump.B%ld", sDir.Str(), l);
+      sFn.Sprintf( "%s/MemDump.txt", sDir.Str());
     else
-      sFn.Sprintf( "%sBlockDump.%ld", sDir.Str(), l);
+      sFn.Sprintf( "%sMemDump.txt", sDir.Str());
 
     // open the dump file for append
     #ifdef HAVE__FSOPEN_F
@@ -1969,17 +2052,17 @@ xbInt16 xbFile::DumpBlockToDisk( xbUInt32 ulBlockNo, size_t lBlkSize ){
     #else
     if(( fpd = fopen( sFn.Str(), "w+b")) == NULL ){
     #endif
-      iErrorStop = 140;
+      iErrorStop = 100;
       iRc = XB_OPEN_ERROR;
       throw iRc;
     }
 
+    int i;
     // dump the block to the file
-    p = buf;
-    for( size_t l = 0; l < lBlkSize; l++ ){
-      //if( fputc( *p, fpd ) != *p ){
-      if( fputc( *p, fpd ) == EOF ){
-        iErrorStop = 150;
+    for( size_t l = 0; l < lSize; l++ ){
+      i = *p;
+      if( fputc( i, fpd ) == EOF ){
+        iErrorStop = 110;
         iRc = XB_WRITE_ERROR;
         throw iRc;
       }
@@ -1988,6 +2071,103 @@ xbInt16 xbFile::DumpBlockToDisk( xbUInt32 ulBlockNo, size_t lBlkSize ){
     // close the dump file
     fclose( fpd );
   }
+  catch (xbInt16 iRc ){
+    xbString sMsg;
+    sMsg.Sprintf( "xbFile::DumpBlockToDisk() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+    xbase->WriteLogMessage( sMsg.Str() );
+    xbase->WriteLogMessage( GetErrorMessage( iRc ));
+    if( fpd )
+      fclose( fpd );
+  }
+  return iRc;
+}
+
+/***********************************************************************/
+//! @brief Debugging routine - dump a block to the log file.
+/*!
+  This routine dumps a block to the log file. This is
+  primarily used for debugging and analysis purposes.
+
+  \param ulBlockNo Block number to write
+  \param lBlxkSize Size of block
+  \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbFile::DumpBlockToDisk( xbUInt32 ulBlockNo, size_t lBlkSize ){
+
+  xbInt16 iRc = 0;
+  xbInt16 iErrorStop = 0;
+
+  xbUInt32 ulStartBlock;
+  xbUInt32 ulEndBlock;
+
+  char *p = 0x00;
+
+  xbString sDir;
+  xbString sFn;
+  char *buf = NULL;
+  FILE *fpd = NULL;
+  try{
+
+    if( ulBlockNo == 0 ){
+      ulStartBlock = 0;
+      xbUInt64 ullFileSizeulBlockNo;
+      if(( iRc = GetFileSize( ullFileSizeulBlockNo )) != XB_NO_ERROR ){
+        iErrorStop = 100;
+        throw iRc;
+      }
+      ulEndBlock = (xbUInt32) (ullFileSizeulBlockNo / lBlkSize);
+    } else {
+      ulStartBlock = ulBlockNo; 
+      ulEndBlock = ulBlockNo;
+    }
+
+    if(( buf = (char *) malloc( lBlkSize )) == NULL ){
+      iErrorStop = 110;
+      iRc = XB_NO_MEMORY;
+      throw iRc;
+    }
+
+    sDir = GetLogDirectory();
+    char cLastChar = sDir[sDir.Len()];
+
+    for( xbUInt32 l = ulStartBlock; l < ulEndBlock; l++ ){
+
+      if(( iRc = ReadBlock( l, lBlkSize, buf )) != XB_NO_ERROR ){
+        iErrorStop = 120;
+        throw iRc;
+      }
+
+      // build logfile name
+      if( cLastChar != '/' && cLastChar != '\\' )
+        sFn.Sprintf( "%s/BlockDump.B%ld", sDir.Str(), l);
+      else
+        sFn.Sprintf( "%sBlockDump.%ld", sDir.Str(), l);
+
+      // open the dump file for append
+      #ifdef HAVE__FSOPEN_F
+      if(( fpd = _fsopen( sFn.Str(), "w+b", 0x40 )) == NULL ){
+      #else
+      if(( fpd = fopen( sFn.Str(), "w+b")) == NULL ){
+      #endif
+        iErrorStop = 130;
+        iRc = XB_OPEN_ERROR;
+        throw iRc;
+      }
+
+      // dump the block to the file
+      p = buf;
+      for( size_t l = 0; l < lBlkSize; l++ ){
+        //if( fputc( *p, fpd ) != *p ){
+        if( fputc( *p, fpd ) == EOF ){
+          iErrorStop = 140;
+          iRc = XB_WRITE_ERROR;
+          throw iRc;
+        }
+        p++;
+      }
+      // close the dump file
+      fclose( fpd );
+    }
 
     // free the buffer
     if( buf )
@@ -1995,10 +2175,7 @@ xbInt16 xbFile::DumpBlockToDisk( xbUInt32 ulBlockNo, size_t lBlkSize ){
   }
   catch (xbInt16 iRc ){
     xbString sMsg;
-    if( iErrorStop == 160 )
-      sMsg.Sprintf( "xbFile::DumpBlockToDisk() Exception Caught. Error Stop = [%d] iRc = [%d] c=[%c][%x]", iErrorStop, iRc, *p, *p );
-    else
-      sMsg.Sprintf( "xbFile::DumpBlockToDisk() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+    sMsg.Sprintf( "xbFile::DumpBlockToDisk() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
     xbase->WriteLogMessage( sMsg.Str() );
     xbase->WriteLogMessage( GetErrorMessage( iRc ));
     if( buf )
@@ -2007,7 +2184,6 @@ xbInt16 xbFile::DumpBlockToDisk( xbUInt32 ulBlockNo, size_t lBlkSize ){
       fclose( fpd );
   }
   return iRc;
-
 }
 #endif
 /***********************************************************************/
diff --git a/src/core/xbfilter.cpp b/src/core/xbfilter.cpp
index 507a9e7..0fb643d 100755
--- a/src/core/xbfilter.cpp
+++ b/src/core/xbfilter.cpp
@@ -26,8 +26,7 @@ This module handles uda (user data area) methods
 namespace xb{
 
 /************************************************************************/
-xbFilter::xbFilter( xbXBase *xbase, xbDbf *dbf ) {
-  this->xbase  = xbase;
+xbFilter::xbFilter( xbDbf *dbf ) {
   this->dbf    = dbf;
   this->exp    = NULL;
   lLimit       = 0;       // max number of responses
@@ -63,6 +62,12 @@ void xbFilter::ResetQryCnt(){
 }
 
 /************************************************************************/
+xbInt16 xbFilter::Set( const char *sFilter ) {
+  xbString sFilt( sFilter );
+  return Set( sFilt );
+}
+
+/************************************************************************/
 xbInt16 xbFilter::Set( xbString &sFilter ) {
 
   xbInt16 iRc = XB_NO_ERROR;
@@ -72,7 +77,7 @@ xbInt16 xbFilter::Set( xbString &sFilter ) {
     if( exp )
       delete exp;
 
-    exp = new xbExp( xbase, dbf );
+    exp = new xbExp( dbf->GetXbasePtr(), dbf );
     if(( iRc = exp->ParseExpression( sFilter.Str() )) != XB_NO_ERROR ){
       iErrorStop = 100;
       throw iRc;
@@ -88,8 +93,8 @@ xbInt16 xbFilter::Set( xbString &sFilter ) {
   catch (xbInt16 iRc ){
     xbString sMsg;
     sMsg.Sprintf( "xbFilter::SetExpression() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
-    xbase->WriteLogMessage( sMsg.Str() );
-    xbase->WriteLogMessage( xbase->GetErrorMessage( iRc ));
+    dbf->GetXbasePtr()->WriteLogMessage( sMsg.Str() );
+    dbf->GetXbasePtr()->WriteLogMessage( dbf->GetXbasePtr()->GetErrorMessage( iRc ));
   }
   return iRc;
 }
@@ -141,8 +146,8 @@ xbInt16 xbFilter::GetFirstRecord( xbInt16 iOption ) {
   catch (xbInt16 iRc ){
     xbString sMsg;
     sMsg.Sprintf( "xbFilter::GetFirstRecord() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
-    xbase->WriteLogMessage( sMsg.Str() );
-    xbase->WriteLogMessage( xbase->GetErrorMessage( iRc ));
+    dbf->GetXbasePtr()->WriteLogMessage( sMsg.Str() );
+    dbf->GetXbasePtr()->WriteLogMessage( dbf->GetXbasePtr()->GetErrorMessage( iRc ));
   }
   return iRc;
 }
@@ -196,8 +201,8 @@ xbInt16 xbFilter::GetNextRecord( xbInt16 iOption ){
   catch (xbInt16 iRc ){
     xbString sMsg;
     sMsg.Sprintf( "xbFilter::GetNextRecord() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
-    xbase->WriteLogMessage( sMsg.Str() );
-    xbase->WriteLogMessage( xbase->GetErrorMessage( iRc ));
+    dbf->GetXbasePtr()->WriteLogMessage( sMsg.Str() );
+    dbf->GetXbasePtr()->WriteLogMessage( dbf->GetXbasePtr()->GetErrorMessage( iRc ));
   }
   return iRc;
 }
@@ -251,8 +256,8 @@ xbInt16 xbFilter::GetPrevRecord( xbInt16 iOption ){
   catch (xbInt16 iRc ){
     xbString sMsg;
     sMsg.Sprintf( "xbFilter::GetPrevRecord() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
-    xbase->WriteLogMessage( sMsg.Str() );
-    xbase->WriteLogMessage( xbase->GetErrorMessage( iRc ));
+    dbf->GetXbasePtr()->WriteLogMessage( sMsg.Str() );
+    dbf->GetXbasePtr()->WriteLogMessage( dbf->GetXbasePtr()->GetErrorMessage( iRc ));
   }
   return iRc;
 }
@@ -304,8 +309,8 @@ xbInt16 xbFilter::GetLastRecord( xbInt16 iOption ){
   catch (xbInt16 iRc ){
     xbString sMsg;
     sMsg.Sprintf( "xbFilter::GetLastRecord() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
-    xbase->WriteLogMessage( sMsg.Str() );
-    xbase->WriteLogMessage( xbase->GetErrorMessage( iRc ));
+    dbf->GetXbasePtr()->WriteLogMessage( sMsg.Str() );
+    dbf->GetXbasePtr()->WriteLogMessage( dbf->GetXbasePtr()->GetErrorMessage( iRc ));
   }
   return iRc;
 }
@@ -363,8 +368,8 @@ xbInt16 xbFilter::GetFirstRecordIx( xbInt16 iOption ) {
   catch (xbInt16 iRc ){
     xbString sMsg;
     sMsg.Sprintf( "xbFilter::GetFirstRecordIx() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
-    xbase->WriteLogMessage( sMsg.Str() );
-    xbase->WriteLogMessage( xbase->GetErrorMessage( iRc ));
+    dbf->GetXbasePtr()->WriteLogMessage( sMsg.Str() );
+    dbf->GetXbasePtr()->WriteLogMessage( dbf->GetXbasePtr()->GetErrorMessage( iRc ));
   }
   return iRc;
 }
@@ -419,8 +424,8 @@ xbInt16 xbFilter::GetNextRecordIx( xbInt16 iOption ){
   catch (xbInt16 iRc ){
     xbString sMsg;
     sMsg.Sprintf( "xbFilter::GetNextRecordIx() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
-    xbase->WriteLogMessage( sMsg.Str() );
-    xbase->WriteLogMessage( xbase->GetErrorMessage( iRc ));
+    dbf->GetXbasePtr()->WriteLogMessage( sMsg.Str() );
+    dbf->GetXbasePtr()->WriteLogMessage( dbf->GetXbasePtr()->GetErrorMessage( iRc ));
   }
   return iRc;
 }
@@ -475,8 +480,8 @@ xbInt16 xbFilter::GetPrevRecordIx( xbInt16 iOption ){
   catch (xbInt16 iRc ){
     xbString sMsg;
     sMsg.Sprintf( "xbFilter::GetPrevRecordIx() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
-    xbase->WriteLogMessage( sMsg.Str() );
-    xbase->WriteLogMessage( xbase->GetErrorMessage( iRc ));
+    dbf->GetXbasePtr()->WriteLogMessage( sMsg.Str() );
+    dbf->GetXbasePtr()->WriteLogMessage( dbf->GetXbasePtr()->GetErrorMessage( iRc ));
   }
   return iRc;
 }
@@ -491,7 +496,6 @@ xbInt16 xbFilter::GetLastRecordIx( xbInt16 iOption ){
       iErrorStop = 100;
       throw iRc;
     }
-
     lCurQryCnt = 0;
     if(( iRc = dbf->GetCurIx()->GetLastKey( dbf->GetCurTag(), iOption )) != XB_NO_ERROR ){
       if( iRc == XB_EOF )
@@ -501,7 +505,6 @@ xbInt16 xbFilter::GetLastRecordIx( xbInt16 iOption ){
         throw iRc;
       }
     }
-
     xbBool bFound = xbFalse;
     while( !bFound && iRc == XB_NO_ERROR ){
       if(( iRc = exp->ProcessExpression()) != XB_NO_ERROR ){
@@ -528,12 +531,11 @@ xbInt16 xbFilter::GetLastRecordIx( xbInt16 iOption ){
   catch (xbInt16 iRc ){
     xbString sMsg;
     sMsg.Sprintf( "xbFilter::GetLastRecordIx() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
-    xbase->WriteLogMessage( sMsg.Str() );
-    xbase->WriteLogMessage( xbase->GetErrorMessage( iRc ));
+    dbf->GetXbasePtr()->WriteLogMessage( sMsg.Str() );
+    dbf->GetXbasePtr()->WriteLogMessage( dbf->GetXbasePtr()->GetErrorMessage( iRc ));
   }
   return iRc;
 }
-
 #endif  // XB_INDEX_SUPPORT
 
 
diff --git a/src/core/xbixmdx.cpp b/src/core/xbixmdx.cpp
index 95f342c..135cde8 100755
--- a/src/core/xbixmdx.cpp
+++ b/src/core/xbixmdx.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -108,7 +108,7 @@ xbInt16 xbIxMdx::AddKey( void * vpTag, xbUInt32 ulRecNo ){
      } else {
 
        // land here with a full leaf node
-       //std::cout << "Section B begin split leaf node\n";
+       // std::cout << "Section B begin split leaf node\n";
 
        iHeadNodeUpdateOpt = 1;
        npRightNode = AllocateIxNode( npTag, GetBlockSize() + (xbUInt32) npTag->iKeyItemLen, npTag->npCurNode->ulBlockNo * (xbUInt32) iBlockFactor );
@@ -122,7 +122,7 @@ xbInt16 xbIxMdx::AddKey( void * vpTag, xbUInt32 ulRecNo ){
          ulNewRightChild = npRightNode->ulBlockNo * (xbUInt32) iBlockFactor;
        }
 
-       //std::cout << "ulNewRightChild = " << ulNewRightChild << "\n";
+       // std::cout << "ulNewRightChild = " << ulNewRightChild << "\n";
 
        if(( iRc = xbIxMdx::SplitNodeL( npTag, npTag->npCurNode, npRightNode, npTag->npCurNode->iCurKeyNo, npTag->cpKeyBuf, ulRecNo )) != XB_NO_ERROR ){
          iErrorStop = 130;
@@ -169,7 +169,8 @@ xbInt16 xbIxMdx::AddKey( void * vpTag, xbUInt32 ulRecNo ){
        // section D - if cur node is split root, create new root
 
        if(( npTag->npCurNode->ulBlockNo * (xbUInt32) iBlockFactor ) == npTag->ulRootPage ){
-         // std::cout << "Section D begin\n";
+
+         // std::cout << "Section D begin right node = " << npRightNode << "\n";
 
          if(( iRc = AddKeyNewRoot( npTag, npTag->npCurNode, npRightNode )) != XB_NO_ERROR ){
              iErrorStop = 160;
@@ -179,9 +180,10 @@ xbInt16 xbIxMdx::AddKey( void * vpTag, xbUInt32 ulRecNo ){
          if( npRightNode )
            npRightNode = FreeNodeChain( npRightNode );
 
-         //std::cout << "Section D end\n";
+         // std::cout << "Section D end\n";
 
        } else {
+
          // std::cout << "Section E, put key in parent\n";
          if(( iRc = InsertNodeI( (void *) vpTag, (xbIxNode *) npParent, (xbInt16) npParent->iCurKeyNo, BlockToPage( npRightNode->ulBlockNo ))) != XB_NO_ERROR ){
            iErrorStop = 170;
@@ -284,8 +286,8 @@ xbInt16 xbIxMdx::AddKeyNewRoot(  xbMdxTag *npTag, xbIxNode *npLeft, xbIxNode *np
     // std::cout << "AddKeyNewRoot - LeftBlock  = " << npLeft->ulBlockNo << "\n";
     // std::cout << "AddKeyNewRoot - RightBlock = " << npRight->ulBlockNo << "\n";
 
-    pLastKey = (char *) malloc( (size_t) npTag->iKeyLen );
 
+    pLastKey = (char *) malloc( (size_t) npTag->iKeyLen );
     if(( iRc = GetLastKeyForBlockNo( npTag, npLeft->ulBlockNo, pLastKey )) != XB_NO_ERROR ){
       iErrorStop = 110;
       throw iRc;
@@ -301,10 +303,17 @@ xbInt16 xbIxMdx::AddKeyNewRoot(  xbMdxTag *npTag, xbIxNode *npLeft, xbIxNode *np
 
     // set the key
     pTrg+= 4;
+    // std::cout << "AddKeyNewRoot - key [" << pLastKey << "] len = [" << strlen( pLastKey) << "]\n";
     memcpy( pTrg, pLastKey, (size_t) npTag->iKeyLen );
 
     // set the right node number
-    pTrg+= (npTag->iKeyLen);
+    //pTrg+= (npTag->iKeyLen);
+    // pTrg+= (npTag->iKeyItemLen)-4;
+
+    pTrg+= npTag->iKeyItemLen - 4;
+
+    //pTrg-=4;
+
     ePutUInt32( pTrg, npRight->ulBlockNo * (xbUInt32) iBlockFactor );
 
      // write out the new block
@@ -598,15 +607,17 @@ xbInt16 xbIxMdx::CheckTagIntegrity( void *vpTag, xbInt16 iOpt ){
         iErrorStop = 100;
         throw iRc;
       }
-	  bLocked = xbTrue;
+      bLocked = xbTrue;
     }
     #endif
 
     memset( npTag->cpKeyBuf2, 0x00, (size_t) npTag->iKeyLen );
+    // memset( npTag->cpKeyBuf2, 0x00, (size_t) npTag->iKeyItemLen );
     cKeyType = GetKeyType( vpTag );
 
     pPrevKeyBuf = (char *) calloc( 1, (size_t) npTag->iKeyLen );
     iRc = GetFirstKey( vpTag, 0 );
+
     memcpy( pPrevKeyBuf, GetKeyData( npTag->npCurNode, npTag->npCurNode->iCurKeyNo, npTag->iKeyItemLen ), (size_t) npTag->iKeyLen );
 
     // for each key in the index, make sure it is trending in the right direction
@@ -719,7 +730,7 @@ xbInt16 xbIxMdx::CheckTagIntegrity( void *vpTag, xbInt16 iOpt ){
       free( pPrevKeyBuf );
 
     if( iErrorStop == 160 ){
-      sMsg.Sprintf( "xbIxNdx::CheckTagIntegrity() Missing index entry for record [%d]", ulThisRecNo );
+      sMsg.Sprintf( "xbIxMdx::CheckTagIntegrity() Missing index entry for record [%d]", ulThisRecNo );
       xbase->WriteLogMessage( sMsg, iOpt );
     }
   }
@@ -1171,8 +1182,13 @@ xbInt16  xbIxMdx::CreateTag( const xbString &sName, const xbString &sKey, const
 
     tte->cKeyType2    = tte->cKeyType;
     tte->iKeyItemLen  = tte->iKeyLen + 4;
+    while(( tte->iKeyItemLen % 4 ) != 0 ) tte->iKeyItemLen++;
 
     tte->iKeysPerBlock = (xbInt16) (GetBlockSize() - 12) / tte->iKeyItemLen;
+
+    //std::cout << "-------------- create tag info\n";
+    //std::cout << "keylen=" << tte->iKeyLen << " iKeyItemLen = " << tte->iKeyItemLen << " keys per block calc = " << tte->iKeysPerBlock << "\n";
+
     tte->cKeyFmt3 = CalcTagKeyFmt( *tte->exp );
 
 //  printf( "ulRootPage=[%d] cKeyFmt2=[%d] cKeyType2=[%d] iKeyLen=[%d]iKeysPerBlock=[%d]\n", tte->ulRootPage, tte->cKeyFmt2, tte->cKeyType2, tte->iKeyLen,  tte->iKeysPerBlock );
@@ -2657,6 +2673,7 @@ xbInt16 xbIxMdx::GetFirstKey( void *vpTag, xbInt16 iRetrieveSw = 0 ){
   // convert the tag pointer to mdx tag pointer
   xbMdxTag * mpTag = (xbMdxTag *) vpTag;
 
+
   try{
     // clear out any history
     if( mpTag->npNodeChain ){
@@ -2668,6 +2685,7 @@ xbInt16 xbIxMdx::GetFirstKey( void *vpTag, xbInt16 iRetrieveSw = 0 ){
       iErrorStop = 100;
       throw iRc;
     }
+
     // lRootPage is available
     if(( iRc = GetBlock( vpTag, (mpTag->ulRootPage / (xbUInt32) iBlockFactor), 1 )) != XB_NO_ERROR ){
       iErrorStop = 110;
@@ -2683,8 +2701,7 @@ xbInt16 xbIxMdx::GetFirstKey( void *vpTag, xbInt16 iRetrieveSw = 0 ){
       return iRc;
     }
 
-    while( !IsLeaf( vpTag, mpTag->npCurNode ))   // go down the chain looking for a leaf node
-    {
+    while( !IsLeaf( vpTag, mpTag->npCurNode )){   // go down the chain looking for a leaf node
       if(( iRc = GetKeyPtr( vpTag, 0, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
         iErrorStop = 120;
         throw iRc;
@@ -2878,7 +2895,7 @@ xbInt16 xbIxMdx::GetLastKey( xbUInt32 ulBlockNo, void *vpTag, xbInt16 iRetrieveS
     }
 
     mpTag->npCurNode->iCurKeyNo = ulNoOfKeys;
-    ulNoOfKeys = eGetUInt32( mpTag->npCurNode->cpBlockData );    
+    ulNoOfKeys = eGetUInt32( mpTag->npCurNode->cpBlockData );
 
     xbUInt32 ulKeyPtr = 0;
     while( !IsLeaf( vpTag, mpTag->npCurNode )){   // go down the chain looking for a leaf node
@@ -3559,6 +3576,11 @@ xbInt16 xbIxMdx::InsertNodeI( void *vpTag, xbIxNode *npNode, xbInt16 iSlotNo, xb
     pSrc = pLastKey;
     for( xbInt16 i = 0; i < npTag->iKeyLen; i++ )
       *pTrg++ = *pSrc++;
+
+    pTrg = pNewKeyPos;
+    //pTrg+= npTag->iKeyItemLen - 4;
+    pTrg+= npTag->iKeyItemLen;
+
     ePutUInt32( pTrg, ulPtr);
     ePutInt32( npNode->cpBlockData, ++lKeyCnt );
 
@@ -4683,7 +4705,7 @@ xbInt16 xbIxMdx::SplitNodeI( void *vpTag, xbIxNode * npLeft, xbIxNode *npRight,
   }
   catch (xbInt16 iRc ){
     xbString sMsg;
-    sMsg.Sprintf( "xbIxNdx::SplitNodeI() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+    sMsg.Sprintf( "xbIxMdx::SplitNodeI() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
     xbase->WriteLogMessage( sMsg );
     xbase->WriteLogMessage( GetErrorMessage( iRc ));
   }
@@ -4712,7 +4734,7 @@ xbInt16 xbIxMdx::SplitNodeI( void *vpTag, xbIxNode * npLeft, xbIxNode *npRight,
   \returns <a href="xbretcod_8h.html">Return Codes</a>  
 */
 
-xbInt16 xbIxMdx::SplitNodeL( void *vpTag, xbIxNode * npLeft, xbIxNode *npRight, 
+xbInt16 xbIxMdx::SplitNodeL( void *vpTag, xbIxNode * npLeft, xbIxNode *npRight,
     xbInt16 iSlotNo, char * cpKeyBuf, xbUInt32 ulPtr ){
 
   xbInt16  iRc = XB_NO_ERROR;
diff --git a/src/core/xbixndx.cpp b/src/core/xbixndx.cpp
index dcec5f9..9d946dd 100755
--- a/src/core/xbixndx.cpp
+++ b/src/core/xbixndx.cpp
@@ -342,7 +342,7 @@ xbInt16 xbIxNdx::CheckTagIntegrity( void *vpTag, xbInt16 iOpt ){
         iErrorStop = 100;
         throw iRc;
       }
-	  bLocked = xbTrue;
+      bLocked = xbTrue;
     }
     #endif
 
@@ -425,7 +425,6 @@ xbInt16 xbIxNdx::CheckTagIntegrity( void *vpTag, xbInt16 iOpt ){
       sMsg.Sprintf( "CheckTagIntegrity()  Index entry count [%ld] matches dbf record count [%ld]", ulIxCnt, ulDbfCnt );
       xbase->WriteLogMessage( sMsg, iOpt );
     }
-	
     if( pPrevKeyBuf )
       free( pPrevKeyBuf );
 
diff --git a/src/core/xblog.cpp b/src/core/xblog.cpp
index ea7c9d6..6031c9e 100755
--- a/src/core/xblog.cpp
+++ b/src/core/xblog.cpp
@@ -25,8 +25,8 @@ namespace xb{
 //! @brief Constructor.
 xbLog::xbLog() : xbFile( NULL ){
 
-  SetDirectory( GetDefaultLogDirectory());
-  SetFileName ( GetDefaultLogFileName());
+  SetDirectory( GetLogDirectory());
+  SetFileName ( GetLogFileName());
 
   bLoggingStatus = xbFalse;
   lLogSize       = 50000;
diff --git a/src/core/xbssv.cpp b/src/core/xbssv.cpp
index 252daab..d3e1070 100755
--- a/src/core/xbssv.cpp
+++ b/src/core/xbssv.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -15,8 +15,6 @@ Email Contact:
 
 #include "xbase.h"
 
-
-
 namespace xb{
 
 const xbErrorMessage xbErrorMessages[] = {
@@ -26,6 +24,7 @@ const xbErrorMessage xbErrorMessages[] = {
   { XB_DUP_TABLE_OR_ALIAS,      "Duplicate Alias/Table Name" },
   { XB_INVALID_NODELINK,        "Invalid Node Link" },
   { XB_KEY_NOT_UNIQUE,          "Key Not Unique" },
+  { XB_MEMCPY_ERROR,            "Memory copy failure" },
   { XB_FILE_EXISTS,             "File Already Exists" },
   { XB_ALREADY_OPEN,            "Database already open" },
   { XB_DBF_FILE_NOT_OPEN,       "DBF File Not Open" },
@@ -49,6 +48,8 @@ const xbErrorMessage xbErrorMessages[] = {
   { XB_INVALID_TABLE_NAME,      "Invalid Table Name" },
   { XB_EMPTY,                   "Empty Table or Index" },
   { XB_LIMIT_REACHED,           "Limit Reached" },
+  { XB_BLOCKREAD_NOT_ENABLED,   "Block Read Mode is not enabled" },
+  { XB_DIRECTORY_ERROR,         "Directory Read/Write error" },
   { XB_INVALID_FIELD_TYPE,      "Unknown Field Type" },
   { XB_INVALID_FIELD_NO,        "Invalid Field Number" },
   { XB_INVALID_DATA,            "Invalid Data" },
@@ -89,12 +90,13 @@ xbBool   xbSsv::bDefaultAutoCommit      = xbTrue;
 xbString xbSsv::sDataDirectory   = PROJECT_DATA_DIR;
 #else
 xbString xbSsv::sDataDirectory   = PROJECT_DATA_DIR;
-#endif
+#endif  // 
 
 #ifdef XB_LOGGING_SUPPORT
-xbString xbSsv::sDefaultLogDirectory    = PROJECT_LOG_DIR;
-xbString xbSsv::sDefaultLogFileName     = PROJECT_DFLT_LOGFILE;
-#endif
+xbString xbSsv::sLogDirectory    = PROJECT_LOG_DIR;
+//xbString xbSsv::sLogDirectory    = "";
+xbString xbSsv::sLogFileName     = PROJECT_DFLT_LOGFILE;
+#endif  // XB_LOGGING_SUPPORT
 
 #ifdef XB_LOCKING_SUPPORT
 xbInt32  xbSsv::lDefaultLockWait        = 100;
@@ -104,18 +106,21 @@ xbInt16  xbSsv::iDefaultLockFlavor      = 1;
 xbBool   xbSsv::bMultiUser              = xbTrue;
 #else
 xbBool   xbSsv::bMultiUser              = xbFalse;
-#endif
+#endif  // XB_LOCKING_SUPPORT
 
 #if defined (XB_NDX_SUPPORT) || defined (XB_MDX_SUPPORT)
 xbInt16  xbSsv::iUniqueKeyOpt = XB_HALT_ON_DUPKEY;
   // is one of XB_HALT_ON_DUPKEY || XB_EMULATE_DBASE
-#endif
+#endif  // defined (XB_NDX_SUPPORT) || defined (XB_MDX_SUPPORT)
 
 
 #ifdef XB_MDX_SUPPORT
 xbInt16  xbSsv::iCreateMdxBlockSize     = 1024;   // 1024 is DBase 7 default size for MDX index blocks
-#endif
+#endif  // XB_MDX_SUPPORT
 
+#ifdef XB_BLOCKREAD_SUPPORT
+xbUInt32 xbSsv::ulDefaultBlockReadSize  = 32768;  // 32K buffer for block DBF datafile reads
+#endif  // XB_BLOCKREAD_SUPPORT
 
 /*************************************************************************/
 //! @brief Class Constructor.
@@ -139,7 +144,6 @@ void xbSsv::BitDump( char c ) const {
 xbBool xbSsv::BitSet( unsigned char c, xbInt16 iBitNo ) const {
   return c & 1 << iBitNo;
 }
-
 /*************************************************************************/
 //! @brief Display error message on console for a given error number.
 /*!
@@ -164,7 +168,6 @@ void xbSsv::DisplayError( xbInt16 iErrorCode ) const {
 xbBool xbSsv::GetDefaultAutoCommit() const {
   return bDefaultAutoCommit;
 }
-
 /*************************************************************************/
 //! @brief Get the current data directory.
 /*!
@@ -184,19 +187,6 @@ xbString &xbSsv::GetDataDirectory() const {
 xbString & xbSsv::GetDefaultDateFormat() const {
   return sDefaultDateFormat;
 }
-
-/*************************************************************************/
-// @brief Get the default file format version.
-/*
-   \returns 3 - Dbase III file format<br>
-            4 - Dbase IV file format<br>
-*/
-
-/*
-xbInt16  xbSsv::GetDefaultFileVersion() const {
-  return iDefaultFileVersion;
-}
-*/
 /*************************************************************************/
 //! @brief Get the Endian type.
 /*!
@@ -206,7 +196,6 @@ xbInt16  xbSsv::GetDefaultFileVersion() const {
 xbInt16  xbSsv::GetEndianType() const {
   return iEndianType;
 }
-
 /*************************************************************************/
 //! @brief Get an error message.
 /*!
@@ -230,7 +219,25 @@ const char * xbSsv::GetErrorMessage( xbInt16 iErrorCode ) const{
    }
    return "";
 }
+/*************************************************************************/
+//! @brief Get home directory.
+/*!
+   \param sHomeDirOut - Output home directory for current user.
+   \returns void
+*/
+
+void xbSsv::GetHomeDir( xbString &sHomeDirOut ){
 
+  #ifdef WIN32
+    sHomeDirOut.Sprintf( "%s%s", getenv( "HOMEDRIVE" ), getenv( "HOMEPATH" ));
+  #else
+    sHomeDirOut.Sprintf( "%s", getenv( "HOME" ));
+    sHomeDirOut.Trim();
+    if( sHomeDirOut == "" )
+      sHomeDirOut.Sprintf( "%s", getpwuid( getuid())->pw_dir );
+  #endif
+  sHomeDirOut.Trim();
+}
 /*************************************************************************/
 //! @brief Set the data directory.
 /*!
@@ -240,7 +247,6 @@ const char * xbSsv::GetErrorMessage( xbInt16 iErrorCode ) const{
 void xbSsv::SetDataDirectory( const xbString &sDataDirectory ){
   this->sDataDirectory = sDataDirectory;
 
-
   #ifdef WIN32
     this->sDataDirectory.SwapChars( '/', '\\' );
   #else
@@ -302,57 +308,53 @@ void xbSsv::SetEndianType() {
 /*!
    \returns Returns the log file name.
 */
-xbString & xbSsv::GetDefaultLogFileName() const {
-  return sDefaultLogFileName;
+xbString & xbSsv::GetLogFileName() const {
+  return sLogFileName;
 }
 
-
 /*************************************************************************/
 //! @brief Get the default log directory.
 /*!
    \returns Returns the log directory.
 */
-xbString & xbSsv::GetDefaultLogDirectory() const {
-  return sDefaultLogDirectory;
+xbString & xbSsv::GetLogDirectory() const {
+  return sLogDirectory;
 }
 
 
 /*************************************************************************/
 //! @brief Set the default log directory name.
 /*!
-   \param sDefaultLogDirectory  Name of desired log directory.
+   \param sLogDirectory  Name of desired log directory.
 
 */
-void xbSsv::SetDefaultLogDirectory( const xbString &sDefaultLogDirectory ){
-
-  this->sDefaultLogDirectory = sDefaultLogDirectory;
+void xbSsv::SetLogDirectory( const xbString &sLogDirectoryIn ){
 
+  this->sLogDirectory = sLogDirectoryIn;
   #ifdef WIN32
-    this->sDefaultLogDirectory.SwapChars( '/', '\\' );
+    this->sLogDirectory.SwapChars( '/', '\\' );
   #else
-    this->sDefaultLogDirectory.SwapChars( '\\', '/' );
+    this->sLogDirectory.SwapChars( '\\', '/' );
   #endif
 
-
 }
 
 #else
 
-xbString & xbSsv::GetDefaultLogFileName() const {
+xbString & xbSsv::GetLogFileName() const {
   return sNullString;
 }
 
-xbString & xbSsv::GetDefaultLogDirectory() const {
+xbString & xbSsv::GetLogDirectory() const {
   return sNullString;
 }
 
-void xbSsv::SetDefaultLogDirectory( const xbString &sDefaultLogDirectory ){
+void xbSsv::SetLogDirectory( const xbString &sLogDirectory ){
   return;
 }
 
 #endif
 
-
 /*************************************************************************/
 
 #ifdef XB_LOCKING_SUPPORT
@@ -541,6 +543,29 @@ xbInt16 xbSsv::SetUniqueKeyOpt( xbInt16 iOpt ){
 }
 #endif
 /************************************************************************/
+#ifdef XB_BLOCKREAD_SUPPORT
+
+//! @brief Get Default Read Block Size
+/*!
+  This routine returns the default read block size used when allocating
+  buffer space for block reads of table data.  Initial setting is 32768 bytes.
+*/
+xbUInt32 xbSsv::GetDefaultBlockReadSize() const {
+  return ulDefaultBlockReadSize;
+}
+
+
+//! @brief Set Default Read Block Size
+/*!
+  This routine sets the default read block size used when allocating
+  buffer space for block reads of table data.  Initial setting is 32768 bytes.
+*/
+void xbSsv::SetDefaultBlockReadSize( xbUInt32 ulDfltBlockReadSize ){
+   ulDefaultBlockReadSize = ulDfltBlockReadSize;
+}
+
+#endif  // XB_BLOCKREAD_SUPPORT
+/************************************************************************/
 
 
 
diff --git a/src/core/xbstring.cpp b/src/core/xbstring.cpp
index 81e67b8..701e50e 100755
--- a/src/core/xbstring.cpp
+++ b/src/core/xbstring.cpp
@@ -1267,6 +1267,45 @@ xbString &xbString::PadRight( char c, xbUInt32 ulNewLen ){
 //! @brief Determine position of a given character 
 /*!
     \param c Seek character 
+    \param ulStartPos starting position for search, first position is 1
+    \returns Position within string. Returns 0 if not found.
+*/
+xbUInt32 xbString::Pos(char c, xbUInt32 ulStartPos ) const {
+
+  if (data == NULL)
+    return 0;
+  char *p = data;
+
+  if( ulStartPos >= size )
+    return 0;
+
+  xbUInt32 iPos = 0;
+  while( (iPos+1) < ulStartPos ){
+    p++;
+    iPos++;
+  }
+  xbBool bFound = 0;
+  while( *p && !bFound && iPos < ( size - 1 )){
+    if( *p == c )
+      bFound = 1;
+    else {
+      iPos++;
+      p++;
+    }
+  }
+
+  if( bFound )
+    return iPos + 1;
+  else
+    return 0;
+}
+
+
+
+/************************************************************************/
+//! @brief Determine position of a given character 
+/*!
+    \param c Seek character 
     \returns Position within string. Returns 0 if not found.
 */
 xbUInt32 xbString::Pos(char c) const {
@@ -1375,41 +1414,51 @@ xbString &xbString::Replace( const char *sReplace, const char *sReplaceWith, xbI
 
   xbBool bDone = xbFalse;
   xbUInt32 ulPos;
-  xbUInt32 ulNewSize;
+  xbUInt32 ulNewLen;
+  xbUInt32 ulReplaceWithLen;
+  xbUInt32 ulRsLen;    // size of right side of string after replaced data
   xbUInt32 ulSp2;
   char *sBuf2;
 
+  const char *s;        // source ptr
+  char *t;              // target ptr
+
   while( !bDone ){
     ulPos = Pos( sReplace );
     if( ulPos == 0 ){
       bDone = xbTrue;
     } else {
 
-      ulNewSize = this->size + sizeof( sReplaceWith ) - sizeof( sReplace );
-      sBuf2 = (char *) calloc( 1, ulNewSize );
+      ulReplaceWithLen = (xbUInt32) strlen( sReplaceWith );
+      ulNewLen = this->size + ulReplaceWithLen - (xbUInt32) strlen( sReplace );
+      sBuf2 = (char *) calloc( 1, ulNewLen );
 
       // copy part1
+      t = sBuf2;
+      s = data;
       for( xbUInt32 ul = 0; ul < ulPos-1; ul++ )
-        sBuf2[ul] = data[ul];
+        *t++ = *s++;
 
       // copy part2
-      strcat( sBuf2, sReplaceWith );
+      s = sReplaceWith;
+      for( xbUInt32 ul = 0; ul < ulReplaceWithLen; ul++ )
+        *t++ = *s++;
 
       // copy part3
-      ulSp2 = ulPos + strlen( sReplace );
-      char *p = data;
-      p+= (ulSp2 - 1);
-      strcat( sBuf2, p );
+      ulSp2 = ulPos + (xbUInt32) strlen( sReplace );
+      s = data;
+      s+= (ulSp2 - 1);
+      ulRsLen = (xbUInt32) strlen( s );
+      for( xbUInt32 ul = 0; ul < ulRsLen; ul++ )
+        *t++ = *s++;
 
       if( iOption )
         bDone = xbTrue;
 
       free(data);
       data = sBuf2;
-
     }
   }
-
   return *this;
 }
 
diff --git a/src/core/xbtblmgr.cpp b/src/core/xbtblmgr.cpp
index f154dc6..2fe6a8c 100755
--- a/src/core/xbtblmgr.cpp
+++ b/src/core/xbtblmgr.cpp
@@ -22,20 +22,19 @@ Email Contact:
 namespace xb{
 
 /*************************************************************************/
-
 xbTblMgr::xbTblMgr(){
   TblList = NULL;
   iOpenTableCount = 0;
 }
 
 /*************************************************************************/
-
 xbTblMgr::~xbTblMgr(){
   xbTblList *l;
   if( TblList ){
     while( TblList ){
       l = TblList;
       TblList = TblList->pNext;
+      delete l->psFqTblName;
       delete l->psTblName;
       delete l->psTblAlias;
       free( l );
@@ -44,47 +43,74 @@ xbTblMgr::~xbTblMgr(){
 }
 
 /*************************************************************************/
-
-xbInt16 xbTblMgr::AddTblToTblList( xbDbf *d, const xbString & sTblName ){
-  return AddTblToTblList( d, sTblName, "" );
+xbInt16 xbTblMgr::AddTblToTblList( xbDbf *d, const xbString & sFqTblName ){
+  return AddTblToTblList( d, sFqTblName, "" );
 }
 
 /*************************************************************************/
+xbInt16 xbTblMgr::AddTblToTblList( xbDbf *d, const xbString & sFqTblName, const xbString & sTblAlias ) {
+
+  // Set the Fq (fully qualified name)
+  // Pull the table name from the FQ name
+  // Set the Alias to the table name if the alias name is not provided
 
-xbInt16 xbTblMgr::AddTblToTblList( xbDbf *d, const xbString & sTblName, const xbString & sTblAlias ) {
 
   xbTblList *i, *s, *t;
   xbInt16 iRc = 0;
   xbInt16 iErrorStop = 0;
+  xbString sTblName;
   xbString sAlias;
+  xbString sTemp;
+  xbString sFqTemp;
+  xbUInt32 iSlashPos;
+
+  // std::cout << "AddTblToTblList fq in = [" << sFqTblName.Str() << "] alias in =[" << sTblAlias.Str() << "]\n";
 
   try{
 
-    if( sTblName.Len() == 0 ){
+    if( sFqTblName.Len() == 0 ){
       iErrorStop = 100;
       iRc = XB_INVALID_TABLE_NAME;
       throw iRc;
     }
 
-    if( sTblAlias.Len() == 0 ){
+    sTblName = sFqTblName;
+    sTblName.SwapChars( '\\', '/' );
+    iSlashPos = sTblName.GetLastPos( '/' );
+
+    // std::cout << "slashpos = " << iSlashPos << "\n";
+
+
+    if( iSlashPos > 0 ){
+      sTblName.Ltrunc( iSlashPos );           // remove the directory part from the table name
+      sFqTemp = sFqTblName;
+    } else{
+      sFqTemp.Sprintf( "%s%s", GetDataDirectory().Str(), sFqTblName.Str());   // add the dir part to the FQ name
+    }
+
+    xbUInt32 iDbfPos = sFqTemp.Pos( ".DBF" );
+    if( iDbfPos == 0 )
+      sFqTemp += ".DBF";
+    else
+      sTblName.Resize( sTblName.Len() - 3 );
+
+    if( sTblAlias.Len() == 0 )
       sAlias = sTblName;
-      sAlias.SwapChars( '\\', '/' );
-      xbUInt32 iPos = sAlias.GetLastPos( '/' );
-      if( iPos > 0 )            /* get rid of the directory part of the name */
-        sAlias.Ltrunc( iPos );
-    } else {
+    else
       sAlias = sTblAlias;
-    }
+
+    //std::cout << "fq=[" << sFqTemp.Str() << "] tblname = [" << sTblName.Str() << "] alias = [" << sAlias.Str() << "]\n";
 
     if((i = (xbTblList *) calloc(1, sizeof(xbTblList))) == NULL){
       iErrorStop = 110;
       iRc = XB_NO_MEMORY;
       throw iRc;
     }
-    i->psTblName  = new xbString( sTblName );
-    i->psTblAlias = new xbString( sAlias );
-    i->pDbf       = d;
-    i->pNext      = NULL;
+    i->psFqTblName  = new xbString( sFqTemp );
+    i->psTblName    = new xbString( sTblName );
+    i->psTblAlias   = new xbString( sAlias );
+    i->pDbf         = d;
+    i->pNext        = NULL;
 
     // insert new table into the list of open tables, sorted by table name 
     s = NULL;
@@ -97,7 +123,7 @@ xbInt16 xbTblMgr::AddTblToTblList( xbDbf *d, const xbString & sTblName, const xb
 
     if( t && (strcmp( t->psTblAlias->Str(), sAlias.Str()) == 0 )){
       iErrorStop = 120;
-      delete i->psTblName;
+      delete i->psFqTblName;
       delete i->psTblAlias;
       free( i );
       iRc = XB_DUP_TABLE_OR_ALIAS;
@@ -131,7 +157,7 @@ xbInt16 xbTblMgr::DisplayTableList() const {
   else{
     while( l ){
       iTblCnt++;
-      std::cout << iTblCnt << " Table=[" << l->psTblName->Str() << "]  Alias=[" << l->psTblAlias->Str() << "]" << std::endl;
+      std::cout << iTblCnt << " FqFileName=[" << l->psFqTblName->Str() << "]  TableName=[" << l->psTblName->Str() << "] Alias=[" << l->psTblAlias->Str() << "]" << std::endl;
       l = l->pNext;
     }
   }
@@ -149,6 +175,7 @@ xbInt16 xbTblMgr::DisplayTableList() const {
 
 xbDbf *xbTblMgr::GetDbfPtr(const xbString& sTblAlias) const {
 
+
   xbTblList *t;
   t = TblList;
   xbString s;
@@ -159,14 +186,26 @@ xbDbf *xbTblMgr::GetDbfPtr(const xbString& sTblAlias) const {
     s.Set( sTblAlias );
 
   while( t ){
-    if( s == t->psTblAlias->Str())
+    if( s == t->psTblAlias->Str()){
+       return t->pDbf;
+    }
+    t = t->pNext;
+  }
+
+  t = TblList;
+  while( t ){
+    std::cout << "s = [" << s.Str() << "] tbl name = [" << t->psTblName->Str() << "]\n";
+    if( s == t->psTblName->Str()){
+      std::cout << "found\n";
       return t->pDbf;
+    }
     t = t->pNext;
   }
 
+
   t = TblList;
   while( t ){
-    if( sTblAlias == t->psTblName->Str())
+    if( sTblAlias == t->psFqTblName->Str())
       return t->pDbf;
     t = t->pNext;
   }
@@ -227,6 +266,7 @@ xbInt16 xbTblMgr::RemoveTblFromTblList( const xbString & sTblAlias ) {
       else
         TblList = i->pNext;
 
+      delete i->psFqTblName;
       delete i->psTblName;
       delete i->psTblAlias;
       free( i );
@@ -254,6 +294,7 @@ xbInt16 xbTblMgr::RemoveTblFromTblList( xbDbf *pTbl ) {
       else
         TblList = i->pNext;
 
+      delete i->psFqTblName;
       delete i->psTblName;
       delete i->psTblAlias;
       free( i );
diff --git a/src/core/xbxbase.cpp b/src/core/xbxbase.cpp
index 7443b26..20b7fcc 100755
--- a/src/core/xbxbase.cpp
+++ b/src/core/xbxbase.cpp
@@ -24,6 +24,10 @@ xbXBase::xbXBase() {
   #ifdef XB_LOGGING_SUPPORT
   xLog = new xbLog();
   #endif
+
+  xbFile f( this );
+  f.SetHomeFolders();
+
 }
 /*************************************************************************/
 //! @brief Class Deconstructor.
@@ -69,6 +73,53 @@ xbInt16 xbXBase::CloseAllTables(){
   }
   return iRc;
 }
+
+
+
+/*************************************************************************/
+//! @brief Parse commmand line options for a given parm request
+/*!
+  \param lArgc Value passed from main( argc, argv[] )
+  \param sArgv Valued passed from main
+  \param sOptRqst Option to search for in the arguments list
+  \param sParmOut String token immediately to the right of the the option request, if found
+  \returns 0 - paramater request not found<br> 1 - Parameter found
+*/
+
+xbInt16  xbXBase::GetCmdLineOpt( xbInt32 lArgc, char **sArgv, const char *sOptRqst, xbString &sParmOut ){
+  xbString sOpt( sOptRqst );
+  return GetCmdLineOpt( lArgc, sArgv, sOpt, sParmOut );
+}
+
+/*************************************************************************/
+//! @brief Parse commmand line options for a given parm request
+/*!
+  \param lArgc Value passed from main( argc, argv[] )
+  \param sArgv Valued passed from main
+  \param sOptRqst Option to search for in the arguments list
+  \param sParmOut String token immediately to the right of the the option request, if found
+  \returns 0 - paramater request not found<br> 1 - Parameter found
+*/
+
+xbInt16  xbXBase::GetCmdLineOpt( xbInt32 lArgc, char **sArgv, xbString &sOptRqst, xbString &sParmOut ){
+
+  xbInt16 iFound = 0;
+  sParmOut = "";
+  if( lArgc < 2 )  // first string is the program name
+    return iFound;
+
+  xbInt32 i = 1;
+  while( iFound == 0 && i < lArgc ){
+    if( sOptRqst == sArgv[i] ){
+      iFound = 1;
+      if( i < (lArgc-1))
+        sParmOut = sArgv[i+1];
+    }
+    i++;
+  }
+  return iFound;
+}
+
 /*************************************************************************/
 #ifdef XB_LOGGING_SUPPORT
 //! @brief Get fully qualified log file name.
@@ -109,6 +160,7 @@ xbBool xbXBase::GetLogStatus() const {
   \return void
 */
 void xbXBase::SetLogFileName( const xbString & sLogFileName ){
+
   xLog->SetFileName( sLogFileName );
 }
 
@@ -550,7 +602,7 @@ xbDbf* xbXBase::Open( const xbString &sTableName, xbInt16 &iRc ){
   \param iOpenMode - XB_READ_WRITE or XB_READ
   \param iShareMode - XB_SINGLE_USER or XB_MULTI_USER
   \param iRequestVersion 0 - Highest available
-                         4 - Version  four dbf
+                         4 - Version four dbf
                          3 - Version three dbf
   \param iRc - Return code from open request
   \returns param dbf - Output pointer to dbf file opened or null if error
diff --git a/src/examples/xb_ex_expression.cpp b/src/examples/xb_ex_expression.cpp
index dc6d7e6..840e9c6 100755
--- a/src/examples/xb_ex_expression.cpp
+++ b/src/examples/xb_ex_expression.cpp
@@ -65,7 +65,9 @@ void PrintResult( xbString *sExpression, xbExp *exp ){
 }
 
 //*********************************************************************************************************************************
-int main( int ac, char ** av ){
+//int main( int ac, char ** av ){
+
+int main(){
 
   xbInt16 iRc        = 0;
   xbInt16 iErrorStop = 0;
diff --git a/src/examples/xb_ex_ssv.cpp b/src/examples/xb_ex_ssv.cpp
new file mode 100755
index 0000000..a78345f
--- /dev/null
+++ b/src/examples/xb_ex_ssv.cpp
@@ -0,0 +1,134 @@
+/*  xb_ex_ssv.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2021,2022,2023 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+This program demonstrates using functionality of the xbSsv class  (Shared system values)
+
+*/
+
+#include "xbase.h"
+
+using namespace xb;
+
+int main( int ac, char ** av ){
+
+  xbXBase  x;              // set up xbase for business
+  xbString sMsg;           // a message string
+
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  std::cout << sMsg.Str() << std::endl;
+
+
+  // example code to set up log file usage
+  #ifdef XB_LOGGING_SUPPORT
+    char     cSeperator;                      // is this a unix (/) or windows (\) file system
+    xbString sLog;                            // general string for log file activities
+    sLog = x.GetLogFqFileName().Str();        // get the system default log file name
+    std::cout << "System default logfile is [" << sLog.Str() << "]" << std::endl;
+
+    cSeperator = sLog.GetPathSeparator();     // get the seperator from 
+    std::cout << "Path seperator = [" << cSeperator << "]" << std::endl;
+
+    sLog.Sprintf( "..%c", cSeperator );
+    x.SetLogDirectory( sLog );
+    std::cout << "sLog = [" << sLog.Str() << "]\n";
+
+    sLog = x.GetLogFqFileName().Str();        // get the system default log file name
+    std::cout << "New logfile is [" << sLog.Str() << "]" << std::endl;
+
+    // turn on logging after file name set
+    x.EnableMsgLogging();
+  #endif  // XB_LOGGING_SUPPORT
+
+  // const char *GetErrorMessage( xbInt16 ErrorCode ) const;
+  // void DisplayError( xbInt16 ErrorCode ) const;
+  std::cout << "DisplayError( -100 ) - ";
+  x.DisplayError( -100 );
+  //  << "]" << std::endl;
+
+  // void      SetDefaultDateFormat( const xbString &sDefaultDateFormat );
+  // xbString& GetDefaultDateFormat() const;
+  std::cout << "GetDefaultDateFormat() - " << x.GetDefaultDateFormat().Str() << std::endl;
+
+
+  //  void       SetDataDirectory          ( const xbString &sDataDirectory );
+  // xbString& GetDataDirectory() const;
+  std::cout << "GetDataDirectory() - " << x.GetDataDirectory().Str() << std::endl;
+
+  // xbInt16 GetEndianType() const;
+  if( x.GetEndianType() == 'L' )
+    std::cout << "Little Endian Architecture." << std::endl;
+  else
+    std::cout << "Bid Endian Architecture." << std::endl;
+
+  //xbBool GetDefaultAutoCommit() const;
+  //void SetDefaultAutoCommit( xbBool bDefaultAutoCommit );
+  if( x.GetDefaultAutoCommit())
+    std::cout << "AutoCommit is on." << std::endl;
+  else
+    std::cout << "AutoCommit is off." << std::endl;
+
+  //xbBool     GetMultiUser              () const;
+  //void       SetMultiUser              ( xbBool bMultiUser );
+  if( x.GetMultiUser())
+    std::cout << "Multi user (locking) is enabled." << std::endl;
+  else
+    std::cout << "Multi user (locking) not enabled." << std::endl;
+
+  #if defined (XB_NDX_SUPPORT) || defined (XB_MDX_SUPPORT)
+  // xbInt16    GetUniqueKeyOpt           () const;
+  // xbInt16    SetUniqueKeyOpt           ( xbInt16 iUniqueKeyOpt );
+  //   XB_HALT_ON_DUPKEY
+  //   XB_EMULATE_DBASE
+  if( x.GetUniqueKeyOpt() == XB_HALT_ON_DUPKEY )
+    std::cout << "UniqueKey option - XB_HALT_ON_DUPKEY" << std::endl;
+  else if( x.GetUniqueKeyOpt() == XB_EMULATE_DBASE )
+    std::cout << "UniqueKey option - XB_EMULATE_DBASE" << std::endl;
+  #endif  // (XB_NDX_SUPPORT) || defined (XB_MDX_SUPPORT)
+
+  #ifdef XB_LOCKING_SUPPORT
+  //xbInt16    GetDefaultLockRetries     () const;
+  //void       SetDefaultLockRetries     ( xbInt16 iRetryCount );
+  //xbInt32    GetDefaultLockWait        () const;
+  //void       SetDefaultLockWait        ( xbInt32 lRetryWait );
+  //xbInt16    GetDefaultLockFlavor      () const;
+  //void       SetDefaultLockFlavor      ( xbInt16 iLockFlavor );
+  //xbBool     GetDefaultAutoLock        () const;
+  //void       SetDefaultAutoLock        ( xbBool bAutoLock );
+  //void       EnableDefaultAutoLock     ();
+  //void       DisableDefaultAutoLock    ();
+
+  std::cout << "GetDefaultLockRetries() - " << x.GetDefaultLockRetries() << std::endl;
+  std::cout << "GetDefaultLockWait() - " << x.GetDefaultLockWait() << std::endl;
+  std::cout << "GetDefaultAutoLock() - " << x.GetDefaultAutoLock() << std::endl;
+  #endif  // XB_LOCKING_SUPPORT
+
+  #ifdef XB_MDX_SUPPORT
+  // xbInt16    GetCreateMdxBlockSize() const;
+  // xbInt16    SetCreateMdxBlockSize( xbInt16 ulBlockSize );
+  std::cout << "GetCreateMdxBlockSize() - " << x.GetCreateMdxBlockSize() << std::endl;
+  #endif  // XB_MDX_SUPPORT
+
+  #ifdef XB_BLOCKREAD_SUPPORT
+  // xbUInt32   GetDefaultBlockReadSize() const;
+  // void       SetDefaultBlockReadSize( xbUInt32 ulDfltBlockReadSize );
+  std::cout << "GetDefaultBlockReadSize() - " << x.GetDefaultBlockReadSize() << std::endl;  
+  #endif  // XB_BLOCKREAD_SUPPORT
+
+  //xbBool     BitSet                    ( unsigned char c, xbInt16 iBitNo ) const;
+  //void       BitDump                   ( unsigned char c ) const;
+  //void       BitDump                   ( char c ) const;
+  std::cout << "BitDump( 'A' ) - ";
+  x.BitDump( 'A' );
+
+  return 0;
+}
diff --git a/src/examples/xb_ex_v4_upd_dbf.cpp b/src/examples/xb_ex_v4_upd_dbf.cpp
index 96b6bdf..75d0641 100755
--- a/src/examples/xb_ex_v4_upd_dbf.cpp
+++ b/src/examples/xb_ex_v4_upd_dbf.cpp
@@ -258,15 +258,15 @@ int main()
       throw iRc;
     }
 
-
     // example code to loop through the table
-    for( xbUInt32 ulTuple = 1; ulTuple <= MyTable->GetRecordCount(); ulTuple++ ){
-      if(( iRc = MyTable->GetRecord( ulTuple ) != XB_NO_ERROR )){
+    for( xbUInt32 ul = 1; ul <= MyTable->GetRecordCount(); ul++ ){
+      if(( iRc = MyTable->GetRecord( ul )) != XB_NO_ERROR ){
         iErrorStop = 430;
         throw iRc;
       }
       // do something with the record here
       std::cout << "Tuple = " << MyTable->GetCurRecNo() << std::endl;
+
     }
 
     /* Close database and associated indexes */
diff --git a/src/include/xbase.h b/src/include/xbase.h
index 480d716..4ab8892 100755
--- a/src/include/xbase.h
+++ b/src/include/xbase.h
@@ -3,7 +3,7 @@
 
 Xbase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license
 
@@ -41,6 +41,10 @@ Email Contact:
 #include <ctype.h>
 #endif
 
+#ifdef HAVE_PWD_H
+#include <pwd.h>
+#endif
+
 #ifdef HAVE_STDARG_H
 #include <stdarg.h>
 #endif
@@ -89,6 +93,7 @@ Email Contact:
 #include <xbexp.h>
 
 #include <xbtag.h>
+#include <xbblkread.h>
 #include <xbdbf.h>             /* dbf base class   */
 #include <xbindex.h>           /* index base class */
 #include <xbfilter.h>
diff --git a/src/include/xbblkread.h b/src/include/xbblkread.h
new file mode 100755
index 0000000..353c618
--- /dev/null
+++ b/src/include/xbblkread.h
@@ -0,0 +1,70 @@
+/*  xbblkread.h
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+#ifndef __XB_BLKREAD_H__
+#define __XB_BLKREAD_H__
+
+namespace xb{
+#ifdef XB_BLOCKREAD_SUPPORT
+
+
+
+//! @brief xbBlockRead class.
+/*!
+The xbBlockRead class can be used to read blocks of records at one time
+rather than one record at a time for perfomance improvements when reading a DBF file sequentially.<br>
+
+*/
+
+
+class XBDLLEXPORT xbBlockRead {
+
+  public:
+    xbBlockRead( xbDbf * d );
+    ~xbBlockRead();
+
+    #ifdef XB_DEBUG_SUPPORT
+    void     DumpReadBlockInternals();
+    #endif
+
+    xbInt16  Init( xbUInt32 ulBlkSize = 0 );
+
+    xbUInt32 GetBlockFirstRecNo() const;
+    xbUInt32 GetBlockRecCnt() const;
+    xbUInt32 GetBlockSize() const;
+
+    xbInt16  GetRecord( xbUInt32 ulRecNo );            // retrieve a data record from a block to RecBuf
+    xbInt16  SetBlockSize( xbUInt32 ulBlkSize );
+
+
+  private:
+
+    xbInt16  GetBlockForRecNo( xbUInt32 ulRecNo );    // retrieve block from disk for a given record number
+
+    char     *pBlock;             // block pointer
+    xbUInt32 ulBlkSize;           // block size in bytes
+    xbUInt32 ulFirstBlkRec;       // first recod number in the block
+    xbUInt32 ulRecCnt;            // number of records in block
+    xbUInt32 ulMaxRecs;           // max number of records block can handle
+    xbBool   bEof;                // EOF flag
+    xbDbf    *dbf;                // reference to associated dbf file
+//    xbXBase  *xbase;              // reference to main xbXBase structure
+    time_t   tFmTime;             // file modify time at time of block read
+
+};
+
+#endif // XB_BLOCKREAD
+}  /* namespace */
+#endif  /*  __XB_BLOCKREAD_H__  */
diff --git a/src/include/xbconfig.h.in b/src/include/xbconfig.h.in
index 969b761..f0d475a 100755
--- a/src/include/xbconfig.h.in
+++ b/src/include/xbconfig.h.in
@@ -51,6 +51,7 @@
 #cmakedefine HAVE_DOS_H
 #cmakedefine HAVE_FCNTL_H
 #cmakedefine HAVE_INTTYPES_H
+#cmakedefine HAVE_PWD_H
 #cmakedefine HAVE_STDARG_H
 #cmakedefine HAVE_STDARGS_H
 #cmakedefine HAVE_STRING_H
@@ -100,6 +101,7 @@
 #cmakedefine XB_SQL_SUPPORT
 #cmakedefine XB_INF_SUPPORT
 #cmakedefine XB_FILTER_SUPPORT
+#cmakedefine XB_BLOCKREAD_SUPPORT
 
 #cmakedefine XB_UTILS_SUPPORT
 #cmakedefine XB_EXAMPLES_SUPPORT
diff --git a/src/include/xbdate.h b/src/include/xbdate.h
index 5406cbb..8dff463 100755
--- a/src/include/xbdate.h
+++ b/src/include/xbdate.h
@@ -92,7 +92,6 @@ class XBDLLEXPORT xbDate : public xbSsv {
   xbBool      DateIsValid ( const xbString &sDate8 ) const;
   xbInt16     DayOf( xbInt16 iFormat ) const;
   xbInt16     CTOD( const xbString &sCtodInDate );
-//  xbInt16     FormatDate( const char *sFmtIn, xbString &sFmtOut );
   xbInt16     FormatDate( const xbString &sFmtIn, xbString &sFmtOut );
   const char  *Str() const;
   xbBool      IsLeapYear( xbInt16 iYear ) const;
diff --git a/src/include/xbdbf.h b/src/include/xbdbf.h
index c0842cb..16799f2 100755
--- a/src/include/xbdbf.h
+++ b/src/include/xbdbf.h
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014, 2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -168,11 +168,14 @@ class XBDLLEXPORT xbDbf : public xbFile {
   virtual xbInt16  DumpRecord       ( xbUInt32 ulRecNo, xbInt16 iOutputDest = 0, xbInt16 iOutputFmt = 0 );
   virtual xbInt16  GetAutoCommit    () const;
   virtual xbInt16  GetAutoCommit    ( xbInt16 iOption ) const;
+  virtual xbBool   GetBof           ();
   virtual xbUInt32 GetCurRecNo      () const;
   virtual xbInt16  GetDbfStatus     () const;
+  virtual xbBool   GetEof           ();
   virtual xbInt32  GetFieldCnt      () const;
   virtual xbInt16  GetFirstRecord   ();
   virtual xbInt16  GetFirstRecord   ( xbInt16 iOption );
+  virtual xbUInt16 GetHeaderLen     () const;
   virtual xbInt16  GetLastRecord    ();
   virtual xbInt16  GetLastRecord    ( xbInt16 iOption );
 
@@ -360,7 +363,11 @@ class XBDLLEXPORT xbDbf : public xbFile {
   //virtual xbInt16  SetCreateMdxBlockSize( xbInt16 ulBlockSize );
   //#endif
 
-
+  #ifdef XB_BLOCKREAD_SUPPORT
+  xbInt16 DisableBlockReadProcessing();
+  xbInt16 EnableBlockReadProcessing();
+  xbBool  GetBlockReadStatus() const;
+  #endif  // XB_BLOCKREAD_SUPPORT
 
  protected:
   #ifdef XB_INDEX_SUPPORT
@@ -378,6 +385,10 @@ class XBDLLEXPORT xbDbf : public xbFile {
   virtual  xbInt16  GetInfFileName( xbString &sNdxIdxFileName );
   #endif   // XB_INF_SUPPORT
 
+  #ifdef XB_BLOCKREAD_SUPPORT
+  friend class xbBlockRead;
+  #endif // XB_BLOCKREAD_SUPPORT
+
 
   #ifdef XB_LOCKING_SUPPORT
   void     SetHeaderLocked   ( xbBool bTableLocked );
@@ -426,7 +437,7 @@ class XBDLLEXPORT xbDbf : public xbFile {
 
   xbSchemaRec *SchemaPtr;          // Pointer to field data
   char     *RecBuf;                // Pointer to record buffer
-  char     *RecBuf2;               // Pointer to original rec buf
+  char     *RecBuf2;               // Pointer to original rec buf allocation
 
 
 /* Next several variables are database header fields, up through dbase V */
@@ -448,28 +459,32 @@ class XBDLLEXPORT xbDbf : public xbFile {
   void     ResetNoOfRecords(); 
 
 
-#ifdef XB_LOCKING_SUPPORT
+  #ifdef XB_LOCKING_SUPPORT
   xbInt16  iAutoLock;                     // 0 - autolock off, 1 - autolock on
   xbInt16  iLockFlavor;
   xbBool   bTableLocked;                  // is the table locked
   xbBool   bHeaderLocked;                 // is the header locked
   xbUInt32 ulAppendLocked;                // record number of the new record for the append lock operation
   xbLinkListOrd<xbUInt32> lloRecLocks;    // ordered link list of locked records
-#endif
-
+  #endif
 
-#ifdef XB_INDEX_SUPPORT
+  #ifdef XB_INDEX_SUPPORT
   xbIxList *ixList;                      // pointer to a list of indices associated with the table
   xbIx     *pCurIx;                      // Pointer to current index class
   void     *vpCurIxTag;                  // Pointer to current tag
   xbString sCurIxType;                   // Current index type
   xbLinkList<xbTag *> llTags;            // linked list of open tags
+  #endif // XB_INDEX_SUPPORT
 
-#endif // XB_INDEX_SUPPORT
+  #ifdef XB_INF_SUPPORT
+  xbLinkList<xbString> llInfData;        // linked list of strings containing ndx file entries
+  #endif   // XB_INF_SUPPORT
+
+  #ifdef XB_BLOCKREAD_SUPPORT
+  xbBlockRead *pRb;
+  xbBool      bBlockReadEnabled;        // if true, then block read mode is on
+  #endif
 
-#ifdef XB_INF_SUPPORT
-  xbLinkList<xbString> llInfData;      // linked list of strings containing ndx file entries
-#endif   // XB_INF_SUPPORT
 
 
 };
diff --git a/src/include/xbfile.h b/src/include/xbfile.h
index ffbda06..af04e98 100755
--- a/src/include/xbfile.h
+++ b/src/include/xbfile.h
@@ -60,6 +60,9 @@ class XBDLLEXPORT xbFile : public xbSsv {
              xbFile( xbXBase * x );
 
              ~xbFile();
+
+    xbInt16  SetHomeFolders();
+
     xbInt16  CreateUniqueFileName( const xbString &sDirIn, const xbString &sExtIn, xbString &sFqnOut );
     xbInt16  CreateUniqueFileName( const xbString &sDirIn, const xbString &sExtIn, xbString &sFqnOut, xbInt16 iOption );
 
@@ -158,6 +161,7 @@ class XBDLLEXPORT xbFile : public xbSsv {
 
     #ifdef XB_DEBUG_SUPPORT
     xbInt16  DumpBlockToDisk( xbUInt32 ulBlockNo, size_t lBlockSize );
+    xbInt16  DumpMemToDisk  ( char *p, size_t lBlockSize );
     #endif
 
 
diff --git a/src/include/xbfilter.h b/src/include/xbfilter.h
index 8722256..635d117 100755
--- a/src/include/xbfilter.h
+++ b/src/include/xbfilter.h
@@ -37,9 +37,10 @@ namespace xb{
 class XBDLLEXPORT xbFilter {
 
  public:
-  xbFilter( xbXBase *xbase, xbDbf *dbf );
+  xbFilter( xbDbf *dbf );
   ~xbFilter();
   xbInt16 Set( xbString &sFilterExpression );
+  xbInt16 Set( const char *sFilterExpression );
   xbInt16 GetFirstRecord( xbInt16 iOpt = 1 );
   xbInt16 GetNextRecord ( xbInt16 iOpt = 1 );
   xbInt16 GetPrevRecord ( xbInt16 iOpt = 1 );
@@ -50,7 +51,6 @@ class XBDLLEXPORT xbFilter {
   xbInt32 GetQryCnt() const;
 
   #ifdef XB_INDEX_SUPPORT
-//  void    Set( xbIx *pIx, void *vpTag );
   xbInt16 GetFirstRecordIx( xbInt16 iOpt = 1 );
   xbInt16 GetNextRecordIx ( xbInt16 iOpt = 1 );
   xbInt16 GetPrevRecordIx ( xbInt16 iOpt = 1 );
@@ -59,7 +59,7 @@ class XBDLLEXPORT xbFilter {
 
 
  private:
-  xbXBase  *xbase;
+//  xbXBase  *xbase;
   xbDbf    *dbf;
   xbExp    *exp;
 
diff --git a/src/include/xbretcod.h b/src/include/xbretcod.h
index 6b73527..ec1f91b 100755
--- a/src/include/xbretcod.h
+++ b/src/include/xbretcod.h
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -27,6 +27,7 @@ namespace xb{
   #define XB_DUP_TABLE_OR_ALIAS        -110       // table manager
   #define XB_INVALID_NODELINK          -120       // linklist
   #define XB_KEY_NOT_UNIQUE            -121       // linklist
+  #define XB_MEMCPY_ERROR              -122       // memcpy failure
 
   #define XB_FILE_EXISTS               -200       // file
   #define XB_ALREADY_OPEN              -201       // file
@@ -51,6 +52,8 @@ namespace xb{
   #define XB_INVALID_TABLE_NAME        -220       // file
   #define XB_EMPTY                     -221       // file
   #define XB_LIMIT_REACHED             -222       // file
+  #define XB_BLOCKREAD_NOT_ENABLED     -223       // file
+  #define XB_DIRECTORY_ERROR           -224       // file
 
   #define XB_INVALID_FIELD_TYPE        -300       // field
   #define XB_INVALID_FIELD_NO          -301       // field
diff --git a/src/include/xbsql.h b/src/include/xbsql.h
index 653096c..07ffb70 100755
--- a/src/include/xbsql.h
+++ b/src/include/xbsql.h
@@ -39,7 +39,83 @@ struct XBDLLEXPORT xbSqlFld{
   xbSqlFld * Next;     // Next field in list
 };
 
+class xbStmt;
+
+
+struct XBDLLEXPORT xbTblJoin {            //  structure for defining joined tables in the query
+
+  xbString sTableName;
+  xbString sAlias;
+  xbString sJoinExp;                      // table join expression
+  xbDbf    *pDbf;                         // pointer the the dbf structure for this table
+  xbTag    *pTag;                         // pointer to relevant tag for this table, null for record order
+  xbExp    *pLinkExp;                     // pointer to parsed linkage expression
+  char     cJoinType;                     // M - Master
+                                          // L - Left   or Full Left
+                                          // R - Right  or Full Right
+                                          // I - Inner
+                                          // O - Outer  or Full Outer Outer
+
+  xbTblJoin *pMaster;                     // pointer to master table, null if this is the primary master
+  xbLinkList<xbTblJoin *> llSubList;      // linked list of subordinate tables
+//  xbStmt    *pSubQuery;                 // pointer to sub query
+  xbTblJoin   *next;                      // next tbl
+};
+
+
+class XBDLLEXPORT xbStmt : public xbSsv{
+
+ public:
+  xbStmt( xbXBase *x );
+  ~xbStmt();
+
+  #ifdef XB_DEBUG_SUPPORT
+  xbInt16 DumpStmtInternals();
+  xbInt16 Test();
+  #endif
+
+  xbInt16 ExecuteQuery( const xbString &sCmdLine ); 
+
+//  xbInt16 FetchFirst();
+//  xbInt16 FetchNext();
+//  xbInt16 FetchPrev();
+//  xbInt16 FetchLast();
+//  xbString &GetField( const xbString sFldName );
 
+ protected:
+
+ private:
+
+  xbInt16  AddQryTbl( const xbString &sTable, const xbString &sAlias, const xbString &sExpression, const char cJoinType );
+  xbInt16  CvtSqlExp2DbaseExp( const xbString &sExpIn, xbString &sExpOut );
+  xbInt16  GetNextFromSeg( const xbString &sLineIn, xbString &sFromSegOut );
+  xbUInt32 GetNextToken( const xbString &sCmdLineIn, xbString &sTokenOut, xbUInt32 ulStartPos );
+  xbInt16  GetParenCnt( const xbString &sToken );
+  xbInt16  ParseFromStmt( const xbString &sFromLine );
+  xbInt16  ParseStmt( const xbString &sCmdLine );
+  xbInt16  ProcessFromSeg( const xbString &sFromStmtSeg );
+  xbInt16  UpdateJoinList( char cType, const xbString &sTableName, const xbString &sAlias, const xbString &sExp, xbDbf *d, xbExp *e  );   //, xbTag *t);
+
+  xbXBase  *xbase;    // pointer to xbase structure
+
+
+  xbTblJoin * pTblList;
+  xbSqlFld *fl;       // field list in sql select statement
+  xbString sStmt;     // complete query statment
+  xbString sFields;   // list of fields
+  xbString sFrom;     // from statment
+  xbString sWhere;    // where clause
+  xbString sOrderBy;  // sort order
+  xbString sGroupBy;  // group by
+  xbString sHaving;   // having
+  xbUInt32 ulFromPos;
+  xbUInt32 ulWherePos;
+  xbUInt32 ulOrderByPos;
+  xbUInt32 ulGroupByPos;
+  xbUInt32 ulHavingPos;
+
+
+};
 
 
 class XBDLLEXPORT xbSql : public xbSsv {
@@ -68,7 +144,7 @@ class XBDLLEXPORT xbSql : public xbSsv {
 // xbInt16  SqlCreateView( const xbString &sCmdLine );
 // xbInt16  SqlDropView( const xbString &sCmdLine );
 // xbInt16  SqlUpdate( const xbString &sCmdLine );
-   xbInt16  SqlSelect( const xbString &sCmdLine );
+// xbInt16  SqlSelect( const xbString &sCmdLine );
 
    void     SqlHelp() const;
    xbInt16  SqlInsert( const xbString &sCmLine );
diff --git a/src/include/xbssv.h b/src/include/xbssv.h
index b9345fd..d050bcb 100755
--- a/src/include/xbssv.h
+++ b/src/include/xbssv.h
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -77,9 +77,11 @@ class XBDLLEXPORT xbSsv{
   xbBool     GetDefaultAutoCommit      () const;
   void       SetDefaultAutoCommit      ( xbBool bDefaultAutoCommit );
 
-  xbString&  GetDefaultLogDirectory    () const;
-  xbString&  GetDefaultLogFileName     () const;
-  void       SetDefaultLogDirectory    ( const xbString &sDefaultLogDirectory );
+  void       GetHomeDir                ( xbString &sHomeDirOut );
+
+  xbString&  GetLogDirectory           () const;
+  xbString&  GetLogFileName            () const;
+  void       SetLogDirectory           ( const xbString &sLogDirectory );
 
   xbBool     GetMultiUser              () const;
   void       SetMultiUser              ( xbBool bMultiUser );
@@ -87,7 +89,7 @@ class XBDLLEXPORT xbSsv{
   #if defined (XB_NDX_SUPPORT) || defined (XB_MDX_SUPPORT)
   xbInt16    GetUniqueKeyOpt           () const;
   xbInt16    SetUniqueKeyOpt           ( xbInt16 iUniqueKeyOpt );
-  #endif
+  #endif  // (XB_NDX_SUPPORT) || defined (XB_MDX_SUPPORT)
 
   #ifdef XB_LOCKING_SUPPORT
   xbInt16    GetDefaultLockRetries     () const;
@@ -100,12 +102,18 @@ class XBDLLEXPORT xbSsv{
   void       SetDefaultAutoLock        ( xbBool bAutoLock );
   void       EnableDefaultAutoLock     ();
   void       DisableDefaultAutoLock    ();
-  #endif
+  #endif  // XB_LOCKING_SUPPORT
 
   #ifdef XB_MDX_SUPPORT
   xbInt16    GetCreateMdxBlockSize() const;
   xbInt16    SetCreateMdxBlockSize( xbInt16 ulBlockSize );
-  #endif
+  #endif  // XB_MDX_SUPPORT
+
+  #ifdef XB_BLOCKREAD_SUPPORT
+  xbUInt32   GetDefaultBlockReadSize() const;
+  void       SetDefaultBlockReadSize( xbUInt32 ulDfltBlockReadSize );
+  #endif  // XB_BLOCKREAD_SUPPORT
+
 
  protected:
 
@@ -121,8 +129,8 @@ class XBDLLEXPORT xbSsv{
   static xbString sDataDirectory;          //Data file directory
 
   #ifdef XB_LOGGING_SUPPORT
-  static xbString sDefaultLogDirectory;    //Default location to store log files
-  static xbString sDefaultLogFileName;     //Default LogFileName
+  static xbString sLogDirectory;    //Default location to store log files
+  static xbString sLogFileName;     //Default LogFileName
   #endif
 
   static xbInt16  iDefaultFileVersion;     // 3 = DBase 3
@@ -150,7 +158,6 @@ class XBDLLEXPORT xbSsv{
 #endif
 
 
-
 #if defined (XB_NDX_SUPPORT) || defined (XB_MDX_SUPPORT)
 
   static xbInt16 iUniqueKeyOpt;
@@ -167,6 +174,10 @@ class XBDLLEXPORT xbSsv{
 #endif // XB_MDX_SUPPORT
 
 
+#ifdef XB_BLOCKREAD_SUPPORT
+  static xbUInt32 ulDefaultBlockReadSize;
+#endif  // XB_BLOCKREAD_SUPPORT
+
 
 };
 
diff --git a/src/include/xbstring.h b/src/include/xbstring.h
index f5a22da..3e70acc 100755
--- a/src/include/xbstring.h
+++ b/src/include/xbstring.h
@@ -131,6 +131,8 @@ class XBDLLEXPORT xbString {
   xbString  &Mid(xbUInt32 ulPos, xbUInt32 lLen );
   xbString  &PadLeft( char c, xbUInt32 ulLen );
   xbString  &PadRight( char c, xbUInt32 ulLen );
+
+  xbUInt32  Pos(char c, xbUInt32 ulStartPos ) const;
   xbUInt32  Pos(char c) const;
   xbUInt32  Pos(const char *s) const;
   xbString  &PutAt(xbUInt32 ulPos, char c);
diff --git a/src/include/xbtblmgr.h b/src/include/xbtblmgr.h
index 150026b..2c31e45 100755
--- a/src/include/xbtblmgr.h
+++ b/src/include/xbtblmgr.h
@@ -30,8 +30,9 @@ class XBDLLEXPORT xbDbf;
 /* this structure is a linked list of open tables */
 struct XBDLLEXPORT xbTblList{
   xbTblList *pNext;
-  xbString  *psTblName;            /* Name of table - same table can be opened multiple times, but must have unique alias */
-  xbString  *psTblAlias;           /* TblAliasName must be unique */
+  xbString  *psFqTblName;          // Fully qualified name of table - same table can be opened multiple times, but must have unique alias
+  xbString  *psTblName;            // Table name without path, without extension
+  xbString  *psTblAlias;           // TblAliasName must be unique, same as TblNAme if Alias not provided
   xbDbf     *pDbf;
 };
 
@@ -39,8 +40,8 @@ class XBDLLEXPORT xbTblMgr : public xbSsv {
  public:
   xbTblMgr();
   ~xbTblMgr();
-  xbInt16     AddTblToTblList        ( xbDbf *d, const xbString &sTblName );
-  xbInt16     AddTblToTblList        ( xbDbf *d, const xbString &sTblName, const xbString &sTblAlias );
+  xbInt16     AddTblToTblList        ( xbDbf *d, const xbString &sFqTblName );
+  xbInt16     AddTblToTblList        ( xbDbf *d, const xbString &sFqTblName, const xbString &sTblAlias );
   xbInt16     DisplayTableList       () const;
   xbDbf *     GetDbfPtr              ( const xbString &sTblAlias ) const;
   xbDbf *     GetDbfPtr              ( xbInt16 sItemNo ) const;
diff --git a/src/include/xbuda.h b/src/include/xbuda.h
index 84eccee..e5c0e91 100755
--- a/src/include/xbuda.h
+++ b/src/include/xbuda.h
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -34,7 +34,7 @@ class XBDLLEXPORT xbUda {
  public:
   xbUda();
   ~xbUda();
-  
+
   xbInt16 AddTokenForKey( const xbString &sKey, const xbString &sToken );
   void    Clear();
   xbInt16 DelTokenForKey( const xbString &sKey );
@@ -42,7 +42,7 @@ class XBDLLEXPORT xbUda {
   xbInt16 GetTokenForKey( const xbString &sKey, xbString &sData );
   xbInt16 UpdTokenForKey( const xbString &sKey, const xbString &sToken );
   void    DumpUda() const;
-  
+
  private:
    xbLinkListOrd<xbString> llOrd;
 
diff --git a/src/include/xbxbase.h b/src/include/xbxbase.h
index 204e744..fe1f323 100755
--- a/src/include/xbxbase.h
+++ b/src/include/xbxbase.h
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -148,6 +148,9 @@ class XBDLLEXPORT xbXBase : public xbTblMgr{
 
   void     xbSleep        ( xbInt32 lMillisecs );
 
+  xbInt16  GetCmdLineOpt  ( xbInt32 lArgc, char **argv, const char *sOptRqst, xbString &sParmOut );
+  xbInt16  GetCmdLineOpt  ( xbInt32 lArgc, char **argv, xbString &sOptRqst, xbString &sParmOut );
+
 
   /* xbase functions */
   #ifdef XB_FUNCTION_SUPPORT
@@ -207,6 +210,11 @@ class XBDLLEXPORT xbXBase : public xbTblMgr{
   friend class xbBcd;
   friend class xbExp;
 
+  #ifdef XB_BLOCKREAD_SUPPORT
+  friend class xbBlockRead;
+  #endif // XB_BLOCKREAD_SUPPORT
+
+
   xbInt16 GetFunctionInfo( const xbString &sExpLine, char &cReturnType, xbInt16 &iReturnLenCalc, xbInt32 &lReturnLenVal ) const;
   static xbInt16 xbMemcmp( const unsigned char *s1, const unsigned char *s2, size_t n );
 
diff --git a/src/sql/xbalttbl.cpp b/src/sql/xbalttbl.cpp
index 576eab7..8a36b46 100755
--- a/src/sql/xbalttbl.cpp
+++ b/src/sql/xbalttbl.cpp
@@ -79,17 +79,12 @@ xbInt16 xbSql::SqlAlterTable( const xbString &sCmdLine ){
     sTrgTbl.ExtractElement( sCmd, ' ', 4, 0 );
     sTrgTbl.Trim();
 
-    std::cout << "source table name = " << sSrcTbl.Str() << "\n";
+//    std::cout << "source table name = " << sSrcTbl.Str() << "\n";
 //    std::cout << "target table name = " << sTrgTbl.Str() << "\n";
 
     //  if not open, attempt to open it
     dbf = xbase->GetDbfPtr( sSrcTbl );
 
-    if( dbf )
-      std::cout << "dbf valued\n";
-    else
-      std::cout << "dbf not valued\n";
-
     if( !dbf ){
       if(( iRc = xbase->OpenHighestVersion( sSrcTbl, "", &dbf )) != XB_NO_ERROR ){
         iErrorStop = 120;
diff --git a/src/sql/xbcrix.cpp b/src/sql/xbcrix.cpp
index 8dc6f62..6a391f7 100755
--- a/src/sql/xbcrix.cpp
+++ b/src/sql/xbcrix.cpp
@@ -147,13 +147,13 @@ xbInt16 xbSql::SqlCreateIndex( const xbString &sCmdLine ){
       }
     }
     if( dbf == NULL ){
-      iErrorStop = 50;
+      iErrorStop = 130;
       iRc = XB_FILE_NOT_FOUND;
       throw iRc;
     }
     sCmd.Ltrunc( ulPos );
 
-    std::cout << "cp1 ulPos = " << ulPos << " sCmd = [" << sCmd << "]\n";
+    // std::cout << "cp1 ulPos = " << ulPos << " sCmd = [" << sCmd << "]\n";
 
     //ulPos = sCmd.GetLastPos( ')' );
     xbString sKeyExpression;
@@ -180,7 +180,7 @@ xbInt16 xbSql::SqlCreateIndex( const xbString &sCmdLine ){
       lPos++;
     }
 
-    std::cout << "Key Expression =[" << sKeyExpression << "]\n";
+    // std::cout << "Key Expression =[" << sKeyExpression << "]\n";
 
     sCmd.Ltrunc( lPos );
     sCmd.Trim();
@@ -216,7 +216,7 @@ xbInt16 xbSql::SqlCreateIndex( const xbString &sCmdLine ){
 
     #ifdef XB_LOCKING_SUPPORT
     if(( iRc = dbf->LockTable( XB_LOCK )) != XB_NO_ERROR ){
-      iErrorStop = 130;
+      iErrorStop = 140;
       throw iRc;
     }
     #endif  // XB_LOCKING_SUPPORT
@@ -227,7 +227,7 @@ xbInt16 xbSql::SqlCreateIndex( const xbString &sCmdLine ){
     void *vpTag;
 
     if(( iRc = dbf->CreateTag( sIxType, sIxName, sKeyExpression, sFilter, bDesc, bUnique, xbFalse, &pIx, &vpTag )) != XB_NO_ERROR ){
-      iErrorStop = 140;
+      iErrorStop = 150;
       throw iRc;
     }
     //    std::cout << "SqlCreateIndex() - back from tag create\n";
@@ -239,7 +239,7 @@ xbInt16 xbSql::SqlCreateIndex( const xbString &sCmdLine ){
         sCmd.ToUpperCase();
         if( sCmd.Pos( "ASSOCIATE" )){
           if(( iRc = dbf->AssociateIndex( "NDX", sIxName, 0 )) != XB_NO_ERROR ){
-            iErrorStop = 150;
+            iErrorStop = 160;
             throw iRc;
           }
         }
@@ -255,14 +255,14 @@ xbInt16 xbSql::SqlCreateIndex( const xbString &sCmdLine ){
 
 
     if(( iRc = pIx->Reindex( &vpTag )) != XB_NO_ERROR ){
-      iErrorStop = 160;
+      iErrorStop = 170;
       throw iRc;
     }
 
 
     #ifdef XB_LOCKING_SUPPORT
     if(( iRc = dbf->LockTable( XB_UNLOCK )) != XB_NO_ERROR ){
-      iErrorStop = 140;
+      iErrorStop = 180;
       throw iRc;
     }
     #endif  // XB_LOCKING_SUPPORT
diff --git a/src/sql/xbcrtbl.cpp b/src/sql/xbcrtbl.cpp
index 7f6b8fa..dfb3403 100755
--- a/src/sql/xbcrtbl.cpp
+++ b/src/sql/xbcrtbl.cpp
@@ -29,7 +29,7 @@ xbInt16 xbSql::SqlCreateTable( const xbString &sCmdLine ){
   // expected format:
   // CREATE TABLE tablename.dbf (Field1 CHAR(10), INTFLD1 INTEGER, ... )
 
-  // supported fields types
+  // supported field types
   //
   //  SQL TYPE      XBASE Field Type
   //  --------      ----------------
@@ -61,6 +61,7 @@ xbInt16 xbSql::SqlCreateTable( const xbString &sCmdLine ){
   xbLinkList<xbString> ll;
   xbSchema *schema = NULL;
   xbString sMsg;
+  xbString sWork;
 
   try{
     //  retrieve table name
@@ -75,7 +76,7 @@ xbInt16 xbSql::SqlCreateTable( const xbString &sCmdLine ){
     xbFile f( xbase );
     f.SetFileName( sTableName );
     if( f.FileExists() ){
-      iErrorStop = 10;
+      iErrorStop = 100;
       iRc = XB_FILE_EXISTS;
       throw iRc;
     }
@@ -90,8 +91,6 @@ xbInt16 xbSql::SqlCreateTable( const xbString &sCmdLine ){
     s.Remove( s.Len(), 1 );
 
     s.Trim();
-    //std::cout << "s = [" << s << "]\n";
-
 
     xbBool bDone = xbFalse;
     xbInt16 iLoop = 0;
@@ -129,7 +128,7 @@ xbInt16 xbSql::SqlCreateTable( const xbString &sCmdLine ){
       else if( sDataType == "SMALLINT" || sDataType == "INTEGER" || sDataType == "DATE" || sDataType == "VARCHAR" || sDataType == "LOGICAL" )
         iAttribCnt = 0;
       else{
-        iErrorStop = 20;
+        iErrorStop = 110;
         iRc = XB_INVALID_FIELD_TYPE;
         throw iRc;
       }
@@ -143,25 +142,37 @@ xbInt16 xbSql::SqlCreateTable( const xbString &sCmdLine ){
       } else if( iAttribCnt > 0 ){
         lPos = s.Pos( '(' );
         if( lPos <= 0 ){
-          iErrorStop = 30;
+          iErrorStop = 120;
           iRc = XB_INVALID_FIELD_LEN;
           throw iRc;
         }
         s.Ltrunc( lPos );
-        if( iAttribCnt == 1 )
-          lPos = s.Pos( ')' );
-        else
-          lPos = s.Pos( ',' );
-
-        sAttrib1.Assign( s, 1, lPos-1 );
-        sAttrib1.Trim();
-        s.Ltrunc( lPos );
 
-        if( iAttribCnt > 1 ){
-          lPos = s.Pos( ')' );
-          sAttrib2.Assign( s, 1, lPos-1 );
-          s.Ltrunc( lPos );
+        lPos = s.Pos( ')' );
+        if( lPos <= 0 ){
+          iErrorStop = 130;
+          iRc = XB_INVALID_FIELD_LEN;
+          throw iRc;
         }
+        sWork.Assign( s, 1, lPos - 1);
+        sWork.Trim();
+
+        if( iAttribCnt == 1 ){
+          sAttrib1 = sWork;
+        } else {
+          lCmPos = sWork.Pos( ',' );
+          if( lCmPos <= 0 ){
+            iErrorStop = 140;
+            iRc = XB_INVALID_FIELD_LEN;
+            throw iRc;
+          }
+          sAttrib1.Assign( sWork, 1, lCmPos - 1);
+          sAttrib1.Trim();
+          sWork.Ltrunc( lCmPos );
+          sAttrib2 = sWork;
+          sAttrib2.Trim();
+        }
+        s.Ltrunc( lPos );
       }
 
       s.Ltrim();
@@ -229,7 +240,7 @@ xbInt16 xbSql::SqlCreateTable( const xbString &sCmdLine ){
     dbf = new xbDbf3( xbase );
     #endif
     if(( iRc = dbf->CreateTable( sTableName, "", schema, 0, XB_MULTI_USER )) != XB_NO_ERROR ){
-      iErrorStop = 50;
+      iErrorStop = 150;
       throw iRc;
     }
 
diff --git a/src/sql/xbcrtbl.save.cpp b/src/sql/xbcrtbl.save.cpp
new file mode 100755
index 0000000..445ad56
--- /dev/null
+++ b/src/sql/xbcrtbl.save.cpp
@@ -0,0 +1,256 @@
+/* xbcrtbl.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2019,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+#include "xbase.h"
+
+#ifdef XB_SQL_SUPPORT
+
+namespace xb{
+
+
+/***********************************************************************/
+xbInt16 xbSql::SqlCreateTable( const xbString &sCmdLine ){
+
+
+  // std::cout << "CREATE TABLE " << sCmdLine << std::endl;
+
+  // expected format:
+  // CREATE TABLE tablename.dbf (Field1 CHAR(10), INTFLD1 INTEGER, ... )
+
+  // supported field types
+  //
+  //  SQL TYPE      XBASE Field Type
+  //  --------      ----------------
+  //  SMALLINT      NUMERIC(6,0)
+  //  INTEGER       NUMERIC(11,0)
+  //  DECIMAL(x,y)  NUMERIC(x+1,y)
+  //  NUMERIC(x,y)  NUMERIC(x,y)
+  //  FLOAT(x,y)    FLOAT(x,y)
+  //  CHAR(n)       CHARACTER(n)
+  //  DATE          DATE
+  //  VARCHAR       MEMO
+  //  LOGICAL       LOGICAL
+
+  xbInt16 iRc = 0;
+  xbInt16 iErrorStop = 0;
+  xbString sTableName;
+  xbString sFieldName;
+  xbString sDataType;
+  xbString sAttrib1;
+  xbString sAttrib2;
+  xbString sLlEntry;
+  xbInt16  iType = 0;
+  xbInt16  iAttribCnt;  // number of attributes for a given data type
+  xbString s;
+  xbUInt32 lPos = 0;
+  xbUInt32 lSpPos = 0;    // space position
+  xbUInt32 lCmPos = 0;    // comma position
+  xbUInt32 lLpPos = 0;    // left paren position
+  xbLinkList<xbString> ll;
+  xbSchema *schema = NULL;
+  xbString sMsg;
+
+  try{
+    //  retrieve table name
+    s.ExtractElement( sCmdLine, '(', 1, 0 );
+    sTableName.ExtractElement( s, ' ', 3, 0 );
+    sTableName.Trim();
+
+    // std::cout << "Tablename = [" << sTableName << "]\n";
+
+
+    // determine if it already exists
+    xbFile f( xbase );
+    f.SetFileName( sTableName );
+    if( f.FileExists() ){
+      iErrorStop = 100;
+      iRc = XB_FILE_EXISTS;
+      throw iRc;
+    }
+
+    // build out table structure with parms from the sql string
+    lPos = sCmdLine.Pos( '(' );
+    s = sCmdLine;
+    s.Ltrunc( lPos );
+    s.Trim();
+
+    // remove the last byte, should be a )
+    s.Remove( s.Len(), 1 );
+
+    s.Trim();
+    //std::cout << "s = [" << s << "]\n";
+
+
+    xbBool bDone = xbFalse;
+    xbInt16 iLoop = 0;
+    while( !bDone && iLoop++ < 255 ){
+      sFieldName.ExtractElement( s, ' ', 1 , 0 );
+      lPos = sFieldName.Len();
+      sFieldName.Trim();
+      if( sFieldName.Len() > 10 )
+        sFieldName.Mid( 1, 10 );   // shrink to 10 buytes if too big
+
+      //std::cout << "field name=[" << sFieldName << "]\n"; 
+      s.Ltrunc( lPos + 1 );
+      s.Ltrim();
+      //std::cout << "remainder after field name removed = [" << s << "]\n";
+
+      // Data type is delimited with either a space, comma or left paren
+      lPos = 9999999;
+      lSpPos = s.Pos( ' ' );
+      lCmPos = s.Pos( ',' );
+      lLpPos = s.Pos( '(' );
+      if( lSpPos != 0 ) lPos = lSpPos;
+      if( lCmPos != 0 && lCmPos < lPos ) lPos = lCmPos;
+      if( lLpPos != 0 && lLpPos < lPos ) lPos = lLpPos;
+
+      //sMsg.Sprintf( "SpPos=[%d] CmPos=[%d] LpPos=[%d] lPos=[%d]", lSpPos, lCmPos, lLpPos, lPos );
+      //std::cout << sMsg << "\n";
+
+      sDataType.Assign( s, 1, lPos-1 );
+
+      //std::cout << "DataType=[" << sDataType << "]\n";
+      if( sDataType == "CHAR" )
+        iAttribCnt = 1;
+      else if( sDataType == "DECIMAL" || sDataType == "NUMERIC" || sDataType == "FLOAT" )
+        iAttribCnt = 2;
+      else if( sDataType == "SMALLINT" || sDataType == "INTEGER" || sDataType == "DATE" || sDataType == "VARCHAR" || sDataType == "LOGICAL" )
+        iAttribCnt = 0;
+      else{
+        iErrorStop = 110;
+        iRc = XB_INVALID_FIELD_TYPE;
+        throw iRc;
+      }
+
+      sAttrib1 = "";
+      sAttrib2 = "0";
+
+      if( iAttribCnt == 0 ){
+        s.Ltrunc( sDataType.Len());
+
+      } else if( iAttribCnt > 0 ){
+        lPos = s.Pos( '(' );
+        if( lPos <= 0 ){
+          iErrorStop = 110;
+          iRc = XB_INVALID_FIELD_LEN;
+          throw iRc;
+        }
+        s.Ltrunc( lPos );
+        if( iAttribCnt == 1 )
+          lPos = s.Pos( ')' );
+        else
+          lPos = s.Pos( ',' );
+
+        sAttrib1.Assign( s, 1, lPos-1 );
+        sAttrib1.Trim();
+        s.Ltrunc( lPos );
+
+        if( iAttribCnt > 1 ){
+          lPos = s.Pos( ')' );
+          sAttrib2.Assign( s, 1, lPos-1 );
+          s.Ltrunc( lPos );
+        }
+      }
+
+      s.Ltrim();
+      s.ZapLeadingChar( ',' );
+      s.Ltrim();
+
+      if( sDataType == "CHAR" ){
+        iType = XB_CHAR_FLD;
+      } else if( sDataType == "DECIMAL" ){
+        xbInt32 lVal = atol( sAttrib1.Str()) + 1;
+        sAttrib1.Sprintf( "%d", lVal );
+        iType = XB_NUMERIC_FLD;
+      } else if( sDataType == "SMALLINT" ){
+        sAttrib1 = "6";
+        iType = XB_NUMERIC_FLD;
+      } else if( sDataType == "INTEGER" ){
+        sAttrib1 = "11";
+        iType = XB_NUMERIC_FLD;
+      } else if( sDataType == "NUMERIC" ){
+        iType = XB_NUMERIC_FLD;
+      } else if( sDataType == "FLOAT" ) {
+        iType = XB_FLOAT_FLD;
+      } else if( sDataType == "DATE" ){
+        iType = XB_DATE_FLD;
+        sAttrib1 = "8";
+      } else if( sDataType == "VARCHAR" ){
+        iType = XB_MEMO_FLD;
+        sAttrib1 = "10";
+      } else if( sDataType == "LOGICAL" ){
+        iType = XB_LOGICAL_FLD;
+        sAttrib1 = "1";
+      }
+      sLlEntry.Sprintf( "%s,%s,%c,%s,%s", sFieldName.Str(), sDataType.Str(), iType, sAttrib1.Str(), sAttrib2.Str());
+      ll.InsertAtEnd( sLlEntry );
+
+      if( s.Len() == 0 )
+        bDone = xbTrue;
+    }
+
+    schema = (xbSchema *) calloc( ll.GetNodeCnt()+1, sizeof( xbSchema ));
+    xbLinkListNode<xbString> * llN = ll.GetHeadNode();
+    xbUInt32 ulCnt = ll.GetNodeCnt();
+
+    char *pTrg;
+    for( xbUInt32 i = 0; i < ulCnt; i++ ){
+      s = llN->GetKey();
+      sFieldName.ExtractElement( s, ',', 1 , 0 );
+      pTrg = schema[i].cFieldName;
+      for( xbUInt32 j = 0; j < sFieldName.Len(); j++ )
+        *pTrg++ = sFieldName[j+1];
+      sDataType.ExtractElement( s, ',', 3, 0 );
+      schema[i].cType = sDataType[1];
+      sAttrib1.ExtractElement( s, ',', 4, 0 );
+      schema[i].iFieldLen = atoi( sAttrib1.Str());
+      sAttrib2.ExtractElement( s, ',', 5, 0 );
+      schema[i].iNoOfDecs = atoi( sAttrib2.Str());
+      llN = llN->GetNextNode();
+    }
+
+    // create the table
+    xbDbf * dbf = NULL;
+    #ifdef XB_DBF4_SUPPORT
+    dbf = new xbDbf4( xbase );
+    #elif defined (XB_DBF3_SUPPORT)
+    dbf = new xbDbf3( xbase );
+    #endif
+    if(( iRc = dbf->CreateTable( sTableName, "", schema, 0, XB_MULTI_USER )) != XB_NO_ERROR ){
+      iErrorStop = 120;
+      throw iRc;
+    }
+
+    free( schema );
+    ll.Clear();
+  }
+  catch (xbInt16 iRc ){
+    xbString sMsg;
+    if( sFieldName.Len() > 0 )
+      sMsg.Sprintf( "xbSql::SqlCreateTbl() Exception Caught. Error Stop = [%d] rc = [%d] table = [%s] field = [%s]", iErrorStop, iRc, sTableName.Str(), sFieldName.Str() );
+    else
+      sMsg.Sprintf( "xbSql::SqlCreateTbl() Exception Caught. Error Stop = [%d] rc = [%d] table = [%s]", iErrorStop, iRc, sTableName.Str() );
+
+    xbase->WriteLogMessage( sMsg.Str() );
+    xbase->WriteLogMessage( GetErrorMessage( iRc ));
+    if( schema ) free( schema );
+  }
+  return iRc;
+}
+
+/***********************************************************************/
+}              /* namespace       */
+#endif         /*  XB_SQL_SUPPORT */
+
diff --git a/src/sql/xbdelete.cpp b/src/sql/xbdelete.cpp
index 157b281..82b4937 100755
--- a/src/sql/xbdelete.cpp
+++ b/src/sql/xbdelete.cpp
@@ -95,7 +95,7 @@ xbInt16 xbSql::SqlDelete( const xbString &sCmdLine ){
       }
     } else {
 
-      xbFilter f( dbf->GetXbasePtr(), dbf );
+      xbFilter f( dbf );
       if(( iRc = f.Set( sFilter )) != XB_NO_ERROR ){
         iErrorStop = 150;
         throw iRc;
diff --git a/src/sql/xbdrptbl.cpp b/src/sql/xbdrptbl.cpp
index e2cfa9d..b03ee8f 100755
--- a/src/sql/xbdrptbl.cpp
+++ b/src/sql/xbdrptbl.cpp
@@ -61,7 +61,7 @@ xbInt16 xbSql::SqlDropTable( const xbString &sCmdLine ){
       sNode.Trim();
       sNode.ToUpperCase();
       if( sNode != "EXISTS" ){
-        iErrorStop = 10;
+        iErrorStop = 100;
         iRc = XB_SYNTAX_ERROR;
         throw iRc;
       } else {
@@ -91,22 +91,21 @@ xbInt16 xbSql::SqlDropTable( const xbString &sCmdLine ){
         if( iRc == XB_FILE_NOT_FOUND && bIfExists ){
           return XB_NO_ERROR;
         } else {
-          iErrorStop = 20;
+          iErrorStop = 110;
           throw iRc;
         }
       }
     }
     if( dbf == NULL ){
-      iErrorStop = 40;
+      iErrorStop = 120;
       iRc = XB_OPEN_ERROR;
       throw iRc;
     }
 
     if(( dbf->DeleteTable()) != XB_NO_ERROR ){
-      iErrorStop = 50;
+      iErrorStop = 130;
       throw iRc;
     }
-
   }
 
   catch (xbInt16 iRc ){
diff --git a/src/sql/xbselect.cpp b/src/sql/xbselect.cpp
index 91c0485..7f12e99 100755
--- a/src/sql/xbselect.cpp
+++ b/src/sql/xbselect.cpp
@@ -21,18 +21,23 @@ namespace xb{
 
 
 /***********************************************************************/
-xbInt16 xbSql::SqlSelect( const xbString &sCmdLine ){
+xbInt16 xbStmt::ExecuteQuery( const xbString &sCmdLine ){
 
-  std::cout << "SELECT [" << sCmdLine << "]\n";
+  std::cout << "xbStmt::ExecuteQuery() - SELECT [" << sCmdLine << "]\n";
   // expected format:
   //  SELECT 
 
   xbInt16  iRc = 0;
   xbInt16  iErrorStop = 0;
-  xbUInt32 ulPos;
+  // xbUInt32 ulPos;
 
   try{
 
+    if(( iRc = ParseStmt( sCmdLine )) != XB_NO_ERROR ){
+      iErrorStop = 100;
+      throw iRc;
+    }
+
 /*
     xbString sCmd = sCmdLine;
     sCmd.Trim();
@@ -63,12 +68,12 @@ xbInt16 xbSql::SqlSelect( const xbString &sCmdLine ){
 
       if( sToken == '^' ){
         if(( iRc = uda.DelTokenForKey( sKey )) != XB_NO_ERROR ){
-          iErrorStop = 10;
+          iErrorStop = 100;
           throw iRc;
         }
       } else {
         if(( iRc = uda.UpdTokenForKey( sKey, sToken )) != XB_NO_ERROR ){
-          iErrorStop = 10;
+          iErrorStop = 110;
           throw iRc;
         }
       }
@@ -78,7 +83,7 @@ xbInt16 xbSql::SqlSelect( const xbString &sCmdLine ){
   }
   catch (xbInt16 iRc ){
     xbString sMsg;
-    sMsg.Sprintf( "xbSql::SqlSelect() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, iRc );
+    sMsg.Sprintf( "xbStmt::ExecuteQuery() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, iRc );
     xbase->WriteLogMessage( sMsg.Str() );
     xbase->WriteLogMessage( GetErrorMessage( iRc ));
   }
diff --git a/src/sql/xbset.cpp b/src/sql/xbset.cpp
index 98de309..d0e8821 100755
--- a/src/sql/xbset.cpp
+++ b/src/sql/xbset.cpp
@@ -63,17 +63,16 @@ xbInt16 xbSql::SqlSet( const xbString &sCmdLine ){
 
       if( sToken == '^' ){
         if(( iRc = uda.DelTokenForKey( sKey )) != XB_NO_ERROR ){
-          iErrorStop = 10;
+          iErrorStop = 100;
           throw iRc;
         }
       } else {
         if(( iRc = uda.UpdTokenForKey( sKey, sToken )) != XB_NO_ERROR ){
-          iErrorStop = 10;
+          iErrorStop = 110;
           throw iRc;
         }
       }
     }
-
   }
   catch (xbInt16 iRc ){
     xbString sMsg;
diff --git a/src/sql/xbsql.cpp b/src/sql/xbsql.cpp
index 5261b1a..12d3379 100755
--- a/src/sql/xbsql.cpp
+++ b/src/sql/xbsql.cpp
@@ -123,9 +123,6 @@ xbInt16 xbSql::ExecuteNonQuery( const xbString &sCmdLine ) {
   else if( sNode1 == "USE" )
     iRc = SqlUse( sCmd );
 
-  else if( sNode1 == "SELECT" )
-    iRc = SqlSelect( sCmd );
-
   else if( sNode1 == "SET" )
     iRc = SqlSet( sCmd );
 
diff --git a/src/sql/xbstmt.cpp b/src/sql/xbstmt.cpp
new file mode 100755
index 0000000..61c84fd
--- /dev/null
+++ b/src/sql/xbstmt.cpp
@@ -0,0 +1,679 @@
+/* xbsql.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+#include "xbase.h"
+
+#ifdef XB_SQL_SUPPORT
+
+namespace xb{
+
+/***********************************************************************/
+xbStmt::xbStmt( xbXBase *x ){
+   xbase        = x;
+   pTblList     = NULL;
+   fl           = NULL;
+   ulFromPos    = 0;
+   ulWherePos   = 0;
+   ulOrderByPos = 0;
+   ulGroupByPos = 0;
+   ulHavingPos  = 0;
+}
+
+/***********************************************************************/
+xbStmt::~xbStmt(){
+
+  std::cout << "xbStmt::~xbStmt()  - need to release all allocated structures and memory here\n";
+
+}
+
+/***********************************************************************/
+xbInt16  xbStmt::CvtSqlExp2DbaseExp( const xbString &sExpIn, xbString &sExpOut ){
+
+  // convert Ansi SQL expression to a DBase compatible expression
+
+  xbInt16  iRc        = 0;
+  xbInt16  iErrorStop = 0;
+
+  try{
+
+    // convert   tablename.fieldname   to   tablename->fieldname
+    sExpOut = sExpIn[1];
+    xbUInt32 ulPos = 2;
+    while( ulPos < sExpIn.Len() ){
+      if( sExpIn[ulPos] == '.' && sExpIn[ulPos-1] != ' ' && sExpIn[ulPos+1] != ' ' )
+        sExpOut += "->";
+      else
+        sExpOut += sExpIn[ulPos];
+      ulPos++;
+    }
+    sExpOut += sExpIn[ulPos];
+
+    sExpOut.Replace( " AND ", " .AND. ", 0 );
+    sExpOut.Replace( " and ", " .AND. ", 0 );
+    sExpOut.Replace( " OR ",  " .OR. ",  0 );
+    sExpOut.Replace( " or ",  " .OR. ",  0 );
+  }
+  catch (xbInt16 iRc ){
+    xbString sMsg;
+    sMsg.Sprintf( "xbStmt::CvtSqlExp2DbaseExp() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, iRc );
+    xbase->WriteLogMessage( sMsg.Str() );
+    xbase->WriteLogMessage( GetErrorMessage( iRc ));
+  }
+  return iRc;
+}
+
+
+/***********************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+xbInt16 xbStmt::DumpStmtInternals(){
+
+  std::cout << "************** Dump Statment Internals ***************" << std::endl;
+  std::cout << "Statement [" << sStmt    << "]\n";
+  std::cout << "Fields    [" << sFields  << "]\n";
+  std::cout << "From      [" << sFrom    << "]\n";
+  std::cout << "Where     [" << sWhere   << "]\n";
+  std::cout << "Order By  [" << sOrderBy << "]\n";
+  std::cout << "Group By  [" << sGroupBy << "]\n";
+  std::cout << "Having    [" << sHaving  << "]\n";
+
+  xbTblJoin *p = pTblList;
+  if( p ){
+    std::cout << "Tbl List\n";
+    std::cout << "Type,Name,Alias,Exp\n";
+    while( p ){
+      std::cout << p->cJoinType << "," << p->sTableName.Str() << "," << p->sAlias.Str() << "," << p->sJoinExp.Str() << "\n";
+      p = p->next;
+    }
+  }
+  std::cout << "*************** End of Internals ************" << std::endl;
+  return 0;
+}
+
+xbInt16 xbStmt::Test(){
+  xbString s;
+
+  s = "(ABC)";
+  std::cout << "[" << s.Str() << "][" << GetParenCnt( s ) << "]\n";
+  s = "(ABC) )";
+  std::cout << "[" << s.Str() << "][" << GetParenCnt( s ) << "]\n";
+  s = "(";
+  std::cout << "[" << s.Str() << "][" << GetParenCnt( s ) << "]\n";
+  s = "( (";
+  std::cout << "[" << s.Str() << "][" << GetParenCnt( s ) << "]\n";
+  s = "aaa)";
+  std::cout << "[" << s.Str() << "][" << GetParenCnt( s ) << "]\n";
+  s = "aaa";
+  std::cout << "[" << s.Str() << "][" << GetParenCnt( s ) << "]\n";
+
+  return 0;
+
+}
+#endif  // XB_DEBUG_SUPPORT
+
+
+/***********************************************************************/
+xbInt16 xbStmt::GetNextFromSeg( const xbString &sLineIn, xbString &sFromSegOut ){
+
+  xbInt16  iRc        = 0;
+  xbInt16  iErrorStop = 0;
+  xbInt16  iParenCtr  = 0;
+  xbUInt32 ulPos      = 1;
+  xbUInt32 ulTsp      = 0;            // token start position
+  xbBool   bDone      = xbFalse;
+  xbString sToken;
+
+  try{
+    sFromSegOut = "";
+    while( !bDone ){
+      ulTsp = GetNextToken( sLineIn, sToken, ulPos );
+      if( sToken == "" ){
+        bDone = xbTrue;
+
+      } else {
+        iParenCtr += GetParenCnt( sToken );
+        if( iParenCtr == 0 && ulPos > 1  ){
+          sToken.ToUpperCase();
+          if( sToken == "LEFT" || sToken == "RIGHT" || sToken == "FULL" ||
+              sToken == "INNER" || sToken == "OUTER" || sToken[1] == '(' ){
+            bDone = xbTrue;
+          }
+        }
+      }
+      ulPos += (sToken.Len() + 1);
+    }
+    if( ulTsp > 1 )
+      sFromSegOut.Assign( sLineIn, 1, ulTsp - 2 );
+  }
+  catch (xbInt16 iRc ){
+    xbString sMsg;
+    sMsg.Sprintf( "xbStmt::GetNextFromSeg() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, iRc );
+    xbase->WriteLogMessage( sMsg.Str() );
+    xbase->WriteLogMessage( GetErrorMessage( iRc ));
+  }
+  return iRc;
+}
+
+/***********************************************************************/
+
+xbUInt32 xbStmt::GetNextToken( const xbString &sCmdLineIn, xbString &sTokenOut, xbUInt32 ulStartPos ){
+
+  // input 
+  //   sCmdLine   - Entire Command line
+  //   ulStartPos - Where to start searching for the next token
+  // returns the position of the beginning of the token in the main command line
+
+  xbUInt32 ul = ulStartPos;
+  xbUInt32 ulTokenStartPos = 0;
+  sTokenOut = "";
+
+  while( ul <= sCmdLineIn.Len() && sCmdLineIn[ul] == ' ' )
+    ul++;
+  ulTokenStartPos = ul;
+
+  while( ul <= sCmdLineIn.Len() && sCmdLineIn[ul] != ' ' ){
+    sTokenOut += sCmdLineIn[ul];
+    ul++;
+  }
+
+  return ulTokenStartPos;
+}
+/***********************************************************************/
+xbInt16 xbStmt::GetParenCnt( const xbString &sToken ){
+
+  xbInt16 iParenCnt = 0;
+
+  for( xbUInt32 i = 1; i <= sToken.Len(); i++ ){
+    if( sToken[i] == '(' )
+      iParenCnt++;
+    else if( sToken[i] == ')' )
+      iParenCnt--;
+  }
+  return iParenCnt;
+}
+
+
+/***********************************************************************/
+xbInt16 xbStmt::ParseFromStmt( const xbString &sFromLine ){
+
+  xbInt16  iRc           = 0;
+  xbInt16  iErrorStop    = 0;
+  xbBool   bDone         = xbFalse;
+  xbString sFromSeg;
+  xbString sLine = sFromLine;
+
+  try{
+    std::cout << "ParseFromSeg [" << sFromLine.Str() << "]\n";
+
+    while( !bDone ){
+      if(( iRc = GetNextFromSeg( sLine, sFromSeg)) != XB_NO_ERROR ){
+        iErrorStop = 100;
+        throw iRc;
+      }
+      if( sFromSeg.Len() == 0 ){
+        bDone = xbTrue;
+      } else {
+        if(( iRc = ProcessFromSeg( sFromSeg )) != XB_NO_ERROR ){
+          iErrorStop = 110;
+          throw iRc;
+        }
+        sLine.Ltrunc( sFromSeg.Len() );
+        sLine.Ltrim();
+      }
+    }
+  }
+  catch (xbInt16 iRc ){
+    xbString sMsg;
+    sMsg.Sprintf( "xbStmt::ParseFromSeg() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, iRc );
+    xbase->WriteLogMessage( sMsg.Str() );
+    xbase->WriteLogMessage( GetErrorMessage( iRc ));
+  }
+
+  return iRc;
+}
+/***********************************************************************/
+xbInt16 xbStmt::ParseStmt( const xbString &sCmdLine ){
+
+  xbInt16  iRc           = 0;
+  xbInt16  iErrorStop    = 0;
+  xbInt16  iParenCnt     = 0;
+  xbUInt32 ulStartPos    = 7;
+  xbUInt32 ulLen         = 0;
+
+
+  xbBool   bFromFound    = xbFalse;
+  xbBool   bWhereFound   = xbFalse;
+  xbBool   bOrderByFound = xbFalse;
+  xbBool   bGroupByFound = xbFalse;
+  xbBool   bHavingFound  = xbFalse;
+  xbBool   bDone         = xbFalse;
+
+  xbString sToken;
+
+  sStmt.Set( sCmdLine );
+  sStmt.Trim();
+
+  try{
+
+    std::cout << "ParseStmt - [" << sStmt << "]\n";
+
+    xbUInt32 ulPos = ulStartPos;
+
+    while( !bFromFound && !bDone ){
+      ulPos = GetNextToken( sStmt, sToken, ulPos );
+      if( sToken == "" ){
+        bDone = xbTrue;
+      } else {
+        iParenCnt += GetParenCnt( sToken );
+        if( iParenCnt == 0 ){
+          sToken.ToUpperCase();
+          if( sToken == "FROM" ){
+            bFromFound = xbTrue;
+            ulFromPos = ulPos;
+            sFrom.Assign( sStmt, ulFromPos );
+          }
+        }
+        ulPos += sToken.Len() + 1;
+      }
+    }
+
+    // look for the where clause
+    if( bFromFound )
+      ulPos = ulFromPos + 5;
+    else
+      ulPos = ulStartPos;
+
+    bDone = xbFalse;
+    while( !bWhereFound && !bDone ){
+      ulPos = GetNextToken( sStmt, sToken, ulPos );
+      if( sToken == "" ){
+        bDone = xbTrue;
+      } else {
+        iParenCnt += GetParenCnt( sToken );
+        if( iParenCnt == 0 ){
+          sToken.ToUpperCase();
+          if( sToken == "WHERE" ){
+            bWhereFound = xbTrue;
+            ulWherePos = ulPos;
+            sWhere.Assign( sStmt, ulWherePos+6 );
+          }
+        }
+        ulPos += sToken.Len() + 1;
+      }
+    }
+
+
+    // look for the order clause
+    if( bWhereFound )
+      ulPos = ulWherePos + 6;
+    else if( bFromFound )
+      ulPos = ulFromPos + 5;
+    else
+      ulPos = ulStartPos;
+
+    bDone = xbFalse;
+    while( !bOrderByFound && !bDone ){
+      ulPos = GetNextToken( sStmt, sToken, ulPos );
+      if( sToken == "" ){
+        bDone = xbTrue;
+      } else {
+        iParenCnt += GetParenCnt( sToken );
+        if( iParenCnt == 0 ){
+          sToken.ToUpperCase();
+          if( sToken == "ORDER" ){
+            xbString sToken2;
+            xbUInt32 ulPos2 = GetNextToken( sStmt, sToken2, ulPos + 6 );
+            if( sToken2 != "" ){
+              sToken2.ToUpperCase();
+              if( sToken2 == "BY" ){
+                bOrderByFound = xbTrue;
+                ulOrderByPos = ulPos;
+                sOrderBy.Assign( sStmt, ulPos2 + 3 );
+              }
+            }
+          }
+        }
+        ulPos += sToken.Len() + 1;
+      }
+    }
+
+
+    bDone = xbFalse;
+    while( !bGroupByFound && !bDone ){
+      ulPos = GetNextToken( sStmt, sToken, ulPos );
+      if( sToken == "" ){
+        bDone = xbTrue;
+      } else {
+        iParenCnt += GetParenCnt( sToken );
+        if( iParenCnt == 0 ){
+          sToken.ToUpperCase();
+          if( sToken == "GROUP" ){
+            xbString sToken2;
+            xbUInt32 ulPos2 = GetNextToken( sStmt, sToken2, ulPos + 6 );
+            if( sToken2 != "" ){
+              sToken2.ToUpperCase();
+              if( sToken2 == "BY" ){
+                bGroupByFound = xbTrue;
+                ulGroupByPos = ulPos;
+                sGroupBy.Assign( sStmt, ulPos2 + 3 );
+              }
+            }
+          }
+        }
+        ulPos += sToken.Len() + 1;
+      }
+    }
+
+    bDone = xbFalse;
+    while( !bHavingFound && !bDone ){
+      ulPos = GetNextToken( sStmt, sToken, ulPos );
+      if( sToken == "" ){
+        bDone = xbTrue;
+      } else {
+        iParenCnt += GetParenCnt( sToken );
+        if( iParenCnt == 0 ){
+          sToken.ToUpperCase();
+          if( sToken == "HAVING" ){
+            bHavingFound = xbTrue;
+            ulHavingPos = ulPos;
+            sHaving.Assign( sStmt, ulHavingPos + 7 );
+          }
+        }
+        ulPos += sToken.Len() + 1;
+      }
+    }
+
+
+    // do the fields part
+    if( bFromFound )
+      ulLen = ulFromPos - 7;
+    else if( bWhereFound )
+      ulLen = ulWherePos - 7;
+    else if( bOrderByFound )
+      ulLen = ulOrderByPos - 7;
+    else if( bGroupByFound )
+      ulLen = ulGroupByPos - 7;
+    else if( bHavingFound )
+      ulLen = ulHavingPos - 7;
+    else 
+      ulLen = sStmt.Len() - 7;
+    sFields.Assign( sStmt, 7, ulLen );
+    sFields.Trim();
+
+    // do the FROM part
+    if( bFromFound ){
+      if( bWhereFound )
+        ulLen = ulWherePos - ulFromPos;
+      else if( bOrderByFound )
+        ulLen = ulOrderByPos - ulFromPos;
+      else if( bGroupByFound )
+        ulLen = ulGroupByPos - ulFromPos;
+      else if( bHavingFound )
+        ulLen = ulHavingPos - ulFromPos;
+      else 
+        ulLen = sStmt.Len() - ulFromPos;
+      sFrom.Resize( ulLen );
+      sFrom.Trim();
+
+    }
+
+
+    // do the WHERE part
+    if( bWhereFound ){
+      ulLen = 0;
+      if( bOrderByFound )
+        ulLen = ulOrderByPos - ulWherePos - 6;
+      else if( bGroupByFound )
+        ulLen = ulGroupByPos - ulWherePos - 6;
+      else if( bHavingFound )
+        ulLen = ulHavingPos - ulWherePos - 6;
+
+     if( ulLen > 0 )
+        sWhere.Resize( ulLen );
+      sWhere.Trim();
+    }
+
+    // FIXME if there is more than one space between ORDER and BY then this doesn't work quite right
+    // do the ORDER BY part
+    if( bOrderByFound ){
+      if( bGroupByFound )
+        ulLen = ulGroupByPos - ulOrderByPos - 9;
+      else if( bHavingFound )
+        ulLen = ulHavingPos - ulOrderByPos - 9;
+      else 
+        ulLen = sStmt.Len() - ulOrderByPos - 9;
+      sOrderBy.Resize( ulLen );
+      sOrderBy.Trim();
+    }
+
+    // FIXME if there is more than one space between ORDER and BY then this doesn't work quite right
+    // do the GROUP BY part
+    if( bGroupByFound ){
+      if( bHavingFound )
+        ulLen = ulHavingPos - ulGroupByPos - 9;
+      else 
+        ulLen = sStmt.Len() - ulGroupByPos - 9;
+      sGroupBy.Resize( ulLen );
+      sGroupBy.Trim();
+    }
+
+    if( bFromFound ){
+      if(( iRc = ParseFromStmt( sFrom )) != XB_NO_ERROR ){
+        iErrorStop = 100;
+        throw iRc;
+      }
+    }
+
+  }
+  catch (xbInt16 iRc ){
+    xbString sMsg;
+    sMsg.Sprintf( "xbStmt::ParseStmt() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, iRc );
+    xbase->WriteLogMessage( sMsg.Str() );
+    xbase->WriteLogMessage( GetErrorMessage( iRc ));
+  }
+
+  return iRc;
+}
+
+/***********************************************************************/
+xbInt16 xbStmt::ProcessFromSeg( const xbString &sFromSeg ){
+
+
+  xbInt16  iRc        = 0;
+  xbInt16  iErrorStop = 0;
+  char     cType      = ' ';
+  xbString sToken;
+  xbString sTable;
+  xbString sAlias;
+  xbString sWork;
+  xbString sExp;
+  xbUInt32 iPos;
+  xbBool   bDone;
+  xbExp    * pJoinExp = NULL;
+
+  try{
+
+    std::cout << "ProcessFromSeg for segment [" << sFromSeg.Str() << "]\n";
+
+    GetNextToken( sFromSeg, sToken, 1 );
+    sToken.ToUpperCase();
+
+    std::cout << "sToken1 = [" << sToken.Str() << "]\n";
+
+    if( sToken == "FROM" ){
+      // FROM has to be the first statement, and exist only once
+      if( pTblList ){
+        iErrorStop = 100;
+        iRc = XB_PARSE_ERROR;
+        throw iRc;
+      }
+      cType = 'M';
+    } else if( sToken == "LEFT" )
+      cType = 'L';
+    else if( sToken == "RIGHT" )
+      cType = 'R';
+    else if( sToken == "RIGHT" )
+      cType = 'R';
+    else if( sToken == "INNER" )
+      cType = 'I';
+    else if( sToken == "OUTER" || sToken == "FULL" )
+      cType = 'O';
+    else if( sToken[1] == '(' )
+      cType = 'Q';
+    else{
+      iErrorStop = 100;
+      iRc = XB_PARSE_ERROR;
+      throw iRc;
+    }
+
+
+    if( cType == 'M' ){
+      // expecting "FROM table"  or "FROM table alias"
+      iPos = GetNextToken( sFromSeg, sToken, 5 );
+      sTable = sToken;
+
+      iPos = GetNextToken( sFromSeg, sToken, iPos + sToken.Len() + 1 );
+      if( sToken.Len() > 0 )
+        sAlias = sToken;
+      else
+        sAlias = "";
+
+      sWork = sToken;
+      sWork.ToUpperCase();
+      iPos = sWork.Pos( ".DBF" );
+      if( iPos == 0 )
+        sTable += ".DBF";
+
+   //   std::cout << "table = [" << sTable.Str() << "] alias = [" << sAlias.Str() << "]\n";
+
+    } else if( cType != 'Q' ){
+      sWork = sFromSeg;
+      sWork.ToUpperCase();
+      iPos = sWork.Pos( " ON " );
+      if( iPos == 0 ){
+        iErrorStop = 110;
+        iRc = XB_PARSE_ERROR;
+        throw iRc;
+      }
+      bDone = xbFalse;
+
+      sWork.Assign( sFromSeg, iPos + 4 );
+      CvtSqlExp2DbaseExp( sWork, sExp );
+      sExp.Trim();
+      std::cout << "ON = [" << sExp.Str() << "]\n";
+
+
+      // need to get past the keywords LEFT, FULL, OUTER, RIGHT, INNER and get the table name here
+      iPos = sToken.Len() + 1;
+      while( !bDone ){
+        iPos = GetNextToken( sFromSeg, sToken, iPos );
+        sWork = sToken;
+        sWork.ToUpperCase();
+        if( sWork != "LEFT" && sWork != "RIGHT" && sWork != "INNER" && sWork != "OUTER" && sWork != "FULL" && sWork != "JOIN" )
+          bDone = xbTrue;
+        else
+          iPos += (sWork.Len() + 1);
+      }
+
+      sTable = sToken;
+      GetNextToken( sFromSeg, sAlias, iPos + sTable.Len() + 1 );
+      sWork.ToUpperCase();
+      iPos = sWork.Pos( ".DBF" );
+      if( iPos == 0 )
+        sTable += ".DBF";
+      sWork = sAlias;
+      sWork.ToUpperCase();
+      if( sWork == "ON" )
+        sAlias = "";
+    }
+
+
+    // open table
+    //std::cout << "attempting to open table " << sTable.Str() << "\n";
+    xbDbf *d = NULL;
+    if(( iRc = xbase->OpenHighestVersion( sTable, sAlias, &d )) != XB_NO_ERROR ){
+      iErrorStop = 120;
+      throw iRc;
+    }
+
+
+
+    // build out table linkage expression
+    if( cType == 'M' )
+      sExp = "MASTER";
+    else if( cType == 'L' ){
+      pJoinExp = new xbExp( xbase );
+
+      //  std::cout << "Parsing expression [" << sExp.Str() << "]\n";
+      if(( iRc = pJoinExp->ParseExpression( d, sExp )) != XB_NO_ERROR ){
+        iErrorStop = 130;
+        throw iRc;
+      }
+   }
+
+
+    // attach to correct location in list
+
+
+    // update the UpdateJoinList routine as appropriate
+//    if(( iRc = UpdateJoinList( cType, sTable, sAlias, NULL, NULL, NULL, NULL )) != XB_NO_ERROR ){
+
+    if(( iRc = UpdateJoinList( cType, sTable, sAlias, sExp, d, pJoinExp )) != XB_NO_ERROR ){
+      iErrorStop = 110;
+      throw iRc;
+    }
+
+
+  }
+  catch (xbInt16 iRc ){
+    xbString sMsg;
+    sMsg.Sprintf( "xbStmt::ProcessFromSeg() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, iRc );
+    xbase->WriteLogMessage( sMsg.Str() );
+    xbase->WriteLogMessage( GetErrorMessage( iRc ));
+  }
+  return iRc;
+}
+
+/***********************************************************************/
+xbInt16  xbStmt::UpdateJoinList( char cType, const xbString &sTableName, const xbString &sAlias, const xbString &sExp, xbDbf *d, xbExp *e ){
+//  xbTag *t ){
+
+
+  std::cout << "Update join list for table " << sTableName.Str() << "\n";
+
+  xbTblJoin *pTj;
+  if(( pTj = (xbTblJoin *) calloc( 1, sizeof( xbTblJoin ))) == NULL )
+    return XB_NO_MEMORY;
+
+  pTj->cJoinType = cType;
+  pTj->sTableName.Set( sTableName );
+  pTj->sAlias.Set( sAlias );
+  pTj->sJoinExp.Set( sExp );
+  pTj->pDbf = d;
+  pTj->pLinkExp = e;
+
+/*
+  
+  pTj->pTag = t;
+*/
+
+  if( cType == 'M' )
+    pTblList = pTj;
+
+  return 0;
+}
+/***********************************************************************/
+}              /* namespace       */
+#endif         /*  XB_SQL_SUPPORT */
+
diff --git a/src/tests/xb_test_bcd.cpp b/src/tests/xb_test_bcd.cpp
index 1eab20f..f735935 100755
--- a/src/tests/xb_test_bcd.cpp
+++ b/src/tests/xb_test_bcd.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2017,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2017,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -45,6 +45,7 @@ int main( int argCnt, char **av )
   xbXBase x;
 
   #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( iPo ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
@@ -55,8 +56,6 @@ int main( int argCnt, char **av )
   #endif
 
   x.SetDataDirectory( PROJECT_DATA_DIR );
-  x.EnableMsgLogging();
-
 
   if( iPo > 0 ){
     std::cout << "XBase bcd testing program.." << std::endl;
diff --git a/src/tests/xb_test_blockread.cpp b/src/tests/xb_test_blockread.cpp
new file mode 100755
index 0000000..ff55d23
--- /dev/null
+++ b/src/tests/xb_test_blockread.cpp
@@ -0,0 +1,168 @@
+/*  xb_test_blockread.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
+
+The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    XDB-devel@lists.sourceforge.net
+    XDB-users@lists.sourceforge.net
+
+*/
+
+// This program tests the class xbBlockRead
+// usage:   xb_test_blockread QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+  xbSchema MyDbfRec[] = 
+  {
+    { "NFLD",       XB_NUMERIC_FLD,   10, 0 },
+    { "CFLD",       XB_CHAR_FLD,      89, 0 },
+    { "",0,0,0 }
+  };
+
+
+int main( int argCnt, char **av )
+{
+  xbInt16 iRc  = 0;
+  xbInt16 iRc2 = 0;
+  int iPo = 1;         /* print option */
+                       /* 0 - QUIET    */
+                       /* 1 - NORMAL   */
+                       /* 2 - VERBOSE  */
+
+  if( argCnt > 1 ) {
+    if( av[1][0] == 'Q' )
+      iPo = 0;
+    else if( av[1][0] == 'V' )
+      iPo = 2;
+  }
+
+  xbXBase x;
+  x.SetDataDirectory( PROJECT_DATA_DIR );
+
+  xbDbf4 dbf( &x );
+
+  #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
+  x.EnableMsgLogging();
+  if( iPo ){
+    std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+  }
+  xbString sMsg;
+  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  x.WriteLogMessage( sMsg );
+  #endif
+
+
+  InitTime();
+
+
+  iRc2 = dbf.CreateTable( "BLOCKRD.DBF", "BlockRead", MyDbfRec, XB_OVERLAY, XB_MULTI_USER );
+  iRc += TestMethod( iPo, "CreateTable()", (xbInt32) iRc2, XB_NO_ERROR );
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+
+  // fill the file with several blocks of data
+  for( xbInt32 i = 0; i < 50; i++ ){
+    iRc2 = dbf.BlankRecord();
+    if( iRc2 != XB_NO_ERROR )
+      iRc += TestMethod( iPo, "BlankRecord()", (xbInt32) iRc2, XB_NO_ERROR );
+
+    iRc2 = dbf.PutLongField( 0, i+1 );
+    if( iRc2 != XB_NO_ERROR )
+      iRc += TestMethod( iPo, "PutLongField()", (xbInt32) iRc2, XB_NO_ERROR );
+
+    iRc2 = dbf.AppendRecord();
+    if( iRc2 != XB_NO_ERROR )
+      iRc += TestMethod( iPo, "AppendRecord()", (xbInt32) iRc2, XB_NO_ERROR );
+
+    iRc2 = dbf.Commit();
+    if( iRc2 != XB_NO_ERROR )
+      iRc += TestMethod( iPo, "Commit()", (xbInt32) iRc2, XB_NO_ERROR );
+  }
+
+
+  dbf.SetDefaultBlockReadSize( 2000 );
+
+  // enable block read for this table
+  iRc += TestMethod( iPo, "EnableBlockReadProcessing()", dbf.EnableBlockReadProcessing(), XB_NO_ERROR );
+
+  xbUInt32 ulFld = 0;
+  xbUInt32 ulCtr = 1;
+
+  iRc2 = XB_NO_ERROR;
+  while( iRc2 == XB_NO_ERROR ){
+    //    std::cout << ulCtr << "\n";
+    iRc2 += dbf.GetRecord( ulCtr );
+    if( iRc2 != XB_NO_ERROR && iRc != XB_INVALID_RECORD )
+      TestMethod( iPo, "GetRecord()", iRc, XB_NO_ERROR );
+
+    if( iRc2 == XB_NO_ERROR ){
+      dbf.GetULongField( "NFLD", ulFld );
+      if( ulFld != ulCtr ){
+        std::cout << "ulFld = " << ulFld << " ulCtr = " << ulCtr << "\n";
+        iRc += TestMethod( iPo, "Field Compare", (xbDouble) ulFld, (xbDouble) ulCtr );
+      }
+    }
+    ulCtr++;
+  }
+
+  // std::cout << "**********Delete every other record\n";
+  iRc2 = dbf.GetFirstRecord();
+  while( iRc2 == XB_NO_ERROR ){
+    if( (dbf.GetCurRecNo() % 2) != 0 ){
+      dbf.DeleteRecord();
+      dbf.Commit();
+    }
+    iRc2 = dbf.GetNextRecord();
+  }
+
+
+  // test filter for deleted records
+  #ifdef XB_FILTER_SUPPORT
+  xbFilter f( &dbf );
+  xbString sFilt = ".NOT. DELETED()";
+  f.Set( sFilt );
+  iRc2 = f.GetFirstRecord();
+  while( iRc2 == XB_NO_ERROR ){
+    dbf.GetULongField( "NFLD", ulFld );
+    if( (ulFld % 2) != 0 ){
+      iRc += TestMethod( iPo, "Filter GetNextRecord()", ulFld % 2, 0 );
+    }
+    iRc2 = f.GetNextRecord();
+  }
+  #endif  // XB_FILTER_SUPPORT
+
+
+  iRc += TestMethod( iPo, "DisableBlockReadProcessing()", dbf.DisableBlockReadProcessing(), XB_NO_ERROR );
+  //iRc2 = dbf.DeleteTable();
+
+  iRc2 = dbf.Close();
+  iRc += TestMethod( iPo, "Close()", (xbInt32) iRc2, XB_NO_ERROR );
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+
+  #ifdef XB_LOGGING_SUPPORT
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+  x.WriteLogMessage( sMsg );
+  #endif
+
+
+  if( iPo > 0 || iRc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
+
+  return iRc;
+}
+
diff --git a/src/tests/xb_test_date.cpp b/src/tests/xb_test_date.cpp
index 1d9b523..7aee584 100755
--- a/src/tests/xb_test_date.cpp
+++ b/src/tests/xb_test_date.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -40,8 +40,9 @@ int main( int argCnt, char **av )
       po = 2;
   }
 
-#ifdef XB_LOGGING_SUPPORT
   xbXBase x;
+  #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( po ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
@@ -49,7 +50,7 @@ int main( int argCnt, char **av )
   xbString sMsg;
   sMsg.Sprintf( "Program [%s] initializing...", av[0] );
   x.WriteLogMessage( sMsg );
-#endif
+  #endif
   InitTime();
 
   xbDate d1;
diff --git a/src/tests/xb_test_dbf_v3_memos.cpp b/src/tests/xb_test_dbf_v3_memos.cpp
index ad3e8e0..e42edb1 100755
--- a/src/tests/xb_test_dbf_v3_memos.cpp
+++ b/src/tests/xb_test_dbf_v3_memos.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -55,6 +55,7 @@ int main( int argCnt, char **av )
   xbXBase x;
 
   #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( po ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
@@ -65,7 +66,6 @@ int main( int argCnt, char **av )
   #endif
 
   x.SetDataDirectory( PROJECT_DATA_DIR );
-  x.EnableMsgLogging();
 
   #ifdef XB_LOCKING_SUPPORT
   x.DisableDefaultAutoLock();
diff --git a/src/tests/xb_test_dbf_v3_nomemos.cpp b/src/tests/xb_test_dbf_v3_nomemos.cpp
index e5adc48..2dfeb7e 100755
--- a/src/tests/xb_test_dbf_v3_nomemos.cpp
+++ b/src/tests/xb_test_dbf_v3_nomemos.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -59,7 +59,8 @@ int main( int argCnt, char **av )
 
   xbXBase x;
 
-#ifdef XB_LOGGING_SUPPORT
+  #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( po ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
@@ -67,10 +68,9 @@ int main( int argCnt, char **av )
   xbString sMsg;
   sMsg.Sprintf( "Program [%s] initializing...", av[0] );
   x.WriteLogMessage( sMsg );
-#endif
+  #endif
 
   x.SetDataDirectory( PROJECT_DATA_DIR );
-  x.EnableMsgLogging();
 
   #ifdef XB_LOCKING_SUPPORT
   x.DisableDefaultAutoLock();
@@ -97,7 +97,7 @@ int main( int argCnt, char **av )
 
   xbDbf3 V3Dbf2( &x );
   // next occurrence should error as a dup
-  x.WriteLogMessage( "Second create attempt" );
+  x.WriteLogMessage( "Second create attempt, should generate an error." );
   iRc2 = V3Dbf2.CreateTable( "TestV3.DBF", "TestV3", MyV3Record, XB_DONTOVERLAY, XB_MULTI_USER );
   iRc += TestMethod( po, "CreateTable()", iRc2, XB_FILE_EXISTS );
   if( iRc2 != XB_FILE_EXISTS ){
diff --git a/src/tests/xb_test_dbf_v4_memos.cpp b/src/tests/xb_test_dbf_v4_memos.cpp
index 2b0e09c..47a9053 100755
--- a/src/tests/xb_test_dbf_v4_memos.cpp
+++ b/src/tests/xb_test_dbf_v4_memos.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -47,8 +47,8 @@ int main( int argCnt, char **av )
 
   xbXBase x;
 
-#ifdef XB_LOGGING_SUPPORT
-
+  #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( po ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
@@ -56,11 +56,9 @@ int main( int argCnt, char **av )
   xbString sMsg;
   sMsg.Sprintf( "Program [%s] initializing...", av[0] );
   x.WriteLogMessage( sMsg );
-
-#endif
+  #endif
 
   x.SetDataDirectory( PROJECT_DATA_DIR );
-  x.EnableMsgLogging();
 
   #ifdef XB_LOCKING_SUPPORT
   x.DisableDefaultAutoLock();
diff --git a/src/tests/xb_test_dbf_v4_nomemos.cpp b/src/tests/xb_test_dbf_v4_nomemos.cpp
index 4036588..984eb63 100755
--- a/src/tests/xb_test_dbf_v4_nomemos.cpp
+++ b/src/tests/xb_test_dbf_v4_nomemos.cpp
@@ -2,7 +2,7 @@
 
 XBase Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -56,9 +56,19 @@ int main( int argCnt, char **av )
     { "",0,0,0 }
   };
 
+  xbSchema MyV4ZipRecord[] = 
+  {
+    { "ZIPCODE",    XB_NUMERIC_FLD,   5, 0 },
+    { "CITY",       XB_CHAR_FLD,     30, 0 },
+    { "STATE",      XB_CHAR_FLD,      2, 0 },
+    { "",0,0,0 }
+  };
+
+
   xbXBase x;
 
   #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( po ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
@@ -69,7 +79,6 @@ int main( int argCnt, char **av )
   #endif
 
   x.SetDataDirectory( PROJECT_DATA_DIR );
-  x.EnableMsgLogging();
 
   #ifdef XB_LOCKING_SUPPORT
   x.DisableDefaultAutoLock();
@@ -318,10 +327,26 @@ int main( int argCnt, char **av )
   rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldAMT, sf ), XB_NO_ERROR );
   rc += TestMethod( po, "GetField()", sf, "   432.55", 9 );
 
+
+  xbDbf4 V4DbfZ( &x );                // version 4 dbf file
+  rc2 = V4DbfZ.CreateTable( "TestV4Zip.DBF", "TestV4Zip", MyV4ZipRecord, XB_OVERLAY, XB_MULTI_USER );
+  rc += TestMethod( po, "CreateTable()", (xbInt32) rc2, XB_NO_ERROR );
+  if( rc2 )
+    x.DisplayError( rc2 );
+
+
+
   rc += TestMethod( po, "Close()", V4Dbf.Close(), XB_NO_ERROR );
   if( po == 2 )
     x.DisplayTableList();
 
+
+  rc += TestMethod( po, "Close()", V4DbfZ.Close(), XB_NO_ERROR );
+  if( po == 2 )
+    x.DisplayTableList();
+
+
+
   if( po > 0 || rc < 0 )
     fprintf( stdout, "Total Errors = %d\n", rc * -1 );
 
diff --git a/src/tests/xb_test_expnode.cpp b/src/tests/xb_test_expnode.cpp
index 3fb716d..cbd79c9 100755
--- a/src/tests/xb_test_expnode.cpp
+++ b/src/tests/xb_test_expnode.cpp
@@ -2,7 +2,7 @@
 
 XBase Software Library
 
-Copyright (c) 1997,2003,2014,2017,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2017,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -42,6 +42,7 @@ int main( int argCnt, char **av )
   xbXBase x;
 
   #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( po ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
@@ -52,7 +53,6 @@ int main( int argCnt, char **av )
   #endif
 
   x.SetDataDirectory( PROJECT_DATA_DIR );
-  x.EnableMsgLogging();
   InitTime();
 
   if( po > 0 ){
diff --git a/src/tests/xb_test_expression.cpp b/src/tests/xb_test_expression.cpp
index 75ed3e5..ac1cde7 100755
--- a/src/tests/xb_test_expression.cpp
+++ b/src/tests/xb_test_expression.cpp
@@ -2,7 +2,7 @@
 
 XBase Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -67,7 +67,7 @@ xbInt16 DevTester( xbXBase * xb, xbDbf * dbf, const char * sExpIn ){
   if( iRc == XB_NO_ERROR ){
     #ifdef XB_DEBUG_SUPPORT
     exp.DumpTree( xbTrue );
-	#endif   // XB_DEBUG_SUPPORT
+    #endif   // XB_DEBUG_SUPPORT
     std::cout << "dump nodes\n";
     n = exp.GetNextNodeTest( NULL );
     if( !n ){
@@ -86,7 +86,6 @@ xbInt16 DevTester( xbXBase * xb, xbDbf * dbf, const char * sExpIn ){
     std::cout << "Parse Error [" << iRc << "]\n";
     return -1;
   }
-  return 0;
 }
 
 /**************************************************************************/
@@ -394,6 +393,7 @@ int main( int argCnt, char **av )
   xbDate d;
 
   #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( po ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
@@ -404,7 +404,6 @@ int main( int argCnt, char **av )
   #endif
 
   x.SetDataDirectory( PROJECT_DATA_DIR );
-  x.EnableMsgLogging();
   InitTime();
 
   if( po > 0 ){
diff --git a/src/tests/xb_test_file.cpp b/src/tests/xb_test_file.cpp
index 4614805..cf835c2 100755
--- a/src/tests/xb_test_file.cpp
+++ b/src/tests/xb_test_file.cpp
@@ -1,6 +1,6 @@
 /* xb_test_file.cpp
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -42,6 +42,7 @@ int main( int argCnt, char **av )
   xbXBase x;
 
   #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( po ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
diff --git a/src/tests/xb_test_filter.cpp b/src/tests/xb_test_filter.cpp
index ac4b896..000e196 100755
--- a/src/tests/xb_test_filter.cpp
+++ b/src/tests/xb_test_filter.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2020,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2020,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -41,7 +41,6 @@ int main( int argCnt, char **av )
       iPo = 2;
   }
 
-
   xbSchema MyV4Record[] = 
   {
     { "CFLD",       XB_CHAR_FLD,      6, 0 },
@@ -50,9 +49,9 @@ int main( int argCnt, char **av )
     { "",0,0,0 }
   };
 
-
   xbXBase x;
   #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( iPo ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
@@ -64,7 +63,6 @@ int main( int argCnt, char **av )
   #endif
 
   x.SetDataDirectory( PROJECT_DATA_DIR );
-  x.EnableMsgLogging();
 
   char c;
   xbString s;
@@ -114,7 +112,7 @@ int main( int argCnt, char **av )
   iRc += TestMethod( iPo, "SetCurTag()", MyFile->SetCurTag( "" ), XB_NO_ERROR );
   #endif // XB_INDEX_SUPPORT
 
-  xbFilter f1( &x, MyFile );
+  xbFilter f1( MyFile );
   xbString sMyFilterExpression = "LEFT( CFLD, 2 ) = 'YY'";
   iRc += TestMethod( iPo, "Set()", f1.Set( sMyFilterExpression ), XB_NO_ERROR );
 
diff --git a/src/tests/xb_test_funcs.cpp b/src/tests/xb_test_funcs.cpp
index e8b73b0..c7bf0d3 100755
--- a/src/tests/xb_test_funcs.cpp
+++ b/src/tests/xb_test_funcs.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -61,6 +61,7 @@ int main( int argCnt, char **av )
 
 
   #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( po ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
diff --git a/src/tests/xb_test_linklist.cpp b/src/tests/xb_test_linklist.cpp
index dc253af..288ee99 100755
--- a/src/tests/xb_test_linklist.cpp
+++ b/src/tests/xb_test_linklist.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -42,7 +42,8 @@ int main( int argCnt, char **av )
   }
 
   xbXBase x;
-#ifdef XB_LOGGING_SUPPORT
+  #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( po ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
@@ -50,7 +51,8 @@ int main( int argCnt, char **av )
   xbString sMsg;
   sMsg.Sprintf( "Program [%s] initializing...", av[0] );
   x.WriteLogMessage( sMsg );
-#endif
+  #endif
+
   InitTime();
 
   xbLinkList<xbString> ll;
diff --git a/src/tests/xb_test_lock.cpp b/src/tests/xb_test_lock.cpp
index 7e9865b..39332ad 100755
--- a/src/tests/xb_test_lock.cpp
+++ b/src/tests/xb_test_lock.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -59,6 +59,7 @@ int main( int argCnt, char **av )
 
 
   #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( po > 0 ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
@@ -69,7 +70,6 @@ int main( int argCnt, char **av )
   #endif
 
   x.SetDataDirectory( PROJECT_DATA_DIR );
-  x.EnableMsgLogging();
   InitTime();
   #ifdef XB_DBF4_SUPPORT
   MyFile = new xbDbf4( &x );                /* version 4 dbf file */
diff --git a/src/tests/xb_test_lock2.cpp b/src/tests/xb_test_lock2.cpp
index 3dd4b57..d5534ec 100755
--- a/src/tests/xb_test_lock2.cpp
+++ b/src/tests/xb_test_lock2.cpp
@@ -2,7 +2,7 @@
 
 XBase Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -57,8 +57,8 @@ int main( int argCnt, char **av )
   }
 
   #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   xbString sLogFileName =  x.GetLogFqFileName().Str();
-
   sLogFileName.Resize( sLogFileName.Len() - 3 );
   sLogFileName += "_l2.txt";
   x.SetLogFileName( sLogFileName );
@@ -72,7 +72,6 @@ int main( int argCnt, char **av )
   #endif
 
   x.SetDataDirectory( PROJECT_DATA_DIR );
-  x.EnableMsgLogging();
   InitTime();
 
   #ifdef XB_DBF4_SUPPORT
diff --git a/src/tests/xb_test_log.cpp b/src/tests/xb_test_log.cpp
index 613b7dd..28ae552 100755
--- a/src/tests/xb_test_log.cpp
+++ b/src/tests/xb_test_log.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -21,18 +21,13 @@ Email Contact:
 #include "xbase.h"
 
 using namespace xb;
-
 #include "tstfuncs.cpp"
 
-
-
 int main( int argCnt, char **av )
 {
   int rc = 0;
 
-#ifdef XB_LOGGING_SUPPORT
-
-
+  #ifdef XB_LOGGING_SUPPORT
   int po = 1;          /* print option */
                        /* 0 - QUIET    */
                        /* 1 - NORMAL   */
@@ -46,6 +41,7 @@ int main( int argCnt, char **av )
   }
 
   xbXBase x;
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   InitTime();
   if( po ){
@@ -55,21 +51,18 @@ int main( int argCnt, char **av )
   sMsg.Sprintf( "Program [%s] initializing...", av[0] );
   x.WriteLogMessage( sMsg );
 
-
   xbString sNewLogFileName = "Logfile2.txt";
   sMsg.Sprintf( "Switching to logfile [%s]", sNewLogFileName.Str() );
   x.WriteLogMessage( sMsg );
 
-
   x.DisableMsgLogging();
   rc += TestMethod( po, "Set/Get Log Status()", x.GetLogStatus(), xbFalse );
   x.SetLogFileName( sNewLogFileName );
-  x.EnableMsgLogging();
 
+  x.EnableMsgLogging();
   rc += TestMethod( po, "Set/Get Log Status()", x.GetLogStatus(), 1 );
   rc += TestMethod( po,"WriteLogMessage()", x.WriteLogMessage( "Test log message........" ), XB_NO_ERROR );
 
-
   sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
   x.WriteLogMessage( sMsg );
 
diff --git a/src/tests/xb_test_mdx.cpp b/src/tests/xb_test_mdx.cpp
index af191ad..2ef5ffb 100755
--- a/src/tests/xb_test_mdx.cpp
+++ b/src/tests/xb_test_mdx.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -55,20 +55,28 @@ int main( int argCnt, char **av )
   };
 
 
+  xbSchema MyV4Record2[] = 
+  {
+    { "CHAR1",   XB_CHAR_FLD,    1, 0 },
+    { "CHAR27",  XB_CHAR_FLD,   27, 0 },
+    { "",0,0,0 }
+  };
+
+
   xbXBase x;
 
-#ifdef XB_LOGGING_SUPPORT
+  #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( iPo ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
   }
   sMsg.Sprintf( "Program [%s] initializing...", av[0] );
   x.WriteLogMessage( sMsg );
-#endif
+  #endif
 
   x.SetDataDirectory( PROJECT_DATA_DIR );
-  x.EnableMsgLogging();
-  x.SetMultiUser( false );
+  x.SetMultiUser( xbFalse );
   InitTime();
 
   if( iPo > 0 )
@@ -92,6 +100,7 @@ int main( int argCnt, char **av )
            xbInt16 iDescending, xbInt16 iUnique, xbInt16 iOverLay, xbIx **xbIxOut, void **vpTagOut );
   */
 
+
   iRc2 = V4DbfX1->CreateTag( "MDX", "CITY_TAGA",  "CITY", "", 0, 0, XB_OVERLAY, &pIx, &pTag );
   iRc += TestMethod( iPo, "CreateTag(1)", iRc2, 0 );
 
@@ -109,8 +118,6 @@ int main( int argCnt, char **av )
 //  std::cout << iRc2 << "\n";
 
 
-// something in th following block of code causing issues
-
   xbInt32 uZip = 10000;
   for( xbUInt16 i = 0; i < 35; i++ ){
    for( xbUInt16 j = 0; j < 14; j++ ){ 
@@ -147,7 +154,7 @@ int main( int argCnt, char **av )
   }
 
 
-  iRc += TestMethod( iPo, "CheckTagIntegrity()", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "CheckTagIntegrity(1)", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
 
   // attempt to add a dup key, should fail with XB_KEY_NOT_UNIQUE
   iRc2 = V4DbfX1->BlankRecord();
@@ -177,7 +184,7 @@ int main( int argCnt, char **av )
     iRc += TestMethod( iPo, "Abort()", iRc2, XB_NO_ERROR );
 
   iRc += TestMethod( iPo, "DeleteTag()", V4DbfX1->DeleteTag( "MDX", "CITY_TAGA" ), XB_NO_ERROR );
-  iRc += TestMethod( iPo, "CheckTagIntegrity()", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "CheckTagIntegrity(2)", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
 
   iRc2 = V4DbfX1->CreateTag( "MDX", "CITY_TAGF",  "CITY", ".NOT. DELETED()", 0, 0, XB_OVERLAY, &pIx, &pTag );
   iRc += TestMethod( iPo, "CreateTag(4)", iRc2, 0 );
@@ -186,27 +193,29 @@ int main( int argCnt, char **av )
   iRc += TestMethod( iPo, "SetCurTag()", iRc2, XB_NO_ERROR );
   iRc += TestMethod( iPo, "GetCurTagName()", V4DbfX1->GetCurTagName().Str(), "CITY_TAGF", 9 );
 
-  iRc += TestMethod( iPo, "CheckTagIntegrity()", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_INVALID_INDEX );
+  //  next check throws an error message on the display, that is what it is testing, don't need to debug it
+  iRc += TestMethod( iPo, "CheckTagIntegrity(3)", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_INVALID_INDEX );
+
 
   iRc2 = V4DbfX1->Reindex( 0 );
   iRc += TestMethod( iPo, "Reindex( 0 )", iRc2, XB_NO_ERROR );
-  iRc += TestMethod( iPo, "CheckTagIntegrity()", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "CheckTagIntegrity(4)", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
 
   iRc += TestMethod( iPo, "GetCurTagName()", V4DbfX1->GetCurTagName().Str(), "CITY_TAGF", 9 );
 
   iRc2 = V4DbfX1->Reindex( 1 );
   iRc += TestMethod( iPo, "Reindex( 1 )", iRc2, XB_NO_ERROR );
-  iRc += TestMethod( iPo, "CheckTagIntegrity()", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "CheckTagIntegrity(5)", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
 
   // delete everything, all keys should be removed from the filtered index
   iRc += TestMethod( iPo, "DeleteAll(0)", V4DbfX1->DeleteAll( 0 ), XB_NO_ERROR );
   iRc += TestMethod( iPo, "Commit()", V4DbfX1->Commit(), XB_NO_ERROR );
-  iRc += TestMethod( iPo, "CheckTagIntegrity()", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "CheckTagIntegrity(6)", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
 
   // undelete everything, all keys should be added back into the filtered index
   iRc += TestMethod( iPo, "DeleteAll(1)", V4DbfX1->DeleteAll( 1 ), XB_NO_ERROR );
   iRc += TestMethod( iPo, "Commit()", V4DbfX1->Commit(), XB_NO_ERROR );
-  iRc += TestMethod( iPo, "CheckTagIntegrity()", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
+  iRc += TestMethod( iPo, "CheckTagIntegrity(7)", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
 
   // std::cout << "Cur Tag Name = " << V4DbfX1->GetCurTagName().Str() << "\n";
   sKey = "abc";
@@ -239,8 +248,41 @@ int main( int argCnt, char **av )
   iRc += TestMethod( iPo, "Rename()",  V4DbfX1->Rename( "TestMdxR.DBF" ), XB_NO_ERROR );
 
 
+  xbDbf *V4DbfX2 = new xbDbf4( &x );
+  iRc2 = V4DbfX2->CreateTable( "TMDXDB02.DBF", "TestMdxX4", MyV4Record2, XB_OVERLAY, XB_MULTI_USER );
+  iRc += TestMethod( iPo, "CreateTable(2)", iRc2, 0 );
+
+
+  iRc2 = V4DbfX2->CreateTag( "MDX", "TAG1",  "CHAR27", ".NOT. DELETED()", 0, 0, XB_OVERLAY, &pIx, &pTag );
+//  iRc2 = V4DbfX2->CreateTag( "MDX", "TAG2",  "CHAR1", "CHAR1 = 'O' .AND. .NOT. DELETED()", 0, 0, XB_OVERLAY, &pIx, &pTag );
+  iRc += TestMethod( iPo, "CreateTag(4)", iRc2, 0 );
+
+
+
+  for( xbUInt32 ul = 0; ul < 500 && iRc2 == XB_NO_ERROR; ul++ ){
+    c = 'O';
+    V4DbfX2->BlankRecord();
+    iRc2 = V4DbfX2->PutField( 1, c );
+    if( iRc2 != XB_NO_ERROR ){
+      iRc += TestMethod( iPo, "PutField()", iRc2, XB_NO_ERROR );
+    } else {
+      iRc2 = V4DbfX2->AppendRecord();
+      if( iRc2 != XB_NO_ERROR ){
+        iRc += TestMethod( iPo, "AppendRecord()", iRc2, XB_NO_ERROR );
+      } else {
+        iRc2 = V4DbfX2->Commit();
+        if( iRc2 != XB_NO_ERROR ){
+          iRc += TestMethod( iPo, "Commit()", iRc2, XB_NO_ERROR );
+        }
+      }
+    }
+  }
+
+  iRc += TestMethod( iPo, "CheckTagIntegrity(7)", V4DbfX2->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
+
   x.CloseAllTables();
   delete V4DbfX1;
+  delete V4DbfX2;
 
   if( iPo > 0 || iRc < 0 )
     fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
diff --git a/src/tests/xb_test_ndx.cpp b/src/tests/xb_test_ndx.cpp
index b8b97f6..34496b6 100755
--- a/src/tests/xb_test_ndx.cpp
+++ b/src/tests/xb_test_ndx.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -57,6 +57,7 @@ int main( int argCnt, char **av )
   xbString sMsg;
 
   #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( iPo ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
@@ -67,11 +68,7 @@ int main( int argCnt, char **av )
   #endif
 
   x.SetDataDirectory( PROJECT_DATA_DIR );
-  x.EnableMsgLogging();
-
-  #ifdef XB_LOCKING_SUPPORT
-  x.DisableDefaultAutoLock();
-  #endif
+  x.SetMultiUser( xbFalse );
 
   InitTime();
 
@@ -386,11 +383,13 @@ int main( int argCnt, char **av )
       //ix->GetTagName( 0, sTagName );
       sMsg.Sprintf( "CheckTagIntegrity() - [%s]", ix->GetTagName(ix->GetCurTag()).Str());
       iRc += TestMethod( iPo, sMsg, ix->CheckTagIntegrity( ix->GetCurTag(), 2 ), XB_NO_ERROR );
-      ixl = ixl->next;
     }
+    ixl = ixl->next;
   }
 
-  iRc += TestMethod( iPo, "DeleteTable()", V3Dbf->DeleteTable(), XB_NO_ERROR );
+//  iRc += TestMethod( iPo, "DeleteTable()", V3Dbf->DeleteTable(), XB_NO_ERROR );
+
+  x.CloseAllTables();
 
   if( iPo > 0 || iRc < 0 )
     fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
diff --git a/src/tests/xb_test_sql.cpp b/src/tests/xb_test_sql.cpp
index 20c8514..99a4f0b 100755
--- a/src/tests/xb_test_sql.cpp
+++ b/src/tests/xb_test_sql.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014, 2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014, 2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -44,9 +44,10 @@ int main( int argCnt, char **av )
       po = 2;
   }
 
-
-  xbSchema MySqlRecord[] = 
+/*
+  xbSchema MyAddressRecord[] = 
   {
+    { "ADDRESS",     XB_CHAR_FLD,     30, 0 },
     { "CITY",        XB_CHAR_FLD,     30, 0 },
     { "STATE",       XB_CHAR_FLD,      2, 0 },
     { "ZIPCODE",     XB_NUMERIC_FLD,   9, 0 },
@@ -56,9 +57,23 @@ int main( int argCnt, char **av )
     { "",0,0,0 }
   };
 
+  above structure below, depending on how table is created
+
+  sSql = "CREATE TABLE Address.DBF ( ADDRESS CHAR(30), CITY CHAR(30), STATE CHAR(2), ZIPCODE NUMERIC(9,0), NOTES VARCHAR, LASTUPDATE DATE, ACTIVE LOGICAL )";
+*/
+
+  xbSchema MyZipRecord[] = 
+  {
+    { "ZIPCODE",     XB_NUMERIC_FLD,   9, 0 },
+    { "CITY",        XB_CHAR_FLD,     30, 0 },
+    { "STATE",       XB_CHAR_FLD,      2, 0 },
+    { "",0,0,0 }
+  };
+
 
   xbXBase x;
   #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( po ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
@@ -69,9 +84,7 @@ int main( int argCnt, char **av )
   #endif
 
 
-
   x.SetDataDirectory( PROJECT_DATA_DIR );
-  x.EnableMsgLogging();
   InitTime();
 
   xbSql sql( &x );
@@ -81,36 +94,48 @@ int main( int argCnt, char **av )
 
 
   xbDbf4 SqlDbf( &x );                // version 4 dbf file
+  xbDbf4 SqlDbfZ( &x );                // version 4 dbf file
+
 
 
-  // clean up any things possibly needing cleaned up
-  xbString sDir;
-  SqlDbf.GetFileDirPart( sDir );
-  xbString sDbfName;
-  xbString sDbtName;
-  xbString sMdxName;
-  sDbfName.Sprintf( "%sTestSQL.DBF", sDir.Str());
-  sDbtName.Sprintf( "%sTestSQL.DBR", sDir.Str());
-  sMdxName.Sprintf( "%sTestSQL.MDX", sDir.Str());
-  SqlDbf.xbRemove( sDbfName );
-  SqlDbf.xbRemove( sDbtName );
-  SqlDbf.xbRemove( sMdxName );
-  sDbfName.Sprintf( "%sTestSqlR.DBF", sDir.Str());
-  sDbtName.Sprintf( "%sTestSqlR.DBT", sDir.Str());
-  sMdxName.Sprintf( "%sTestSqlR.MDX", sDir.Str());
-  SqlDbf.xbRemove( sDbfName );
-  SqlDbf.xbRemove( sDbtName );
-  SqlDbf.xbRemove( sMdxName );
-
-
-  iRc2 = SqlDbf.CreateTable( "TestSQL.DBF", "TestSQL", MySqlRecord, XB_OVERLAY, XB_MULTI_USER );
+
+
+  sSql = "DROP TABLE IF EXISTS AddressR.DBF";
+  iRc2 = sql.ExecuteNonQuery( sSql );
+  iRc += TestMethod( po, "DropTable()", (xbInt32) iRc2, XB_NO_ERROR );
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+
+
+  sSql = "DROP TABLE IF EXISTS Address.DBF";
+  iRc2 = sql.ExecuteNonQuery( sSql );
+  iRc += TestMethod( po, "DropTable()", (xbInt32) iRc2, XB_NO_ERROR );
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+
+
+  sSql = "CREATE TABLE Address.DBF ( ADDRESS CHAR(30), CITY CHAR(30), STATE CHAR(2), ZIPCODE NUMERIC(9,0), NOTES VARCHAR, LASTUPDATE DATE, ACTIVE LOGICAL   )";
+
+  iRc2 = sql.ExecuteNonQuery( sSql );
+  iRc += TestMethod( po, "CreateTable()", (xbInt32) iRc2, XB_NO_ERROR );
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+/*
+  non sql way to create a table
+  iRc2 = SqlDbf.CreateTable( "Address.DBF", "Address", MyAddressRecord, XB_OVERLAY, XB_MULTI_USER );
   iRc += TestMethod( po, "CreateTable()", (xbInt32) iRc2, XB_NO_ERROR );
   if( iRc2 )
     x.DisplayError( iRc2 );
+*/
+
+//  return 0;
 
   #ifdef XB_MDX_SUPPORT
-  sSql = "CREATE INDEX tag1 ON TestSQL.DBF( CITY, STATE, DTOS( LASTUPDATE )) FILTER .NOT. DELETED()";
-  // xbString sSql = "CREATE INDEX tag1 ON TestSQL.DBF( CITY, STATE )";
+  sSql = "CREATE INDEX tag1 ON Address.DBF( CITY, STATE, DTOS( LASTUPDATE )) FILTER .NOT. DELETED()";
+  // xbString sSql = "CREATE INDEX tag1 ON Address.DBF( CITY, STATE )";
 
   iRc2 = sql.ExecuteNonQuery( sSql );
   iRc += TestMethod( po, "SqL CreateIndex()", (xbInt32) iRc2, XB_NO_ERROR );
@@ -118,65 +143,107 @@ int main( int argCnt, char **av )
     x.DisplayError( iRc2 );
   #endif // XB_MDX_SUPPORT
 
-  sSql = "INSERT INTO TestSQL (CITY, STATE, ZIPCODE, NOTES, LASTUPDATE, ACTIVE ) VALUES ( 'San Diego', 'CA', 92007, 'San Diego is a cool place', '1989-02-09', 'Y')";
+  sSql = "INSERT INTO Address (CITY, STATE, ZIPCODE, NOTES, LASTUPDATE, ACTIVE ) VALUES ( 'San Diego', 'CA', 92007, 'San Diego is a cool place', '1989-02-09', 'Y')";
   iRc2 = sql.ExecuteNonQuery( sSql );
   iRc += TestMethod( po, "SqlInsert()", (xbInt32) iRc2, XB_NO_ERROR );
   if( iRc2 )
     x.DisplayError( iRc2 );
 
-  sSql = "INSERT INTO TestSQL (CITY, STATE, ZIPCODE, NOTES, LASTUPDATE, ACTIVE ) VALUES ( 'Dallas', 'TX', 76248, 'Dallas is hot in the summer', '1989-02-09', 'N')";
+  sSql = "INSERT INTO Address (CITY, STATE, ZIPCODE, NOTES, LASTUPDATE, ACTIVE ) VALUES ( 'Dallas', 'TX', 76248, 'Dallas is hot in the summer', '1989-02-09', 'N')";
   iRc2 = sql.ExecuteNonQuery( sSql );
   iRc += TestMethod( po, "SqlInsert()", (xbInt32) iRc2, XB_NO_ERROR );
   if( iRc2 )
     x.DisplayError( iRc2 );
 
-  sSql = "ALTER TABLE TestSQL.DBF RENAME TO TestSqlR.DBF";
+  sSql = "ALTER TABLE Address.DBF RENAME TO AddressR.DBF";
 
   iRc2 = sql.ExecuteNonQuery( sSql );
   iRc += TestMethod( po, "SqlAlterTable()", (xbInt32) iRc2, XB_NO_ERROR );
   if( iRc2 )
     x.DisplayError( iRc2 );
 
-  x.DisplayTableList();
-
-
-  sSql = "DELETE FROM TestSqlR.DBF WHERE CITY='San Diego'";
+  sSql = "DELETE FROM AddressR.DBF WHERE CITY='San Diego'";
   iRc2 = sql.ExecuteNonQuery( sSql );
   iRc += TestMethod( po, "SqlDelete()", (xbInt32) iRc2, XB_NO_ERROR );
   if( iRc2 )
     x.DisplayError( iRc2 );
 
-  sSql = "UNDELETE FROM TestSqlR.DBF WHERE CITY='San Diego'";
+  sSql = "UNDELETE FROM AddressR.DBF WHERE CITY='San Diego'";
   iRc2 = sql.ExecuteNonQuery( sSql );
   iRc += TestMethod( po, "SqlUndelete()", (xbInt32) iRc2, XB_NO_ERROR );
   if( iRc2 )
     x.DisplayError( iRc2 );
 
-  sSql = "DELETE FROM TestSqlR.DBF";
+  sSql = "DELETE FROM AddressR.DBF";
   iRc2 = sql.ExecuteNonQuery( sSql );
   iRc += TestMethod( po, "SqlDelete()", (xbInt32) iRc2, XB_NO_ERROR );
   if( iRc2 )
     x.DisplayError( iRc2 );
 
-  sSql = "UNDELETE FROM TestSqlR.DBF";
+  sSql = "UNDELETE FROM AddressR.DBF";
   iRc2 = sql.ExecuteNonQuery( sSql );
   iRc += TestMethod( po, "SqlDelete()", (xbInt32) iRc2, XB_NO_ERROR );
   if( iRc2 )
     x.DisplayError( iRc2 );
 
 
-  sSql = "DELETE FROM TestSqlR.DBF WHERE BAD='EXPRESSION'";
+  iRc2 = SqlDbfZ.CreateTable( "ZipCode.DBF", "", MyZipRecord, XB_OVERLAY, XB_MULTI_USER );
+  iRc += TestMethod( po, "CreateTable()", (xbInt32) iRc2, XB_NO_ERROR );
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+
+//  sSql = "INSERT INTO ZipCode.DBF ( ZIPCODE, CITY, STATE ) VALUES ( 75087, 'Rockwall', 'TX' )";
+
+
+//  std::cout << "---------------------------------------------------------\n";
+//  std::cout << sSql.Str() << "\n";
+
+  sSql = "INSERT INTO ZipCode ( CITY ) VALUES ( 'city' )";
+  iRc2 = sql.ExecuteNonQuery( sSql );
+
+
+  iRc += TestMethod( po, "SqlInsert()", (xbInt32) iRc2, XB_NO_ERROR );
+  if( iRc2 )
+    x.DisplayError( iRc2 );
+
+
+
+//**************** work in progress
+
+/*
+  sSql = "DELETE FROM AddressR.DBF WHERE BAD='EXPRESSION'";
   iRc2 = sql.ExecuteNonQuery( sSql );
   iRc += TestMethod( po, "SqlDelete()", (xbInt32) iRc2, XB_INVALID_FIELD_NAME );
+*/
 //  if( iRc2 )
 //    x.DisplayError( iRc2 );
 
 
-//  sSql = "SELECT CITY, STATE ZIPCODE FROM TestSQL.DBF WHERE CITY IS NOT NULL";
-//  iRc += TestMethod( po, "Select()", SqlDbf.Select( sSql ), XB_NO_ERROR );
-
 
   iRc += TestMethod( po, "Close()", SqlDbf.Close(), XB_NO_ERROR );
+  iRc += TestMethod( po, "Close()", SqlDbfZ.Close(), XB_NO_ERROR );
+
+
+//  return 0;
+
+//  std::cout << "---------------------------------------------------------\n";
+
+  xbStmt sqlQry1( &x );
+//  sSql = "SELECT CITY, STATE, ZIPCODE FROM Address.DBF T LEFT JOIN LJ.DBF LJ WHERE CITY IS NOT NULL ORDER BY 2 GROUP BY STATE HAVING ZIPCODE .NOT. NULL";
+//  sSql = "SELECT CITY, STATE, ZIPCODE FROM AddressR.DBF T WHERE CITY IS NOT NULL ORDER BY 2 GROUP BY STATE HAVING ZIPCODE .NOT. NULL";
+
+//  sSql = "SELECT CITY, STATE, ZIPCODE FROM AddressR A LEFT JOIN ZipCode Z ON A.ZIPCODE = Z.ZIPCODE  WHERE CITY IS NOT NULL ORDER BY 2 GROUP BY STATE HAVING ZIPCODE .NOT. NULL";
+//  sSql = "SELECT M.ID, M.LEFTFK0, L0.CFLD FROM MAIN0 M LEFT JOIN LEFT0 L0 ON M.LEFTFK0 = L0.LEFTFK0 WHERE M.ID IS NOT NULL";
+  iRc += TestMethod( po, "Select()", sqlQry1.ExecuteQuery( sSql ), XB_NO_ERROR );
+
+  sqlQry1.DumpStmtInternals();
+
+  // sqlQry1.Test();
+
+
+  x.DisplayTableList();
+
 
   if( po > 0 || iRc < 0 )
     fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
diff --git a/src/tests/xb_test_string.cpp b/src/tests/xb_test_string.cpp
index 9d730db..2f01e51 100755
--- a/src/tests/xb_test_string.cpp
+++ b/src/tests/xb_test_string.cpp
@@ -2,7 +2,7 @@
 
 XBase63 Software Library
 
-Copyright (c) 1997,2003,2014, 2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -46,6 +46,7 @@ int main( int argCnt, char **av = NULL )
   xbString sMsg;
 
   #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( po ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
@@ -55,7 +56,6 @@ int main( int argCnt, char **av = NULL )
   #endif
 
   x.SetDataDirectory( PROJECT_DATA_DIR );
-  x.EnableMsgLogging();
 
   InitTime();
 
@@ -260,6 +260,13 @@ int main( int argCnt, char **av = NULL )
   rc += TestMethod( po, "Pos(\"000\") ", (xbInt32) s1.Pos( "000" ), 0 );
   rc += TestMethod( po, "Pos(\"DEF\") ", (xbInt32) s1.Pos( "DEF" ), 1 );
 
+  s1 = "ABC.123.abc";
+  rc += TestMethod( po, "Pos( '.', 4 )", (xbInt32) s1.Pos( '.', 4 ), 4 );
+  rc += TestMethod( po, "Pos( '.', 5 )", (xbInt32) s1.Pos( '.', 5 ), 8 );
+  rc += TestMethod( po, "Pos( '.', 9 )", (xbInt32) s1.Pos( '.', 9 ), 0 );
+
+
+
   s1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
   rc += TestMethod( po, "Remove(3,5) ", s1.Remove( 3, 5 ), "ABHIJKLMNOPQRSTUVWXYZ", 21 );
 
diff --git a/src/tests/xb_test_tblmgr.cpp b/src/tests/xb_test_tblmgr.cpp
index 451432c..d048594 100755
--- a/src/tests/xb_test_tblmgr.cpp
+++ b/src/tests/xb_test_tblmgr.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014, 2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -13,7 +13,7 @@ Email Contact:
 
 */
 
-// This program tests the class xbXBase
+// This program tests the table manager functions.
 // usage:   xb_test_tblmgr QUITE|NORMAL|VERBOSE
 
 
@@ -25,33 +25,35 @@ using namespace xb;
 
 int main( int argCnt, char **av )
 {
-  int rc = 0;
-  int po = 1;          /* print option */
+  int iRc = 0;
+  int iPo = 1;          /* print option */
                        /* 0 - QUIET    */
                        /* 1 - NORMAL   */
                        /* 2 - VERBOSE  */
 
   if( argCnt > 1 ) {
     if( av[1][0] == 'Q' )
-      po = 0;
+      iPo = 0;
     else if( av[1][0] == 'V' )
-      po = 2;
+      iPo = 2;
   }
 
   xbXBase x;
 
-#ifdef XB_LOGGING_SUPPORT
+  #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
-  if( po ){
+  if( iPo ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
   }
   xbString sMsg;
   sMsg.Sprintf( "Program [%s] initializing...", av[0] );
   x.WriteLogMessage( sMsg );
-#endif
+  #endif
+
   InitTime();
 
-  if( po == 2 ){
+  if( iPo == 2 ){
     std::cout << "DisplayError Test ==> ";
     x.DisplayError( 0 );
     #ifdef WIN32
@@ -73,14 +75,14 @@ int main( int argCnt, char **av )
     return -1;
   #endif
 
-  rc += TestMethod( po, "AddTblToTblLst()", x.AddTblToTblList( d1, "TestTableC" ), 0 );
-  rc += TestMethod( po, "AddTblToTblLst()", x.AddTblToTblList( d1, "TestTableA" ), 0 );
-  rc += TestMethod( po, "AddTblToTblLst()", x.AddTblToTblList( d1, "TestTableB" ), 0 );
-  rc += TestMethod( po, "AddTblToTblLst()", x.AddTblToTblList( d1, "TestTableD" ), 0 );
+  iRc += TestMethod( iPo, "AddTblToTblLst()", x.AddTblToTblList( d1, "TestTableC" ), 0 );
+  iRc += TestMethod( iPo, "AddTblToTblLst()", x.AddTblToTblList( d1, "TestTableA" ), 0 );
+  iRc += TestMethod( iPo, "AddTblToTblLst()", x.AddTblToTblList( d1, "TestTableB" ), 0 );
+  iRc += TestMethod( iPo, "AddTblToTblLst()", x.AddTblToTblList( d1, "TestTableD" ), 0 );
 
 
   // Next line should generate an exception
-  rc += TestMethod( po, "AddTblToTblLst()", x.AddTblToTblList( d1, "TestTableC" ), XB_DUP_TABLE_OR_ALIAS );
+  iRc += TestMethod( iPo, "AddTblToTblLst()", x.AddTblToTblList( d1, "TestTableC" ), XB_DUP_TABLE_OR_ALIAS );
 
   std::cout << "**** Next list should have one each of TestTableA, B, C, D sorted in alpha order ****" << std::endl;
   x.DisplayTableList();
@@ -90,7 +92,7 @@ int main( int argCnt, char **av )
     std::cout << "[PASS] GetDbfPtr()" << std::endl;
   else{
     std::cout << "[FAIL] GetDbfPtr()" << std::endl;
-    rc--;
+    iRc--;
   }
 
 
@@ -98,70 +100,59 @@ std::cout << "cp0\n";
   x.SetDataDirectory( "/ABCDEFG/" );
 
   #ifdef WIN32
-    rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "\\ABCDEFG\\", 9 );
+    iRc += TestMethod( iPo, "Set/GetDataDirectory()", x.GetDataDirectory(),  "\\ABCDEFG\\", 9 );
   #else
-    rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "/ABCDEFG/", 9 );
+    iRc += TestMethod( iPo, "Set/GetDataDirectory()", x.GetDataDirectory(),  "/ABCDEFG/", 9 );
   #endif
 std::cout << "cp1\n";
   x.SetDataDirectory( "/ABCDEFG" );
   #ifdef WIN32
-    rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "\\ABCDEFG", 8 );
+    iRc += TestMethod( iPo, "Set/GetDataDirectory()", x.GetDataDirectory(),  "\\ABCDEFG", 8 );
   #else
-    rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "/ABCDEFG", 8 );
+    iRc += TestMethod( iPo, "Set/GetDataDirectory()", x.GetDataDirectory(),  "/ABCDEFG", 8 );
   #endif
 
 
-  std::cout << "cp2\n";
-
-
   x.SetDataDirectory( "\\ABCDEFG\\");
   #ifdef WIN32
-    rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "\\ABCDEFG\\", 9 );
+    iRc += TestMethod( iPo, "Set/GetDataDirectory()", x.GetDataDirectory(),  "\\ABCDEFG\\", 9 );
   #else
-    rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "/ABCDEFG/", 9 );
+    iRc += TestMethod( iPo, "Set/GetDataDirectory()", x.GetDataDirectory(),  "/ABCDEFG/", 9 );
   #endif
 
-  std::cout << "cp3\n";
-
-
   x.SetDataDirectory( "\\ABCDEFG" );
   #ifdef WIN32
-    rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "\\ABCDEFG", 8 );
+    iRc += TestMethod( iPo, "Set/GetDataDirectory()", x.GetDataDirectory(),  "\\ABCDEFG", 8 );
   #else
-    rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "/ABCDEFG", 8 );
+    iRc += TestMethod( iPo, "Set/GetDataDirectory()", x.GetDataDirectory(),  "/ABCDEFG", 8 );
   #endif
 
-
-  std::cout << "cp4\n";
-
-
   x.SetDataDirectory( "ABCDEFG" );
-  rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(),  "ABCDEFG", 7 );
-
+  iRc += TestMethod( iPo, "Set/GetDataDirectory()", x.GetDataDirectory(),  "ABCDEFG", 7 );
 
-  rc += TestMethod( po, "RemoveTblFromDbList()", x.RemoveTblFromTblList( "TestTableB" ), 0 );
-  rc += TestMethod( po, "RemoveTblFromDbList()", x.RemoveTblFromTblList( "TestTableB" ), XB_NOT_FOUND );
+  iRc += TestMethod( iPo, "RemoveTblFromDbList()", x.RemoveTblFromTblList( "TestTableB" ), 0 );
+  iRc += TestMethod( iPo, "RemoveTblFromDbList()", x.RemoveTblFromTblList( "TestTableB" ), XB_NOT_FOUND );
   std::cout << "**** Next list should not have TestTableB in it ****" << std::endl;
   x.DisplayTableList();
 
 
-  rc += TestMethod( po, "RemoveTblFromDbList()", x.RemoveTblFromTblList( "TestTableA" ), 0 );
-  rc += TestMethod( po, "RemoveTblFromDbList()", x.RemoveTblFromTblList( "TestTableC" ), 0 );
-  rc += TestMethod( po, "RemoveTblFromDbList()", x.RemoveTblFromTblList( "TestTableD" ), 0 );
+  iRc += TestMethod( iPo, "RemoveTblFromDbList()", x.RemoveTblFromTblList( "TestTableA" ), 0 );
+  iRc += TestMethod( iPo, "RemoveTblFromDbList()", x.RemoveTblFromTblList( "TestTableC" ), 0 );
+  iRc += TestMethod( iPo, "RemoveTblFromDbList()", x.RemoveTblFromTblList( "TestTableD" ), 0 );
 
 
   delete d1;
 
-  if( po > 0 || rc < 0 )
-    fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+  if( iPo > 0 || iRc < 0 )
+    fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
 
 
 #ifdef XB_LOGGING_SUPPORT
-  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
+  sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
   x.WriteLogMessage( sMsg );
 #endif
 
 
-  return rc;
+  return iRc;
 }
 
diff --git a/src/tests/xb_test_uda.cpp b/src/tests/xb_test_uda.cpp
index dec41fa..18693b5 100755
--- a/src/tests/xb_test_uda.cpp
+++ b/src/tests/xb_test_uda.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014, 2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -45,7 +45,8 @@ int main( int argCnt, char **av )
 
 
   xbXBase x;
-#ifdef XB_LOGGING_SUPPORT
+  #ifdef XB_LOGGING_SUPPORT
+  x.SetLogDirectory( PROJECT_LOG_DIR );
   x.EnableMsgLogging();
   if( po ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
@@ -53,11 +54,9 @@ int main( int argCnt, char **av )
   xbString sMsg;
   sMsg.Sprintf( "Program [%s] initializing...", av[0] );
   x.WriteLogMessage( sMsg );
-#endif
-
+  #endif
 
   x.SetDataDirectory( PROJECT_DATA_DIR );
-  x.EnableMsgLogging();
 
   xbUda uda;
   iRc += TestMethod( po, "GetTokencCnt()",  uda.GetTokenCnt(), 0 );
diff --git a/src/tests/xb_test_xbase.cpp b/src/tests/xb_test_xbase.cpp
index 9d523c5..4751c25 100755
--- a/src/tests/xb_test_xbase.cpp
+++ b/src/tests/xb_test_xbase.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014, 2022 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under the terms of the GPL Version 3, 2007 license.
 
@@ -27,26 +27,34 @@ using namespace xb;
 int main( int argCnt, char **av )
 {
   int iRc = 0;
-  int po = 1;          /* print option */
+  int iPo = 1;          /* print option */
                        /* 0 - QUIET    */
                        /* 1 - NORMAL   */
                        /* 2 - VERBOSE  */
 
   if( argCnt > 1 ) {
     if( av[1][0] == 'Q' )
-      po = 0;
+      iPo = 0;
     else if( av[1][0] == 'V' )
-      po = 2;
+      iPo = 2;
   }
 
   xbXBase x;
   xbString sMsg;
 
   #ifdef XB_LOGGING_SUPPORT
+
+
+  xbString sLogDir = PROJECT_LOG_DIR;
+//  x.SetLogDirectory( sLogDir );
+  x.SetLogDirectory( PROJECT_LOG_DIR );
+
+
   x.EnableMsgLogging();
-  if( po ){
+  if( iPo ){
     std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
   }
+
   sMsg.Sprintf( "Program [%s] initializing...", av[0] );
   x.WriteLogMessage( sMsg );
   #endif
@@ -54,8 +62,8 @@ int main( int argCnt, char **av )
 
 
   x.SetDefaultDateFormat( "YY-MM-DD" );
-  iRc += TestMethod( po, "SetDefaultDateFormat", x.GetDefaultDateFormat(), "YY-MM-DD", 8 );
-  if( po == 2 ){
+  iRc += TestMethod( iPo, "SetDefaultDateFormat", x.GetDefaultDateFormat(), "YY-MM-DD", 8 );
+  if( iPo == 2 ){
     if( x.GetEndianType() == 'L' )
       std::cout << "Little Endian Architecture" << std::endl;
     else if( x.GetEndianType() == 'B' )
@@ -64,38 +72,32 @@ int main( int argCnt, char **av )
       std::cout << "Undefine Endian Architecture" << std::endl;
   }
 
-  iRc += TestMethod( po, "GetErrorMessage", x.GetErrorMessage( XB_DBF_FILE_NOT_OPEN ), "DBF File Not Open", 17 );
+  iRc += TestMethod( iPo, "GetErrorMessage", x.GetErrorMessage( XB_DBF_FILE_NOT_OPEN ), "DBF File Not Open", 17 );
 
 
   #ifdef XB_LOGGING_SUPPORT
-  xbString sLogDir = PROJECT_LOG_DIR;
-  iRc += TestMethod( po, "GetDefaultLogDirectory()", x.GetDefaultLogDirectory(), sLogDir, sLogDir.Len());
-
+  iRc += TestMethod( iPo, "GetLogDirectory()", x.GetLogDirectory(), sLogDir, sLogDir.Len());
   xbString sLogName = CMAKE_SYSTEM_NAME;
   sLogName += "_";
   sLogName += XB_PLATFORM;
   sLogName += ".xbLog.txt";
-  iRc += TestMethod( po, "GetDefaultLogFileName()", x.GetDefaultLogFileName(), sLogName, sLogName.Len());
-
-  x.WriteLogMessage( "test" );
+  iRc += TestMethod( iPo, "GetLogFileName()", x.GetLogFileName(), sLogName, sLogName.Len());
+  x.WriteLogMessage( "Program xb_test_xbase - test logfile message" );
   #endif
 
   x.xbSleep( 250 );
-
-
-  if( po == 2 ){
+  if( iPo == 2 ){
     std::cout << "DisplayError Test ==> ";
     x.DisplayError( 0 );
   }
-
-  if( po > 0 || iRc < 0 )
+  if( iPo > 0 || iRc < 0 )
     fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
 
 
-#ifdef XB_LOGGING_SUPPORT
+  #ifdef XB_LOGGING_SUPPORT
   sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
   x.WriteLogMessage( sMsg );
-#endif
+  #endif
 
   return iRc;
 }
diff --git a/src/utils/xb_cfg_check.cpp b/src/utils/xb_cfg_check.cpp
index 25ca46c..5489c51 100755
--- a/src/utils/xb_cfg_check.cpp
+++ b/src/utils/xb_cfg_check.cpp
@@ -1,3 +1,19 @@
+/*  xb_cfg_check.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2019,2023 Gary A Kunkel
+
+The xb64 software library is covered under 
+the terms of the GPL Version 3, 2007 license.
+
+Email Contact:
+
+    xb64-devel@lists.sourceforge.net
+    xb64-users@lists.sourceforge.net
+
+*/
+
 
 #include <stdio.h>
 #include <stdlib.h>
@@ -23,7 +39,7 @@ int main()
   fprintf( stdout, "CMAKE C FLAGS           = [%s]\n", CMAKE_C_FLAGS );
   fprintf( stdout, "CMAKE C FLAGS DEBUG     = [%s]\n", CMAKE_C_FLAGS_DEBUG );
   fprintf( stdout, "CMAKE C FLAGS RELEASE   = [%s]\n", CMAKE_C_FLAGS_RELEASE );
-  
+
 
   #ifdef XB_PLATFORM_32
     fprintf( stdout, "XB_PLATFORM_32          = [TRUE]\n" );
@@ -124,13 +140,13 @@ int main()
     fprintf( stdout, "XB_INDEX_SUPPORT        = [OFF]\n" );
   #endif
 
-  #ifdef XB_INDEX_SUPPORT
+  #ifdef XB_NDX_SUPPORT
     fprintf( stdout, "XB_NDX_SUPPORT          = [ON]\n" );
   #else
     fprintf( stdout, "XB_NDX_SUPPORT          = [OFF]\n" );
   #endif
 
-  #ifdef XB_INDEX_SUPPORT
+  #ifdef XB_MDX_SUPPORT
     fprintf( stdout, "XB_MDX_SUPPORT          = [ON]\n" );
   #else
     fprintf( stdout, "XB_MDX_SUPPORT          = [OFF]\n" );
@@ -142,6 +158,24 @@ int main()
     fprintf( stdout, "XB_SQL_SUPPORT          = [OFF]\n" );
   #endif
 
+  #ifdef XB_INF_SUPPORT
+    fprintf( stdout, "XB_INF_SUPPORT          = [ON]\n" );
+  #else
+    fprintf( stdout, "XB_INF_SUPPORT          = [OFF]\n" );
+  #endif
+
+  #ifdef XB_FILTER_SUPPORT
+    fprintf( stdout, "XB_FILTER_SUPPORT       = [ON]\n" );
+  #else
+    fprintf( stdout, "XB_FILTER_SUPPORT       = [OFF]\n" );
+  #endif
+
+  #ifdef XB_BLOCKREAD_SUPPORT
+    fprintf( stdout, "XB_BLOCKREAD_SUPPORT    = [ON]\n" );
+  #else
+    fprintf( stdout, "XB_BLOCKREAD_SUPPORT    = [OFF]\n" );
+  #endif
+
 
   fprintf( stdout, "\nDirectories:\n" );
   fprintf( stdout, "HOME_DIRECTORY                 = [%s]\n",   CMAKE_HOME_DIRECTORY );
@@ -159,32 +193,32 @@ int main()
 
   fprintf( stdout, "Field sizes:\n" );
   fprintf( stdout, "SIZEOF_VOID_P         = [%s]\n", CMAKE_SIZEOF_VOID_P );
-  fprintf( stdout, "sizeof(char *)        = [%ld]\n", sizeof( char *));
-  fprintf( stdout, "sizeof(int)           = [%ld]\n", sizeof( int ));
-  fprintf( stdout, "sizeof(long)          = [%ld]\n", sizeof( long ));
-  fprintf( stdout, "sizeof(char)          = [%ld]\n", sizeof( char ));
+  fprintf( stdout, "sizeof(char *)        = [%zd]\n", sizeof( char *));
+  fprintf( stdout, "sizeof(int)           = [%zd]\n", sizeof( int ));
+  fprintf( stdout, "sizeof(long)          = [%zd]\n", sizeof( long ));
+  fprintf( stdout, "sizeof(char)          = [%zd]\n", sizeof( char ));
   #ifdef HAVE_WCHAR_H
-  fprintf( stdout, "sizeof(wchar_t)       = [%ld]\n", sizeof( wchar_t ));
+  fprintf( stdout, "sizeof(wchar_t)       = [%zd]\n", sizeof( wchar_t ));
   #endif
 
   #ifdef HAVE_WINDOWS_H
-  fprintf( stdout, "sizeof(DWORD)         = [%ld]\n", sizeof( DWORD ));
-  #endif
-
-  fprintf( stdout, "sizeof(double)        = [%ld]\n", sizeof( double ));
-  fprintf( stdout, "sizeof(float)         = [%ld]\n", sizeof( float ));
-  fprintf( stdout, "sizeof(size_t)        = [%ld]\n", sizeof( size_t ));
-  fprintf( stdout, "sizeof(off_t)         = [%ld]\n\n", sizeof( off_t ));
-
-  fprintf( stdout, "sizeof(xbBool)        = [%ld]\n", sizeof( xbBool ));
-  fprintf( stdout, "sizeof(xbInt16)       = [%ld]\n", sizeof( xbInt16 ));
-  fprintf( stdout, "sizeof(xbUInt16)      = [%ld]\n", sizeof( xbUInt16 ));
-  fprintf( stdout, "sizeof(xbInt32)       = [%ld]\n", sizeof( xbInt32 ));
-  fprintf( stdout, "sizeof(xbUInt32)      = [%ld]\n", sizeof( xbUInt32 ));
-  fprintf( stdout, "sizeof(xbInt64)       = [%ld]\n", sizeof( xbInt64 ));
-  fprintf( stdout, "sizeof(xbUInt64)      = [%ld]\n", sizeof( xbUInt64 ));
-  fprintf( stdout, "sizeof(xbFloat)       = [%lu]\n", sizeof( xbFloat ));
-  fprintf( stdout, "sizeof(xbDouble)      = [%lu]\n", sizeof( xbDouble ));
+  fprintf( stdout, "sizeof(DWORD)         = [%zd]\n", sizeof( DWORD ));
+  #endif
+
+  fprintf( stdout, "sizeof(double)        = [%zd]\n", sizeof( double ));
+  fprintf( stdout, "sizeof(float)         = [%zd]\n", sizeof( float ));
+  fprintf( stdout, "sizeof(size_t)        = [%zd]\n", sizeof( size_t ));
+  fprintf( stdout, "sizeof(off_t)         = [%zd]\n\n", sizeof( off_t ));
+
+  fprintf( stdout, "sizeof(xbBool)        = [%zd]\n", sizeof( xbBool ));
+  fprintf( stdout, "sizeof(xbInt16)       = [%zd]\n", sizeof( xbInt16 ));
+  fprintf( stdout, "sizeof(xbUInt16)      = [%zd]\n", sizeof( xbUInt16 ));
+  fprintf( stdout, "sizeof(xbInt32)       = [%zd]\n", sizeof( xbInt32 ));
+  fprintf( stdout, "sizeof(xbUInt32)      = [%zd]\n", sizeof( xbUInt32 ));
+  fprintf( stdout, "sizeof(xbInt64)       = [%zd]\n", sizeof( xbInt64 ));
+  fprintf( stdout, "sizeof(xbUInt64)      = [%zd]\n", sizeof( xbUInt64 ));
+  fprintf( stdout, "sizeof(xbFloat)       = [%zu]\n", sizeof( xbFloat ));
+  fprintf( stdout, "sizeof(xbDouble)      = [%zu]\n", sizeof( xbDouble ));
 
 
   fprintf( stdout, "\nHeader files:\n" );
diff --git a/src/utils/xb_copydbf.cpp b/src/utils/xb_copydbf.cpp
index 1f88eb9..2466b1b 100755
--- a/src/utils/xb_copydbf.cpp
+++ b/src/utils/xb_copydbf.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2019 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2019,2023 Gary A Kunkel
 
 The xb64 software library is covered under 
 the terms of the GPL Version 3, 2007 license.
@@ -17,42 +17,80 @@ Email Contact:
 #include <xbase.h>
 using namespace xb;
 
-int main(int ac,char** av)
+
+void PrintHelp();
+void PrintHelp(){
+  std::cout << "Usage: xb_copydbf [-h] [-?] [--help] [-v] [--version] -s source.DBF -t target.DBF"  << std::endl << std::endl;
+  std::cout << "This program copies the structure of a table defined in source.DBF to target.DBF.  Data and indices are not included.";
+  std::cout << std::endl << std::endl;
+}
+void PrintVersion();
+void PrintVersion(){
+  std::cout << "Xbase64 Version: " << xbase_VERSION_MAJOR << "." << xbase_VERSION_MINOR << "." << xbase_VERSION_PATCH << std::endl;
+}
+
+
+int main(int argc, char *argv[])
 {
-  if (3 != ac) {
-    std::cout <<
-    "\nUsage: xb_copydbf filename1 filename2\n"
-    "This program copies the structure of one dbf file to another\n";
+
+  xbXBase x;
+  xbInt16 iRc;
+  xbDbf *dSrc = NULL;
+  xbDbf *dTrg = NULL;
+
+  xbString sParm;
+  xbString sSrcDbf;
+  xbString sTrgDbf;
+
+  if (argc < 2 || x.GetCmdLineOpt( argc, argv, "-h", sParm ) ||
+                  x.GetCmdLineOpt( argc, argv, "-?", sParm ) ||
+                  x.GetCmdLineOpt( argc, argv, "--help", sParm )){
+    PrintHelp();
+    return 1;
+  }
+
+  if ( x.GetCmdLineOpt( argc, argv, "-v", sParm ) ||
+       x.GetCmdLineOpt( argc, argv, "--version", sParm )){
+    PrintVersion();
     return 1;
   }
 
-  char* sFileName = av[1];
-  char* tFileName = av[2];
+  if( !x.GetCmdLineOpt( argc, argv, "-s", sSrcDbf ) || sSrcDbf == "" ){
+    PrintHelp();
+    return 1;
+  }
 
-  xbXBase x;
-  xbInt16 iRc;
-  xbDbf *MyFile = NULL;
-  xbDbf *MyNewFile = NULL;
+  if( !x.GetCmdLineOpt( argc, argv, "-t", sTrgDbf ) || sTrgDbf == "" ){
+    PrintHelp();
+    return 1;
+  }
 
   #ifdef XB_LOGGING_SUPPORT
   x.EnableMsgLogging();
   xbString sMsg;
-  sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+  sMsg.Sprintf( "Program [%s] initializing...", argv[0] );
   x.WriteLogMessage( sMsg );
   #endif
 
-  if(( iRc = x.OpenHighestVersion( sFileName, "", &MyFile )) != XB_NO_ERROR ){
-    std::cout << "Could not open file iRc = " << iRc  << " file = "  << sFileName << std::endl;
+  if(( iRc = x.OpenHighestVersion( sSrcDbf, "", &dSrc )) != XB_NO_ERROR ){
+    std::cout << "Could not open file iRc = " << iRc  << " file = "  << sSrcDbf.Str() << std::endl;
     x.DisplayError( iRc );
-    return 0;
+    return 1;
   }
 
-  if(( iRc = MyFile->CopyDbfStructure( MyNewFile, tFileName, tFileName, XB_DONTOVERLAY, XB_SINGLE_USER )) != XB_NO_ERROR ){
-      std::cout << "Could not copy file " << tFileName << " Error = " << iRc  << "\n";
-      return 3;
+  #ifdef XB_DBF4_SUPPORT
+  dTrg = new xbDbf4( &x );
+  #else
+  dTrg = new xbDbf3( &x );
+  #endif
+
+  if(( iRc = dSrc->CopyDbfStructure( dTrg, sTrgDbf, sTrgDbf, XB_DONTOVERLAY, XB_SINGLE_USER )) != XB_NO_ERROR ){
+      std::cout << "Could not copy file " << sTrgDbf.Str() << " Error = " << iRc  << "\n";
+      x.DisplayError( iRc );
+      return 1;
   }
 
-  MyFile->Close();
+  x.CloseAllTables();
   return 0;
 }
 
diff --git a/src/utils/xb_dbfutil.cpp b/src/utils/xb_dbfutil.cpp
index 9c04fe3..e50495e 100755
--- a/src/utils/xb_dbfutil.cpp
+++ b/src/utils/xb_dbfutil.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2021 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2021,2022,2023 Gary A Kunkel
 
 The xb64 software library is covered under 
 the terms of the GPL Version 3, 2007 license.
@@ -29,11 +29,13 @@ using namespace xb;
 ///@cond DOXYOFF
 class xbUtil{
  public:
-   xbUtil();
+   xbUtil( xbXBase *x );
    ~xbUtil();
    xbDbf  *GetTablePtr( const char * cTitle );
    void    DisplayActiveTable() const;
 
+   void    Help();
+
    // menus
    xbInt16 GetOption();
    xbInt32 GetLong();
@@ -215,8 +217,8 @@ class xbUtil{
 
 
  private:
-   xbXBase x;
-   xbDbf * dActiveTable;
+   xbXBase *x;
+   xbDbf   *dActiveTable;
 
    #ifdef XB_EXPRESSION_SUPPORT
    xbExp *exp;
@@ -233,18 +235,19 @@ class xbUtil{
 };
 
 /*************************************************************************************/
-xbUtil::xbUtil()
+xbUtil::xbUtil( xbXBase *x )
 {
+  this->x = x;
   dActiveTable = NULL;
-  x.EnableMsgLogging();
-  x.SetLogSize( 10000000L );
+  x->EnableMsgLogging();
+  x->SetLogSize( 10000000L );
 
   #ifdef XB_EXPRESSION_SUPPORT
   exp = NULL;
   #endif
 
   #ifdef XB_SQL_SUPPORT
-  sql = new xbSql( &x );
+  sql = new xbSql( x );
   #endif // XB_SQL_SUPPORT
 
   #ifdef XB_FILTER_SUPPORT
@@ -256,7 +259,7 @@ xbUtil::xbUtil()
 /*************************************************************************************/
 xbUtil::~xbUtil(){
 
-  x.CloseAllTables();
+  x->CloseAllTables();
 
   if( dActiveTable ) 
     delete dActiveTable;
@@ -272,6 +275,17 @@ xbUtil::~xbUtil(){
   #endif // XB_FILTER_SUPPORT
 }
 
+
+/*************************************************************************************/
+void xbUtil::Help(){
+  std::cout << "Program xb_dbfutil provides a menu driven application for accessing" << std::endl;
+  std::cout << "the xbase64 library functions." << std::endl << std::endl;
+  std::cout << "Menu choices can be selected directly with out accessing the given menus" << std::endl;
+  std::cout << "by entering a '=' followed by the menu choices.  For example, entering '=3.4'" << std::endl;
+  std::cout << "would be the same as going to menu #3 and entering a 4, which is the sequence" << std::endl;
+  std::cout << "for opening a file." << std::endl;
+}
+
 /*************************************************************************************/
 #ifdef XB_NDXINF_SUPPORT
 
@@ -294,7 +308,7 @@ void xbUtil::AddInfFileData()
   std::cout << "Enter NDX index file name (FILENAME.NDX)" << std::endl;
   std::cin.getline( cBuf, 128 );
   xbInt16 iRc = dActiveTable->AssociateIndex( "NDX", cBuf, 0 );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void xbUtil::DeleteInfFileData()
@@ -303,7 +317,7 @@ void xbUtil::DeleteInfFileData()
   std::cout << "Enter NDX index file name (FILENAME.NDX)" << std::endl;
   std::cin.getline( cBuf, 128 );
   xbInt16 iRc = dActiveTable->AssociateIndex( "NDX", cBuf, 1 );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void xbUtil::InfFileHelp()
@@ -329,7 +343,7 @@ void xbUtil::LockIndices(){
     return;
   }
   xbInt16 iRc = dActiveTable->LockIndices( XB_LOCK );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void xbUtil::UnlockIndices(){
@@ -343,7 +357,7 @@ void xbUtil::UnlockIndices(){
     return;
   }
   xbInt16 iRc = dActiveTable->LockIndices( XB_UNLOCK );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 #endif   // XB_LOCKING_SUPPORT
@@ -381,11 +395,11 @@ void xbUtil::ParseExpression( xbInt16 iOption ){
     exp = NULL;
   }
 
-  exp = new xbExp( &x, dActiveTable );
+  exp = new xbExp( x, dActiveTable );
   iRc = exp->ParseExpression( sExpression );
 
   if( iOption == 0 )
-    x.DisplayError( iRc );
+    x->DisplayError( iRc );
 }
 
 /*************************************************************************************/
@@ -404,7 +418,7 @@ void xbUtil::ProcessParsedExpression( xbInt16 iOption ){
 
  xbInt16 iRc = exp->ProcessExpression();
  if( iRc != XB_NO_ERROR ){
-   x.DisplayError( iRc );
+   x->DisplayError( iRc );
    return;
  }
 
@@ -496,7 +510,7 @@ void xbUtil::IsLeapYear(){
 #ifdef XB_SQL_SUPPORT
 void xbUtil::ExecSqlNonQuery(){
 
-  xbSql sql( &x );
+  xbSql sql( x );
   std::cout << "ExecSqlNonQuery\n";
 
   char sSql[2048];
@@ -504,7 +518,7 @@ void xbUtil::ExecSqlNonQuery(){
   std::cin.getline( sSql, 2048 );
 
   xbInt16 iRc = sql.ExecuteNonQuery( sSql );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void xbUtil::ExecSqlQuery(){
@@ -681,7 +695,7 @@ void xbUtil::LockDbf(){
   xbInt16 iRc;
   std::cout << std::endl << "Lock Table"  << std::endl;
   iRc = dActiveTable->LockTable( XB_LOCK );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void xbUtil::LockAppend(){
@@ -696,7 +710,7 @@ void xbUtil::LockAppend(){
   xbInt16 iRc;
   std::cout << std::endl << "Lock Append"  << std::endl;
   iRc = dActiveTable->LockAppend( XB_LOCK );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void xbUtil::UnlockAppend(){
@@ -711,7 +725,7 @@ void xbUtil::UnlockAppend(){
   xbInt16 iRc;
   std::cout << std::endl << "Unlock Append"  << std::endl;
   iRc = dActiveTable->LockAppend( XB_UNLOCK );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 #ifdef XB_MEMO_SUPPORT
 void xbUtil::LockMemo(){
@@ -726,7 +740,7 @@ void xbUtil::LockMemo(){
   xbInt16 iRc;
   std::cout << std::endl << "Lock Memo"  << std::endl;
   iRc = dActiveTable->LockMemo( XB_LOCK );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void xbUtil::UnlockMemo(){
@@ -741,7 +755,7 @@ void xbUtil::UnlockMemo(){
   xbInt16 iRc;
   std::cout << std::endl << "Unlock Memo"  << std::endl;
   iRc = dActiveTable->LockMemo( XB_UNLOCK );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 #endif
 
@@ -760,8 +774,10 @@ void xbUtil::LockRecord(){
 
   char cBuf[15];
   std::cin.getline( cBuf, 15 );
-  iRc = dActiveTable->LockRecord( XB_LOCK, atol( cBuf ));
-  x.DisplayError( iRc );
+  //iRc = dActiveTable->LockRecord( XB_LOCK, atol( cBuf ));
+  iRc = dActiveTable->LockRecord( XB_LOCK, strtoul( cBuf, NULL, 0 ));
+  
+  x->DisplayError( iRc );
 }
 
 void xbUtil::UnlockRecord(){
@@ -779,8 +795,9 @@ void xbUtil::UnlockRecord(){
 
   char cBuf[15];
   std::cin.getline( cBuf, 15 );
-  iRc = dActiveTable->LockRecord( XB_UNLOCK, atol( cBuf ));
-  x.DisplayError( iRc );
+  //iRc = dActiveTable->LockRecord( XB_UNLOCK, atol( cBuf ));
+  iRc = dActiveTable->LockRecord( XB_UNLOCK, strtoul( cBuf, NULL, 0 ));
+  x->DisplayError( iRc );
 }
 
 void xbUtil::UnlockDbf(){
@@ -796,7 +813,7 @@ void xbUtil::UnlockDbf(){
   xbInt16 iRc;
   std::cout << std::endl << "Unlock Table" << std::endl;
   iRc = dActiveTable->LockTable( XB_UNLOCK );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void xbUtil::UnlockHeader(){
@@ -812,7 +829,7 @@ void xbUtil::UnlockHeader(){
   xbInt16 iRc;
   std::cout << std::endl << "Unlock Table Header" << std::endl;
   iRc = dActiveTable->LockHeader( XB_UNLOCK );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void xbUtil::LockHeader(){
@@ -826,7 +843,7 @@ void xbUtil::LockHeader(){
   xbInt16 iRc;
   std::cout << std::endl << "Lock Table Header" << std::endl;
   iRc = dActiveTable->LockHeader( XB_LOCK );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 #ifdef XB_DEBUG_SUPPORT
@@ -860,7 +877,7 @@ void xbUtil::xbFileLock(){
   s1 = cBufLen;
   s1.CvtLongLong( llLen );
   xbInt16 iRc = dActiveTable->xbLock( XB_LOCK, llSpos, (size_t) llLen );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void xbUtil::xbFileUnlock(){
@@ -884,7 +901,7 @@ void xbUtil::xbFileUnlock(){
   }
   xbInt16 iRc;
   iRc = dActiveTable->xbLock( XB_UNLOCK, atol( cBufOffset ), (size_t) atol( cBufLen ));
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 #endif
@@ -968,7 +985,7 @@ void xbUtil::UpdateFieldData(){
   std::cin.getline( cFldData,  256 );
 
   if(( rc = dActiveTable->PutField( cFldName, cFldData )) != XB_NO_ERROR ){
-    x.DisplayError( rc );
+    x->DisplayError( rc );
     return;
   }
   std::cout << "Success" << std::endl;
@@ -999,9 +1016,10 @@ void xbUtil::ShowMemoFieldData(){
       std::cout << "Record number not entered" << std::endl;
       return;
     }
-    ulRecNo = atol( cBuf );
+    //ulRecNo = atol( cBuf );
+    ulRecNo = strtoul( cBuf, NULL, 0 );
     if(( rc = dActiveTable->GetRecord( ulRecNo )) != XB_NO_ERROR ){
-      x.DisplayError( rc );
+      x->DisplayError( rc );
       return;
     }
   }
@@ -1009,12 +1027,12 @@ void xbUtil::ShowMemoFieldData(){
   std::cin.getline( cFldName,  40 );
   if(( rc = dActiveTable->GetMemoField( cFldName, sMemoData )) != XB_NO_ERROR ){
     std::cout << "rc = " << rc << std::endl;
-    x.DisplayError( rc );
+    x->DisplayError( rc );
     return;
   }
   if(( rc = dActiveTable->GetMemoFieldLen( cFldName, ulFldLen )) != XB_NO_ERROR ){
     std::cout << "rc = " << rc << std::endl;
-    x.DisplayError( rc );
+    x->DisplayError( rc );
     return;
   }
   std::cout << sMemoData.Str() << std::endl;
@@ -1047,9 +1065,10 @@ void xbUtil::UpdateMemoFieldData(){
       std::cout << "Record number not entered" << std::endl;
       return;
     }
-    ulRecNo = atol( cBuf );
+    //ulRecNo = atol( cBuf );
+    ulRecNo = strtoul( cBuf, NULL, 0 );
     if(( rc = dActiveTable->GetRecord( ulRecNo )) != XB_NO_ERROR ){
-      x.DisplayError( rc );
+      x->DisplayError( rc );
       return;
     }
   }
@@ -1059,13 +1078,13 @@ void xbUtil::UpdateMemoFieldData(){
   std::cin.getline( cMemoData,  2048 );
   if(( rc = dActiveTable->UpdateMemoField( cFldName, cMemoData )) != XB_NO_ERROR ){
     std::cout << "rc = " << rc << std::endl;
-    x.DisplayError( rc );
+    x->DisplayError( rc );
     return;
   }
 
   if(( rc = dActiveTable->PutRecord( dActiveTable->GetCurRecNo())) != XB_NO_ERROR ){
     std::cout << "rc = " << rc << std::endl;
-    x.DisplayError( rc );
+    x->DisplayError( rc );
     return;
   }
 }
@@ -1098,9 +1117,10 @@ void xbUtil::DeleteMemoField(){
       std::cout << "Record number not entered" << std::endl;
       return;
     }
-    ulRecNo = atol( cBuf );
+    //ulRecNo = atol( cBuf );
+    ulRecNo = strtoul( cBuf, NULL, 0 );
     if(( rc = dActiveTable->GetRecord( ulRecNo )) != XB_NO_ERROR ){
-      x.DisplayError( rc );
+      x->DisplayError( rc );
       return;
     }
   }
@@ -1108,12 +1128,12 @@ void xbUtil::DeleteMemoField(){
   std::cin.getline( cFldName,  40 );
   if(( rc = dActiveTable->UpdateMemoField( cFldName, "" )) != XB_NO_ERROR ){
     std::cout << "rc = " << rc << std::endl;
-    x.DisplayError( rc );
+    x->DisplayError( rc );
     return;
   }
   if(( rc = dActiveTable->PutRecord( dActiveTable->GetCurRecNo())) != XB_NO_ERROR ){
     std::cout << "rc = " << rc << std::endl;
-    x.DisplayError( rc );
+    x->DisplayError( rc );
     return;
   }
 }
@@ -1123,13 +1143,13 @@ void xbUtil::SelectActiveTable(){
 
   char cBuf[15];
   xbInt16 iLineNo;
-  if( x.GetOpenTableCount() == 0 ){
+  if( x->GetOpenTableCount() == 0 ){
     std::cout << "No open tables" << std::endl;
     std::cout << "Use menu option =3.4 to open a table" << std::endl;
     return;
   }
 
-  x.DisplayTableList();
+  x->DisplayTableList();
   std::cout << std::endl << "Enter line number:" << std::endl;
   std::cin.getline( cBuf,  15 );
   if( strlen( cBuf ) == 0 ){
@@ -1137,7 +1157,7 @@ void xbUtil::SelectActiveTable(){
     return;
   }
   iLineNo = atoi( cBuf );
-  dActiveTable = x.GetDbfPtr( iLineNo );
+  dActiveTable = x->GetDbfPtr( iLineNo );
 }
 
 /*************************************************************************************/
@@ -1157,7 +1177,7 @@ void xbUtil::CommitRecord(){
   if(( rc = dActiveTable->Commit()) == XB_NO_ERROR )
     std::cout << "Success" << std::endl;
   else
-    x.DisplayError( rc );
+    x->DisplayError( rc );
 }
 /*************************************************************************************/
 void xbUtil::AbortRecord(){
@@ -1176,14 +1196,14 @@ void xbUtil::AbortRecord(){
   if(( rc = dActiveTable->Abort()) == XB_NO_ERROR )
     std::cout << "Success" << std::endl;
   else
-    x.DisplayError( rc );
+    x->DisplayError( rc );
 }
 /*************************************************************************************/
 void xbUtil::DumpRecord(){
 
   char    cBuf[15];
   xbInt16 rc;
-  xbUInt32 lRecNo;
+  xbUInt32 ulRecNo;
   if( !dActiveTable )
     dActiveTable = GetTablePtr( " - select table" );
   if( !dActiveTable ){
@@ -1199,9 +1219,10 @@ void xbUtil::DumpRecord(){
       std::cout << "Record number not entered" << std::endl;
       return;
     }
-    lRecNo = atol( cBuf );
-    if(( rc = dActiveTable->GetRecord( lRecNo )) != XB_NO_ERROR ){
-      x.DisplayError( rc );
+    //lRecNo = atol( cBuf );
+    ulRecNo = strtoul( cBuf, NULL, 0 );
+    if(( rc = dActiveTable->GetRecord( ulRecNo )) != XB_NO_ERROR ){
+      x->DisplayError( rc );
       return;
     }
   }
@@ -1209,7 +1230,7 @@ void xbUtil::DumpRecord(){
   if(( rc = dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2 )) == XB_NO_ERROR )
     std::cout << "Success" << std::endl;
   else
-    x.DisplayError( rc );
+    x->DisplayError( rc );
 }
 /*************************************************************************************/
 void xbUtil::GetFirstRecord(){
@@ -1227,7 +1248,7 @@ void xbUtil::GetFirstRecord(){
   if(( iRc = dActiveTable->GetFirstRecord()) == XB_NO_ERROR )
     dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
   else
-    x.DisplayError( iRc );
+    x->DisplayError( iRc );
 }
 /*************************************************************************************/
 void xbUtil::GetNextRecord(){
@@ -1242,7 +1263,7 @@ void xbUtil::GetNextRecord(){
   if(( iRc = dActiveTable->GetNextRecord()) == XB_NO_ERROR )
     dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
   else
-    x.DisplayError( iRc );
+    x->DisplayError( iRc );
 }
 /*************************************************************************************/
 void xbUtil::GetPrevRecord(){
@@ -1257,7 +1278,7 @@ void xbUtil::GetPrevRecord(){
   if(( iRc = dActiveTable->GetPrevRecord()) == XB_NO_ERROR )
     dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
   else
-    x.DisplayError( iRc );
+    x->DisplayError( iRc );
 }
 /*************************************************************************************/
 void xbUtil::GetLastRecord(){
@@ -1274,15 +1295,15 @@ void xbUtil::GetLastRecord(){
   if(( iRc = dActiveTable->GetLastRecord()) == XB_NO_ERROR )
     dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(),2);
   else
-    x.DisplayError( iRc );
+    x->DisplayError( iRc );
 }
 
 /*************************************************************************************/
 void xbUtil::UndeleteRecord(){
 
-  char    cBuf[15];
-  xbInt16 rc;
-  xbUInt32 lRecNo;
+  char     cBuf[15];
+  xbInt16  rc;
+  xbUInt32 ulRecNo;
 
   if( !dActiveTable )
     dActiveTable = GetTablePtr( " - select table" );
@@ -1292,7 +1313,6 @@ void xbUtil::UndeleteRecord(){
     return;
   }
   DisplayActiveTable();
-
   if( dActiveTable->GetCurRecNo() == 0 ){
     std::cout << "Enter Record number" << std::endl;
     std::cin.getline( cBuf,  15 );
@@ -1300,29 +1320,30 @@ void xbUtil::UndeleteRecord(){
       std::cout << "Record number not entered" << std::endl;
       return;
     }
-    lRecNo = atol( cBuf );
-    if(( rc = dActiveTable->GetRecord( lRecNo )) != XB_NO_ERROR ){
-      x.DisplayError( rc );
+    //lRecNo = atol( cBuf );
+    ulRecNo = strtoul( cBuf, NULL, 0 );
+    if(( rc = dActiveTable->GetRecord( ulRecNo )) != XB_NO_ERROR ){
+      x->DisplayError( rc );
       return;
     }
   }
-
   if(( dActiveTable->RecordDeleted()) == xbFalse )
     std::cout << "Record is not flagged for deletion" << std::endl;
   else{
     if(( rc = dActiveTable->UndeleteRecord()) == XB_NO_ERROR )
       std::cout << "Success" << std::endl;
     else
-      x.DisplayError( rc );
+      x->DisplayError( rc );
   }
 }
 
 /*************************************************************************************/
 void xbUtil::DeleteRecord(){
 
-  char    cBuf[15];
-  xbInt16 rc;
-  xbUInt32 lRecNo;
+  char     cBuf[15];
+  xbInt16  rc;
+  xbUInt32 ulRecNo;
+
   if( !dActiveTable )
     dActiveTable = GetTablePtr( " - select table" );
   if( !dActiveTable ){
@@ -1337,9 +1358,11 @@ void xbUtil::DeleteRecord(){
       std::cout << "Record number not entered" << std::endl;
       return;
     }
-    lRecNo = atol( cBuf );
-    if(( rc = dActiveTable->GetRecord( lRecNo )) != XB_NO_ERROR ){
-      x.DisplayError( rc );
+    //ulRecNo = atol( cBuf );
+
+    ulRecNo = strtoul( cBuf, NULL, 0 );
+    if(( rc = dActiveTable->GetRecord( ulRecNo )) != XB_NO_ERROR ){
+      x->DisplayError( rc );
       return;
     }
   }
@@ -1350,16 +1373,16 @@ void xbUtil::DeleteRecord(){
     if(( rc = dActiveTable->DeleteRecord()) == XB_NO_ERROR )
       std::cout << "Success" << std::endl;
     else
-      x.DisplayError( rc );
+      x->DisplayError( rc );
   }
 }
 
 /*************************************************************************************/
 void xbUtil::PutRecord(){
 
-  char    cBuf[15];
-  xbInt16 rc;
-  xbUInt32 lRecNo;
+  char     cBuf[15];
+  xbInt16  rc;
+  xbUInt32 ulRecNo;
 
   if( !dActiveTable )
     dActiveTable = GetTablePtr( " - select table" );
@@ -1376,11 +1399,12 @@ void xbUtil::PutRecord(){
     std::cout << "Record number not entered" << std::endl;
     return;
   }
-  lRecNo = atol( cBuf );
-  if(( rc = dActiveTable->PutRecord( lRecNo )) == XB_NO_ERROR )
+  //lRecNo = atol( cBuf );
+  ulRecNo = strtoul( cBuf, NULL, 0 );
+  if(( rc = dActiveTable->PutRecord( ulRecNo )) == XB_NO_ERROR )
     std::cout << "Success" << std::endl;
   else
-    x.DisplayError( rc );
+    x->DisplayError( rc );
 }
 
 /*************************************************************************************/
@@ -1396,7 +1420,7 @@ void xbUtil::AppendRecord(){
   if(( rc = dActiveTable->AppendRecord()) == XB_NO_ERROR )
     std::cout << "Success" << std::endl;
   else
-    x.DisplayError( rc );
+    x->DisplayError( rc );
 }
 
 /*************************************************************************************/
@@ -1412,7 +1436,7 @@ void xbUtil::BlankRecord(){
   if(( rc = dActiveTable->BlankRecord()) == XB_NO_ERROR )
     std::cout << "Success" << std::endl;
   else
-    x.DisplayError( rc );
+    x->DisplayError( rc );
 }
 
 /*************************************************************************************/
@@ -1449,16 +1473,14 @@ void xbUtil::RenameTable(){
     dActiveTable = NULL;
     std::cout << "Table closed.  Reopen if needed.\n";
   }
-
-
 }
 
 /*************************************************************************************/
 void xbUtil::GetRecord(){
 
-  char    cBuf[15];
-  xbInt16 iRc;
-  xbUInt32 lRecNo;
+  char     cBuf[15];
+  xbInt16  iRc;
+  xbUInt32 ulRecNo;
 
   if( !dActiveTable )
     dActiveTable = GetTablePtr( " - select table" );
@@ -1476,11 +1498,12 @@ void xbUtil::GetRecord(){
     std::cout << "Record number not entered" << std::endl;
     return;
   }
-  lRecNo = atol( cBuf );
-  if(( iRc = dActiveTable->GetRecord( lRecNo )) == XB_NO_ERROR )
+  //lRecNo = atol( cBuf );
+  ulRecNo = strtoul( cBuf, NULL, 0 );
+  if(( iRc = dActiveTable->GetRecord( ulRecNo )) == XB_NO_ERROR )
     dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
   else
-    x.DisplayError( iRc );
+    x->DisplayError( iRc );
 }
 /*************************************************************************************/
 void xbUtil::DisplayActiveTable() const{
@@ -1513,7 +1536,7 @@ void xbUtil::DisplayActiveTable() const{
 xbDbf * xbUtil::GetTablePtr( const char * cTitle ){
 
   xbDbf   *d;
-  xbInt16 iOpenTableCnt = x.GetOpenTableCount();
+  xbInt16 iOpenTableCnt = x->GetOpenTableCount();
   char    cBuf[15];
   xbInt16 iLineNo;
 
@@ -1521,10 +1544,10 @@ xbDbf * xbUtil::GetTablePtr( const char * cTitle ){
     std::cout << "No open tables" << std::endl;
     return NULL;
   } else if( iOpenTableCnt == 1 ){
-    d = x.GetDbfPtr( 1 );
+    d = x->GetDbfPtr( 1 );
   } else {
     std::cout << "Select file/table " << cTitle << std::endl;
-    x.DisplayTableList();
+    x->DisplayTableList();
     std::cout << std::endl << "Enter line number:" << std::endl;
     memset( cBuf, 0x00, 15 );
     std::cin.getline( cBuf,  15 );
@@ -1537,7 +1560,7 @@ xbDbf * xbUtil::GetTablePtr( const char * cTitle ){
       std::cout << "Invalid selection.  Valid line numbers are 1 through " << iOpenTableCnt << std::endl;
       return NULL;
     }
-    d = x.GetDbfPtr( iLineNo );
+    d = x->GetDbfPtr( iLineNo );
   }
   return d;
 }
@@ -1551,7 +1574,7 @@ void xbUtil::UpdateTableAutoCommit(){
     std::cout << "                   If unsure, leave the option turned on at the DBMS level (default)"           << std::endl;
     std::cout << "                   and don't over ride the setting at the table level"             << std::endl << std::endl;
     std::cout << " -1 ==> Use DBMS setting which is currently [";
-    if( x.GetDefaultAutoCommit() )
+    if( x->GetDefaultAutoCommit() )
       std::cout << "ON]" << std::endl;
     else
       std::cout << "OFF]" << std::endl;
@@ -1584,7 +1607,7 @@ void xbUtil::CopyDbfStructure(){
   xbDbf   *d;
   xbInt16 rc;
   char    filename[128];
-  xbFile  f( &x );
+  xbFile  f( x );
   xbDbf   *dNewTable;
   d = GetTablePtr( "" );
 
@@ -1592,14 +1615,14 @@ void xbUtil::CopyDbfStructure(){
 
     if( d->GetVersion() == 3 ){
       #ifdef XB_DBF3_SUPPORT
-      dNewTable = new xbDbf3( &x );
+      dNewTable = new xbDbf3( x );
       #else
       std::cout << "Dbase III file support not build into library. See XB_DBF3_SUPPORT" << std::endl;
       return;
       #endif
     } else if( d->GetVersion() == 4 ){
       #ifdef XB_DBF4_SUPPORT
-      dNewTable = new xbDbf4( &x );
+      dNewTable = new xbDbf4( x );
       #else
       std::cout << "Dbase IV file support not build into library. See XB_DBF4_SUPPORT" << std::endl;
       return;
@@ -1622,13 +1645,13 @@ void xbUtil::CopyDbfStructure(){
     }
     if(( rc = d->CopyDbfStructure( dNewTable, filename, filename, 0, XB_MULTI_USER )) != XB_NO_ERROR ){
       std::cout << "Error " << rc << " creating new file" << std::endl;
-      x.DisplayError( rc );
+      x->DisplayError( rc );
       return;
     }
     std::cout << "Table " << f.GetFqFileName().Str() << " created" << std::endl;
     if(( rc = dNewTable->Close()) != XB_NO_ERROR ){
       std::cout << "Error " << rc << " closing new file" << std::endl;
-      x.DisplayError( rc );
+      x->DisplayError( rc );
       return;
     }
   }
@@ -1649,7 +1672,7 @@ void xbUtil::ZapTable(){
   if( iRc == XB_NO_ERROR )
     std::cout << "Table Zapped (all rows deleted)" << std::endl;
   else
-    x.DisplayError( iRc );
+    x->DisplayError( iRc );
 }
 /*************************************************************************************/
 void xbUtil::Pack(){
@@ -1666,7 +1689,7 @@ void xbUtil::Pack(){
   if( iRc == XB_NO_ERROR )
     std::cout << "Table Packed" << std::endl;
   else
-    x.DisplayError( iRc );
+    x->DisplayError( iRc );
 }
 /*************************************************************************************/
 void xbUtil::DisplayTableStats(){
@@ -1699,7 +1722,7 @@ void xbUtil::DisplayTableStats(){
     // DBMS settings
       if( d->GetAutoCommit( 0 ) == -1 ){
         std::cout << "Table Auto Commit     = [Use DBMS Setting]"  << std::endl;
-        if( x.GetDefaultAutoCommit() )
+        if( x->GetDefaultAutoCommit() )
           std::cout << "DBMS Auto Commit      = [ON]"  << std::endl;
         else
           std::cout << "DBMS Auto Commit      = [OFF]"  << std::endl;
@@ -1714,24 +1737,24 @@ void xbUtil::DisplayTableStats(){
 /*************************************************************************************/
 void xbUtil::CloseAllTables(){
 
-  xbInt16 sOpenTableCnt = x.GetOpenTableCount();
+  xbInt16 sOpenTableCnt = x->GetOpenTableCount();
   xbInt16 rc;
   if( sOpenTableCnt == 0 ){
     std::cout << "No open tables" << std::endl;
     return;
   }
-  rc = x.CloseAllTables();
+  rc = x->CloseAllTables();
   if( rc == XB_NO_ERROR )
    std::cout << "All open tables closed" << std::endl;
   else
-    x.DisplayError( rc );
+    x->DisplayError( rc );
   dActiveTable = NULL;
 }
 
 /*************************************************************************************/
 void xbUtil::Close(){
   xbDbf   *d;
-//  xbInt16 sOpenTableCnt = x.GetOpenTableCount();
+//  xbInt16 sOpenTableCnt = x->GetOpenTableCount();
 
   d = GetTablePtr( "to close" );
   if( d ){
@@ -1746,7 +1769,7 @@ void xbUtil::Close(){
 /*************************************************************************************/
 void xbUtil::Open(){
   xbInt16  rc;
-  xbFile   f( &x );
+  xbFile   f( x );
   xbDbf    *dTable;
   char     filename[128];
   unsigned char cFileTypeByte;
@@ -1766,18 +1789,18 @@ void xbUtil::Open(){
   }
   if(( rc = f.GetXbaseFileTypeByte( f.GetFqFileName(), cFileTypeByte )) != XB_NO_ERROR ){
     std::cout << "Could not open file or determine file type rc = " << rc << " file = " << filename << std::endl;
-    x.DisplayError( rc );
+    x->DisplayError( rc );
     return;
   }
   std:: cout << "File Type Byte ";
-  x.BitDump( cFileTypeByte );
+  x->BitDump( cFileTypeByte );
   std::cout << "\n";
   std::cout << "Table Type = [" << f.DetermineXbaseTableVersion( cFileTypeByte ) << "]\n";
   std::cout << "Memo Type  = [" << f.DetermineXbaseMemoVersion( cFileTypeByte ) << "]\n";
 
   if( f.DetermineXbaseTableVersion( cFileTypeByte ) == 4 ){
     #ifdef XB_DBF4_SUPPORT
-      dTable = new xbDbf4( &x );
+      dTable = new xbDbf4( x );
     #else
       std::cout << "Dbase IV file support not build into library. See XB_DBF4_SUPPORT" << std::endl;
       return;
@@ -1785,21 +1808,21 @@ void xbUtil::Open(){
 
   } else if( f.DetermineXbaseTableVersion( cFileTypeByte ) == 3 ){
     #ifdef XB_DBF3_SUPPORT
-      dTable = new xbDbf3( &x );
+      dTable = new xbDbf3( x );
     #else
       std::cout << "Dbase III file support not build into library. See XB_DBF3_SUPPORT" << std::endl;
       return;
     #endif
   } else {
     std::cout << "Unsupported file type file = " << filename << " type = ";
-    x.BitDump( cFileTypeByte );
+    x->BitDump( cFileTypeByte );
     std::cout << std::endl;
     return;
   }
 
   if(( rc =  dTable->Open( filename )) != 0 ){
     std::cout << "Could not open file rc = " << rc  << " file = "  << filename << std::endl;
-    x.DisplayError( rc );
+    x->DisplayError( rc );
     return;
   }
 
@@ -1821,9 +1844,9 @@ void xbUtil::UpdateDefaultLockRetries(){
     std::cout << "Default Lock Retry Count not updated" << std::endl;
     return;
   } else {
-    x.SetDefaultLockRetries( atoi( cBuf ));
+    x->SetDefaultLockRetries( atoi( cBuf ));
     std::cout << "Default Lock Retry Count updated to ["
-              << x.GetDefaultLockRetries() << "]" << std::endl;
+              << x->GetDefaultLockRetries() << "]" << std::endl;
   }
 }
 
@@ -1835,9 +1858,9 @@ void xbUtil::UpdateDefaultLockWait(){
     std::cout << "Default Lock Wait Time not updated" << std::endl;
     return;
   } else {
-    x.SetDefaultLockWait( atoi( cBuf ));
+    x->SetDefaultLockWait( atoi( cBuf ));
     std::cout << "Default Lock Wait Time updated to ["
-              << x.GetDefaultLockWait() << "]" << std::endl;
+              << x->GetDefaultLockWait() << "]" << std::endl;
   }
 }
 
@@ -1854,38 +1877,38 @@ void xbUtil::UpdateDefaultLockFlavor(){
     std::cout << "Default Lock Flavor not updated" << std::endl;
     return;
   } else {
-    x.SetDefaultLockFlavor( atoi( cBuf ));
+    x->SetDefaultLockFlavor( atoi( cBuf ));
     std::cout << "Default Lock Flavor updated to ["
-              << x.GetDefaultLockFlavor() << "]" << std::endl;
+              << x->GetDefaultLockFlavor() << "]" << std::endl;
   }
 }
 void xbUtil::ToggleDefaultAutoLock(){
-  if( x.GetDefaultAutoLock()){
-    x.DisableDefaultAutoLock();
-    x.WriteLogMessage( "xb_dbfutil - Default Auto Lock disabled" );
+  if( x->GetDefaultAutoLock()){
+    x->DisableDefaultAutoLock();
+    x->WriteLogMessage( "xb_dbfutil - Default Auto Lock disabled" );
     std::cout << "Default Auto Lock disabled" << std::endl;
   } else {
-    x.EnableDefaultAutoLock();
-    x.WriteLogMessage( "xb_dbfutil - Default Auto Lock enabled" );
+    x->EnableDefaultAutoLock();
+    x->WriteLogMessage( "xb_dbfutil - Default Auto Lock enabled" );
     std::cout << "Default Auto Lock enabled" << std::endl;
   }
 } 
 
 void xbUtil::ToggleMultiUserMode(){
-  if( x.GetMultiUser()){
-    x.SetMultiUser( xbFalse );
-    x.WriteLogMessage( "xb_dbfutil - Multi user mode disabled" );
+  if( x->GetMultiUser()){
+    x->SetMultiUser( xbFalse );
+    x->WriteLogMessage( "xb_dbfutil - Multi user mode disabled" );
     std::cout << "Multi user mode disabled" << std::endl;
   } else {
-    x.SetMultiUser( xbTrue );
-    x.WriteLogMessage( "xb_dbfutil - Multu user mode enabled" );
+    x->SetMultiUser( xbTrue );
+    x->WriteLogMessage( "xb_dbfutil - Multu user mode enabled" );
     std::cout << "Multi user mode enabled" << std::endl;
   }
 }
 #endif
 /*************************************************************************************/
 void xbUtil::ListFilesInDataDirectory(){
-  std::cout << "List files for [" << x.GetDataDirectory().Str() << "]" << std::endl << std::endl;
+  std::cout << "List files for [" << x->GetDataDirectory().Str() << "]" << std::endl << std::endl;
   xbString s1;
   xbInt16 iCnt = 0;
 
@@ -1894,7 +1917,7 @@ void xbUtil::ListFilesInDataDirectory(){
   WIN32_FIND_DATA fData;
   HANDLE hFile;
 
-  xbString sSearchPath = x.GetDataDirectory();
+  xbString sSearchPath = x->GetDataDirectory();
   xbUInt32 l = sSearchPath.Len();
   char cPathSeperator = sSearchPath.GetPathSeparator();
   char cLastChar = sSearchPath.GetCharacter( l );
@@ -1926,7 +1949,7 @@ void xbUtil::ListFilesInDataDirectory(){
   DIR *dir;
   struct dirent *ent;
 
-  if(( dir = opendir( x.GetDataDirectory() )) != NULL ){
+  if(( dir = opendir( x->GetDataDirectory() )) != NULL ){
     while(( ent = readdir( dir )) != NULL ){
       s1 = ent->d_name;
       if( s1 != "." && s1 != ".." ){
@@ -1947,20 +1970,20 @@ void xbUtil::UpdateLogDirectory(){
   char cNewDir[256];
   cNewDir[0] = 0x00;
   std::cout << std::endl << "Update Log Directory" << std::endl;
-  std::cout << "Current Log File Directory = [" << x.GetLogDirectory().Str() << "]" << std::endl;
+  std::cout << "Current Log File Directory = [" << x->GetLogDirectory().Str() << "]" << std::endl;
   std::cout << "Enter '1' to erase the Log File Directory" << std::endl;
-  std::cout << "Enter '2' to change Log File Directory to [" << x.GetDefaultLogDirectory().Str() << "]" << std::endl;
+  std::cout << "Enter '2' to change Log File Directory to [" << x->GetLogDirectory().Str() << "]" << std::endl;
   std::cout << "Enter new log directory.  Enter for no updates." << std::endl;
   std::cin.getline( cNewDir, 256 );
   if( strlen( cNewDir ) > 0 ){
     if( cNewDir[0] == '1' )
-      x.SetLogDirectory( "" );
+      x->SetLogDirectory( "" );
     else if( cNewDir[0] == '2' )
-      x.SetLogDirectory( x.GetDefaultLogDirectory());
+      x->SetLogDirectory( x->GetLogDirectory());
     else 
-      x.SetLogDirectory( cNewDir );
+      x->SetLogDirectory( cNewDir );
 
-    std::cout << "Log File Directory is [" << x.GetLogDirectory().Str() << "]" << std::endl;
+    std::cout << "Log File Directory is [" << x->GetLogDirectory().Str() << "]" << std::endl;
   }
   else
    std::cout << "Log Directory not updated" << std::endl;
@@ -1971,51 +1994,51 @@ void xbUtil::UpdateLogFileName(){
   cNewFile[0] = 0x00;
 
   std::cout << std::endl << "Update Log File Name" << std::endl;
-  std::cout << "Current Log File Name = [" << x.GetLogFileName().Str() << "]" << std::endl;
-  std::cout << "Enter '1' to change change Log File Name to default [" << x.GetDefaultLogFileName().Str() << "]" << std::endl;
+  std::cout << "Current Log File Name = [" << x->GetLogFileName().Str() << "]" << std::endl;
+  std::cout << "Enter '1' to change change Log File Name to default [" << x->GetLogFileName().Str() << "]" << std::endl;
   std::cout << "Enter new Log File Name" << std::endl;
   std::cin.getline( cNewFile, 256 );
   if( strlen( cNewFile ) > 0 ){
     if( cNewFile[0] == '1' )
-      x.SetLogFileName( x.GetDefaultLogFileName());
+      x->SetLogFileName( x->GetLogFileName());
     else
-      x.SetLogFileName( cNewFile );
+      x->SetLogFileName( cNewFile );
 
-    std::cout << "Log File Name is [" << x.GetLogFileName().Str() << "]" << std::endl;
+    std::cout << "Log File Name is [" << x->GetLogFileName().Str() << "]" << std::endl;
   } else
     std::cout << "Log File Name not updated" << std::endl;
 }
 /*************************************************************************************/
 void xbUtil::WriteLogMessage(){
-  if( x.GetLogStatus()) {
+  if( x->GetLogStatus()) {
     char cMsg[256];
     std::cout << "Enter a message to write to the log file (256 byte max)" << std::endl;
     std::cin.getline( cMsg, 256 );
-    x.WriteLogMessage( cMsg );
+    x->WriteLogMessage( cMsg );
   } else 
     std::cout << "Logging disabled" << std::endl;
 }
 /*************************************************************************************/
 void xbUtil::ToggleLoggingStatus(){
-  if( x.GetLogStatus()){
-    x.DisableMsgLogging();
-    x.WriteLogMessage( "xb_dbfutil - Logging disabled" );
+  if( x->GetLogStatus()){
+    x->DisableMsgLogging();
+    x->WriteLogMessage( "xb_dbfutil - Logging disabled" );
     std::cout << "Logging disabled" << std::endl;
   } else {
-    x.EnableMsgLogging();
-    x.WriteLogMessage( "xb_dbfutil - Logging enabled" );
+    x->EnableMsgLogging();
+    x->WriteLogMessage( "xb_dbfutil - Logging enabled" );
     std::cout << "Logging enabled" << std::endl;
   }
 }
 /*************************************************************************************/
 void xbUtil::ToggleDefaultAutoCommit(){
-  if( x.GetDefaultAutoCommit()){
-    x.SetDefaultAutoCommit( xbFalse );
-    x.WriteLogMessage( "xb_dbfutil - Default Auto Commit disabled" );
+  if( x->GetDefaultAutoCommit()){
+    x->SetDefaultAutoCommit( xbFalse );
+    x->WriteLogMessage( "xb_dbfutil - Default Auto Commit disabled" );
     std::cout << "Default Auto Commit disabled" << std::endl;
   } else {
-    x.SetDefaultAutoCommit( xbTrue );
-    x.WriteLogMessage( "xb_dbfutil - Default Auto Commit enabled" );
+    x->SetDefaultAutoCommit( xbTrue );
+    x->WriteLogMessage( "xb_dbfutil - Default Auto Commit enabled" );
     std::cout << "Default Auto Commit enabled" << std::endl;
   }
 }
@@ -2024,19 +2047,19 @@ void xbUtil::UpdateDataDirectory(){
  char cNewDir[256];
   cNewDir[0] = 0x00;
   std::cout << std::endl << "Update Default Data Directory" << std::endl;
-  std::cout << "Current Default Data Directory = [" << x.GetDataDirectory().Str() << "]" << std::endl;
+  std::cout << "Current Default Data Directory = [" << x->GetDataDirectory().Str() << "]" << std::endl;
   std::cout << "Enter '1' to erase the Default Data Directory" << std::endl;
   std::cout << "Enter '2' to change Default Data Directory to [" << PROJECT_DATA_DIR << "]" << std::endl;
   std::cout << "Enter new directory" << std::endl;
   std::cin.getline( cNewDir, 256 );
   if( strlen( cNewDir ) > 0 ){
     if( cNewDir[0] == '1' )
-      x.SetDataDirectory( "" );
+      x->SetDataDirectory( "" );
     else if( cNewDir[0] == '2' )
-      x.SetDataDirectory( PROJECT_DATA_DIR );
+      x->SetDataDirectory( PROJECT_DATA_DIR );
     else
-      x.SetDataDirectory( cNewDir );
-    std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+      x->SetDataDirectory( cNewDir );
+    std::cout << "Default Data Directory is [" << x->GetDataDirectory().Str() << "]" << std::endl;
   }
   else
     std::cout << "Default Data Directory not updated" << std::endl;
@@ -2044,20 +2067,20 @@ void xbUtil::UpdateDataDirectory(){
 /*************************************************************************************/
 void xbUtil::ListSystemSettings(){
   std::cout << std::endl << "List System Settings" << std::endl;
-  std::cout << "Default Data Directory  = [" << x.GetDataDirectory().Str()    << "]" << std::endl;
-//  std::cout << "Default File Version    = [" << x.GetDefaultFileVersion()      << "]" << std::endl;
+  std::cout << "Default Data Directory  = [" << x->GetDataDirectory().Str()    << "]" << std::endl;
+//  std::cout << "Default File Version    = [" << x->GetDefaultFileVersion()      << "]" << std::endl;
   #ifdef XB_LOCKING_SUPPORT
   std::cout << "Default Auto Locking    = [";
-  if( x.GetDefaultAutoLock())
+  if( x->GetDefaultAutoLock())
     std::cout << "ON]" << std::endl;
   else
     std::cout << "OFF]" << std::endl;
 
-  std::cout << "Default Lock Retries    = [" << x.GetDefaultLockRetries()      << "]" << std::endl;
-  std::cout << "Default Lock Wait Time  = [" << x.GetDefaultLockWait()         << "] (millisecs)" << std::endl;
+  std::cout << "Default Lock Retries    = [" << x->GetDefaultLockRetries()      << "]" << std::endl;
+  std::cout << "Default Lock Wait Time  = [" << x->GetDefaultLockWait()         << "] (millisecs)" << std::endl;
 
   std::cout << "Default Lock Flavor     = [";
-  switch (x.GetDefaultLockFlavor()){
+  switch (x->GetDefaultLockFlavor()){
     case 1:
       std::cout << "Dbase]" << std::endl;
       break;
@@ -2075,26 +2098,26 @@ void xbUtil::ListSystemSettings(){
       break;
   } 
   #endif
-  std::cout << "Default Log Directory   = [" << x.GetDefaultLogDirectory().Str()     << "]" << std::endl;
-  std::cout << "Default Logfile Name    = [" << x.GetDefaultLogFileName().Str()      << "]" << std::endl;
+  std::cout << "Log Directory           = [" << x->GetLogDirectory().Str()     << "]" << std::endl;
+  std::cout << "Logfile Name            = [" << x->GetLogFileName().Str()      << "]" << std::endl;
   std::cout << "Default Auto Commit     = [";
-  if( x.GetDefaultAutoCommit())
+  if( x->GetDefaultAutoCommit())
     std::cout << "ON]" << std::endl;
   else
     std::cout << "OFF]" << std::endl;
 
   std::cout << "Logging Status          = [";
-  if( x.GetLogStatus())
+  if( x->GetLogStatus())
     std::cout << "ON]" << std::endl;
   else
     std::cout << "OFF]" << std::endl;
   std::cout << "Endian Type             = [";
-  if( x.GetEndianType() == 'L' )
+  if( x->GetEndianType() == 'L' )
     std::cout << "Little Endian]" << std::endl;
   else
     std::cout << "Big Endian]" << std::endl;
 
-  if( x.GetMultiUser())
+  if( x->GetMultiUser())
     std::cout << "Multi User Mode         = [ON]";
   else
     std::cout << "Multi User Mode         = [OFF]";
@@ -2109,7 +2132,9 @@ void xbUtil::ProcessOption( const xbString &sOption ){
     else if( sOption == "=0.99" )
       // exit right now, now cleanup or termination of anything
       exit(0);
-    else if( sOption == "=2" )  
+    else if( sOption == "=1" )
+      Help();
+    else if( sOption == "=2" )
       SystemMenu();
     else if( sOption == "=2.1" )
       ListSystemSettings();
@@ -2144,7 +2169,7 @@ void xbUtil::ProcessOption( const xbString &sOption ){
     else if( sOption == "=3.2" )
       UpdateDataDirectory();
     else if( sOption == "=3.3" )
-      x.DisplayTableList();
+      x->DisplayTableList();
     else if( sOption == "=3.4" )
       Open();
     else if( sOption == "=3.5" )
@@ -2808,7 +2833,7 @@ void xbUtil::FileMenu()
      case 0:                                      break;
      case 1:  ListFilesInDataDirectory();         break;
      case 2:  UpdateDataDirectory();              break;
-     case 3:  x.DisplayTableList();               break;
+     case 3:  x->DisplayTableList();               break;
      case 4:  Open();                             break;
      case 5:  Close();                            break;
      case 6:  CloseAllTables();                   break;
@@ -2963,6 +2988,7 @@ void xbUtil::MainMenu()
     option = GetOption();
     switch( option ){
      case 0:                       break;
+     case 1: Help();               break;
      case 2: SystemMenu();         break;
      case 3: FileMenu();           break;
      case 4: RecordMenu();         break;
@@ -3114,7 +3140,7 @@ void xbUtil::OpenIndex(){
   xbString sIxFileName = cBuf;
 
   iRc = dActiveTable->OpenIndex( sIxType, sIxFileName );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void xbUtil::CloseIndexFile(){
@@ -3141,7 +3167,7 @@ void xbUtil::CloseIndexFile(){
   }
 
   xbInt16 iRc = dActiveTable->CloseIndexFile( pIx );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void xbUtil::CreateIndexTag(){
@@ -3227,7 +3253,7 @@ void xbUtil::CreateIndexTag(){
   void *vpTag;
 
   xbInt16 iRc = dActiveTable->CreateTag( sIxType, sIxName, sKeyExpression, sFilter, iDescending, iUnique, 0, &pIx, &vpTag );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void xbUtil::GetFirstKey(){
@@ -3252,7 +3278,7 @@ void xbUtil::GetFirstKey(){
   if( iRc == XB_NO_ERROR )
       dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
   else
-      x.DisplayError( iRc );
+      x->DisplayError( iRc );
 }
 
 void xbUtil::GetNextKey(){
@@ -3277,7 +3303,7 @@ void xbUtil::GetNextKey(){
   if( iRc == XB_NO_ERROR )
     dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
   else
-    x.DisplayError( iRc );
+    x->DisplayError( iRc );
 }
 
 void xbUtil::GetPrevKey(){
@@ -3303,7 +3329,7 @@ void xbUtil::GetPrevKey(){
   if( iRc == XB_NO_ERROR )
     dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
   else
-    x.DisplayError( iRc );
+    x->DisplayError( iRc );
 }
 
 void xbUtil::GetLastKey(){
@@ -3328,7 +3354,7 @@ void xbUtil::GetLastKey(){
   if( iRc == XB_NO_ERROR )
     dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
   else
-    x.DisplayError( iRc );
+    x->DisplayError( iRc );
 }
 
 void xbUtil::FindKey(){
@@ -3387,7 +3413,7 @@ void xbUtil::FindKey(){
   if( iRc == XB_NO_ERROR )
       dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
   else
-      x.DisplayError( iRc );
+      x->DisplayError( iRc );
 }
 
 void   xbUtil::CheckIntegrity(){
@@ -3410,7 +3436,7 @@ void   xbUtil::CheckIntegrity(){
   void *vpCurTag = dActiveTable->GetCurTag();
   
   xbInt16 iRc = pIx->CheckTagIntegrity( vpCurTag, 2 );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void   xbUtil::Reindex(){
@@ -3433,7 +3459,7 @@ void   xbUtil::Reindex(){
   }
   void *vpCurTag = dActiveTable->GetCurTag();
   xbInt16 iRc = pIx->Reindex( &vpCurTag );
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void   xbUtil::DeleteTag(){
@@ -3455,7 +3481,7 @@ void   xbUtil::DeleteTag(){
   }
   void *vpCurTag = dActiveTable->GetCurTag();
   xbInt16 iRc = dActiveTable->DeleteTag( dActiveTable->GetCurIxType(), pIx->GetTagName( vpCurTag ));
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void   xbUtil::AssociateNonProdIx(){
@@ -3494,7 +3520,7 @@ void xbUtil::DumpRecsByIx( xbInt16 iOpt ){
   std::cout << "1 - 1 line per record"  << std::endl;
   xbInt16 iDispFmt = GetOption();
 
-  x.WriteLogMessage( "--------- Dump Recs By Index -------------", iDispOpt );
+  x->WriteLogMessage( "--------- Dump Recs By Index -------------", iDispOpt );
   void *vpCurTag = dActiveTable->GetCurTag();
   xbUInt32 lRecCnt = 0;
   xbInt16 iRc = 0;
@@ -3509,7 +3535,7 @@ void xbUtil::DumpRecsByIx( xbInt16 iOpt ){
         lRecCnt++;
       }
     } else {
-      x.DisplayError( iRc );
+      x->DisplayError( iRc );
     }
   } else if( iOpt == 1 ) {
     iRc = pIx->GetLastKey( vpCurTag, 1 );
@@ -3668,10 +3694,10 @@ void xbUtil::SetFilter()
   if( filt )
     delete filt;
 
-  filt = new xbFilter( &x, dActiveTable );
+  filt = new xbFilter( dActiveTable );
   xbInt16 iRc = filt->Set( s );
 
-  x.DisplayError( iRc );
+  x->DisplayError( iRc );
 }
 
 void xbUtil::GetFirstFilterRec()
@@ -3689,7 +3715,7 @@ void xbUtil::GetFirstFilterRec()
   if(( iRc = filt->GetFirstRecord()) == XB_NO_ERROR )
     dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
   else
-    x.DisplayError( iRc );
+    x->DisplayError( iRc );
 }
 
 void xbUtil::GetNextFilterRec()
@@ -3706,7 +3732,7 @@ void xbUtil::GetNextFilterRec()
   if(( iRc = filt->GetNextRecord()) == XB_NO_ERROR )
     dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
   else
-    x.DisplayError( iRc );
+    x->DisplayError( iRc );
 }
 
 void xbUtil::GetPrevFilterRec()
@@ -3723,7 +3749,7 @@ void xbUtil::GetPrevFilterRec()
   if(( iRc = filt->GetPrevRecord()) == XB_NO_ERROR )
     dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
   else
-    x.DisplayError( iRc );
+    x->DisplayError( iRc );
 }
 
 void xbUtil::GetLastFilterRec()
@@ -3740,17 +3766,46 @@ void xbUtil::GetLastFilterRec()
   if(( iRc = filt->GetLastRecord()) == XB_NO_ERROR )
     dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
   else
-    x.DisplayError( iRc );
+    x->DisplayError( iRc );
 }
 #endif  //  XB_FILTER_SUPPORT
 
 ///@endcond DOXYOFF
 
+
+/*************************************************************************************/
+void PrintHelp();
+void PrintHelp(){
+  std::cout << "Usage: xb_dbfutil [-h] [-?] [--help] [-v] [--version]"  << std::endl << std::endl;
+  std::cout << "This program provides a menu driven tool for accissing the functionality og the xbase64 library" << std::endl;
+  std::cout << "and provides access to DBF, MDX, NDX and MDT xbase formatted data files." << std::endl << std::endl;
+}
+void PrintVersion();
+void PrintVersion(){
+  std::cout << "Xbase64 Version: " << xbase_VERSION_MAJOR << "." << xbase_VERSION_MINOR << "." << xbase_VERSION_PATCH << std::endl;
+}
 /*************************************************************************************/
-int main(int, char**)
+int main(int argc, char *argv[] )
 {
-  std::cout << "xb_dbfutil initializing" << std::endl;
-  xbUtil u;
+
+  // std::cout << "xb_dbfutil initializing" << std::endl;
+  xbXBase x;
+
+  xbString sParm;
+  if (x.GetCmdLineOpt( argc, argv, "-h", sParm ) ||
+      x.GetCmdLineOpt( argc, argv, "-?", sParm ) ||
+      x.GetCmdLineOpt( argc, argv, "--help", sParm )){
+    PrintHelp();
+    return 1;
+  }
+
+  if ( x.GetCmdLineOpt( argc, argv, "-v", sParm ) ||
+       x.GetCmdLineOpt( argc, argv, "--version", sParm )){
+    PrintVersion();
+    return 1;
+  }
+
+  xbUtil u( &x );
   u.MainMenu();
   return 0;
 }
diff --git a/src/utils/xb_deletall.cpp b/src/utils/xb_deletall.cpp
index 720710f..3a8f6e4 100755
--- a/src/utils/xb_deletall.cpp
+++ b/src/utils/xb_deletall.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2017,2019 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2017,2019,2023 Gary A Kunkel
 
 The xb64 software library is covered under 
 the terms of the GPL Version 3, 2007 license.
@@ -24,32 +24,62 @@ This program sets the delete flag on all records in a dbf file
 
 using namespace xb;
 
-int main(int ac,char** av)
+
+
+void PrintHelp();
+void PrintHelp(){
+  std::cout << "Usage: xb_deleteall [-h] [-?] [--help] [-v] [--version] -i myfile"  << std::endl << std::endl;
+  std::cout << "This program flags all the records in a DBF table for deletion.  To physically remove the deleted records, see program xb_pack.";
+  std::cout << std::endl << std::endl;
+}
+void PrintVersion();
+void PrintVersion(){
+  std::cout << "Xbase64 Version: " << xbase_VERSION_MAJOR << "." << xbase_VERSION_MINOR << "." << xbase_VERSION_PATCH << std::endl;
+}
+
+
+int main(int argc, char *argv[])
 {
+
   xbXBase x;
   xbDbf *MyFile = NULL;
   xbFile f( &x );
   xbInt16 iRc = 0;
 
-  if (ac <= 1) {
-    std::cout << "\nUsage: xb_deletall filename...\n";
+  xbString sParm;
+
+  if (argc < 2 || x.GetCmdLineOpt( argc, argv, "-h", sParm ) ||
+                  x.GetCmdLineOpt( argc, argv, "-?", sParm ) ||
+                  x.GetCmdLineOpt( argc, argv, "--help", sParm )){
+    PrintHelp();
+    return 1;
+  }
+
+  if ( x.GetCmdLineOpt( argc, argv, "-v", sParm ) ||
+       x.GetCmdLineOpt( argc, argv, "--version", sParm )){
+    PrintVersion();
+    return 1;
+  }
+
+  if( !x.GetCmdLineOpt( argc, argv, "-i", sParm ) || sParm == "" ){
+    PrintHelp();
     return 1;
   }
 
-  if(( iRc = x.OpenHighestVersion( av[1], "", &MyFile )) != XB_NO_ERROR ){
-    std::cout << "Could not open file iRc = " << iRc  << " file = "  << av[1] << std::endl;
+  if(( iRc = x.OpenHighestVersion( sParm.Str(), "", &MyFile )) != XB_NO_ERROR ){
+    std::cout << "Could not open file RC = " << iRc  << " file = "  << sParm.Str() << std::endl;
     x.DisplayError( iRc );
-    return 0;
+    return 1;
   }
 
   iRc = MyFile->DeleteAllRecords(); 
   if( iRc != XB_NO_ERROR ) {
-    std::cout << "Error Deleting all records - database ==> "  << av[1]  << "\n";
-    std::cout << " Return Code = " << iRc;
+    std::cout << "Error Deleting all records - database ==> "  << sParm.Str()  << "\n";
+    std::cout << "Return Code = " << iRc;
+    x.DisplayError( iRc );
+    return 1;
   }
   MyFile->Close();
-  std::cout << "\nDone...\n\n";
-  
+  delete MyFile;
   return 0;
-
 }
\ No newline at end of file
diff --git a/src/utils/xb_dumpdbt.cpp b/src/utils/xb_dumpdbt.cpp
index bc95ab7..05b7209 100755
--- a/src/utils/xb_dumpdbt.cpp
+++ b/src/utils/xb_dumpdbt.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2017 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2017,2023 Gary A Kunkel
 
 The xb64 software library is covered under 
 the terms of the GPL Version 3, 2007 license.
@@ -16,16 +16,25 @@ Email Contact:
 
 
 #include <xbase.h>
-
 using namespace xb;
 
-int main( int ac, char **av )
-{
 
+void PrintHelp();
+void PrintHelp(){
+  std::cout << "Usage: xb_dumpdbt [-h] [-?] [--help] [-v] [--version] -i filename.DBF"  << std::endl << std::endl;
+  std::cout << "This program dumps memo record data from an xbase formatted DBT file to stdout." << std::endl << std::endl;
+}
+void PrintVersion();
+void PrintVersion(){
+  std::cout << "Xbase64 Version: " << xbase_VERSION_MAJOR << "." << xbase_VERSION_MINOR << "." << xbase_VERSION_PATCH << std::endl;
+}
+
+int main(int argc, char *argv[] )
+{
 
-#ifdef XB_MEMO_SUPPORT
-  xbXBase x;
 
+  #ifdef XB_MEMO_SUPPORT
+  xbXBase  x;
   xbInt16  iRc;
   char     cFieldType;
   xbDbf    *MyFile = NULL;
@@ -34,19 +43,33 @@ int main( int ac, char **av )
   xbInt32  lBlockPtr;
   xbString sMemoFldData;
 
-  if( ac <= 1 ){
-    std::cout << "\nUsage: dumpdbt filename...\n";
+  xbString sParm;
+  if (argc < 2 || x.GetCmdLineOpt( argc, argv, "-h", sParm ) ||
+                  x.GetCmdLineOpt( argc, argv, "-?", sParm ) ||
+                  x.GetCmdLineOpt( argc, argv, "--help", sParm )){
+    PrintHelp();
+    return 1;
+  }
+
+  if ( x.GetCmdLineOpt( argc, argv, "-v", sParm ) ||
+       x.GetCmdLineOpt( argc, argv, "--version", sParm )){
+    PrintVersion();
     return 1;
   }
 
-  if(( iRc = x.OpenHighestVersion( av[1], "", &MyFile )) != XB_NO_ERROR ){
-    std::cout << "Could not open file iRc = " << iRc  << " file = "  << av[1] << std::endl;
+  if( !x.GetCmdLineOpt( argc, argv, "-i", sParm ) || sParm == "" ){
+    PrintHelp();
+    return 1;
+  }
+
+  if(( iRc = x.OpenHighestVersion( sParm.Str(), "", &MyFile )) != XB_NO_ERROR ){
+    std::cout << "Could not open file iRc = " << iRc  << " file = "  << sParm.Str() << std::endl;
     x.DisplayError( iRc );
-    return 0;
+    return 1;
   }
 
   if( MyFile->GetMemoFieldCnt() == 0 ) {
-    std::cout << "No memo fields exist in " << av[1] << std::endl;
+    std::cout << "No memo fields exist in " << sParm.Str() << std::endl;
   } else {
 
     xbUInt32 ulRecCnt = 0;
@@ -78,10 +101,9 @@ int main( int ac, char **av )
     MyFile->Close();
     delete MyFile;
   }
-
-#else
-    std::cout << "\nXB_MEMO_SUPPORT is OFF\n";
-#endif
+  #else
+  std::cout << "\nXB_MEMO_SUPPORT is OFF\n";
+  #endif
 
   return 0;
 }
diff --git a/src/utils/xb_dumphdr.cpp b/src/utils/xb_dumphdr.cpp
deleted file mode 100755
index 267f4c5..0000000
--- a/src/utils/xb_dumphdr.cpp
+++ /dev/null
@@ -1,45 +0,0 @@
-/*  xb_dumphdr.cpp
-
-XBase64 Software Library
-
-Copyright (c) 1997,2003,2014 Gary A Kunkel
-
-The xb64 software library is covered under 
-the terms of the GPL Version 3, 2007 license.
-
-Email Contact:
-
-    xb64-devel@lists.sourceforge.net
-    xb64-users@lists.sourceforge.net
-
-*/
-
-
-#include <xbase.h>
-
-using namespace xb;
-
-int main( int ac, char ** av ){
-
-
-  xbInt16 iRc;
-  xbXBase x;
-  xbDbf   *MyFile = NULL;
-
-  if( ac <= 1 ) {
-    std::cout << "\nUsage: xb_dumphdr filename...\n";
-    return 1;
-  }
-
-  if(( iRc = x.OpenHighestVersion( av[1], "", &MyFile )) != XB_NO_ERROR ){
-    std::cout << "Could not open file iRc = " << iRc  << " file = "  << av[1] << std::endl;
-    x.DisplayError( iRc );
-    return 0;
-  }
-
-  MyFile->DumpHeader( 4 );
-  MyFile->Close();
-  delete MyFile;
-
-  return 0;
-}
diff --git a/src/utils/xb_dumpix.cpp b/src/utils/xb_dumpix.cpp
deleted file mode 100755
index afd8764..0000000
--- a/src/utils/xb_dumpix.cpp
+++ /dev/null
@@ -1,56 +0,0 @@
-/*  xb_dumpix.cpp
-
-XBase64 Software Library
-
-Copyright (c) 1997,2003,2014 Gary A Kunkel
-
-The xb64 software library is covered under 
-the terms of the GPL Version 3, 2007 license.
-
-Email Contact:
-
-    xb64-devel@lists.sourceforge.net
-    xb64-users@lists.sourceforge.net
-
-*/
-
-
-// This program dumps an index file's internal data blocks.
-// This program is for index development and debugging purposes
-
-
-#include <xbase.h>
-
-using namespace xb;
-
-int main( int ac, char ** av ){
-
-
-  xbInt16 iRc;
-  xbXBase x;
-  xbDbf   *MyFile = NULL;
-  x.EnableMsgLogging();
-  x.SetLogSize( 1000000L );
-
-  if( ac <= 1 ) {
-    std::cout << "\nUsage: xb_dumphdr filename...\n";
-    return 1;
-  }
-  if(( iRc = x.OpenHighestVersion( av[1], "", &MyFile )) != XB_NO_ERROR ){
-    std::cout << "Could not open file iRc = " << iRc  << " file = "  << av[1] << std::endl;
-    x.DisplayError( iRc );
-    return 0;
-  }
-  xbIx *pIx = MyFile->GetCurIx();
-  if( pIx ){
-    // pIx->DumpHeader( 2, 3 );
-    pIx->DumpTagBlocks( 2 );
-  } else {
-    std::cout << av[1] << "No current index found" << std::endl;
-  }
-
-  MyFile->Close();
-  delete MyFile;
-
-  return 0;
-}
diff --git a/src/utils/xb_dumprecs.cpp b/src/utils/xb_dumprecs.cpp
index 0a85f45..cf6e33c 100755
--- a/src/utils/xb_dumprecs.cpp
+++ b/src/utils/xb_dumprecs.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2019 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2019,2023 Gary A Kunkel
 
 The xb64 software library is covered under 
 the terms of the GPL Version 3, 2007 license.
@@ -17,27 +17,57 @@ Email Contact:
 #include <xbase.h>
 using namespace xb;
 
-int main(int ac,char** av)
+void PrintHelp();
+void PrintHelp(){
+  std::cout << "Usage: xb_dumprecs [-h] [-?] [--help] [-v] [--version] -i filename.DBF"  << std::endl << std::endl;
+  std::cout << "This program dumps data records in an xbase formatted DBF file to stdout in csv format." << std::endl;
+  std::cout << "Memo data (variable length) is not included in this export.  See program xb_dumpdpt for memo data." << std::endl << std::endl;
+}
+void PrintVersion();
+void PrintVersion(){
+  std::cout << "Xbase64 Version: " << xbase_VERSION_MAJOR << "." << xbase_VERSION_MINOR << "." << xbase_VERSION_PATCH << std::endl;
+}
+
+int main(int argc, char *argv[] )
 {
   xbXBase x;
+
+
   xbInt16 iRc;
   x.EnableMsgLogging();
   x.SetLogSize( 1000000L );
-//  xbUInt32 ulRecCnt = 0;
 
-  if (ac <= 1) {
-    std::cout << "Usage: xb_dumprecs filename..." << std::endl;
+  xbString sParm;
+  if (argc < 2 || x.GetCmdLineOpt( argc, argv, "-h", sParm ) ||
+                  x.GetCmdLineOpt( argc, argv, "-?", sParm ) ||
+                  x.GetCmdLineOpt( argc, argv, "--help", sParm )){
+    PrintHelp();
+    return 1;
+  }
+
+  if ( x.GetCmdLineOpt( argc, argv, "-v", sParm ) ||
+       x.GetCmdLineOpt( argc, argv, "--version", sParm )){
+    PrintVersion();
+    return 1;
+  }
+
+  if( !x.GetCmdLineOpt( argc, argv, "-i", sParm ) || sParm == "" ){
+    PrintHelp();
     return 1;
   }
 
   xbDbf *MyFile = NULL;
-  if(( iRc = x.OpenHighestVersion( av[1], "", &MyFile )) != XB_NO_ERROR ){
-    std::cout << "Could not open file iRc = " << iRc  << " file = "  << av[1] << std::endl;
+  if(( iRc = x.OpenHighestVersion( sParm.Str(), "", &MyFile )) != XB_NO_ERROR ){
+    std::cout << "Could not open file RC = " << iRc  << " file = "  << sParm.Str() << std::endl;
     x.DisplayError( iRc );
-    return 0;
+    return 1;
   }
 
-//  std::cout << "Processing file sequentially from beginning..." << std::endl;
+  //  std::cout << "Processing file sequentially from beginning..." << std::endl;
+
+  #ifdef XB_BLOCKREAD_SUPPORT
+  MyFile->EnableBlockReadProcessing();
+  #endif
 
   xbUInt32 j = 0;
   xbUInt32 ulRecCnt = 0;
@@ -48,15 +78,21 @@ int main(int ac,char** av)
     return iRc;
   while( j < ulRecCnt ){
     if( j == 0 )
-      iRc = MyFile->DumpRecord(++j, 2, 2 );
+      iRc = MyFile->DumpRecord(++j, 2, 2 );   // header + data
     else
-      iRc = MyFile->DumpRecord(++j, 2, 1 );
+      iRc = MyFile->DumpRecord(++j, 2, 1 );   // data only
     if( iRc != XB_NO_ERROR ){
       x.DisplayError( iRc );
       return 1;
     }
   }
-//  std::cout << j << " Records written to logile" << std::endl;
+  std::cout << j << " Records processed." << std::endl;
+
+  #ifdef XB_BLOCKREAD_SUPPORT
+  MyFile->DisableBlockReadProcessing();
+  #endif
+
   MyFile->Close();
+
   return 0;
 }
diff --git a/src/utils/xb_execsql.cpp b/src/utils/xb_execsql.cpp
index d474593..daa6b6e 100755
--- a/src/utils/xb_execsql.cpp
+++ b/src/utils/xb_execsql.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2023 Gary A Kunkel
 
 The xb64 software library is covered under 
 the terms of the GPL Version 3, 2007 license.
diff --git a/src/utils/xb_pack.cpp b/src/utils/xb_pack.cpp
index ccec5a3..0cbba7e 100755
--- a/src/utils/xb_pack.cpp
+++ b/src/utils/xb_pack.cpp
@@ -2,7 +2,7 @@
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2017 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2017,2023 Gary A Kunkel
 
 The xb64 software library is covered under 
 the terms of the GPL Version 3, 2007 license.
@@ -17,33 +17,59 @@ Email Contact:
 #include <xbase.h>
 using namespace xb;
 
-int main(int ac,char** av)
-{
-  if (ac <= 1) {
-    std::cout <<
-    "\nUsage: xb_pack filename...\n"
-    "\nThis program does automatically reindexes any open NDX or MDX indexes.";
-    return 1;
-  }
+void PrintHelp();
+void PrintHelp(){
+  std::cout << "Usage: xb_pack [-h] [-?] [--help] [-v] [--version] -i filename.DBF"  << std::endl << std::endl;
+  std::cout << "This program removes data records that are flagged for deletion in a DBF file and rebuilds indices." << std::endl << std::endl;
+}
+void PrintVersion();
+void PrintVersion(){
+  std::cout << "Xbase64 Version: " << xbase_VERSION_MAJOR << "." << xbase_VERSION_MINOR << "." << xbase_VERSION_PATCH << std::endl;
+}
 
+int main(int argc, char *argv[] )
+{
   xbXBase x;
   xbInt16 iRc;
   xbDbf * MyFile = NULL;
-  if(( iRc = x.OpenHighestVersion( av[1], "", &MyFile )) != XB_NO_ERROR ){
-    std::cout << "Could not open file iRc = " << iRc  << " file = "  << av[1] << std::endl;
+
+  xbString sParm;
+  if (argc < 2 || x.GetCmdLineOpt( argc, argv, "-h", sParm ) ||
+                  x.GetCmdLineOpt( argc, argv, "-?", sParm ) ||
+                  x.GetCmdLineOpt( argc, argv, "--help", sParm )){
+    PrintHelp();
+    return 1;
+  }
+
+  if ( x.GetCmdLineOpt( argc, argv, "-v", sParm ) ||
+       x.GetCmdLineOpt( argc, argv, "--version", sParm )){
+    PrintVersion();
+    return 1;
+  }
+
+  if( !x.GetCmdLineOpt( argc, argv, "-i", sParm ) || sParm == "" ){
+    PrintHelp();
+    return 1;
+  }
+
+  if(( iRc = x.OpenHighestVersion( sParm.Str(), "", &MyFile )) != XB_NO_ERROR ){
+    std::cout << "Could not open file iRc = " << iRc  << " file = "  << sParm.Str() << std::endl;
     x.DisplayError( iRc );
-    return 0;
+    return 1;
   }
 
   if(( iRc  = MyFile->Pack()) != XB_NO_ERROR ) {
-    std::cout << "\nError packing DBF database ==> " << av[1] << std::endl;
+    std::cout << "\nError packing DBF database ==> " << sParm.Str() << std::endl;
     std::cout << " Return Code = " << iRc << std::endl;
+    return 1;
   }
 
   #ifdef XB_INDEX_SUPPORT
   if(( iRc  = MyFile->Reindex( 1 )) != XB_NO_ERROR ) {
-    std::cout << "\nError reindexing DBF database ==> " << av[1] << std::endl;
+    std::cout << "\nError reindexing DBF database ==> " << sParm.Str() << std::endl;
     std::cout << " Return Code = " << iRc << std::endl;
+    x.DisplayError( iRc );
+    return 1;
   }
   #endif  // XB_INDEX_SUPPORT
 
diff --git a/src/utils/xb_tblinfo.cpp b/src/utils/xb_tblinfo.cpp
index 6b88403..241642a 100755
--- a/src/utils/xb_tblinfo.cpp
+++ b/src/utils/xb_tblinfo.cpp
@@ -1,8 +1,8 @@
-/*  xb_dumpmdx.cpp
+/*  xb_tblinfo.cpp
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2021 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2021,2023 Gary A Kunkel
 
 The xb64 software library is covered under 
 the terms of the GPL Version 3, 2007 license.
@@ -19,85 +19,86 @@ Email Contact:
 
 using namespace xb;
 
-int main( int ac, char ** av ){
+
+void PrintHelp();
+void PrintHelp(){
+  std::cout << "Usage: xb_tblinfo [-h] [-?] [--help] [-v] [--version] -i filename.DBF"  << std::endl << std::endl;
+  std::cout << "This program dumps table definition information from a DBF file and associated indices." << std::endl << std::endl;
+}
+void PrintVersion();
+void PrintVersion(){
+  std::cout << "Xbase64 Version: " << xbase_VERSION_MAJOR << "." << xbase_VERSION_MINOR << "." << xbase_VERSION_PATCH << std::endl;
+}
+
+int main(int argc, char *argv[] ){
 
   xbXBase  x;
-  xbBool   bHdr      = xbFalse;
   xbInt16  iRc;
   xbString sTagName;
   xbDbf    *MyFile = NULL;
 
-  #ifdef   XB_MDX_SUPPORT
-  #ifdef   XB_DEBUG_SUPPORT
-  xbBool   bMdxFound = xbFalse;
-  #endif   // XB_DEBUG_SUPPORT
-  #endif   // XB_MDX_SUPPORT
-
-
   x.EnableMsgLogging();
   x.SetLogSize( 1000000L );
 
-
-  if( ac <= 1 ) {
-    std::cout << "\nUsage: xb_dumpmdx filename.DBF -h -tTAGNAME...\n";
-    std::cout << "-h dump mdx file header (default)\n";
-    std::cout << "-tTAGNAME where TAGNAME is the name of a tag for extract\n";
+  xbString sParm;
+  if (argc < 2 || x.GetCmdLineOpt( argc, argv, "-h", sParm ) ||
+                  x.GetCmdLineOpt( argc, argv, "-?", sParm ) ||
+                  x.GetCmdLineOpt( argc, argv, "--help", sParm )){
+    PrintHelp();
     return 1;
   }
 
-  if( ac > 2 ){
-    for( int i = 1; i< ac; i++ ){
-      if( strstr( av[i], "-h" ))
-        bHdr = xbTrue;
-      else if( strstr( av[i], "-t" ))
-        sTagName.Set( av[i]+2 );
-    }
+  if ( x.GetCmdLineOpt( argc, argv, "-v", sParm ) ||
+       x.GetCmdLineOpt( argc, argv, "--version", sParm )){
+    PrintVersion();
+    return 1;
   }
 
-  if( bHdr == xbFalse && sTagName == "" )
-    bHdr = xbTrue;
-
-
-  //  std::cout << "Hdr = " << bHdr << std::endl;
-  if( sTagName != "" )
-    std::cout << "Tag = " << sTagName.Str() << std::endl;
+  if( !x.GetCmdLineOpt( argc, argv, "-i", sParm ) || sParm == "" ){
+    PrintHelp();
+    return 1;
+  }
 
-  if(( iRc = x.OpenHighestVersion( av[1], "", &MyFile )) != XB_NO_ERROR ){
-    std::cout << "Could not open file iRc = " << iRc  << " file = "  << av[1] << std::endl;
+  if(( iRc = x.OpenHighestVersion( sParm.Str(), "", &MyFile )) != XB_NO_ERROR ){
+    std::cout << "Could not open file iRc = " << iRc  << " file = "  << sParm.Str() << std::endl;
     x.DisplayError( iRc );
-    return 0;
+    return 1;
   }
   MyFile->DumpHeader( 4 );
 
-  #ifdef XB_MDX_SUPPORT
-  // for each mdx file, dump the header
-  xbIxList *ixl = MyFile->GetIxList();
-  xbIx *ixp;
+
+
+  #ifdef XB_INDEX_SUPPORT
+  xbIxList *ixl;
+  xbIx     *ixp;
   xbString sFileType;
+
+  #ifdef XB_MDX_SUPPORT
+  ixl = MyFile->GetIxList();
   while( ixl ){
     ixp = ixl->ix;
     ixp->GetFileType( sFileType );
-
-    #ifdef XB_DEBUG_SUPPORT
-    if( sFileType == "MDX" ){
-      bMdxFound = xbTrue;
-      if( bHdr ){
-        ixp->DumpHeader( 1, 3 );
-      }
-    }
-    #endif // XB_DEBUG_SUPPORT
+    if( sFileType == "MDX" )
+      ixp->DumpHeader( 1, 3 );
     ixl = ixl->next;
   }
-
-  #ifdef XB_DEBUG_SUPPORT
-  if( !bMdxFound )
-    std::cout << "No MDX index for file." << std::endl;
-  #endif  // XB_DEBUG_SUPPORT
   #endif // XB_MDX_SUPPORT
 
 
+  #ifdef XB_NDX_SUPPORT
+  ixl = MyFile->GetIxList();
+  while( ixl ){
+    ixp = ixl->ix;
+    ixp->GetFileType( sFileType );
+    if( sFileType == "NDX" )
+      ixp->DumpHeader( 1, 3 );
+    ixl = ixl->next;
+  }
+  #endif // XB_NDX_SUPPORT
+
+  #endif // XB_INDEX_SUPPORT
+
   MyFile->Close();
   delete MyFile;
-
   return 0;
 }
diff --git a/src/utils/xb_undelall.cpp b/src/utils/xb_undelall.cpp
index 4f1af12..5fb1323 100755
--- a/src/utils/xb_undelall.cpp
+++ b/src/utils/xb_undelall.cpp
@@ -1,8 +1,8 @@
-/*  xb_deletall.cpp
+/*  xb_undelall.cpp
 
 XBase64 Software Library
 
-Copyright (c) 1997,2003,2014,2017 Gary A Kunkel
+Copyright (c) 1997,2003,2014,2017,2023 Gary A Kunkel
 
 The xb64 software library is covered under 
 the terms of the GPL Version 3, 2007 license.
@@ -13,8 +13,7 @@ Email Contact:
     xb64-users@lists.sourceforge.net
 
 
-
-This program sets the delete flag on all records in a dbf file
+This program removes the delete flag on all records flagged for deletion in a DBF file
 
 */
 
@@ -24,32 +23,60 @@ This program sets the delete flag on all records in a dbf file
 
 using namespace xb;
 
-int main(int ac,char** av)
+
+
+void PrintHelp();
+void PrintHelp(){
+  std::cout << "Usage: xb_undelall [-h] [-?] [--help] [-v] [--version] -i myfile"  << std::endl << std::endl;
+  std::cout << "This program removes the deletion flags all the records in a DBF table that are flagged for deletion.";
+  std::cout << std::endl << std::endl;
+}
+void PrintVersion();
+void PrintVersion(){
+  std::cout << "Xbase64 Version: " << xbase_VERSION_MAJOR << "." << xbase_VERSION_MINOR << "." << xbase_VERSION_PATCH << std::endl;
+}
+
+
+int main(int argc, char *argv[])
 {
 
   xbXBase x;
   xbDbf *MyFile = NULL;
   xbInt16 iRc = 0;
 
-  if (ac <= 1) {
-    std::cout << "\nUsage: xb_deletall filename...\n";
+  xbString sParm;
+
+  if (argc < 2 || x.GetCmdLineOpt( argc, argv, "-h", sParm ) ||
+                  x.GetCmdLineOpt( argc, argv, "-?", sParm ) ||
+                  x.GetCmdLineOpt( argc, argv, "--help", sParm )){
+    PrintHelp();
+    return 1;
+  }
+
+  if ( x.GetCmdLineOpt( argc, argv, "-v", sParm ) ||
+       x.GetCmdLineOpt( argc, argv, "--version", sParm )){
+    PrintVersion();
     return 1;
   }
 
-  if(( iRc = x.OpenHighestVersion( av[1], "", &MyFile )) != XB_NO_ERROR ){
-    std::cout << "Could not open file iRc = " << iRc  << " file = "  << av[1] << std::endl;
+  if( !x.GetCmdLineOpt( argc, argv, "-i", sParm ) || sParm == "" ){
+    PrintHelp();
+    return 1;
+  }
+
+  if(( iRc = x.OpenHighestVersion( sParm.Str(), "", &MyFile )) != XB_NO_ERROR ){
+    std::cout << "Could not open file RC = " << iRc  << " file = "  << sParm.Str() << std::endl;
     x.DisplayError( iRc );
-    return 0;
+    return 1;
   }
 
   iRc = MyFile->UndeleteAllRecords(); 
   if( iRc != XB_NO_ERROR ) {
-    std::cout << "Error Undeleting all records - database ==> "  << av[1]  << "\n";
+    std::cout << "Error Undeleting all records - database ==> "  << sParm.Str()  << "\n";
     std::cout << " Return Code = " << iRc;
+    return 1;
   }
   MyFile->Close();
   delete MyFile;
-  std::cout << "\nDone...\n\n";
-  
   return 0;
 }
\ No newline at end of file
diff --git a/src/utils/xb_zap.cpp b/src/utils/xb_zap.cpp
deleted file mode 100755
index 4660cd8..0000000
--- a/src/utils/xb_zap.cpp
+++ /dev/null
@@ -1,52 +0,0 @@
-/*  xb_zap.cpp
-
-XBase64 Software Library
-
-Copyright (c) 1997,2003,2014,2017 Gary A Kunkel
-
-The xb64 software library is covered under 
-the terms of the GPL Version 3, 2007 license.
-
-Email Contact:
-
-    xb64-devel@lists.sourceforge.net
-    xb64-users@lists.sourceforge.net
-
-*/
-
-#include <xbase.h>
-using namespace xb;
-
-int main(int ac,char** av)
-{
-  if (ac <= 1) {
-     std::cout << 
-           "\nUsage: zap filename...\n"
-           "\nThis program does not automatically reindex any indices."
-           "\nUse the reindex program to reindex any indexes associated"
-           "\nwith the database, or build your own program which executes "
-           "\nthe PackDatabase() method after opening all the index files "
-           "\nassociated with the database.\n\n"
-           ;
-     return 1;
-  }
-
-  xbXBase x;
-  xbInt16 iRc;
-  xbDbf *MyFile = NULL;
-
-  if(( iRc = x.OpenHighestVersion( av[1], "", &MyFile )) != XB_NO_ERROR ){
-    std::cout << "Could not open file " << av[1] << std::endl;
-    return iRc;
-  }
-
-  if(( iRc = MyFile->Zap()) != XB_NO_ERROR ) {
-    std::cout << "\nError packing DBF database ==> " << av[1] << std::endl;
-    std::cout << " Return Code = " << iRc << std::endl;
-  }
-  MyFile->Close();
-  delete MyFile;
-
-  std::cout << "\nZap Database complete..." << std::endl;
-  return 0;
-}