summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2022-12-07 13:17:14 +0100
committerJörg Frings-Fürst <debian@jff-webhosting.net>2022-12-07 13:17:14 +0100
commit4875a3dd9b183dcd2256e2abfc4ccf7484c233b4 (patch)
tree0abbea881ded030851014ffdd60fbf71fead8f65 /src
parentdaf17154bf13139d9375f48525d19d6aaba08155 (diff)
New upstream version 4.0.2upstream/4.0.2
Diffstat (limited to 'src')
-rwxr-xr-xsrc/core/xbbcd.cpp333
-rwxr-xr-xsrc/core/xbdate.cpp802
-rwxr-xr-xsrc/core/xbdbf.cpp4220
-rwxr-xr-xsrc/core/xbdbf3.cpp577
-rwxr-xr-xsrc/core/xbdbf4.cpp590
-rwxr-xr-xsrc/core/xbexp.cpp2643
-rwxr-xr-xsrc/core/xbexpnode.cpp562
-rwxr-xr-xsrc/core/xbfields.cpp1122
-rwxr-xr-xsrc/core/xbfile.cpp2052
-rwxr-xr-xsrc/core/xbfilter.cpp569
-rwxr-xr-xsrc/core/xbfuncs.cpp850
-rwxr-xr-xsrc/core/xbixbase.cpp792
-rwxr-xr-xsrc/core/xbixmdx.cpp5067
-rwxr-xr-xsrc/core/xbixndx.cpp2840
-rwxr-xr-xsrc/core/xblog.cpp208
-rwxr-xr-xsrc/core/xbmemo.cpp219
-rwxr-xr-xsrc/core/xbmemo3.cpp590
-rwxr-xr-xsrc/core/xbmemo4.cpp1372
-rwxr-xr-xsrc/core/xbssv.cpp550
-rwxr-xr-xsrc/core/xbstring.cpp1839
-rwxr-xr-xsrc/core/xbtag.cpp121
-rwxr-xr-xsrc/core/xbtblmgr.cpp257
-rwxr-xr-xsrc/core/xbuda.cpp78
-rwxr-xr-xsrc/core/xbxbase.cpp712
-rwxr-xr-xsrc/examples/xb_ex_date.cpp210
-rwxr-xr-xsrc/examples/xb_ex_sql.cpp111
-rwxr-xr-xsrc/examples/xb_ex_string.cpp385
-rwxr-xr-xsrc/examples/xb_ex_v3_create_dbf.cpp102
-rwxr-xr-xsrc/examples/xb_ex_v3_upd_dbf.cpp282
-rwxr-xr-xsrc/examples/xb_ex_v4_create_dbf.cpp81
-rwxr-xr-xsrc/examples/xb_ex_v4_upd_dbf.cpp283
-rwxr-xr-xsrc/include/xbase.h93
-rwxr-xr-xsrc/include/xbbcd.h95
-rwxr-xr-xsrc/include/xbconfig.h.in122
-rwxr-xr-xsrc/include/xbdate.h123
-rwxr-xr-xsrc/include/xbdbf.h538
-rwxr-xr-xsrc/include/xbexp.h215
-rwxr-xr-xsrc/include/xbexpnode.h120
-rwxr-xr-xsrc/include/xbfile.h194
-rwxr-xr-xsrc/include/xbfilter.h78
-rwxr-xr-xsrc/include/xbindex.h605
-rwxr-xr-xsrc/include/xblnklst.h257
-rwxr-xr-xsrc/include/xblnklstord.h367
-rwxr-xr-xsrc/include/xblnknod.h94
-rwxr-xr-xsrc/include/xblog.h66
-rwxr-xr-xsrc/include/xbmemo.h223
-rwxr-xr-xsrc/include/xbretcod.h94
-rwxr-xr-xsrc/include/xbsql.h69
-rwxr-xr-xsrc/include/xbssv.h177
-rwxr-xr-xsrc/include/xbstring.h183
-rwxr-xr-xsrc/include/xbtag.h74
-rwxr-xr-xsrc/include/xbtblmgr.h61
-rwxr-xr-xsrc/include/xbtypes.h55
-rwxr-xr-xsrc/include/xbuda.h52
-rwxr-xr-xsrc/include/xbxbase.h222
-rwxr-xr-xsrc/sql/xbcrix.cpp279
-rwxr-xr-xsrc/sql/xbcrtbl.cpp256
-rwxr-xr-xsrc/sql/xbdrpix.cpp143
-rwxr-xr-xsrc/sql/xbdrptbl.cpp125
-rwxr-xr-xsrc/sql/xbinsert.cpp190
-rwxr-xr-xsrc/sql/xbset.cpp91
-rwxr-xr-xsrc/sql/xbsql.cpp143
-rwxr-xr-xsrc/tests/tstfuncs.cpp581
-rwxr-xr-xsrc/tests/xb_test_bcd.cpp128
-rwxr-xr-xsrc/tests/xb_test_date.cpp189
-rwxr-xr-xsrc/tests/xb_test_dbf_v3_memos.cpp233
-rwxr-xr-xsrc/tests/xb_test_dbf_v3_nomemos.cpp323
-rwxr-xr-xsrc/tests/xb_test_dbf_v4_memos.cpp335
-rwxr-xr-xsrc/tests/xb_test_dbf_v4_nomemos.cpp330
-rwxr-xr-xsrc/tests/xb_test_expnode.cpp123
-rwxr-xr-xsrc/tests/xb_test_expression.cpp791
-rwxr-xr-xsrc/tests/xb_test_file.cpp212
-rwxr-xr-xsrc/tests/xb_test_filter.cpp185
-rwxr-xr-xsrc/tests/xb_test_funcs.cpp288
-rwxr-xr-xsrc/tests/xb_test_linklist.cpp340
-rwxr-xr-xsrc/tests/xb_test_lock.cpp874
-rwxr-xr-xsrc/tests/xb_test_lock2.cpp208
-rwxr-xr-xsrc/tests/xb_test_log.cpp88
-rwxr-xr-xsrc/tests/xb_test_mdx.cpp243
-rwxr-xr-xsrc/tests/xb_test_ndx.cpp330
-rwxr-xr-xsrc/tests/xb_test_ndx2.cpp145
-rwxr-xr-xsrc/tests/xb_test_sql.cpp107
-rwxr-xr-xsrc/tests/xb_test_string.cpp397
-rwxr-xr-xsrc/tests/xb_test_tblmgr.cpp167
-rwxr-xr-xsrc/tests/xb_test_uda.cpp98
-rwxr-xr-xsrc/tests/xb_test_xbase.cpp106
-rwxr-xr-xsrc/utils/checkndx.cpp71
-rwxr-xr-xsrc/utils/dbfxtrct.cpp182
-rwxr-xr-xsrc/utils/preamble.txt19
-rwxr-xr-xsrc/utils/reindex.cpp83
-rwxr-xr-xsrc/utils/xb_cfg_check.cpp370
-rwxr-xr-xsrc/utils/xb_copydbf.cpp62
-rwxr-xr-xsrc/utils/xb_dbfutil.cpp3719
-rwxr-xr-xsrc/utils/xb_deletall.cpp55
-rwxr-xr-xsrc/utils/xb_dumpdbt.cpp87
-rwxr-xr-xsrc/utils/xb_dumphdr.cpp45
-rwxr-xr-xsrc/utils/xb_dumpix.cpp56
-rwxr-xr-xsrc/utils/xb_dumprecs.cpp62
-rwxr-xr-xsrc/utils/xb_execsql.cpp95
-rwxr-xr-xsrc/utils/xb_pack.cpp55
-rwxr-xr-xsrc/utils/xb_tblinfo.cpp91
-rwxr-xr-xsrc/utils/xb_undelall.cpp55
-rwxr-xr-xsrc/utils/xb_zap.cpp52
103 files changed, 47803 insertions, 0 deletions
diff --git a/src/core/xbbcd.cpp b/src/core/xbbcd.cpp
new file mode 100755
index 0000000..4855e80
--- /dev/null
+++ b/src/core/xbbcd.cpp
@@ -0,0 +1,333 @@
+/* xbbcd.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
+
+ BCD class
+
+*/
+
+#include "xbase.h"
+
+#ifdef XB_INDEX_SUPPORT
+///@cond DOXYOFF
+namespace xb{
+
+
+
+xbBool bcdBitSet( unsigned char c, xbInt16 iBitNo ){
+ return c & 1 << iBitNo;
+}
+void bcdBitDump( unsigned char c ){
+ for( int i = 7; i >= 0; i-- )
+ std::cout << (bcdBitSet( c, i ) ? 1 : 0);
+}
+void bcdBitDump( char c ){
+ bcdBitDump( (unsigned char) c );
+}
+
+
+/***********************************************************************/
+void xbBcd::ctor(){
+ memset( &bcd, 0x00, sizeof( xbBcdStruct ));
+}
+/***********************************************************************/
+xbBcd::xbBcd( xbDouble d ) {
+ Set( d );
+}
+/***********************************************************************/
+xbBcd::xbBcd( const xbString &sNumIn ) {
+ Set( sNumIn );
+}
+/***********************************************************************/
+xbBcd::xbBcd( const void *vBcdIn ) {
+ memcpy( &bcd, vBcdIn, sizeof( xbBcdStruct ));
+}
+/***********************************************************************/
+void xbBcd::Set( xbDouble d ) {
+ ctor();
+ xbString s( d );
+ StringToBcd( s );
+}
+/***********************************************************************/
+void xbBcd::Set( const xbString &sNumIn ) {
+ ctor();
+ StringToBcd( sNumIn );
+}
+/***********************************************************************/
+void xbBcd::Set( const void *vBcdIn ) {
+ memcpy( &bcd, vBcdIn, sizeof( xbBcdStruct ));
+}
+/***********************************************************************/
+void xbBcd::StringToBcd( const xbString &sIn )
+{
+
+ unsigned char cEdc = 0; // encoded digit count
+ xbUInt32 iPos; // current position in source string
+ xbBool bDecHit = xbFalse; // decimal position hit?
+ unsigned char *p = bcd.cData; // pointer to cData
+ xbInt16 iBytePos = 0; // next load position in xbs structure
+ xbInt16 iBcdDataPos = 0; // current position in output structure
+ xbByteSplit xbs; // combiner
+
+
+ ctor();
+ xbString sNum( sIn );
+ xbBool bSign = xbFalse;
+
+ sNum.Trim();
+ if( sNum[1] == '-' ){
+ bSign = 1;
+ sNum.ZapLeadingChar( '-' );
+ }
+ sNum.ZapLeadingChar( '0' );
+
+ xbInt16 iDecPos = sNum.Pos( '.' );
+ if( iDecPos > 0 ){
+ sNum.ZapTrailingChar( '0' );
+ cEdc = (unsigned char) (sNum.Len() - 1);
+ } else {
+ cEdc = (unsigned char) (sNum.Len());
+ }
+ if( cEdc > 31 ) cEdc = 31; // max 5 bit number
+
+
+ if( sNum[1] == '.' ){
+ iPos = 2;
+ bDecHit = xbTrue;
+ while( sNum[iPos] == '0' && iPos <= sNum.Len()){
+ bcd.cSigDigits--;
+ iPos++;
+ }
+ } else {
+ iPos = 1;
+ }
+
+ while( iPos <= sNum.Len() ){
+ if( sNum[iPos] == '.' )
+ bDecHit = true;
+ else{
+ if( !bDecHit ){
+ bcd.cSigDigits++;
+ }
+ if( iBytePos++ == 0 ){
+ xbs.c2 = (unsigned) sNum[iPos] - 0x30;
+ } else {
+ xbs.c1 = (unsigned) sNum[iPos] - 0x30;
+ iBytePos = 0;
+ if( iBcdDataPos++ < 10 ){
+ memcpy( p++, &xbs, 1 );
+ xbs.c1 = 0x00;
+ }
+ }
+ }
+ iPos++;
+ }
+
+ if( iBytePos == 1 && iBcdDataPos < 10 ){
+ memcpy( p, &xbs, 1 );
+ }
+
+ bcd.cSigDigits += 52;
+ bcd.cEncDigits = cEdc << 2;
+ bcd.cEncDigits = bcd.cEncDigits | 0x01;
+ if( bSign )
+ bcd.cEncDigits = bcd.cEncDigits | 0x80;
+
+
+/*
+ std::cout << "num in = " << sIn.Str() << "\n";
+ unsigned char bW[12];
+ memcpy( bW, &bcd, 12 );
+ std::cout << "bx ";
+ for( int i = 0; i < 12; i++ ){
+ bcdBitDump( bW[i] );
+ std::cout << " ";
+ }
+ std::cout << "\n";
+
+ unsigned char cSign = bcd.cEncDigits >> 7;
+ std::cout << "bs ";
+ bcdBitDump( cSign );
+ std::cout << "\n";
+
+ std::cout << "test = ";
+ bcdBitDump( cEdc );
+ std::cout << " ";
+ bcdBitDump( GetEncDigitsNoSign() );
+ std::cout << "\n";
+ bcdBitDump( bcd.cEncDigits );
+
+ unsigned char c = bcd.cEncDigits;
+ c = c << 1;
+ c = c >> 3;
+ std::cout << " ";
+ bcdBitDump( c );
+ std::cout << "\n";
+*/
+}
+/***********************************************************************/
+void xbBcd::ToChar( char * cOut ){
+
+ memcpy( cOut, &bcd, sizeof( xbBcdStruct ));
+}
+/***********************************************************************/
+void xbBcd::ToDouble( xbDouble &d ){
+ xbString s;
+ ToString( s );
+ d = atof( s.Str());
+}
+/***********************************************************************/
+void xbBcd::ToString( xbString &sStringOut ){
+
+// printf( "\n\n\nToString " );
+// printf( "Sig digits [%d] EncodedDigits [%d] sign [%d] sizeof struct [%d]\n",
+// bcd.cSigDigits - 52 , bcd.EncDigits, bcd.Sign, sizeof( xbBcdStruct ));
+
+// this routine converts a bcd numeric key value to a base 10 number in a string
+
+
+ xbBool bHasDot = false;
+ xbInt16 iSig = bcd.cSigDigits - 52;
+ xbByteSplit xbs;
+ unsigned char *p = bcd.cData;
+ unsigned char c;
+
+// xbInt16 iEnc = bcd.cEncDigits;
+ xbInt16 iEnc = GetEncDigitsNoSign();
+
+ // set the sign
+ // if( bcd.Sign )
+ if( bcd.cEncDigits >> 7 )
+ sStringOut = "-";
+ else
+ sStringOut = "";
+
+ // do add any needed zeroes after the decimal
+ if( iSig <= 0 ){
+ if( iEnc > 0 ){
+ sStringOut.Append( "." );
+ bHasDot = true;
+ }
+ for( xbInt16 i = iSig; i < 0; i++ )
+ sStringOut.Append( "0" );
+ }
+
+ // do the encoded digits
+ while( iEnc > 0 ){
+ if( iSig == 0 && !bHasDot )
+ sStringOut.Append( "." );
+ c = *p++;
+ memcpy( &xbs, &c, 1 );
+ c = xbs.c2 + 0x30;
+ sStringOut.Append((char) c );
+ iSig--;
+ iEnc--;
+ if( iEnc > 0 ){
+ if( iSig == 0 && !bHasDot )
+ sStringOut.Append( "." );
+ c = xbs.c1 + 0x30;
+ sStringOut.Append((char) c );
+ iSig--;
+ iEnc--;
+ }
+ }
+ // do the trailing zeroes
+ while( iSig-- > 0 )
+ sStringOut.Append( "0" );
+ if( sStringOut == "" )
+ sStringOut = "0";
+
+}
+
+/***********************************************************************/
+xbInt16 xbBcd::Compare( xbDouble d ){
+ xbBcd bcdIn( d );
+
+ xbString s;
+ bcdIn.ToString( s );
+ return Compare( bcdIn );
+}
+
+/***********************************************************************/
+xbInt16 xbBcd::Compare( const xbBcd &bcdIn ){
+ // if this == bcdIn return 0
+ // if this < bcdIn return -1
+ // if this > bcdIn return 1
+
+
+ xbInt16 iRc = 0;
+// if( bcd.Sign != bcdIn.GetSign() ){
+// bcd.Sign > 0 ? iRc = -1 : iRc = 1;
+
+ if( (bcd.cEncDigits >> 7 ) != bcdIn.GetSign() ){
+ (bcd.cEncDigits >> 7 ) > 0 ? iRc = -1 : iRc = 1;
+ return iRc;
+ }
+
+ if( bcd.cSigDigits != bcdIn.GetSigDigits()){
+ // if( !bcd.Sign ){ // positive numbers
+ if( !(bcd.cEncDigits >> 7 )){ // positive numbers
+ if( bcd.cSigDigits > bcdIn.GetSigDigits())
+ return 1;
+ else
+ return -1;
+ } else { // negative numbers
+ if( bcd.cSigDigits > bcdIn.GetSigDigits())
+ return -1;
+ else
+ return 1;
+ }
+ }
+
+// iRc = xbXBase::xbMemcmp( bcd.cData, bcdIn.GetData(), (size_t)((bcd.cEncDigits + 1) / 2) );
+ iRc = xbXBase::xbMemcmp( bcd.cData, bcdIn.GetData(), (size_t)((GetEncDigitsNoSign() + 1) / 2) );
+ if( iRc == 0 )
+ return 0;
+ // else if((!bcd.Sign && iRc > 0) || (bcd.Sign && iRc < 0 ))
+ else if((!(bcd.cEncDigits >> 7) && iRc > 0) || ((bcd.cEncDigits >> 7) && iRc < 0 ))
+ return 1;
+ else
+ return -1;
+}
+
+
+/***********************************************************************/
+unsigned char xbBcd::GetEncDigitsNoSign() const {
+ unsigned char c = bcd.cEncDigits << 1;
+ return c >> 3;
+}
+/***********************************************************************/
+unsigned xbBcd::GetSign() const {
+ //return bcd.Sign;
+ return bcd.cEncDigits >> 7;
+}
+/***********************************************************************/
+unsigned xbBcd::GetSigDigits() const {
+ return bcd.cSigDigits;
+}
+/***********************************************************************/
+unsigned xbBcd::GetActualSigDigits() const {
+ return bcd.cSigDigits - (xbUInt32) 52;
+}
+/***********************************************************************/
+const unsigned char * xbBcd::GetData() const {
+ const unsigned char *p = bcd.cData;
+ return p;
+}
+/***********************************************************************/
+const void * xbBcd::GetBcd() const {
+ return &bcd;
+}
+} /* namespace */
+///@endcond DOXYOFF
+#endif /* XB_INDEX_SUPPORT */
+
diff --git a/src/core/xbdate.cpp b/src/core/xbdate.cpp
new file mode 100755
index 0000000..ba0fdf1
--- /dev/null
+++ b/src/core/xbdate.cpp
@@ -0,0 +1,802 @@
+/* xbdate.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"
+#include <time.h>
+
+namespace xb{
+
+int xbDate::iDaysInMonths[2][13];
+int xbDate::iAggregatedDaysInMonths[2][13];
+
+/*************************************************************************/
+//! @brief Constructor.
+
+xbDate::xbDate() {
+ Sysdate();
+ SetDateTables();
+}
+
+/*************************************************************************/
+//! @brief Constructor.
+/*!
+ \param sDate8In - Input date.
+*/
+
+xbDate::xbDate( const xbString & sDate8In ) {
+ if( DateIsValid( sDate8In ))
+ sDate8.Set( sDate8In );
+ else
+ Sysdate();
+ SetDateTables();
+}
+
+/*************************************************************************/
+//! @brief Constructor.
+/*!
+ \param sDate8In - Input date.
+*/
+xbDate::xbDate( const char * sDate8In ) {
+
+ if( DateIsValid( sDate8In ))
+ sDate8.Set( sDate8In );
+ else
+ Sysdate();
+ SetDateTables();
+}
+
+/*************************************************************************/
+//! @brief Constructor.
+/*!
+ \param lJulDate - Input julian date.
+*/
+xbDate::xbDate( xbInt32 lJulDate ) {
+ SetDateTables();
+ JulToDate8( lJulDate );
+}
+
+/*************************************************************************/
+//! @brief Destructor.
+xbDate::~xbDate(){}
+/*************************************************************************/
+//! @brief Set operator=
+/*!
+ \param dt - Date value for set operation.
+*/
+void xbDate::operator=( const xbDate & dt ){
+ sDate8.Set( dt.Str());
+}
+/*************************************************************************/
+//! @brief operator +=
+/*!
+ This routine adds lDays to the date
+ \param lDays - Number of days to add to the date.
+*/
+void xbDate::operator+=( xbInt32 lDays ){
+ JulToDate8( JulianDays() + lDays );
+}
+/*************************************************************************/
+//! @brief operator -=
+/*!
+ This routine subtracts lDays from the date.
+ \param lDays - Number of days to subtract from the date.
+*/
+void xbDate::operator-=( xbInt32 lDays ){
+ JulToDate8( JulianDays() - lDays );
+}
+/*************************************************************************/
+//! @brief operator ++
+/*!
+ This routine adds one day to the date field.
+*/
+void xbDate::operator++(xbInt32){
+ *this+=1;
+}
+/*************************************************************************/
+//! @brief operator --
+/*!
+ This routine subtracts one day from the date field.
+*/
+void xbDate::operator--(xbInt32){
+ *this-=1;
+ return;
+}
+/*************************************************************************/
+//! @brief operator -
+/*!
+ This routine subtracts one date from another date returning the difference.
+ \param dt - Date to subtract.
+ \returns Number of days
+*/
+xbInt32 xbDate::operator-( const xbDate &dt ) const{
+ return JulianDays() - dt.JulianDays();
+}
+/*************************************************************************/
+//! @brief operator +
+/*!
+ This routine adds additional days to a date field.
+ \param lCount - Number of days to add.
+ \returns New date in CCYYMMDD format.
+*/
+const char *xbDate::operator+( xbInt32 lCount ){
+ JulToDate8( JulianDays() + lCount );
+ return sDate8.Str();
+}
+/*************************************************************************/
+//! @brief operator -
+/*!
+ This routine subtracts days from a date field.
+ \param lCount - Number of days to subtract.
+ \returns New date in CCYYMMDD format.
+*/
+const char *xbDate::operator-( xbInt32 lCount ){
+ JulToDate8( JulianDays() - lCount );
+ return sDate8;
+}
+/*************************************************************************/
+//! @brief operator ==
+/*!
+ This routine compares two dates for equality.
+ \param dt - Date to compare.
+ \returns xbTrue - Dates match.<br>xbFalse - Dates don't match.
+*/
+xbBool xbDate::operator==( const xbDate &dt ) const{
+ if( JulianDays() == dt.JulianDays() )
+ return xbTrue;
+ else
+ return xbFalse;
+}
+/*************************************************************************/
+//! @brief operator !=
+/*!
+ This routine compares two dates for inequality.
+ \param dt - Date to compare.
+ \returns xbTrue - Dates don't match.<br>xbFalse - Dates match.
+*/
+xbBool xbDate::operator!=( const xbDate &dt ) const{
+ if( JulianDays() != dt.JulianDays() )
+ return xbTrue;
+ else
+ return xbFalse;
+}
+/*************************************************************************/
+//! @brief operator <
+/*!
+ This routine compares two dates
+ \param dt - Date to compare.
+ \returns xbTrue - Left date is less than right date.<br>
+ xbFalse - Left date is not less than right date.
+*/
+xbBool xbDate::operator<( const xbDate &dt ) const {
+ if( JulianDays() < dt.JulianDays() )
+ return xbTrue;
+ else
+ return xbFalse;
+}
+/*************************************************************************/
+//! @brief >
+/*!
+ This routine compares two dates
+ \param dt - Date to compare.
+ \returns xbTrue - Left date is greater than right date.<br>
+ xbFalse - Left date is not greater than right date.
+*/
+xbBool xbDate::operator>( const xbDate &dt ) const {
+ if( JulianDays() > dt.JulianDays() )
+ return xbTrue;
+ else
+ return xbFalse;
+}
+/*************************************************************************/
+//! @brief operator <=
+/*!
+ This routine compares two dates
+ \param dt - Date to compare.
+ \returns xbTrue - Left date is less than or equal to right date.<br>
+ xbFalse - Left date is not less than or equal to right date.
+*/
+xbBool xbDate::operator<=( const xbDate &dt ) const {
+ if( JulianDays() <= dt.JulianDays() )
+ return xbTrue;
+ else
+ return xbFalse;
+}
+/*************************************************************************/
+//! @brief operator >=
+/*!
+ This routine compares two dates
+ \param dt - Date to compare.
+ \returns xbTrue - Left date is greater than or equal to right date.<br>
+ xbFalse - Left date is not greater than or equal to right date.
+*/
+xbBool xbDate::operator>=( const xbDate &dt ) const {
+ if( JulianDays() >= dt.JulianDays() )
+ return xbTrue;
+ else
+ return xbFalse;
+}
+/*************************************************************************/
+//! @brief Calculate century for a given year.
+/*!
+ This routine calculates a century for a given year. It uses an 80/20
+ rolling date window to calculate the century.
+
+ \param iCalcYear - Two digit year to calculate a century for.
+ \returns Century calculated for the two digit year.
+*/
+xbInt16 xbDate::CalcRollingCenturyForYear( xbInt16 iCalcYear ) const {
+
+ xbDate d;
+ xbInt16 iThisYear = d.YearOf();
+ xbInt16 iThisCentury = d.CenturyOf();
+ iThisYear -= (iThisCentury * 100);
+ if( iThisYear < 80 && iCalcYear < (iThisYear+20) )
+ return iThisCentury;
+ else if( iThisYear >= 80 &&
+ iCalcYear < iThisYear &&
+ iCalcYear >= (iThisYear-80))
+ return iThisCentury;
+ else
+ return iThisCentury - 1;
+}
+/*************************************************************************/
+//! @brief Get century for date.
+/*!
+ \returns This routine returns the century from the date.
+*/
+xbInt16 xbDate::CenturyOf() const {
+ char Century[3];
+ Century[0] = sDate8[1];
+ Century[1] = sDate8[2];
+ Century[2] = 0x00;
+ return( atoi( Century ));
+}
+/*************************************************************************/
+//! @brief Get the day of the week.
+/*!
+ \param sOutCharDay - Output character day of week (Sun-Sat).
+ \returns XB_INVALID_DATE<br>XB_NO_ERROR
+*/
+xbInt16 xbDate::CharDayOf( xbString &sOutCharDay ) {
+
+ struct tm tblock;
+ char buf[25];
+
+ tblock.tm_year = YearOf() - 1900;
+ tblock.tm_mon = MonthOf() - 1;
+ tblock.tm_mday = DayOf( XB_FMT_MONTH );
+ tblock.tm_hour = 0;
+ tblock.tm_min = 0;
+ tblock.tm_sec = 1;
+ tblock.tm_isdst = -1;
+ if( mktime( &tblock ) == -1 ){
+ sOutCharDay = "" ;
+ return XB_INVALID_DATE;
+ } else {
+ strftime( buf, 25, "%A", &tblock );
+ sOutCharDay = buf;
+ }
+ return XB_NO_ERROR;;
+}
+/*************************************************************************/
+//! @brief Get the month from the date.
+/*!
+ \param sOutCharMonth - Output character month.
+ \returns XB_INVALID_DATE<br>XB_NO_ERROR
+*/
+xbInt16 xbDate::CharMonthOf( xbString &sOutCharMonth ) {
+ struct tm tblock;
+ char buf[25];
+ tblock.tm_year = YearOf() - 1900;
+ tblock.tm_mon = MonthOf() - 1;
+ tblock.tm_mday = DayOf( XB_FMT_MONTH );
+ tblock.tm_hour = 0;
+ tblock.tm_min = 0;
+ tblock.tm_sec = 1;
+ tblock.tm_isdst = -1;
+ if( mktime( &tblock ) == -1 ){
+ sOutCharMonth = "";
+ return XB_INVALID_DATE;
+ } else {
+ strftime( buf, 25, "%B", &tblock );
+ sOutCharMonth = buf;
+ }
+ return XB_NO_ERROR;
+}
+/*************************************************************************/
+//! @brief Check a date for valid data.
+/*!
+ \param sDateIn - Date to check for valid formaat of CCYYMMDD.
+ \returns xbTrue - Valid date.<br>xbFalse - Not a valid date.
+*/
+xbBool xbDate::DateIsValid( const xbString &sDateIn ) const {
+
+ xbInt16 iYear, iMonth, iDay;
+ char sYear[5];
+ char sMonth[3];
+ char sDay[3];
+
+ if( sDateIn.Len() != 8 )
+ return xbFalse;
+
+ if(!isdigit( sDateIn[1] ) || !isdigit( sDateIn[2] ) || !isdigit( sDateIn[3] ) ||
+ !isdigit( sDateIn[4] ) || !isdigit( sDateIn[5] ) || !isdigit( sDateIn[6] ) ||
+ !isdigit( sDateIn[7] ) || !isdigit( sDateIn[8] ) )
+ return xbFalse;
+
+ sDay[0] = sDateIn[7];
+ sDay[1] = sDateIn[8];
+ sDay[2] = 0x00;
+ iDay = atoi( sDay );
+
+ sMonth[0] = sDateIn[5];
+ sMonth[1] = sDateIn[6];
+ sMonth[2] = 0x00;
+ iMonth = atoi( sMonth );
+
+ sYear[0] = sDateIn[1];
+ sYear[1] = sDateIn[2];
+ sYear[2] = sDateIn[3];
+ sYear[3] = sDateIn[4];
+ sYear[4] = 0x00;
+ iYear = atoi( sYear );
+
+ // valid years are 0001 thru 9999
+ if( iYear < 1 || iYear > 9999 || iMonth < 1 || iMonth > 12 || iDay < 1 || iDay > 31 )
+ return xbFalse;
+
+ // April, June, September and November have 30 days
+ if(( iMonth==4 || iMonth==6 || iMonth==9 || iMonth==11 )&& iDay > 30 )
+ return xbFalse;
+
+ // check for February with leap year
+ if( iMonth == 2 ){
+ if(( iYear % 4 == 0 && iYear % 100 != 0 ) || iYear % 400 == 0 ){
+ if( iDay > 29 ){
+ return xbFalse;
+ }
+ } else if( iDay > 28 ){
+ return xbFalse;
+ }
+ }
+ return xbTrue;
+}
+
+/*************************************************************************/
+//! @brief
+/*!
+ This routine returns the numeric day.
+ \param iFormat
+ XB_FMT_WEEK Number of day in WEEK 0-6 ( Sat - Fri )<br>
+ XB_FMT_MONTH Number of day in MONTH 1-31<br>
+ XB_FMT_YEAR Number of day in YEAR 1-366
+ \returns XB_INVALID_OPTION<br>XB_NO_ERROR
+*/
+
+xbInt16 xbDate::DayOf( xbInt16 iFormat ) const {
+
+ xbInt16 iOutDay = 0;
+ char sDay[3];
+ xbInt16 iDay, iMonth, iYear, iDay2;
+
+ // check for valid format switch
+ if( iFormat!=XB_FMT_WEEK && iFormat!=XB_FMT_MONTH && iFormat!=XB_FMT_YEAR )
+ return XB_INVALID_OPTION;
+
+ if( iFormat == XB_FMT_WEEK ){
+ //DayOf( XB_FMT_MONTH, iDay );
+ iDay = DayOf( XB_FMT_MONTH );
+ iMonth = MonthOf();
+ iYear = YearOf();
+
+ // The following formula uses Zeller's Congruence to determine the day of the week
+ if( iMonth > 2 ) // init to February
+ iMonth -= 2;
+ else {
+ iMonth += 10;
+ iYear--;
+ }
+ iDay2 = ((13 * iMonth - 1) / 5) + iDay + ( iYear % 100 ) +
+ (( iYear % 100 ) / 4) + ((iYear /100 ) / 4 ) - 2 *
+ ( iYear / 100 ) + 77 ;
+
+ iOutDay = iDay2 - 7 * ( iDay2 / 7 );
+ iOutDay == 6 ? iOutDay = 0 : iOutDay++;
+ }
+ else if( iFormat == XB_FMT_MONTH ){
+ sDay[0] = sDate8[7];
+ sDay[1] = sDate8[8];
+ sDay[2] = 0x00;
+ iOutDay = atoi( sDay );
+ } else {
+ iOutDay = iAggregatedDaysInMonths[IsLeapYear()][MonthOf()-1] + DayOf( XB_FMT_MONTH );
+ }
+ return iOutDay;
+}
+
+/*************************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+//! @brief Dump date information to stdout.
+/*!
+ \param sTitle - Title for output.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+void xbDate::Dump( const char *sTitle ){
+ fprintf( stdout, "%s\n sDate = [%s]\n", sTitle, sDate8.Str() );
+}
+
+/*************************************************************************/
+//! @brief Dump the date tables.
+/*!
+ This dumps the internal date structures to stdout.
+ \returns void
+*/
+
+void xbDate::DumpDateTables(){
+ fprintf( stdout, "Date Tables\n" );
+ fprintf( stdout, "Month *-Aggragated Days-* *--Days In Month--*\n" );
+ fprintf( stdout, " *-NonLeap Leap-* *--NonLeap Leap--*\n" );
+ for( int i = 1; i < 13; i++ )
+ fprintf( stdout, " %2d %3d %3d %3d %3d\n", i,
+ iAggregatedDaysInMonths[0][i],iAggregatedDaysInMonths[1][i],
+ iDaysInMonths[0][i], iDaysInMonths[1][i]);
+}
+#endif
+
+/*************************************************************************/
+//! @brief Format MM/DD/YY date
+/*!
+ This routine takes an MM/DD/YY format date as input and populates a
+ date class with the appropriate YYYYMMDD data.
+
+ \param sCtodInDate - MM/DD/YY formatted date as input.
+ \returns XB_INVALID_OPTION<br>XB_NO_ERROR
+*/
+xbInt16 xbDate::CTOD( const xbString &sCtodInDate ){
+
+
+ if( sCtodInDate[1] != ' ' && ( sCtodInDate[3] == '\\' || sCtodInDate[3] == '/') ){
+ char yy[3];
+ yy[0] = sCtodInDate[7];
+ yy[1] = sCtodInDate[8];
+ yy[2] = 0x00;
+ sDate8.Sprintf( "%02d%c%c%c%c%c%c", CalcRollingCenturyForYear( atoi( yy )),
+ sCtodInDate[7], sCtodInDate[8], sCtodInDate[1], sCtodInDate[2], sCtodInDate[4], sCtodInDate[5] );
+ return XB_NO_ERROR;
+ }
+ else{
+ return XB_INVALID_DATE;
+ }
+}
+/*************************************************************************/
+//! @brief
+/*!
+ This routine will reformat a date based on the format specifiers entered
+ in sFmtIn. If no input format is specified, the routine will use the
+ system default date format.
+
+ \param sFmtIn - A format specifier with the following paramaters:<br>
+
+ 1) YYDDD - A julian date format
+ 2) YY or YYYY will print a 2 or 4 digit year
+ 3) M,MM,MMM or MMMM
+ M - one digit month if no leading zero
+ MM - two digit month, contains leading zero
+ MMM - Jan through Dec
+ MMMM - January through December
+ 4) D,DD,DDD or DDDD
+ D - one digit dayif no leading zero
+ DD - two digit day, contains leading zero
+ DDD - Sun through Sat (or julian if YYDDD)
+ DDDD - Sunday through Saturday
+
+ \param sOutFmtDate - Reformatted output date.
+ \returns XB_NO_ERROR
+ <br><br>
+ Format Examples:<br>
+ MM/DD/YY<br>
+ YYYY-MM-DD<br>
+ DDDDDDDDDDD MMMMMMMMMMM DD,YYYY
+*/
+xbInt16 xbDate::FormatDate( const xbString &sFmtIn, xbString &sOutFmtDate ){
+ xbUInt32 FmtCtr;
+ char type;
+ xbUInt32 iTypeCtr;
+ xbString ws;
+ xbString sWrkFmt;
+ sOutFmtDate = "";
+
+ /* use format for this specific string if available, else use default format */
+ if( strlen( sFmtIn ) > 0 )
+ sWrkFmt = sFmtIn;
+ else
+ sWrkFmt = GetDefaultDateFormat();
+
+ if( strstr( sWrkFmt.Str(), "YYDDD" )){
+ sOutFmtDate.Sprintf( "%c%c%03d", sDate8[3], sDate8[4], DayOf( XB_FMT_YEAR ));
+ } else {
+ FmtCtr = 1;
+ while( FmtCtr <= sWrkFmt.Len() ){
+ if( sWrkFmt[FmtCtr] != 'D' && sWrkFmt[FmtCtr] != 'M' && sWrkFmt[FmtCtr] != 'Y' ){
+ sOutFmtDate += sWrkFmt[FmtCtr];
+ FmtCtr++;
+ iTypeCtr = 0;
+ } else {
+ type = sWrkFmt[FmtCtr];
+ iTypeCtr = 0;
+ while( sWrkFmt[FmtCtr] == type ) {
+ iTypeCtr++;
+ FmtCtr++;
+ }
+ switch( type ){
+ case 'D':
+
+ if( iTypeCtr == 1 ){
+ sOutFmtDate += ws.Sprintf( "%d", DayOf( XB_FMT_MONTH ));
+ }
+ else if( iTypeCtr == 2 ){
+ sOutFmtDate += ws.Sprintf( "%c%c", sDate8[7], sDate8[8] );
+ } else {
+ xbString sCDO;
+ CharDayOf( sCDO );
+ ws.Assign( sCDO, 1, iTypeCtr );
+ sOutFmtDate += ws.Str();
+ }
+ break;
+
+ case 'M':
+ if( iTypeCtr == 1 ){
+ sOutFmtDate += ws.Sprintf( "%d", MonthOf());
+ }
+ else if( iTypeCtr == 2 ){
+ sOutFmtDate += ws.Sprintf( "%c%c", sDate8[5], sDate8[6] );
+ } else {
+ xbString sCMO;
+ CharMonthOf( sCMO );
+ ws.Assign( sCMO, 1, iTypeCtr );
+ sOutFmtDate += ws.Str();
+ }
+ break;
+
+ case 'Y':
+ if( iTypeCtr == 2 ){
+ sOutFmtDate += ws.Sprintf( "%c%c", sDate8[3], sDate8[4] );
+ }
+ else if( iTypeCtr == 4 ){
+ sOutFmtDate += ws.Sprintf( "%c%c%c%c", sDate8[1], sDate8[2], sDate8[3], sDate8[4] );
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ }
+ }
+ return XB_NO_ERROR;
+}
+/*************************************************************************/
+//! @brief Return the date value.
+/*!
+ \returns char ptr to date value.
+*/
+const char * xbDate::Str() const{
+ return sDate8.Str();
+};
+/*************************************************************************/
+//! @brief Determine if date is a leap year.
+/*!
+ \returns xbTrue - Is leapyear.<br> xbFalse - Not a leap year.
+*/
+xbBool xbDate::IsLeapYear() const {
+ xbInt16 iYear = YearOf();
+ if(( iYear % 4 == 0 && iYear % 100 != 0 ) || iYear % 400 == 0 )
+ return xbTrue;
+ else
+ return xbFalse;
+}
+/*************************************************************************/
+//! @brief Determine if date is a leap year.
+/*!
+ \param iYear - Year to check for leap year status.
+ \returns xbTrue - Is leapyear.<br> xbFalse - Not a leap year.
+*/
+xbBool xbDate::IsLeapYear( xbInt16 iYear ) const {
+ if(( iYear % 4 == 0 && iYear % 100 != 0 ) || iYear % 400 == 0 )
+ return xbTrue;
+ else
+ return xbFalse;
+}
+/*************************************************************************/
+//! @brief Calculate julian days for a given date.
+/*!
+ \returns The number of days since 01/01/0001 + JUL_OFFSET.
+*/
+xbInt32 xbDate::JulianDays() const{
+ xbInt32 ly = YearOf() - 1;
+ xbInt32 lDays = ly * 365L + ly / 4L - ly / 100L + ly / 400L;
+ lDays += DayOf( XB_FMT_YEAR );
+ return lDays + JUL_OFFSET;
+}
+/*************************************************************************/
+//! @brief Convert the number of julian days to gregorian date.
+/*!
+ \param lJulDays - Julian days.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbDate::JulToDate8( xbInt32 lJulDays )
+{
+ lJulDays -= JUL_OFFSET;
+ // calculate the year
+ xbInt16 iYear = (xbInt16)(lJulDays / 365.24 );
+ lJulDays -= (iYear * 365L) + (iYear / 4L) - (iYear / 100L) + (iYear / 400L);
+ iYear++;
+ while( lJulDays <= 0 ){
+ iYear--;
+ lJulDays += (365L + IsLeapYear( iYear ));
+ }
+ // this for loop calculates the month by comparing the number of days remaining to one of the tables
+ xbInt16 iIsLeap = IsLeapYear(iYear);
+ xbInt16 iMonth = 1;
+ while( ((xbInt16) lJulDays > iAggregatedDaysInMonths[iIsLeap][iMonth]) && (iMonth < 12) )
+ iMonth++;
+
+ lJulDays -= iAggregatedDaysInMonths[iIsLeap][iMonth-1];
+ sDate8.Sprintf( "%04d%02d%02ld", iYear, iMonth, lJulDays );
+ return XB_NO_ERROR;
+}
+/*************************************************************************/
+//! @brief Set the date to the last day of month for a given date.
+/*!
+ This routine sets the last date of the month.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbDate::LastDayOfMonth(){
+ sDate8.Sprintf( "%4.4d%2.2d%2.2d", YearOf(), MonthOf(), iDaysInMonths[IsLeapYear()][MonthOf()]);
+ return XB_NO_ERROR;
+};
+/*************************************************************************/
+//! @brief Return the month for the date.
+/*!
+ \returns The month of the date.
+*/
+xbInt16 xbDate::MonthOf() const {
+ xbInt16 iOutMonth;
+ char month[3];
+ month[0] = sDate8[5];
+ month[1] = sDate8[6];
+ month[2] = 0x00;
+ iOutMonth = atoi( month );
+ return iOutMonth;
+}
+
+/*************************************************************************/
+//! @brief Set the date.
+/*!
+ \param sDateIn - Input date.
+ \returns XB_NO_ERROR<br>XB_INVALID_DATE
+*/
+xbInt16 xbDate::Set( const xbString & sDateIn ){
+ if( DateIsValid( sDateIn )){
+ sDate8 = sDateIn;
+ return XB_NO_ERROR;
+ }
+ return XB_INVALID_DATE;
+}
+/*************************************************************************/
+//! @brief This routine sets up static data tables on startup.
+/*!
+ \returns void
+*/
+void xbDate::SetDateTables() {
+ if( iAggregatedDaysInMonths[1][12] != 366 ){ /* first time called ? */
+
+ iAggregatedDaysInMonths[0][0] = 0;
+ iAggregatedDaysInMonths[0][1] = 31;
+ iAggregatedDaysInMonths[0][2] = 59;
+ iAggregatedDaysInMonths[0][3] = 90;
+ iAggregatedDaysInMonths[0][4] = 120;
+ iAggregatedDaysInMonths[0][5] = 151;
+ iAggregatedDaysInMonths[0][6] = 181;
+ iAggregatedDaysInMonths[0][7] = 212;
+ iAggregatedDaysInMonths[0][8] = 243;
+ iAggregatedDaysInMonths[0][9] = 273;
+ iAggregatedDaysInMonths[0][10] = 304;
+ iAggregatedDaysInMonths[0][11] = 334;
+ iAggregatedDaysInMonths[0][12] = 365;
+ iAggregatedDaysInMonths[1][0] = 0;
+ iAggregatedDaysInMonths[1][1] = 31;
+ iAggregatedDaysInMonths[1][2] = 60;
+ iAggregatedDaysInMonths[1][3] = 91;
+ iAggregatedDaysInMonths[1][4] = 121;
+ iAggregatedDaysInMonths[1][5] = 152;
+ iAggregatedDaysInMonths[1][6] = 182;
+ iAggregatedDaysInMonths[1][7] = 213;
+ iAggregatedDaysInMonths[1][8] = 244;
+ iAggregatedDaysInMonths[1][9] = 274;
+ iAggregatedDaysInMonths[1][10] = 305;
+ iAggregatedDaysInMonths[1][11] = 335;
+ iAggregatedDaysInMonths[1][12] = 366;
+
+ iDaysInMonths[0][0] = 0;
+ iDaysInMonths[0][1] = 31;
+ iDaysInMonths[0][2] = 28;
+ iDaysInMonths[0][3] = 31;
+ iDaysInMonths[0][4] = 30;
+ iDaysInMonths[0][5] = 31;
+ iDaysInMonths[0][6] = 30;
+ iDaysInMonths[0][7] = 31;
+ iDaysInMonths[0][8] = 31;
+ iDaysInMonths[0][9] = 30;
+ iDaysInMonths[0][10] = 31;
+ iDaysInMonths[0][11] = 30;
+ iDaysInMonths[0][12] = 31;
+ iDaysInMonths[1][0] = 0;
+ iDaysInMonths[1][1] = 31;
+ iDaysInMonths[1][2] = 29;
+ iDaysInMonths[1][3] = 31;
+ iDaysInMonths[1][4] = 30;
+ iDaysInMonths[1][5] = 31;
+ iDaysInMonths[1][6] = 30;
+ iDaysInMonths[1][7] = 31;
+ iDaysInMonths[1][8] = 31;
+ iDaysInMonths[1][9] = 30;
+ iDaysInMonths[1][10] = 31;
+ iDaysInMonths[1][11] = 30;
+ iDaysInMonths[1][12] = 31;
+ }
+}
+/*************************************************************************/
+//! @brief Set the date equal to the system date.
+/*!
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbDate::Sysdate(){
+
+ #ifdef HAVE__LOCALTIME64_S_F
+ __time64_t timer;
+ _time64( &timer );
+ struct tm tblock;
+ _localtime64_s( &tblock, &timer );
+ tblock.tm_year += 1900;
+ tblock.tm_mon++;
+ sDate8.Sprintf( "%4d%02d%02d", tblock.tm_year, tblock.tm_mon, tblock.tm_mday );
+ #else
+ time_t timer;
+ timer = time( &timer );
+ struct tm *tblock;
+ tblock = localtime( &timer );
+ tblock->tm_year += 1900;
+ tblock->tm_mon++;
+ sDate8.Sprintf( "%4d%02d%02d",tblock->tm_year,tblock->tm_mon,tblock->tm_mday );
+ #endif
+
+ return XB_NO_ERROR;
+}
+/*************************************************************************/
+//! @brief Returns the year of the date.
+/*!
+ \returns The year of the date.
+*/
+xbInt16 xbDate::YearOf() const {
+ char year[5];
+ year[0] = sDate8[1];
+ year[1] = sDate8[2];
+ year[2] = sDate8[3];
+ year[3] = sDate8[4];
+ year[4] = 0x00;
+ xbInt16 iOutYear = atoi( year );
+ return iOutYear;
+};
+} /* namespace */ \ No newline at end of file
diff --git a/src/core/xbdbf.cpp b/src/core/xbdbf.cpp
new file mode 100755
index 0000000..8e020fb
--- /dev/null
+++ b/src/core/xbdbf.cpp
@@ -0,0 +1,4220 @@
+/* xbdbf.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"
+
+
+namespace xb{
+
+/************************************************************************/
+//! @brief Constructor
+/*!
+ \param x Pointer to xbXbase
+*/
+xbDbf::xbDbf( xbXBase * x ) : xbFile( x ){
+ xbase = x;
+ SchemaPtr = NULL;
+ RecBuf = NULL;
+ RecBuf2 = NULL;
+ InitVars();
+}
+/************************************************************************/
+void xbDbf::InitVars()
+{
+ iNoOfFields = 0;
+ iDbfStatus = XB_CLOSED;
+ ulCurRec = 0L;
+ cVersion = 0x00;
+ cUpdateYY = 0x00;
+ cUpdateMM = 0x00;
+ cUpdateDD = 0x00;
+ ulNoOfRecs = 0L;
+ uiHeaderLen = 0x00;
+ uiRecordLen = 0x00;
+ cTransactionFlag = 0x00;
+ cEncryptionFlag = 0x00;
+ cIndexFlag = 0x00;
+ cLangDriver = 0x00;
+ iFileVersion = 0; /* Xbase64 file version */
+ iAutoCommit = -1;
+
+ SetFileName ( "" );
+ sAlias.Set ( "" );
+ SetDirectory ( GetDataDirectory());
+
+ #ifdef XB_LOCKING_SUPPORT
+ iLockFlavor = -1;
+ bTableLocked = xbFalse;
+ bHeaderLocked = xbFalse;
+ ulAppendLocked = 0;
+ SetAutoLock( -1 );
+ lloRecLocks.SetDupKeys( xbFalse );
+ #endif
+
+ #ifdef XB_INDEX_SUPPORT
+ ixList = NULL;
+ pCurIx = NULL;
+ vpCurIxTag = NULL;
+ sCurIxType = "";
+ ClearTagList();
+ #endif
+ #ifdef XB_NDXINF_SUPPORT
+ llNdxInfData.Clear();
+ #endif
+}
+
+/************************************************************************/
+//! @brief Destructor
+xbDbf::~xbDbf(){
+
+ // is there is an uncommited update, discard it.
+ // as we don't know if it is an append or an update
+ if( iDbfStatus == XB_UPDATED )
+ Abort();
+
+ if( iDbfStatus != XB_CLOSED )
+ Close();
+
+ if( SchemaPtr ){
+ free( SchemaPtr );
+ SchemaPtr = NULL;
+ }
+ if( RecBuf ){
+ free( RecBuf );
+ RecBuf = NULL;
+ }
+ if( RecBuf2){
+ free( RecBuf2 );
+ RecBuf2 = NULL;
+ }
+ Close();
+}
+/************************************************************************/
+//! @brief Abort any uncommited changes for the current record buffer.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::Abort(){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ if( iDbfStatus == XB_UPDATED ){
+ #ifdef XB_MEMO_SUPPORT
+ if( MemoFieldsExist()){
+ if(( iRc = Memo->Abort()) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ }
+ #endif
+ memcpy( RecBuf, RecBuf2, uiRecordLen );
+ iDbfStatus = XB_OPEN;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::Abort() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/************************************************************************/
+#ifdef XB_INDEX_SUPPORT
+//! @brief Add an index to the internal list of indices for this table.
+/*!
+ The index list is used during any table update process to update any open
+ index file. Index files can contain one or more tags.
+
+ \param ixIn Pointer to index object for a given index file.
+ \param sFmt NDX or MDX.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+
+xbInt16 xbDbf::AddIndex( xbIx * ixIn, const xbString &sFmt ){
+
+ xbIxList *ixt; // this
+ if(( ixt = (xbIxList *) malloc( sizeof( xbIxList ))) == NULL )
+ return XB_NO_ERROR;
+
+ ixt->ix = ixIn;
+ ixt->next = NULL;
+ ixt->sFmt = new xbString( sFmt );
+ ixt->sFmt->ToUpperCase();
+
+ if( ixList ){
+ xbIxList *ixn = ixList; // next
+ while( ixn->next ){
+ ixn = ixn->next;
+ }
+ ixn->next = ixt;
+ } else {
+ ixList = ixt;
+ }
+ return XB_NO_ERROR;
+}
+#endif // XB_INDEX_SUPPORT
+
+
+/************************************************************************/
+//! @brief Append the current record to the data file.
+/*!
+ This method attempts to append the contents of the current record buffer
+ to the end of the DBF file, updates the file date, number of records in the file
+ and updates any open indices associated with this data file.<br>
+
+ To add a record, an application would typically blank the record buffer,
+ update various fields in the record buffer, then append the record.<br>
+
+ The append method performs the following tasks:<br>
+ 1) Create new index key values<br>
+ 2) Lock the table<br>
+ 3) Lock append bytes<br>
+ 4) Lock indices<br>
+ 5) Read the dbf header<br>
+ 6) Check for dup keys<br>
+ 7) Calc last update date, no of recs<br>
+ 8) Add keys<br>
+ 9) Unlock indices<br>
+ 10) Update file header<br>
+ 11) Unlock file header<br>
+ 12) Append record<br>
+ 13) Unlock append bytes<br>
+
+Note: Locking memo files is not needed as the memo file updates are handled outside of the append method.<br>
+
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::AppendRecord(){
+ xbInt16 iErrorStop = 0;
+ xbInt16 iRc = XB_NO_ERROR;
+ xbUInt32 ulSaveCurRec = 0;
+
+ try{
+ #ifdef XB_INDEX_SUPPORT
+ xbIxList *ixList = GetIxList();
+ // do this step first before anything is locked, reduce lock time as much as possible
+ while( ixList ){
+
+ // std::cout << "xbDbf::CreateKeys(x)\n";
+ if(( iRc = ixList->ix->CreateKeys( 1 )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ ixList = ixList->next;
+ }
+ #endif // XB_INDEX_SUPPORT
+
+ // lock everything up for an update
+ #ifdef XB_LOCKING_SUPPORT
+ // xbInt16 iAutoLock = GetAutoLock();
+ if( iAutoLock ){
+
+ if(( iRc = LockHeader( XB_LOCK )) != XB_NO_ERROR ){
+ if( iRc == XB_LOCK_FAILED ) {
+ return iRc;
+ } else {
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+ if(( iRc = LockAppend( XB_LOCK )) != XB_NO_ERROR ){
+ if( iRc == XB_LOCK_FAILED ){
+ LockHeader( XB_UNLOCK );
+ return iRc;
+ } else {
+ iErrorStop = 30;
+ throw iRc;
+ }
+ }
+
+ #ifdef XB_INDEX_SUPPORT
+ if(( iRc = LockIndices( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ #endif // XB_INDEX_SUPPORT
+
+ }
+ #endif // XB_LOCKING_SUPPORT
+ if(( iRc = ReadHeader( 1, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ #ifdef XB_INDEX_SUPPORT
+ ixList = GetIxList();
+
+ while( ixList ){
+ if(( iRc = ixList->ix->CheckForDupKeys()) != 0 ){
+ if( iRc < 0 ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ return XB_KEY_NOT_UNIQUE;
+ }
+ ixList = ixList->next;
+ }
+
+ #endif // XB_INDEX_SUPPORT
+
+ // calculate the latest header information
+ xbDate d;
+ cUpdateYY = (char) d.YearOf() - 1900;
+ cUpdateMM = (char) d.MonthOf();
+ cUpdateDD = (char) d.DayOf( XB_FMT_MONTH );
+ ulSaveCurRec = ulCurRec;
+ ulNoOfRecs++;
+ ulCurRec = ulNoOfRecs;
+
+ #ifdef XB_INDEX_SUPPORT
+
+
+ ixList = GetIxList();
+ while( ixList ){
+ if(( iRc = ixList->ix->AddKeys( ulCurRec )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ ixList = ixList->next;
+ }
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock ){
+ if(( iRc = LockIndices( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ }
+ #endif // XB_LOCKING_SUPPORT
+ #endif // XB_INDEX_SUPPORT
+
+ // rewrite the header record
+ if(( iRc = WriteHeader( 1, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock ){
+ if(( iRc = LockHeader( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw iRc;
+ }
+ }
+ #endif
+
+ // write the last record
+ if(( iRc = xbFseek( (uiHeaderLen+((xbInt64)(ulNoOfRecs-1)*uiRecordLen)), 0 )) != XB_NO_ERROR ){
+ iErrorStop = 80;
+ throw iRc;
+ }
+
+ if(( iRc = xbFwrite( RecBuf, uiRecordLen, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 90;
+ throw iRc;
+ }
+
+ // write the end of file marker
+ if(( iRc = xbFputc( XB_CHAREOF )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock ){
+ if(( iRc = LockAppend( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw( iRc );
+ }
+ }
+ #endif // XB_LOCKING_SUPPORT
+
+ }
+ catch (xbInt16 iRc ){
+ if( ulSaveCurRec != 0 ){
+ ulCurRec = ulSaveCurRec;
+ ulNoOfRecs--;
+ }
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock ){
+ #ifdef XB_INDEX_SUPPORT
+ LockIndices( XB_UNLOCK );
+ #endif // XB_INDEX_SUPPORT
+ LockAppend( XB_UNLOCK );
+ LockHeader( XB_UNLOCK );
+ }
+ #endif // XB_LOCKING_SUPPORT
+
+ if( iRc != XB_LOCK_FAILED && iRc != XB_KEY_NOT_UNIQUE ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::Append() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ }
+
+ if( iRc == XB_NO_ERROR )
+ iDbfStatus = XB_OPEN;
+ return iRc;
+}
+
+/************************************************************************/
+#ifdef XB_NDXINF_SUPPORT
+//! @brief Asscoiate a non production index to a DBF file.
+/*!
+
+ The original Dbase (TM) software supported non production indices (NDX) and production indices (MDX).
+ The production indices are opened automatically when the DBF file is opened but the non-production
+ indices are not. This method is specific to the Xbas64 library and providex a means to link non production
+ NDX index files to the DBF file so they will be opened automatically when the DBF file is opened.<br>
+
+ This routine requires NDXINF support be enabled when building the library.<br>
+ This routine creates a file with the same name as the DBF file, but with an extension of INF.<br>
+
+
+ \param sIxType Currently only NDX. Future versions will support additional non prod index types.
+ \param sIxName The index name.
+ \param iOpt 0 - Add index to .INF if not already there<br>
+ 1 - Remove index from .INF if there
+
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+
+xbInt16 xbDbf::AssociateIndex( const xbString &sIxType, const xbString &sIxName, xbInt16 iOpt ){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ xbString sIxTypeIn = sIxType;
+ sIxTypeIn.Trim();
+ xbString sIxNameIn = sIxName;
+ sIxNameIn.Trim();
+
+ if( sIxTypeIn != "NDX" || sIxName == "" )
+ return XB_INVALID_INDEX;
+
+ if(( iRc = LoadNdxInfData()) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ // check if entry exists
+ xbLinkListNode<xbString> * llN = llNdxInfData.GetHeadNode();
+ xbBool bFound = xbFalse;
+ xbString s;
+
+ while( llN && !bFound ){
+ s = llN->GetKey();
+ if( s.Len() > 0 ){
+ if( sIxNameIn == s )
+ bFound = xbTrue;
+ }
+ llN = llN->GetNextNode();
+ }
+
+ xbBool bUpdated = xbFalse;
+ if( iOpt == 0 && !bFound ){
+ s.Sprintf( "%s%c%c", sIxName.Str(), 0x0d, 0x0a );
+ llNdxInfData.InsertAtEnd( s );
+ bUpdated = xbTrue;
+
+ } else if( iOpt == 1 && bFound ){
+ llNdxInfData.RemoveByVal( s );
+ bUpdated = xbTrue;
+ }
+
+ if( bUpdated ){
+ if(( iRc = SaveNdxInfData()) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+
+ } catch( xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::AssociateIndex() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+#endif // XB_NDXINF_SUPPORT
+
+/************************************************************************/
+//! @brief Blank the record buffer.
+/*!
+
+ This method would typically be called to initialize the record buffer before
+ updates are applied to append a new record.
+
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::BlankRecord()
+{
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+
+ if( iDbfStatus == XB_CLOSED ){
+ iErrorStop = 10;
+ iRc = XB_NOT_OPEN;
+ throw iRc;
+ }
+
+ if( iDbfStatus == XB_UPDATED ){
+ if( GetAutoCommit() == 1 ){
+ if(( iRc = Commit()) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ } else {
+ if(( iRc = Abort()) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ }
+ }
+ ulCurRec = 0;
+ memset( RecBuf, 0x20, uiRecordLen );
+ memset( RecBuf2, 0x20, uiRecordLen );
+ }
+
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::BlankRecord() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+
+ return iRc;
+}
+/************************************************************************/
+#ifdef XB_INDEX_SUPPORT
+
+#ifdef XB_DEBUG_SUPPORT
+
+/*!
+ This method is used to check an index tag's intgerity.
+
+ \param iTagOpt 0 - Check current tag<br>
+ 1 - Check all tag<br>
+
+ \param iOutputOpt Output message destination<br>
+ 0 = stdout<br>
+ 1 = Syslog<br>
+ 2 = Both<br>
+
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::CheckTagIntegrity( xbInt16 iTagOpt, xbInt16 iOutputOpt ){
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+
+// std::cout << "CheckTagIntegrity()\n";
+
+ if( iTagOpt == 0 ){
+ if( pCurIx )
+ return pCurIx->CheckTagIntegrity( vpCurIxTag, iOutputOpt );
+ else
+ return XB_INVALID_TAG;
+
+ } else {
+
+ xbLinkListNode<xbTag *> *llN = GetTagList();
+ xbTag *pTag;
+
+ while( llN ){
+ pTag = llN->GetKey();
+ if(( iRc = pTag->GetIx()->CheckTagIntegrity( pTag->GetVpTag(), iOutputOpt )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ llN = llN->GetNextNode();
+ }
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::CheckTagIntegrity() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+
+ return iRc;
+}
+
+#endif // XB_DEBUG_SUPPORT
+
+/************************************************************************/
+/*!
+ This method is used to reindex / rebuild index tag.
+
+ \param iTagOpt 0 - Reindex current tag<br>
+ 1 - Reindex all tags<br>
+
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::Reindex( xbInt16 iTagOpt ){
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ void *vp;
+
+ try{
+ if( iTagOpt == 0 ){
+ if( pCurIx ){
+
+ //
+ // xbString = save current tag name
+ //
+
+ iRc = pCurIx->Reindex( &vpCurIxTag );
+ if( iRc != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ //
+ // restore current tag name
+ //
+ return iRc;
+
+ } else {
+
+ return XB_INVALID_TAG;
+
+ }
+
+ } else {
+
+ xbLinkListNode<xbTag *> *llN = GetTagList();
+ xbTag *pTag;
+
+ while( llN ){
+ pTag = llN->GetKey();
+ vp = pTag->GetVpTag();
+ if(( iRc = pTag->GetIx()->Reindex( &vp )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ llN = llN->GetNextNode();
+ }
+
+
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::Reindex() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+
+ return iRc;
+}
+
+/************************************************************************/
+// @brief Clear the index tag list.
+/*
+ Protected method. Clears the list inf index tags.
+ \returns void.
+*/
+void xbDbf::ClearTagList(){
+
+ xbTag *pTag;
+ xbBool bDone = xbFalse;
+ while( llTags.GetNodeCnt() > 0 && !bDone ){
+ if( llTags.RemoveFromFront( pTag ) != XB_NO_ERROR ){
+ bDone = xbTrue;
+ } else {
+ if( pTag )
+ delete pTag;
+ }
+ }
+}
+#endif // XB_INDEX_SUPPORT
+
+/************************************************************************/
+//! @brief Close DBF file/table.
+/*!
+ This routine flushes any remaining updates to disk, closes the DBF file and
+ any associated memo and index files.
+
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::Close(){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+
+ if(iDbfStatus == XB_CLOSED)
+ return XB_NO_ERROR;
+
+ else if( iDbfStatus == XB_UPDATED ){
+
+ if( GetAutoCommit() == 1 ){
+ if(( iRc = Commit()) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ } else {
+ if(( iRc = Abort()) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+ }
+
+ if(SchemaPtr){
+ free( SchemaPtr );
+ SchemaPtr = NULL;
+ }
+ if(RecBuf){
+ free( RecBuf );
+ RecBuf = NULL;
+ }
+ if(RecBuf2){
+ free( RecBuf2 );
+ RecBuf2 = NULL;
+ }
+
+
+ #ifdef XB_MEMO_SUPPORT
+ if( iMemoFieldCnt > 0 ){
+ Memo->CloseMemoFile();
+ delete Memo;
+ Memo = NULL;
+ }
+ #endif
+
+ // close any open index files, remove from the ix list
+ #ifdef XB_INDEX_SUPPORT
+ while( ixList ){
+ ixList->ix->Close();
+ RemoveIndex( ixList->ix );
+ }
+ #endif
+
+ #ifdef XB_LOCKING_ON
+ if( xblfh ){
+ fclose( xblfh );
+ xblfh = NULL;
+ }
+ #endif
+
+ if(( iRc = xbase->RemoveTblFromTblList( this )) != XB_NO_ERROR ){
+ xbString sMsg;
+ sMsg.Sprintf( "Alias = [%s]", sAlias.Str());
+ xbase->WriteLogMessage( sMsg.Str() );
+ iErrorStop = 30;
+ throw iRc;
+ }
+
+ xbFclose();
+ InitVars();
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::Close() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+
+/************************************************************************/
+#ifdef XB_INDEX_SUPPORT
+//! @brief Close an open index file
+/*!
+ All index files are automatically closed when the DBF file is closed.
+ Under normal conditions, it is not necessary to explicitly close an index file
+ with this routine. Any updates posted to a DBF file while an index is closed
+ will not be reflected in the closed index file.
+
+ \param pIx Pointer to index object to close.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::CloseIndexFile( xbIx *pIx ){
+
+ xbInt16 iErrorStop = 0;
+ xbInt16 iRc = XB_NO_ERROR;
+
+ try{
+
+ // verify index is open and in the list
+ xbBool bFound = xbFalse;
+ xbIxList *p = GetIxList();
+ while( p && !bFound ){
+ if( pIx == p->ix )
+ bFound = xbTrue;
+ p = p->next;
+ }
+ if( !bFound ){
+ iErrorStop = 10;
+ iRc = XB_NOT_OPEN;
+ throw iRc;
+ }
+
+ // close it
+ if(( iRc = pIx->Close()) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+
+ // remove it from the list
+ if(( iRc = RemoveIndex( pIx )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+
+ // refresh the tag list
+ if(( iRc = UpdateTagList()) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+
+ if( pIx == pCurIx ){
+ pCurIx = NULL;
+ vpCurIxTag = NULL;
+ sCurIxType = "";
+ }
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::CloseIndexFile() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+#endif // XB_INDEX_SUPPORT
+
+/************************************************************************/
+//! @brief Commit updates to disk
+/*!
+
+ This routine commits any pending updates to disk.
+
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::Commit(){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try{
+
+ if( iDbfStatus == XB_UPDATED ){
+ if( ulCurRec == 0 ){
+ if(( iRc = AppendRecord()) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ } else {
+ if(( iRc = PutRecord( ulCurRec )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ }
+ }
+ }
+ catch (xbInt16 iRc ){
+ if( iRc != XB_LOCK_FAILED ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::Commit() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ }
+ return iRc;
+}
+
+
+/************************************************************************/
+//! @brief Copy table (dbf) file structure.
+/*!
+
+ This routine will copy the structure of a dbf file and if successful
+ return a pointer to the new table in an open state.
+
+ \param dNewTable Reference to new table object.
+ \param sNewTableName New table (dbf) name.
+ \param sNewTableAlias Alias name of new table.
+ \param iOverlay xbTrue - Overlay existing file.<br>
+ xbFalse - Don't overlay existing file.
+ \param iShareMode XB_SINGLE_USER<br>
+ XB_MULTI_USER
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+//! Copy DBF structure
+/*!
+*/
+xbInt16 xbDbf::CopyDbfStructure( xbDbf * dNewTable, const xbString &sNewTableName,
+ const xbString & sNewTableAlias, xbInt16 iOverlay, xbInt16 iShareMode ) {
+
+// If successful, the table is returned in an open state after executing this method
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbSchema *newTableSchema = NULL;
+
+ try{
+
+ if( iDbfStatus == XB_CLOSED ){
+ iErrorStop = 10;
+ iRc = XB_DBF_FILE_NOT_OPEN;
+ throw iRc;
+ }
+
+ if( !dNewTable ){
+ iErrorStop = 20;
+ iRc = XB_INVALID_OBJECT;
+ throw iRc;
+ }
+
+ // Get the number of schema entries for this table
+ xbInt32 lSchemaRecCnt = GetFieldCnt() + 1;
+
+ // Allocate a Schema = No Of Fields + 1
+ if((newTableSchema=(xbSchema *)malloc( (size_t) lSchemaRecCnt * sizeof(xbSchema)))==NULL){
+ iErrorStop = 30;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+
+ // Populate the Schema
+ xbInt32 l;
+ for( l = 0; l < lSchemaRecCnt-1; l++ ){
+ memset( newTableSchema[l].cFieldName, 0x00, 11 );
+ for( int x = 0; x < 10 && SchemaPtr[l].cFieldName[x]; x++ )
+ newTableSchema[l].cFieldName[x] = SchemaPtr[l].cFieldName[x];
+ newTableSchema[l].cType = SchemaPtr[l].cType;
+ newTableSchema[l].iFieldLen = SchemaPtr[l].cFieldLen;
+ newTableSchema[l].iNoOfDecs = SchemaPtr[l].cNoOfDecs;
+ }
+
+ // set the last one to zeroes
+ memset( newTableSchema[l].cFieldName, 0x00, 11 );
+ newTableSchema[l].cType = 0;
+ newTableSchema[l].iFieldLen = 0;
+ newTableSchema[l].iNoOfDecs = 0;
+
+ dNewTable->SetVersion();
+ #ifdef XB_MEMO_SUPPORT
+ if( MemoFieldsExist())
+ dNewTable->SetCreateMemoBlockSize( Memo->GetBlockSize() );
+ #endif
+
+ // Call the create a table function
+ if(( iRc = dNewTable->CreateTable( sNewTableName, sNewTableAlias, newTableSchema, iOverlay, iShareMode )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ }
+
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbDbf::CopyDbfStructure() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+
+ if( newTableSchema )
+ free( newTableSchema );
+
+ return iRc;
+}
+
+
+/************************************************************************/
+#ifdef XB_INDEX_SUPPORT
+//! @brief Create a new tag (index) for this dbf file (table).
+/*!
+ This routine creates a new tag (index) on a dbf file. The library currently supports NDX and MDX
+ indices. If you don't have a specific need for an NDX file, use MDX.
+
+ \param sIxType "MDX" or "NDX".
+ \param sName Index or tag name.
+ \param sKey Index key expression,
+ \param sFilter Filter expression. Not applicable for NDX indices.
+ \param iDescending xbTrue for descending. Not available for NDX indices.<br>
+ xbFalse - ascending
+ \param iUnique xbTrue - Unique index<br>xbFalse - Not unique index.
+ \param iOverLay xbTrue - Overlay if exists<br>
+ xbFalse - Don't overlay if it exists.
+ \param pIxOut Pointer to pointer of output index object.
+ \param vpTagOut Pointer to pointer of newly created tag,
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::CreateTag( const xbString &sIxType, const xbString &sName, const xbString &sKey, const xbString &sFilter,
+ xbInt16 iDescending, xbInt16 iUnique, xbInt16 iOverLay, xbIx **pIxOut, void **vpTagOut ){
+
+ // this routine is used to open indices and link to files
+
+ xbInt16 iErrorStop = 0;
+ xbInt16 iRc = XB_NO_ERROR;
+ xbBool bLocked = xbFalse;
+
+ try{
+ xbString sType = sIxType;
+ sType.ToUpperCase();
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( !bTableLocked ){
+ if(( iRc = LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw( iRc );
+ }
+ bLocked = xbTrue;
+ }
+ #endif // XB_LOCKING_SUPPORT
+
+ if( sIxType == "" ){
+ iErrorStop = 100;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+
+ #ifdef XB_NDX_SUPPORT
+ } else if( sIxType == "NDX" ){
+ xbIxNdx *ixNdx = new xbIxNdx( this );
+
+ if(( iRc = ixNdx->CreateTag( sName, sKey, sFilter, iDescending, iUnique, iOverLay, vpTagOut )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ if(( iRc = AddIndex( ixNdx, sIxType )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ *pIxOut = ixNdx;
+
+ // Set the current tag if one not already set
+ if( sCurIxType == "" ){
+ sCurIxType = "NDX";
+ pCurIx = ixNdx;
+ vpCurIxTag = ixNdx->GetTag(0);
+ }
+
+ #endif
+
+ #ifdef XB_MDX_SUPPORT
+ } else if( sIxType == "MDX" ){
+
+ if( GetVersion() == 3 ){ // MDX indexes were version 4 and higher
+ iErrorStop = 200;
+ iRc = XB_INVALID_INDEX;
+ throw iRc;
+ }
+
+ xbIxMdx *ixMdx;
+ xbString s;
+ // look through the index list and see if there is an mdx pointer we can grab
+ xbBool bMdxFound = xbFalse;
+ xbIxList *ixList = GetIxList();
+ while( ixList && !bMdxFound ){
+ s = ixList->sFmt->Str();
+ if( s == "MDX" ){
+ ixMdx = (xbIxMdx *) ixList->ix;
+ bMdxFound = xbTrue;
+ }
+ }
+
+ if( !bMdxFound )
+ ixMdx = new xbIxMdx( this );
+
+ if(( iRc = ixMdx->CreateTag( sName, sKey, sFilter, iDescending, iUnique, iOverLay, vpTagOut )) != XB_NO_ERROR ){
+ iErrorStop = 210;
+ throw iRc;
+ }
+
+ if( !bMdxFound ){
+ if(( iRc = AddIndex( ixMdx, "MDX" )) != XB_NO_ERROR ){
+ iErrorStop = 220;
+ throw iRc;
+ }
+
+ cIndexFlag = 0x01;
+ if(( iRc = WriteHeader( 1, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 230;
+ throw iRc;
+ }
+ }
+ *pIxOut = ixMdx;
+
+ // set the current tag if one not already set
+ if( sCurIxType == "" ){
+ sCurIxType = "MDX";
+ pCurIx = ixMdx;
+ vpCurIxTag = ixMdx->GetTag(0);
+ }
+
+ #endif
+
+ } else {
+ iErrorStop = 200;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+
+ if(( iRc = UpdateTagList()) != XB_NO_ERROR ){
+ iErrorStop = 300;
+ throw iRc;
+ }
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::CreateTag() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( bLocked )
+ LockTable( XB_UNLOCK );
+ #endif // XB_LOCKING_SUPPORT
+
+
+ return iRc;
+}
+#endif // XB_INDEX_SUPPORT
+
+/************************************************************************/
+//! @brief Delete or undelete all records in a dbf file (table).
+/*!
+ This routine deletes or un-deletes all records. The xbase file format contains
+ a leading one byte character used for flagging a record as deleted. When a record
+ is deleted, it's not physically removed from the file, the first byte is flagged as deleted.
+
+ \param iOption 0 - Delete all records.<br>
+ 1 - Un-delete all deleted records.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::DeleteAll( xbInt16 iOption )
+{
+ xbInt16 iErrorStop = 0;
+ xbInt16 iRc = XB_NO_ERROR;
+ xbUInt32 ulRecCnt;
+
+ try{
+ if(( iRc = GetRecordCnt( ulRecCnt )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ if( ulRecCnt == 0 )
+ return XB_NO_ERROR;
+ for( xbUInt32 ul = 0; ul < ulRecCnt; ul++ ){
+ if(( iRc = GetRecord( ul+1 )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ if( iOption == 0 ){ /* delete all option */
+ if( !RecordDeleted()){
+ if(( iRc = DeleteRecord()) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ }
+ } else { /* undelete all option */
+ if( RecordDeleted()){
+ if(( iRc = UndeleteRecord()) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ }
+ }
+ }
+ }
+ catch (xbInt16 iRc ){
+ if( iRc != XB_LOCK_FAILED ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbDbf::DeleteAll() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ }
+ return iRc;
+}
+
+/************************************************************************/
+#ifdef XB_INDEX_SUPPORT
+//! @brief
+/*!
+ This routine deletes all indices associated with the dbf file.
+
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::DeleteAllIndexFiles(){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbBool bLocked = xbFalse;
+
+ #ifdef XB_NDXINF_SUPPORT
+ xbString sIxName;
+ #endif // XB_NDXINF_SUPPORT
+
+ try{
+ #ifdef XB_LOCKING_SUPPORT
+ if( !bTableLocked ){
+ if(( iRc = LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw( iRc );
+ }
+ bLocked = xbTrue;
+ }
+ #endif // XB_LOCKING_SUPPORT
+
+ // close any open index files, delete it, remove from the ix list
+ while( ixList ){
+ ixList->ix->Close();
+ ixList->ix->xbRemove();
+ #ifdef XB_NDXINF_SUPPORT
+ // if XB_NDXINF_SUPPORT is enabled, all open non prod indices should be in here
+ if( *ixList->sFmt != "MDX" ){ // production indices not stored in .INF dataset
+ if(( iRc = ixList->ix->GetFileNamePart( sIxName )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ if(( iRc = AssociateIndex( *ixList->sFmt, sIxName, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ }
+ #endif
+ RemoveIndex( ixList->ix );
+ }
+ } catch( xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::DeleteAllIndexFiles() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ #ifdef XB_LOCKING_SUPPORT
+ if( bLocked )
+ LockTable( XB_UNLOCK );
+ #endif // XB_LOCKING_SUPPORT
+ return iRc;
+}
+#endif // XB_INDEX_SUPPORT
+
+/************************************************************************/
+//! @brief Delete all records.
+/*!
+ This routine deletes all the records in a table / dbf file.
+
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::DeleteAllRecords(){
+ return DeleteAll( 0 );
+}
+
+/************************************************************************/
+#ifdef XB_NDXINF_SUPPORT
+//! @brief Delete .INF File
+/*!
+ The original Dbase (TM) software supported non production indices (NDX) and production indices (MDX).
+ The production indices are opened automatically when the DBF file is opened but the non-production
+ indices are not. This method is specific to the Xbas64 library and providex a means to link non production
+ NDX index files to the DBF file so they will be opened automatically when the DBF file is opened.<br>
+
+ This routine requires NDXINF support be enabled when building the library.<br>
+ This routine deletes the .INF file.<br>
+
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::DeleteNdxInfData(){
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ xbString sNdxInfFileName;
+ if(( iRc = GetNdxInfFileName( sNdxInfFileName )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ xbFile f( xbase );
+ f.SetFileName( sNdxInfFileName );
+ if( f.FileExists()){
+ if(( iRc = f.xbRemove()) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+ } catch( xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::DeleteNdxInfData() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+#endif // XB_NDXINF_SUPPORT
+
+/************************************************************************/
+//! @brief Delete the current record.
+/*!
+ This routine flags the current record for deletion if it's not already flagged.
+
+
+ \returns XB_NO_ERROR<br>
+ XB_INVALID_RECORD
+*/
+
+xbInt16 xbDbf::DeleteRecord(){
+ if( RecBuf && ulCurRec > 0 ){
+ if( RecBuf[0] != 0x2a){
+ if( iDbfStatus != XB_UPDATED ){
+ iDbfStatus = XB_UPDATED;
+ memcpy( RecBuf2, RecBuf, uiRecordLen ); // save off original before making any updates
+ }
+ RecBuf[0] = 0x2a;
+ }
+ return XB_NO_ERROR;
+ }
+ else
+ return XB_INVALID_RECORD;
+}
+/************************************************************************/
+//! @brief Delete a table.
+/*!
+ This routine deletes a given table, associated index files if any, the
+ memo file if any and the .INF file if any.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::DeleteTable(){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ try{
+
+ #ifdef XB_LOCKING_SUPPORT
+ if(( iRc = LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ #endif // XB_LOCKING_SUPPORT
+
+ #ifdef XB_INDEX_SUPPORT
+ if(( iRc = DeleteAllIndexFiles()) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+
+ #ifdef XB_NDXINF_SUPPORT
+ if(( iRc = DeleteNdxInfData()) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ #endif // XB_NDXINF_SUPPORT
+ #endif // XB_INDEX_SUPPORT
+
+ #ifdef XB_MEMO_SUPPORT
+ xbInt16 iMemoFldCnt = GetMemoFieldCnt();
+ xbString sMemoFileName;
+ if(iMemoFldCnt > 0 ){
+ sMemoFileName = Memo->GetFqFileName();
+ }
+ #endif // XB_MEMO_SUPPORT
+
+ if(( iRc = Close()) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+
+ if(( iRc = xbRemove()) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+
+ #ifdef XB_MEMO_SUPPORT
+ if( iMemoFieldCnt > 0 ){
+ xbFile f( xbase );
+ if(( iRc = f.xbRemove( sMemoFileName )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ }
+ #endif // XB_MEMO_SUPPORT
+
+ } catch( xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::DeleteTable() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ #ifdef XB_LOCKING_SUPPORT
+ LockTable( XB_UNLOCK );
+ #endif // XB_LOCKING_SUPPORT
+ return iRc;
+}
+
+/************************************************************************/
+//! @brief Delete an index tag.
+
+/*!
+ This routine deletes an index tag
+ \param sIxType Either "NDX" or "MDX".<br>
+ \param sName Tag name to delete.<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::DeleteTag( const xbString &sIxType, const xbString &sName ){
+
+ xbInt16 iErrorStop = 0;
+ xbInt16 iRc = XB_NO_ERROR;
+ xbIx *pIx = NULL;
+
+ try{
+
+ #ifdef XB_LOCKING_SUPPORT
+ // xbInt16 iAutoLock = GetAutoLock();
+ if( iAutoLock && !GetTableLocked() ){
+ if(( iRc = LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ }
+ #endif
+
+ if( sIxType == "" ){
+ iErrorStop = 110;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+
+ #ifdef XB_NDX_SUPPORT
+ } else if( sIxType == "NDX" ){
+
+ xbIxList *ixl = ixList;
+ xbBool bDone = xbFalse;
+ while( ixl && !bDone ){
+
+ if( ixl->ix->GetTagName( NULL ) == sName ){
+ bDone = xbTrue;
+
+ // remove from .INF if it's there
+ #ifdef XB_NDXINF_SUPPORT
+ if(( iRc = AssociateIndex( "NDX", sName, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ #endif // XB_NDXINF_SUPPORT
+
+ if(( iRc = ixl->ix->DeleteTag( ixl->ix->GetTag( 0 ))) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+
+ if(( iRc = RemoveIndex( ixl->ix )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+
+ if( ixl->ix == pCurIx )
+ SetCurTag( "", NULL, NULL );
+
+ }
+ ixl = ixl->next;
+ }
+ #endif
+
+ #ifdef XB_MDX_SUPPORT
+ } else if( sIxType == "MDX" ){
+ xbIxList *ixl = ixList;
+ xbIxList *ixlNext;
+ xbIxList *ixlPrev = NULL;
+ xbBool bDone = xbFalse;
+ xbIxMdx *pMdx;
+ xbMdxTag *pMdxTag;
+ xbInt16 iTagCnt = 0;
+
+ while( ixl && !bDone ){
+ ixlNext = ixl->next;
+ pMdx = (xbIxMdx *) ixl->ix;
+ iTagCnt = pMdx->GetTagCount();
+ for( xbInt16 i = 0; i < iTagCnt && !bDone; i++ ){
+ pMdxTag = (xbMdxTag *) pMdx->GetTag( i );
+ if( pMdx->GetTagName( pMdxTag ) == sName ){
+ bDone = xbTrue;
+ iRc = pMdx->DeleteTag( pMdxTag );
+ if( iRc > 0 ){
+ // Successful delete of only tag in production mdx file - need to remove it from the list, update the dbf header
+ cIndexFlag = 0x00;
+ if(( iRc = WriteHeader( 1, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+ if(( iRc = RemoveIndex( ixl->ix )) != XB_NO_ERROR ){
+ iErrorStop = 160;
+ throw iRc;
+ }
+ if( ixlPrev == NULL ){
+ // std::cout << "setting ixList to null or should be\n";
+ ixList = ixlNext;
+ } else {
+ ixlPrev = ixlNext;
+ }
+ } else if( iRc < 0 ){
+ iErrorStop = 170;
+ throw iRc;
+ }
+ if( ixl->ix == pCurIx )
+ SetCurTag( "", NULL, NULL );
+ }
+ }
+ ixlPrev = ixl;
+ ixl = ixlNext;
+ }
+
+ if( !bDone )
+ return XB_INVALID_TAG;
+
+ #endif
+
+ } else {
+ iErrorStop = 180;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+
+ if(( iRc = UpdateTagList()) != XB_NO_ERROR ){
+ iErrorStop = 190;
+ throw iRc;
+ }
+
+ // unlock as necessary
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock && GetTableLocked() ){
+ if(( iRc = LockTable( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 200;
+ throw iRc;
+ }
+ }
+ #endif
+
+ }
+ catch (xbInt16 iRc ){
+ if( pIx ) delete pIx;
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::DeleteTag() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock && GetTableLocked() ){
+ LockTable( XB_UNLOCK );
+ }
+ #endif
+
+ }
+ return iRc;
+}
+
+/************************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+//! @brief Dump dbf file header.
+/*!
+ This routine dumps dbf header information to the console.
+
+ \param iOption 1 = Print header only<br>
+ 2 = Field data only<br>
+ 3 = Header and Field data<br>
+ 4 = Header, Field and Memo header data if applicable
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::DumpHeader( xbInt16 iOption ) const {
+ int i;
+ int iMemoCtr = 0;
+
+ if( iOption < 1 || iOption > 4 )
+ return XB_INVALID_OPTION;
+
+ if( iDbfStatus == XB_CLOSED )
+ return XB_NOT_OPEN;
+
+ std::cout << "\nDatabase file " << GetFqFileName() << std::endl << std::endl;
+
+ if( iOption != 2 ){
+ std::cout << "File header data:" << std::endl;
+
+ xbInt16 sVer = DetermineXbaseTableVersion( cVersion );
+
+ if( sVer == 3 )
+ std::cout << "Dbase III file" << std::endl;
+ else if ( sVer == 4 )
+ std::cout << "Dbase IV file" << std::endl << std::endl;
+ else if ( sVer == 5 )
+ std::cout << "Dbase V file" << std::endl << std::endl;
+ else if ( sVer == 7 )
+ std::cout << "Dbase VII file" << std::endl << std::endl;
+ else
+ std::cout << "Unknown Version" << std::endl;
+
+ /* display the bit stream */
+ unsigned char c, tfv, displayMask = 1 << 7;
+ tfv = cVersion;
+ std::cout << "File descriptor bits = ";
+ for( c = 1; c<= 8; c++ ){
+ std::cout << (tfv & displayMask ? '1' : '0');
+ tfv <<= 1;
+ }
+ std::cout << std::endl;
+
+ std::cout << "Descriptor bits legend:" << std::endl;
+ std::cout << " 0-2 = version number" << std::endl;
+ std::cout << " 3 = presence of dBASE IV memo" << std::endl;
+ std::cout << " 4-6 = SQL table presence" << std::endl;
+ std::cout << " 7 = Presence of any memo file (dBASE III PLUS or dBASE IV)" << std::endl << std::endl;
+
+ std::cout << "Last update date = "
+ << (int) cUpdateMM << "/" << (int) cUpdateDD << "/" << (int) cUpdateYY % 100 << std::endl;
+
+ std::cout << "Header length = " << uiHeaderLen << std::endl;
+ std::cout << "Record length = " << uiRecordLen << std::endl;
+ std::cout << "Records in file = " << ulNoOfRecs << std::endl << std::endl << std::endl;
+
+ std::cout << "Transaction Flag = ";
+ xbase->BitDump( cTransactionFlag );
+ std::cout << std::endl;
+
+ std::cout << "Encryption Flag = ";
+ xbase->BitDump( cEncryptionFlag );
+ std::cout << std::endl;
+
+ std::cout << "Index Flag = ";
+ xbase->BitDump( cIndexFlag );
+ std::cout << std::endl;
+
+ std::cout << "Lang Driver = " << (int) cIndexFlag << " - ";
+ xbase->BitDump( cIndexFlag );
+ std::cout << std::endl;
+
+ std::cout << "Open Index Files = " << GetPhysicalIxCnt() << std::endl;
+ }
+
+ if( iOption != 1 ){
+ char c;
+ std::cout << "Field Name Type Length Decimals IxFlag" << std::endl;
+ std::cout << "---------- ---- ------ -------- ------" << std::endl;
+ for( i = 0; i < iNoOfFields; i++ ){
+
+ SchemaPtr[i].cIxFlag ? c = 'Y' : c = ' ';
+
+ if( SchemaPtr[i].cType == 'C' && SchemaPtr[i].cNoOfDecs > 0 )
+ printf( "%10s %1c %4d %4d %c\n", SchemaPtr[i].cFieldName,
+ SchemaPtr[i].cType, SchemaPtr[i].cFieldLen, 0, c );
+ else
+ printf( "%10s %1c %4d %4d %c\n", SchemaPtr[i].cFieldName,
+ SchemaPtr[i].cType, SchemaPtr[i].cFieldLen, SchemaPtr[i].cNoOfDecs, c );
+
+ if( SchemaPtr[i].cType == 'M' )
+ iMemoCtr++;
+ }
+ }
+ std::cout << std::endl;
+
+#ifdef XB_MEMO_SUPPORT
+ if( iOption > 3 && iMemoCtr > 0 )
+ Memo->DumpMemoHeader();
+#endif
+
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+//! Dump record
+/*!
+ Dump the contents of the specified record
+
+
+ \param ulRecNo Record number of record to be dumped.
+ \param iOutputDest 0 = stdout<br>
+ 1 = Syslog<br>
+ 2 = Both<br>
+
+ \param iOutputFmt 0 = with field names<br>
+ 1 = 1 line per rec, no field names<br>
+ 2 = 1 line per rec, first line is a list of field names.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::DumpRecord( xbUInt32 ulRecNo, xbInt16 iOutputDest, xbInt16 iOutputFmt ) {
+ int i, iRc = XB_NO_ERROR;
+
+ xbString sTemp;
+ xbString s2;
+ if( ulRecNo == 0 || ulRecNo > ulNoOfRecs )
+ return XB_INVALID_RECORD;
+
+ if( ulCurRec != ulRecNo ){
+ iRc = GetRecord( ulRecNo );
+ if( iRc != XB_NO_ERROR )
+ return iRc;
+ }
+
+ if( iOutputFmt >= 1 ){
+ if( iOutputFmt == 2 ){
+ sTemp = "RecNo";
+ for( i = 0; i < iNoOfFields; i++ ){
+ s2 = SchemaPtr[i].cFieldName;
+ s2.Trim();
+ sTemp += ",";
+ sTemp += s2;
+ }
+ xbase->WriteLogMessage( sTemp.Str(), iOutputDest );
+ }
+
+ if( RecordDeleted() )
+ s2.Sprintf( "%ld Deleted", ulRecNo );
+
+ else{
+ s2.Sprintf( "%ld ", ulRecNo );
+ //xbString s3;
+ for( i = 0; i < iNoOfFields; i++ ){
+ GetField( i, sTemp );
+ sTemp.Trim();
+ s2.Sprintf( "%s,'%s'", s2.Str(), sTemp.Str());
+ }
+ xbase->WriteLogMessage( s2.Str(),iOutputDest );
+ }
+
+ return XB_NO_ERROR;
+ }
+
+ sTemp.Sprintf( "\nRec Number: %ld", ulRecNo );
+ xbase->WriteLogMessage( sTemp.Str(),iOutputDest);
+
+ if( RecordDeleted())
+ xbase->WriteLogMessage( "Record flagged as deleted", iOutputDest );
+
+
+ #ifdef XB_MEMO_SUPPORT
+ xbString sMemo;
+ #endif
+
+ for( i = 0; i < iNoOfFields; i++ ){
+
+ #ifdef XB_MEMO_SUPPORT
+ GetField( i, sTemp );
+ sTemp.Trim();
+
+ if(SchemaPtr[i].cType == 'M'){
+ GetMemoField( i, sMemo );
+ if( sMemo.Len() > 70 )
+ sMemo.Resize( 70 );
+ s2.Sprintf ( "%c %s = '%s'", SchemaPtr[i].cType, SchemaPtr[i].cFieldName, sMemo.Str());
+ xbase->WriteLogMessage( s2.Str(), iOutputDest);
+
+ /*
+ xbUInt32 ulMlen;
+ if( MemoFieldExists( i )){
+ Memo->GetMemoFieldLen( i, ulMlen );
+ s2.Sprintf( " Len = %d", ulMlen );
+ }
+ xbase->WriteLogMessage( s2.Str(), iOutputDest);
+ */
+
+ }
+ else{
+ s2.Sprintf ( "%c %s = '%s'", SchemaPtr[i].cType, SchemaPtr[i].cFieldName, sTemp.Str());
+ xbase->WriteLogMessage( s2.Str(), iOutputDest);
+ }
+ #else
+ GetField( i, sTemp );
+ sTemp.Trim();
+ s2.Sprintf( "%s = '%s'", SchemaPtr[i].cFieldName, sTemp.Str());
+ xbase->WriteLogMessage( s2.Str(), iOutputDest);
+ #endif
+
+ }
+ return XB_NO_ERROR;
+}
+
+
+/************************************************************************/
+#ifdef XB_LOCKING_SUPPORT
+//! @brief Dump the table lock status
+/*!
+ Debugging routine. Dumps the table lock status to the console.
+ \returns void
+*/
+
+void xbDbf::DumpTableLockStatus() const {
+
+ std::cout << "File Lock Retry Count = [" << GetLockRetryCount() << "]" << std::endl;
+ std::cout << "File Lock Flavor = [";
+ switch (GetLockFlavor()){
+ case 1:
+ std::cout << "Dbase]" << std::endl;
+ break;
+ case 2:
+ std::cout << "Clipper]" << std::endl;
+ break;
+ case 3:
+ std::cout << "Fox]" << std::endl;
+ break;
+ case 9:
+ std::cout << "Xbase64]" << std::endl;
+ break;
+ default:
+ std::cout << "Unknown]" << std::endl;
+ break;
+ }
+ std::cout << "File Auto Lock = [";
+
+ if( GetAutoLock())
+ std::cout << "ON]" << std::endl;
+ else
+ std::cout << "OFF]" << std::endl;
+ if( GetHeaderLocked())
+ std::cout << "Header Locked = [TRUE]\n";
+ else
+ std::cout << "Header Locked = [FALSE]\n";
+
+ if( GetTableLocked())
+ std::cout << "Table Locked = [TRUE]\n";
+ else
+ std::cout << "Table Locked = [FALSE]\n";
+
+ if( GetAppendLocked() > 0 )
+ std::cout << "Append Locked = [" << GetAppendLocked() << "]\n";
+ else
+ std::cout << "Append Locked = [FALSE]\n";
+
+ #ifdef XB_MEMO_SUPPORT
+ if( GetMemoLocked())
+ std::cout << "Memo Locked = [TRUE]\n";
+ else
+ std::cout << "Memo Locked = [FALSE]\n";
+ #endif // XB_MEMO_SUPPORT
+
+ xbLinkListNode<xbUInt32> * llN = GetFirstRecLock();
+ if( llN ){
+ while( llN ){
+ std::cout << "Record Locked = [" << llN->GetKey() << "]\n";
+ llN = llN->GetNextNode();
+ }
+ } else {
+ std::cout << "Record Locked = [None]\n";
+ }
+}
+#endif // XB_LOCKING_SUPPORT
+#endif // XB_DEBUG_SUPPORT
+
+/************************************************************************/
+#ifdef XB_LOCKING_SUPPORT
+//! @brief Get the append locked bytes status
+/*!
+ \returns The record number of the new record for the append lock operation.
+*/
+
+xbUInt32 xbDbf::GetAppendLocked() const {
+ return this->ulAppendLocked;
+}
+
+#endif // XB_LOCKING_SUPPORT
+
+/************************************************************************/
+//! @brief Get auto commit setting.
+/*!
+
+ This routine returns the table setting if set, otherwise returns the system
+ level setting.
+
+ \returns Not 0 - Auto commit on for this table.<br>
+ 0 - Auto commit off for this table.
+*/
+
+xbInt16 xbDbf::GetAutoCommit() const {
+ return GetAutoCommit( 1 );
+}
+
+/************************************************************************/
+//! @brief Get auto commit setting.
+/*!
+
+ \param iOption 0 - Specific setting for this table<br>
+ 1 - If this table should be auto updated (takes DBMS setting into account)
+ \returns Not 0 - Auto commit on for this table.<br>
+ 0 - Auto commit off for this table.
+*/
+
+xbInt16 xbDbf::GetAutoCommit( xbInt16 iOption ) const {
+ if( iOption == 1 && iAutoCommit == -1 )
+ return xbase->GetDefaultAutoCommit();
+ else
+ return iAutoCommit;
+}
+
+
+/************************************************************************/
+//! @brief Get Auto Lock setting.
+/*!
+ \returns Auto lock setting.
+*/
+#ifdef XB_LOCKING_SUPPORT
+xbInt16 xbDbf::GetAutoLock() const{
+ return iAutoLock;
+}
+#endif // XB_LOCKING_SUPPORT
+
+/************************************************************************/
+#ifdef XB_MEMO_SUPPORT
+//! @brief Get the memo file block size used when creating a memo file.
+/*!
+ \returns Memo block size.
+*/
+xbUInt32 xbDbf::GetCreateMemoBlockSize() const {
+ return ulCreateMemoBlockSize;
+}
+#endif
+
+/************************************************************************/
+//! @brief Get a pointer to the current index object.
+/*!
+ \returns Pointer to current index.
+*/
+#ifdef XB_INDEX_SUPPORT
+xbIx *xbDbf::GetCurIx() const {
+ return pCurIx;
+}
+/************************************************************************/
+//! @brief Get pointer to current tag for the current index.
+/*!
+ An index file can have one or more tags. An NDX index has one tag.
+ An MDX file can have up to 47 tags.
+
+ \returns Pointer to current tag.
+*/
+void *xbDbf::GetCurTag() const {
+ return vpCurIxTag;
+}
+/************************************************************************/
+//! @brief Get the current index type.
+/*!
+ \returns NDX for single tag index.<br>
+ MDX for production multi tag index.
+*/
+const xbString &xbDbf::GetCurIxType() const {
+ return sCurIxType;
+}
+
+/************************************************************************/
+//! @brief Get the current tag name.
+/*!
+ \returns Current Tag Name.<br>
+*/
+
+const xbString &xbDbf::GetCurTagName() const {
+
+ if( pCurIx )
+ return pCurIx->GetTagName( vpCurIxTag );
+ else
+ return sNullString;
+}
+
+/************************************************************************/
+//! @brief GetFirstKey for tag.
+/*!
+
+ Position to the first key for the current tag
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+xbInt16 xbDbf::GetFirstKey(){
+ if( pCurIx )
+ return pCurIx->GetFirstKey( vpCurIxTag, 1 );
+ else
+ return XB_INVALID_TAG;
+}
+
+/************************************************************************/
+//! @brief GetLastKey for tag.
+/*!
+
+ Position to the last key for the current tag
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+xbInt16 xbDbf::GetLastKey(){
+ if( pCurIx )
+ return pCurIx->GetLastKey( vpCurIxTag, 1 );
+ else
+ return XB_INVALID_TAG;
+}
+
+/************************************************************************/
+//! @brief GetNextKey for tag.
+/*!
+
+ Position to the next key for the current tag
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+xbInt16 xbDbf::GetNextKey(){
+ if( pCurIx )
+ return pCurIx->GetNextKey( vpCurIxTag, 1 );
+ else
+ return XB_INVALID_TAG;
+}
+
+/************************************************************************/
+//! @brief GetPrevKey for tag.
+/*!
+
+ Position to the previous key for the current tag
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+xbInt16 xbDbf::GetPrevKey(){
+ if( pCurIx )
+ return pCurIx->GetPrevKey( vpCurIxTag, 1 );
+ else
+ return XB_INVALID_TAG;
+}
+
+/************************************************************************/
+//! @brief Find record for key.
+/*!
+
+ Find a key and position to record if key found
+
+ \param sKey String key to find
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+xbInt16 xbDbf::Find( xbString &sKey ){
+ if( pCurIx )
+ return pCurIx->FindKey( vpCurIxTag, sKey.Str(), (xbInt32) sKey.Len(), 1 );
+ else
+ return XB_INVALID_TAG;
+}
+
+/************************************************************************/
+//! @brief Find record for key.
+/*!
+
+ Find a key and position to record if key found
+
+ \param dtKey Date key to find
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+xbInt16 xbDbf::Find( xbDate &dtKey ){
+
+ if( pCurIx )
+ return pCurIx->FindKey( vpCurIxTag, dtKey, 1 );
+ else
+ return XB_INVALID_TAG;
+
+}
+/************************************************************************/
+//! @brief Find record for key.
+/*!
+
+ Find a key and position to record if key found
+
+ \param dtKey Date key to find
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+xbInt16 xbDbf::Find( xbDouble &dKey ){
+
+ if( pCurIx )
+ return pCurIx->FindKey( vpCurIxTag, dKey, 1 );
+ else
+ return XB_INVALID_TAG;
+
+}
+
+
+#endif // XB_INDEX_SUPPORT
+
+/************************************************************************/
+//! @brief Return the current record number.
+/*!
+ \returns Returns the current record number.
+*/
+xbUInt32 xbDbf::GetCurRecNo() const {
+ return ulCurRec;
+}
+
+/************************************************************************/
+//! @brief Return the current dbf status.
+/*!
+ \returns 0 = closed<br>
+ 1 = open<br>
+ 2 = updates pending<br>
+*/
+xbInt16 xbDbf::GetDbfStatus() const {
+ return iDbfStatus;
+}
+/************************************************************************/
+//! @brief Return the number of fields in the table.
+/*!
+ \returns The number of fields in the table.
+*/
+xbInt32 xbDbf::GetFieldCnt() const {
+ return iNoOfFields;
+}
+
+/************************************************************************/
+#ifdef XB_LOCKING_SUPPORT
+//! @brief Get the first first record lock.
+/*!
+ Get the first record lock from a linked list of record locks.
+
+ \returns First record lock.
+*/
+xbLinkListNode<xbUInt32> * xbDbf::GetFirstRecLock() const {
+ return lloRecLocks.GetHeadNode();
+}
+#endif // XB_LOCKING_SUPPORT
+/************************************************************************/
+//! @brief Get the first record.
+/*!
+ Get the first not deleted record. This routines skips over any deleted records.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::GetFirstRecord()
+{
+ return GetFirstRecord( XB_ACTIVE_RECS );
+}
+
+/************************************************************************/
+//! @brief Get the first record.
+/*!
+
+ \param iOption XB_ALL_RECS - Get the first record, deleted or not.<br>
+ XB_ACTIVE_RECS - Get the first active record.<br>
+ XB_DELETED_RECS - Get the first deleted record.<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::GetFirstRecord( xbInt16 iOption )
+{
+ if( ulNoOfRecs == 0 )
+ return XB_EMPTY;
+
+ xbInt16 iRc = GetRecord( 1L );
+ while( iRc == XB_NO_ERROR &&
+ ((RecordDeleted() && iOption == XB_ACTIVE_RECS) ||
+ (!RecordDeleted() && iOption == XB_DELETED_RECS)))
+ if( ulCurRec < ulNoOfRecs )
+ iRc = GetRecord( ulCurRec + 1 );
+ else
+ return XB_EOF;
+
+ return iRc;
+}
+
+/************************************************************************/
+#ifdef XB_LOCKING_SUPPORT
+//! @brief Return lock status of the table header
+/*! \returns DBF header lock status
+*/
+
+xbBool xbDbf::GetHeaderLocked() const {
+ return this->bHeaderLocked;
+}
+#endif
+
+#ifdef XB_INDEX_SUPPORT
+//! @brief Return pointer to list of index files for the table.
+/*!
+ \returns Returns an xbIxList * pointer to list of open index files.
+*/
+
+xbIxList *xbDbf::GetIxList() const{
+ return ixList;
+}
+#endif // XB_INDEX_SUPPORT
+
+
+/************************************************************************/
+//! @brief Get the last record.
+/*!
+ Get the last not deleted record. This routines skips over any deleted records.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::GetLastRecord()
+{
+ return GetLastRecord( XB_ACTIVE_RECS );
+}
+/************************************************************************/
+//! @brief Get the last record.
+/*!
+
+ \param iOption XB_ALL_RECS - Get the last record, deleted or not.<br>
+ XB_ACTIVE_RECS - Get the last active record.<br>
+ XB_DELETED_RECS - Get the last deleted record.<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::GetLastRecord( xbInt16 iOption )
+{
+ if( ulNoOfRecs == 0 )
+ return XB_EMPTY;
+
+ xbInt16 iRc = GetRecord( ulNoOfRecs );
+ while( iRc == XB_NO_ERROR &&
+ ((RecordDeleted() && iOption == XB_ACTIVE_RECS) ||
+ (!RecordDeleted() && iOption == XB_DELETED_RECS)))
+ if( ulCurRec > 1 )
+ iRc = GetRecord( ulCurRec - 1 );
+ else
+ return XB_EOF;
+
+ return iRc;
+}
+
+
+/************************************************************************/
+//! @brief Get lock flavor.
+/*!
+ This routine is currently in place to provide structure for future locking
+ schemes that may differ from the legacy DBase (TM) locking scheme.
+ \returns Always 1.
+*/
+
+xbInt16 xbDbf::GetLockFlavor() const{
+ if( iLockFlavor == -1 )
+ return xbase->GetDefaultLockFlavor();
+ else
+ return iLockFlavor;
+}
+
+/************************************************************************/
+#ifdef XB_MEMO_SUPPORT
+/************************************************************************/
+//! @brief Get the lock status of the memo file.
+/*!
+ \returns Lock status of memo file.
+*/
+xbBool xbDbf::GetMemoLocked() const {
+ if( MemoFieldsExist())
+ return Memo->GetMemoLocked();
+ else
+ return xbFalse;
+}
+/************************************************************************/
+//! @brief Get pointer to Memo object.
+/*!
+ \returns This routine returns the pointer to the memo object.
+*/
+
+xbMemo * xbDbf::GetMemoPtr(){
+ return Memo;
+}
+#endif
+
+
+/************************************************************************/
+#ifdef XB_NDXINF_SUPPORT
+//! @brief Return the .INF file name
+/*!
+ If NDXIDX support is enabled in the library, and a non production (ndx)
+ has been associated with the dbf file, the .INF file name can be retrieved
+ with this routine.
+
+ \param sNdxInfFileName Output string containing .INF file name.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::GetNdxInfFileName( xbString &sNdxInfFileName ){
+
+ sNdxInfFileName = GetFqFileName();
+ xbUInt32 lLen = sNdxInfFileName.Len();
+ if( lLen < 5 )
+ return XB_FILE_NOT_FOUND;
+ sNdxInfFileName.PutAt(lLen-2, 'I');
+ sNdxInfFileName.PutAt(lLen-1, 'N');
+ sNdxInfFileName.PutAt(lLen, 'F');
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+//! @brief Return first node of linked list of .INF items.
+/*!
+ \returns List of .INF entries.
+*/
+
+xbLinkListNode<xbString> * xbDbf::GetNdxInfList() const{
+ return llNdxInfData.GetHeadNode();
+}
+#endif // XB_NDXINF_SUPPORT
+
+
+/************************************************************************/
+//! @brief Get the next record.
+/*!
+ Get the next not deleted record. This routines skips over any deleted records.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::GetNextRecord(){
+ return GetNextRecord( XB_ACTIVE_RECS );
+}
+
+/************************************************************************/
+//! @brief Get the next record.
+/*!
+ \param iOption XB_ALL_RECS - Get the next record, deleted or not.<br>
+ XB_ACTIVE_RECS - Get the next active record.<br>
+ XB_DELETED_RECS - Get the next deleted record.<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::GetNextRecord( xbInt16 iOption ){
+ if( ulNoOfRecs == 0 )
+ return XB_EMPTY;
+ else if( ulCurRec >= ulNoOfRecs )
+ return XB_EOF;
+ xbInt16 iRc = GetRecord( ulCurRec + 1 );
+ while( iRc == XB_NO_ERROR &&
+ ((RecordDeleted() && iOption == XB_ACTIVE_RECS) ||
+ (!RecordDeleted() && iOption == XB_DELETED_RECS)))
+ if( ulCurRec < ulNoOfRecs )
+ iRc = GetRecord( ulCurRec + 1 );
+ else
+ return XB_EOF;
+ return iRc;
+}
+/************************************************************************/
+//! @brief Get the next record.
+/*!
+
+ \param iOption XB_ALL_RECS - Get the next record, deleted or not.<br>
+ XB_ACTIVE_RECS - Get the next active record.<br>
+ XB_DELETED_RECS - Get the next deleted record.<br>
+ \param ulStartRec Get next record, starting from ulStartRec.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::GetNextRecord( xbInt16 iOption , xbUInt32 ulStartRec ){
+
+ if( iOption == 0 )
+ return GetNextRecord();
+ else if( iOption == 1 ){
+ if( ulStartRec > 0 )
+ ulCurRec = ulStartRec;
+ xbInt16 iRc = GetNextRecord();
+ while( iRc == XB_NO_ERROR && RecordDeleted())
+ iRc = GetNextRecord();
+ return iRc;
+ }
+ else
+ return XB_INVALID_OPTION;
+}
+
+
+/************************************************************************/
+#ifdef XB_INDEX_SUPPORT
+//! @brief Physical count of open index files.
+/*!
+
+ Returns a physical count of open index files for the dbf file. An index file
+ can contain one or more tags.
+ \returns Count of open index files.
+*/
+
+xbInt32 xbDbf::GetPhysicalIxCnt() const {
+
+ xbInt32 lCnt = 0;
+ #ifdef XB_INDEX_SUPPORT
+ xbIxList *p = ixList;
+ while( p ){
+ lCnt++;
+ p = p->next;
+ }
+ #endif
+ return lCnt;
+}
+#endif
+
+
+/************************************************************************/
+//! @brief Get the previous record.
+/*!
+ Get the previous not deleted record. This routine skips over any deleted records.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::GetPrevRecord()
+{
+ return GetPrevRecord( XB_ACTIVE_RECS );
+}
+
+/************************************************************************/
+//! @brief Get the previous record.
+/*!
+
+ \param iOption XB_ALL_RECS - Get the previous record, deleted or not.<br>
+ XB_ACTIVE_RECS - Get the previous active record.<br>
+ XB_DELETED_RECS - Get the previous deleted record.<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::GetPrevRecord( xbInt16 iOption ){
+ if( ulNoOfRecs == 0 )
+ return XB_EMPTY;
+ else if( ulCurRec <= 1L )
+ return XB_BOF;
+ xbInt16 iRc = GetRecord( ulCurRec - 1 );
+ while( iRc == XB_NO_ERROR &&
+ ((RecordDeleted() && iOption == XB_ACTIVE_RECS) ||
+ (!RecordDeleted() && iOption == XB_DELETED_RECS)))
+ if( ulCurRec > 1 )
+ iRc = GetRecord( ulCurRec - 1 );
+ else
+ return XB_BOF;
+
+ return iRc;
+}
+
+
+/************************************************************************/
+//! @brief Get record for specified record number.
+/*!
+ Retrieve a record from disk and load it into the record buffer. If auto commit
+ is enabled and there are pending updates, this routine will flush the updates
+ to disk before proceeding to ulRecNo.
+
+ \param ulRecNo - Record number to retrieve.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::GetRecord( xbUInt32 ulRecNo ){
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ /* verify the file is open */
+ if( iDbfStatus == XB_CLOSED ){
+ iErrorStop = 10;
+ iRc = XB_NOT_OPEN;
+ throw iRc;
+ }
+ if( iDbfStatus == XB_UPDATED ){
+ if( GetAutoCommit() == 1 ){
+ if(( iRc = Commit()) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ } else {
+ if(( iRc = Abort()) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ }
+ }
+
+ if( ulRecNo > ulNoOfRecs || ulRecNo == 0L ){
+ iErrorStop = 40;
+ iRc = XB_INVALID_RECORD;
+ throw iRc;
+ }
+
+ if(( xbFseek( (uiHeaderLen+(( (xbInt64) ulRecNo-1L ) * uiRecordLen )), SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ iRc = XB_SEEK_ERROR;
+ throw iRc;
+ }
+
+ if( xbFread( RecBuf, uiRecordLen, 1 ) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ iRc = XB_READ_ERROR;
+ throw iRc;
+ }
+ ulCurRec = ulRecNo;
+ }
+
+ catch (xbInt16 iRc ){
+ if( iRc != XB_LOCK_FAILED ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbDbf::GetRecord() Exception Caught. Error Stop = [%d] iRc = [%d] record = [%d]", iErrorStop, iRc, ulRecNo );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ }
+ return iRc;
+}
+/************************************************************************/
+//! @brief Get pointer to record buffer
+/*!
+ \param iOpt 0 for RecBuf (current) or 1 for RecBuf2 (original contents)
+
+ \returns Pointer to record buffer.
+*/
+char * xbDbf::GetRecordBuf( xbInt16 iOpt ) const {
+ if( iOpt )
+ return RecBuf2;
+ else
+ return RecBuf;
+}
+
+/************************************************************************/
+//! @brief Get the current number of records in the dbf data file.
+/*!
+ \param ulRecCnt Output number of records in file.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::GetRecordCnt( xbUInt32 & ulRecCnt )
+{
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbBool bIlocked = xbFalse;
+ try{
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock && !bTableLocked ){
+ if(( iRc = LockHeader( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ } else
+ bIlocked = xbTrue;
+ }
+
+ if((iRc = ReadHeader(1,1)) != XB_NO_ERROR){
+ LockHeader( XB_UNLOCK );
+ iErrorStop = 20;
+ throw iRc;
+ }
+
+ if( iAutoLock && bIlocked ){
+ if(( iRc = LockHeader( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ }
+ #endif
+ }
+ catch( xbInt16 iRc ){
+ if( iRc != XB_LOCK_FAILED ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbDbf::GetRecordCnt() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ }
+ ulRecCnt = ulNoOfRecs;
+ return iRc;
+}
+/************************************************************************/
+//! @brief Get the dbf record length.
+/*!
+ \returns Record length.
+*/
+xbUInt16 xbDbf::GetRecordLen() const {
+ return uiRecordLen;
+}
+/************************************************************************/
+//! @brief Get table locked status
+/*!
+ \returns Table lock status.
+*/
+
+xbBool xbDbf::GetTableLocked() const {
+ return this->bTableLocked;
+}
+/************************************************************************/
+//! @brief Get tag list for dbf file.
+/*!
+ This routine returns a list of tags for the file.<br>
+
+ The library is structured to support one or more files of the same or differing
+ index types (NDX/MDX), with each file supporting one or more index tags.<br>
+
+ \returns Tag list for the file/table.
+*/
+xbLinkListNode<xbTag *> *xbDbf::GetTagList() const {
+ return llTags.GetHeadNode();
+}
+/************************************************************************/
+//! @brief Get the table alias.
+/*!
+ This routine returns the table alias.
+ \returns Table alias
+*/
+const xbString & xbDbf::GetTblAlias() const {
+ return this->sAlias;
+}
+
+/************************************************************************/
+//! @brief Get the pointer to the xbXbase structure,
+/*!
+ \returns Pointer to xbXbase structure.
+*/
+xbXBase * xbDbf::GetXbasePtr() const {
+ return xbase;
+}
+/************************************************************************/
+#ifdef XB_NDXINF_SUPPORT
+//! @brief Load .INF data file,
+/*!
+ Protected method. This routine loads the ndx inf file.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::LoadNdxInfData(){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ // create file name
+ xbString sNdxInfFileName;
+ if(( iRc = GetNdxInfFileName( sNdxInfFileName )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ // if file does not exist, return no error
+ xbFile fMd( xbase );
+ if( !fMd.FileExists( sNdxInfFileName ))
+ return XB_NO_ERROR;
+
+ // open file file in read only mode
+ if(( iRc = fMd.xbFopen( "r", sNdxInfFileName, GetShareMode())) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ // clear the linked list
+ llNdxInfData.Clear();
+
+ // for each entry in the file, add a linked list item
+ xbString sRec;
+ xbString sLeft3;
+ xbString sFn;
+
+ while( iRc == XB_NO_ERROR ){
+ sRec = "";
+ if(( iRc = fMd.xbFgets( 132, sRec )) == XB_NO_ERROR ){
+ sLeft3 = sRec;
+ sLeft3.Left( 3 );
+ sLeft3.ToUpperCase();
+ if( sLeft3 == "NDX"){
+ sFn.ExtractElement(sRec.Str(), '=', 2 );
+ sFn.ZapChar( 0x0d );
+ sFn.ZapChar( 0x0a );
+ llNdxInfData.InsertAtEnd( sFn );
+ }
+ }
+ }
+ // close the file
+ if(( iRc = fMd.xbFclose()) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+
+ } catch( xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::LoadNdxInfData() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+#endif // XB_NDXINF_SUPPORT
+
+/************************************************************************/
+#ifdef XB_LOCKING_SUPPORT
+//! @brief Lock append bytes.
+/*!
+ This routine locks the append bytes and is used by the AppendRecord function.
+
+ \param iLockFunction XB_LOCK<br>XB_UNLOCK
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::LockAppend( xbInt16 iLockFunction )
+{
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbUInt32 ulAppendRec;
+
+ try{
+ if( iLockFunction == XB_LOCK ){
+ iErrorStop = 100;
+ if( ulAppendLocked > 0 ) /* already have an append lock */
+ return XB_NO_ERROR;
+
+ ulAppendRec = ulNoOfRecs + 1; /* record number needing to be locked */
+ if( GetLockFlavor() == LK_DBASE ){
+ iRc = xbLock( XB_LOCK, LK4026531839, 1 );
+ if( iRc != XB_NO_ERROR ){
+ if( iRc == XB_LOCK_FAILED )
+ return iRc;
+ else{
+ iErrorStop = 120;
+ throw iRc;
+ }
+ }
+
+ xbInt64 llAppendRecLockByte = (xbInt64) LK4026531838 - ulAppendRec;
+ iRc = xbLock( XB_LOCK, llAppendRecLockByte, 1 );
+ if( iRc != XB_NO_ERROR ){
+ xbLock( XB_UNLOCK, LK4026531839, 1 );
+ if( iRc == XB_LOCK_FAILED ){
+ return iRc;
+ } else {
+ iErrorStop = 130;
+ throw iRc;
+ }
+ }
+ ulAppendLocked = ulAppendRec; /* set the append lock switch */
+
+
+ // } else { - other lock-table flavor options go here Clipper, Fox, etc - }
+
+ } else {
+ iErrorStop = 190;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+
+ } else if( iLockFunction == XB_UNLOCK ){
+
+ iErrorStop = 200;
+
+ if( ulAppendLocked == 0 ) /* verify we have an active append lock */
+ return XB_NO_ERROR;
+
+ if( GetLockFlavor() == LK_DBASE ){
+ xbInt64 llAppendRecLockByte =(xbInt64) LK4026531838 - ulAppendLocked;
+ iRc = xbLock( XB_UNLOCK, llAppendRecLockByte, 1 );
+ if( iRc != XB_NO_ERROR ){
+ xbLock( XB_UNLOCK, LK4026531839, 1 );
+ iErrorStop = 220;
+ throw iRc;
+ }
+ iRc = xbLock( XB_UNLOCK, LK4026531839, 1 );
+ if( iRc != XB_NO_ERROR ){
+ iErrorStop = 230;
+ throw iRc;
+ }
+
+ ulAppendLocked = 0; /* release the append lock switch */
+
+ // } else { - other unlock-table flavor options go here Clipper, Fox, etc - }
+
+ } else {
+ iErrorStop = 290;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+ } else {
+ iErrorStop = 300;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+ } catch( xbInt16 iRc ){
+ if( iRc != XB_LOCK_FAILED ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::LockAppendBytes() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ }
+
+ return iRc;
+}
+
+
+/************************************************************************/
+//! @brief Lock Header
+/*!
+ This routine locks the file header.
+ \param iLockFunction XB_LOCK<br>XB_UNLOCK
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::LockHeader( xbInt16 iLockFunction )
+{
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ try{
+
+ if( iLockFunction == XB_LOCK ){
+ iErrorStop = 100;
+ if( GetHeaderLocked())
+ return XB_NO_ERROR;
+
+ iErrorStop = 110;
+ if( GetLockFlavor() == LK_DBASE ){
+
+ iRc = xbLock( XB_LOCK, LK4026531838, 1 );
+
+ if( iRc != XB_NO_ERROR ){
+ if( iRc == XB_LOCK_FAILED )
+ return iRc;
+ else{
+ iErrorStop = 120;
+ throw iRc;
+ }
+ }
+
+ } else {
+ iErrorStop = 190;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+
+ SetHeaderLocked( xbTrue );
+
+ } else if( iLockFunction == XB_UNLOCK ){
+
+ iErrorStop = 200;
+ if( !GetHeaderLocked())
+ return XB_NO_ERROR;
+
+ iErrorStop = 210;
+ if( GetLockFlavor() == LK_DBASE ){
+ iRc = xbLock( XB_UNLOCK, LK4026531838, 1 );
+ if( iRc != XB_NO_ERROR ){
+ iErrorStop = 220;
+ throw iRc;
+ }
+ } else {
+ iErrorStop = 290;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+ SetHeaderLocked( xbFalse );
+ } else {
+ iErrorStop = 300;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+
+ } catch (xbInt16 iRc ){
+ if( iRc != XB_LOCK_FAILED ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::LockHeader() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ }
+ return iRc;
+}
+/************************************************************************/
+#ifdef XB_INDEX_SUPPORT
+//! @brief Lock Index files.
+/*!
+ This routine locks all the index files.
+ \param iLockFunction XB_LOCK<br>XB_UNLOCK
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::LockIndices( xbInt16 iLockFunction )
+{
+ // this function doesn't take into account any Lack Flavors other than DBASE,
+ // would need updated to supprot other lock flavors - Clipper, FoxPro etc
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ xbIxList *ixLI = GetIxList(); // index list item
+
+ while( ixLI ){
+ if( iLockFunction == XB_LOCK ){
+
+ #ifdef XB_NDX_SUPPORT
+ if( *ixLI->sFmt == "NDX" ){
+ if( !ixLI->ix->GetLocked()){
+ if(( iRc = ixLI->ix->xbLock( XB_LOCK, LK4026531838, 1 )) != XB_NO_ERROR ){
+ ixLI->ix->xbLock( XB_UNLOCK, LK4026531838, 1 );
+ iErrorStop = 100;
+ throw iRc;
+ }
+ ixLI->ix->SetLocked( xbTrue );
+ }
+ }
+ #endif
+
+ } else if( iLockFunction == XB_UNLOCK ){
+
+ #ifdef XB_NDX_SUPPORT
+ if( *ixLI->sFmt == "NDX" ){
+ if( ixLI->ix->GetLocked()){
+ if(( iRc = ixLI->ix->xbLock( XB_UNLOCK, LK4026531838, 1 )) != XB_NO_ERROR ){
+ ixLI->ix->xbLock( XB_UNLOCK, LK4026531838, 1 );
+ iErrorStop = 100;
+ throw iRc;
+ }
+ ixLI->ix->SetLocked( xbFalse );
+ }
+ }
+ #endif
+ }
+ ixLI = ixLI->next;
+ }
+
+ } catch( xbInt16 iRc ){
+ if( iRc != XB_LOCK_FAILED ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::LockIndices() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ }
+ return iRc;
+}
+#endif // XB_INDEX_SUPPORT
+/************************************************************************/
+#ifdef XB_MEMO_SUPPORT
+//! @brief Lock Memo file.
+/*!
+ This routine locks the memo file for updates.
+ \param iLockFunction XB_LOCK<br>XB_UNLOCK
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::LockMemo( xbInt16 iLockFunction ){
+ if( MemoFieldsExist())
+ return Memo->LockMemo( iLockFunction );
+ else
+ return XB_NO_ERROR;
+}
+#endif // XB_MEMO_SUPPORT
+
+
+
+/************************************************************************/
+//! @brief Loc Record
+/*!
+ This routine locks a record for update.
+ \param iLockFunction XB_LOCK<br>XB_UNLOCK
+ \param ulRecNo Record number to lock
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::LockRecord( xbInt16 iLockFunction, xbUInt32 ulRecNo )
+{
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ try{
+
+ if( ulRecNo > ulNoOfRecs )
+ return XB_INVALID_RECORD;
+
+ if( iLockFunction == XB_LOCK ){
+ iErrorStop = 100;
+
+ if( lloRecLocks.KeyExists( ulRecNo ))
+ return XB_NO_ERROR;
+
+ if( GetLockFlavor() == LK_DBASE ){
+
+ iRc = xbLock( XB_LOCK, LK4026531838 - ulRecNo, 1 );
+ if( iRc != XB_NO_ERROR ){
+ if( iRc == XB_LOCK_FAILED ){
+ return iRc;
+ } else {
+ iErrorStop = 130;
+ throw iRc;
+ }
+ }
+ // other lock-table flavor options go here Clipper, Fox, etc
+
+ } else {
+ iErrorStop = 190;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+
+ // add the record lock info to the linked list chain of record locks
+ iRc = lloRecLocks.InsertKey( ulRecNo );
+ if( iRc != XB_NO_ERROR ){
+ xbLock( XB_UNLOCK, LK4026531838 - ulRecNo, 1 );
+ iErrorStop = 140;
+ throw iRc;
+ }
+
+ } else if( iLockFunction == XB_UNLOCK ){
+
+ iErrorStop = 200;
+
+ if( !lloRecLocks.KeyExists( ulRecNo ) )
+ return XB_NO_ERROR;
+
+ if( GetLockFlavor() == LK_DBASE ){
+ iRc = xbLock( XB_UNLOCK, LK4026531838 - ulRecNo, 1 );
+ if( iRc != XB_NO_ERROR ){
+ iErrorStop = 220;
+ throw iRc;
+ }
+ } else {
+ iErrorStop = 290;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+
+ // remove the record lock info to the linked list chain of record locks
+ // next line is crashing
+ iRc = lloRecLocks.RemoveKey( ulRecNo );
+ if( iRc != XB_NO_ERROR ){
+ iErrorStop = 230;
+ throw iRc;
+ }
+
+ } else {
+ iErrorStop = 300;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+
+ } catch( xbInt16 iRc ){
+ if( iRc != XB_LOCK_FAILED ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::LockRecord() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ }
+
+ return iRc;
+}
+
+
+/************************************************************************/
+//! @brief Lock table.
+/*!
+ This routine locks the table for updates.
+
+ \param iLockFunction XB_LOCK<br>XB_UNLOCK
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::LockTable( xbInt16 iLockFunction )
+{
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ if( iLockFunction == XB_LOCK ){
+ iErrorStop = 100;
+ if( GetTableLocked())
+ return XB_NO_ERROR; // table already locked
+
+ iErrorStop = 110;
+ if( GetLockFlavor() == LK_DBASE ){
+
+ // lOffset = LK4026531838;
+ // iLen = 2;
+ iRc = xbLock( XB_LOCK, LK4026531838, 2 );
+ if( iRc != XB_NO_ERROR ){
+ if( iRc == XB_LOCK_FAILED )
+ return iRc;
+ else{
+ iErrorStop = 120;
+ throw iRc;
+ }
+ }
+
+ // lOffset = LK3026531838;
+ // iLen = LK1000000000;
+ iRc = xbLock( XB_LOCK, LK3026531838, LK1000000000);
+ if( iRc != XB_NO_ERROR ){
+
+ // lOffset = LK4026531838;
+ // iLen = 2;
+ xbLock( XB_UNLOCK, LK4026531838, 2 );
+ if( iRc == XB_LOCK_FAILED ){
+ return iRc;
+ } else {
+ iErrorStop = 130;
+ throw iRc;
+ }
+ }
+
+ // iRc = xbLock( XB_UNLOCK, lOffset, iLen );
+ iRc = xbLock( XB_UNLOCK, LK3026531838, LK1000000000);
+ if( iRc != XB_NO_ERROR ){
+ // lOffset = LK4026531838;
+ // iLen = 2;
+ xbLock( XB_UNLOCK, LK4026531838, 2 );
+ iErrorStop = 140;
+ throw iRc;
+ }
+
+ // other lock-table flavor options go here Clipper, Fox, etc
+
+ } else {
+ iErrorStop = 190;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+ SetTableLocked( xbTrue );
+
+ } else if( iLockFunction == XB_UNLOCK ){
+
+ iErrorStop = 200;
+ if( !GetTableLocked())
+ return XB_NO_ERROR; // table already unlocked
+
+ iErrorStop = 210;
+ if( GetLockFlavor() == LK_DBASE ){
+
+ // lOffset = LK4026531838;
+ // iLen = 2;
+ iRc = xbLock( XB_UNLOCK, LK4026531838, 2 );
+ if( iRc != XB_NO_ERROR ){
+ iErrorStop = 220;
+ throw iRc;
+ }
+ } else {
+ iErrorStop = 290;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+ SetTableLocked( xbFalse );
+
+ } else {
+ iErrorStop = 300;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+
+ } catch (xbInt16 iRc ){
+ if( iRc != XB_LOCK_FAILED ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::LockFile() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ }
+ return iRc;
+
+}
+
+
+/************************************************************************/
+//! @brief Check for existence of any memo fields.
+/*!
+ \returns xbTrue - Memo fields exist.<br>xbFalse - Memo fields don't exist.
+*/
+xbBool xbDbf::MemoFieldsExist() const {
+#ifdef XB_MEMO_SUPPORT
+ if( iMemoFieldCnt > 0 )
+ return xbTrue;
+#endif
+ return xbFalse;
+}
+
+/************************************************************************/
+//! @brief Open a table/dbf file.
+/*!
+ This routine sets the alias name to the same as the table name.
+
+ \param sTableName Table name to open, Include the .dbf or .DBF extension.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::Open( const xbString & sTableName ) {
+ return Open( sTableName, sTableName );
+}
+
+/************************************************************************/
+//! @brief Open a table/dbf file.
+/*!
+ \param sTableName Table name to open, Include the .dbf or .DBF extension.
+ \param sAlias Alias name to assign to this entry.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::Open( const xbString & sTableName, const xbString & sAlias ){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+
+ try{
+
+ if(( iRc = Open( sTableName, sAlias, XB_READ_WRITE, XB_MULTI_USER )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ // do any .INF data things on the file, like open indices
+ #ifdef XB_NDXINF_SUPPORT
+ if(( iRc = LoadNdxInfData()) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ xbUInt32 llNodeCnt = llNdxInfData.GetNodeCnt();
+ if( llNodeCnt > 0 ){
+ xbString s2;
+ xbLinkListNode<xbString> * llN = llNdxInfData.GetHeadNode();
+ for( xbUInt32 i = 0; i < llNodeCnt; i++ ){
+ s2 = llN->GetKey();
+ if(( iRc = OpenIndex( "NDX", s2 )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc ;
+ }
+ llN = llN->GetNextNode();
+ }
+ }
+ #endif // XB_NDXINF_SUPPORT
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::Open() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+#endif // XB_LOCKING_SUPPORT
+
+/************************************************************************/
+#ifdef XB_INDEX_SUPPORT
+//! @brief Open an index.
+/*!
+ Open an index file for the dbf file.
+
+ \param sIxType - "NDX" or "MDX"
+ \param sFileName - File name of index,
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::OpenIndex( const xbString &sIxType, const xbString &sFileName ){
+
+ // this routine is used to open indices and set up linkages
+
+ xbInt16 iErrorStop = 0;
+ xbInt16 iRc = XB_NO_ERROR;
+ xbIx *pIx = NULL;
+
+ try{
+ xbString sType = sIxType;
+ sType.ToUpperCase();
+
+ if( sType == "" ){
+ iErrorStop = 10;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+
+ #ifdef XB_NDX_SUPPORT
+ } else if( sType == "NDX" ){
+ pIx = new xbIxNdx( this );
+ if(( iRc = pIx->Open( sFileName )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ #endif
+
+ #ifdef XB_MDX_SUPPORT
+ } else if( sType == "MDX" ){
+
+ pIx = new xbIxMdx( this );
+ if(( iRc = pIx->Open( sFileName )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+
+ #endif
+
+ } else {
+ iErrorStop = 40;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+
+ if(( iRc = AddIndex( pIx, sIxType )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ if(( iRc = UpdateTagList()) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ pCurIx = pIx;
+ sCurIxType = sIxType;
+ vpCurIxTag = pIx->GetTag( 0 );
+ }
+ catch (xbInt16 iRc ){
+ if( pIx ) delete pIx;
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::OpenIndex() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+#endif // XB_INDEX_SUPPORT
+
+
+
+/************************************************************************/
+//! @brief Pack dbf file.
+/*!
+ This routine eliminates all deleted records from the file.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::Pack()
+{
+ xbUInt32 ulDeletedRecCnt;
+ return Pack( ulDeletedRecCnt );
+}
+
+
+/************************************************************************/
+//! @brief Pack dbf file.
+/*!
+ This routine eliminates all deleted records from the file and clears
+ out any unused blocks in the memo file if one exists.
+ \param ulDeletedRecCnt - Output - number of recrods removed from the file.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::Pack( xbUInt32 &ulDeletedRecCnt )
+{
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbUInt32 ulLastMovedRec = 0;
+ xbUInt32 ulStartPos = 0;
+ xbUInt32 ulLastPackedRec = 0;
+ xbUInt32 ulMoveRec = 0;
+ xbUInt32 ulRecCnt = 0;
+ ulDeletedRecCnt = 0;
+
+ try{
+ if( !FileIsOpen() ){
+ iErrorStop = 10;
+ iRc = XB_DBF_FILE_NOT_OPEN;
+ throw iRc;
+ }
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock ){
+ if(( iRc = LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+ #endif
+
+ if(( iRc = GetRecordCnt( ulRecCnt )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+
+ xbBool bDone = xbFalse;
+ for( xbUInt32 ulI = 1; ulI <= ulRecCnt && !bDone; ulI++ ){
+
+
+ if(( iRc = GetRecord( ulI )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+
+ if( RecordDeleted()){
+
+ ulDeletedRecCnt++;
+ if( ulI > ulLastMovedRec )
+ ulStartPos = ulI;
+ else
+ ulStartPos = ulLastMovedRec;
+
+ iRc = GetNextRecord( 1, ulStartPos );
+
+ if( iRc == XB_NO_ERROR ){
+ ulMoveRec = ulCurRec;
+ }
+ else if( iRc == XB_EOF ){
+ ulMoveRec = 0;
+ bDone = xbTrue;
+ }
+ else{
+ iErrorStop = 50;
+ throw iRc;
+ }
+ if( ulMoveRec > 0 ){
+ if(( iRc = DeleteRecord()) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ if(( iRc = PutRecord( ulMoveRec )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw iRc;
+ }
+ if(( iRc = UndeleteRecord()) != XB_NO_ERROR ){
+ iErrorStop = 80;
+ throw iRc;
+ }
+ if(( iRc = PutRecord( ulI )) != XB_NO_ERROR ){
+ iErrorStop = 90;
+ throw iRc;
+ }
+ ulLastPackedRec = ulI;
+ }
+
+ } else {
+ ulLastPackedRec = ulI;
+ }
+ }
+
+ if( ulLastPackedRec < ulRecCnt ){
+ // update header record count
+
+ xbDate d;
+ cUpdateYY = (char) d.YearOf() - 1900;
+ cUpdateMM = (char) d.MonthOf();
+ cUpdateDD = (char) d.DayOf( XB_FMT_MONTH );
+ ulNoOfRecs = ulLastPackedRec;
+
+ // rewrite the header record
+ if(( iRc = WriteHeader( 1, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 200;
+ throw iRc;
+ }
+
+ // truncate the file to the new size
+ if(( iRc = xbTruncate( uiHeaderLen + uiRecordLen * ulLastPackedRec )) != XB_NO_ERROR ){
+ iErrorStop = 210;
+ throw iRc;
+ }
+ }
+
+ if( ulNoOfRecs > 0 ){
+ if(( iRc = GetRecord( 1 )) != XB_NO_ERROR ){
+ iErrorStop = 220;
+ throw iRc;
+ }
+ } else {
+ BlankRecord();
+ ulCurRec = 0;
+ }
+
+ #ifdef XB_MEMO_SUPPORT
+ if( iMemoFieldCnt > 0 ){
+ if(( iRc = Memo->PackMemo( 0 )) != XB_NO_ERROR ){
+ iErrorStop = 230;
+ throw iRc;
+ }
+ }
+ #endif // XB_MEMO_SUPPORT
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock ){
+ if(( iRc = LockTable( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 240;
+ throw iRc;
+ }
+ }
+
+ #endif
+ }
+ catch (xbInt16 iRc ){
+ if( iRc != XB_LOCK_FAILED ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::Pack() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ }
+ return iRc;
+}
+
+/************************************************************************/
+//! @brief Write the current record to disk.
+/*!
+ This routine is used to write any updates to the current record buffer to disk.
+
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::PutRecord() {
+ return PutRecord(ulCurRec);
+}
+
+/************************************************************************/
+//! @brief Write record to disk.
+/*!
+ This routine is used to write a copy of the current record buffer to disk
+ for a given record number.
+
+ \param ulRecNo Record number to update.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::PutRecord(xbUInt32 ulRecNo)
+{
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try{
+
+ if( ulRecNo < 1 ){
+ iErrorStop = 100;
+ throw XB_INVALID_RECORD;
+ }
+
+ xbUInt32 ulRecCnt;
+ if(( iRc = GetRecordCnt( ulRecCnt )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ if( ulRecNo > ulRecCnt ){
+ iErrorStop = 120;
+ throw XB_INVALID_RECORD;
+ }
+
+ if( iDbfStatus == XB_CLOSED ){
+ iErrorStop = 130;
+ iRc = XB_NOT_OPEN;
+ throw iRc;
+ }
+ /* lock the database */
+ #ifdef XB_LOCKING_SUPPORT
+ // xbInt16 iAutoLock = GetAutoLock();
+ if( iAutoLock && !bTableLocked ){
+ if(( iRc = LockHeader( XB_LOCK )) != XB_NO_ERROR ){
+ if( iRc == XB_LOCK_FAILED )
+ return iRc;
+ else{
+ iErrorStop = 140;
+ throw iRc;
+ }
+ }
+
+ if(( iRc = ReadHeader( 1, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ LockHeader( XB_UNLOCK );
+ throw iRc;
+ }
+ }
+ #endif
+
+ // verify valid record number request
+ if( ulRecNo > ulNoOfRecs || ulRecNo == 0L ){
+ iErrorStop = 160;
+ iRc = XB_INVALID_RECORD;
+ throw iRc;
+ }
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock ){
+ if( !bTableLocked ){
+ if(( iRc = LockRecord( XB_LOCK, ulRecNo )) != XB_NO_ERROR ){
+ if( iRc == XB_LOCK_FAILED )
+ return iRc;
+ else{
+ iErrorStop = 170;
+ throw iRc;
+ }
+ }
+ }
+
+ #ifdef XB_INDEX_SUPPORT
+ if(( iRc = LockIndices( XB_LOCK )) != XB_NO_ERROR ){
+ if( iRc == XB_LOCK_FAILED )
+ return iRc;
+ else{
+ iErrorStop = 180;
+ throw iRc;
+ }
+ }
+ #endif
+ }
+ #endif
+
+ // build keys, check for duplicate keys, add keys
+ #ifdef XB_INDEX_SUPPORT
+ xbIxList *ixList = GetIxList();
+
+ while( ixList ){
+ if(( iRc = ixList->ix->CreateKeys( 2 )) != XB_NO_ERROR ){
+ iErrorStop = 190;
+ throw iRc;
+ }
+ iRc = ixList->ix->CheckForDupKeys();
+ if( iRc != 0 ){
+ if( iRc < 0 ){
+ iErrorStop = 200;
+ throw iRc;
+ }
+ return XB_KEY_NOT_UNIQUE;
+ }
+ ixList = ixList->next;
+ }
+
+ ixList = GetIxList();
+ while( ixList ){
+
+ if(( iRc = ixList->ix->AddKeys( ulCurRec )) != XB_NO_ERROR ){
+ iErrorStop = 210;
+ throw iRc;
+ }
+ ixList = ixList->next;
+ }
+
+ ixList = GetIxList();
+ while( ixList ){
+
+// if(( iRc = ixList->ix->DeleteKeys( ulCurRec )) != XB_NO_ERROR ){
+
+ if(( iRc = ixList->ix->DeleteKeys()) != XB_NO_ERROR ){
+ iErrorStop = 220;
+ throw iRc;
+ }
+ ixList = ixList->next;
+ }
+ #endif // XB_INDEX_SUPPORT
+
+ // update latest header date if changed
+ xbDate d;
+ if( (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 );
+ // rewrite the header record - first 8 bytes
+ if(( iRc = WriteHeader( 1, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw iRc;
+ }
+ }
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock && !bTableLocked ){
+ if(( iRc = LockHeader( XB_UNLOCK )) != XB_NO_ERROR ){
+ if( iRc == XB_LOCK_FAILED )
+ return iRc;
+ else{
+ iErrorStop = 230;
+ throw iRc;
+ }
+ }
+ }
+ #endif
+
+ // update record
+ iRc = xbFseek( (uiHeaderLen+(( (xbInt64) ulRecNo-1L ) * uiRecordLen )),0 );
+ if( iRc != XB_NO_ERROR ){
+ iErrorStop = 240;
+ throw iRc;
+ }
+
+ if( xbFwrite( RecBuf, uiRecordLen, 1 ) != XB_NO_ERROR ){
+ iErrorStop = 250;
+ iRc = XB_WRITE_ERROR;
+ throw iRc;
+ }
+
+ #ifdef XB_MEMO_SUPPORT
+ if( MemoFieldsExist() ){
+ if(( iRc = Memo->Commit()) != XB_NO_ERROR ){
+ iErrorStop = 260;
+ throw iRc;
+ }
+ }
+ #endif
+
+ // unlock record
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock ){
+ #ifdef XB_INDEX_SUPPORT
+ LockIndices( XB_UNLOCK );
+ #endif // XB_INDEX_SUPPORT
+ if( !bTableLocked ){
+ if(( iRc = LockRecord( XB_UNLOCK, ulRecNo )) != XB_NO_ERROR ){
+ if( iRc == XB_LOCK_FAILED )
+ return iRc;
+ else{
+ iErrorStop = 270;
+ throw iRc;
+ }
+ }
+ }
+ }
+
+ #endif
+ ulCurRec = ulRecNo;
+ iDbfStatus = XB_OPEN;
+ }
+
+ catch (xbInt16 iRc ){
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock ){
+ LockHeader( XB_UNLOCK );
+ LockAppend( XB_UNLOCK );
+ LockRecord( XB_UNLOCK, ulRecNo );
+ LockIndices( XB_UNLOCK );
+ }
+ #endif // XB_LOCKING_SUPPORT
+
+ if( iRc != XB_LOCK_FAILED ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::PutRecord() Exception Caught. Error Stop = [%d] iRc = [%d] record = [%d]", iErrorStop, iRc, ulRecNo );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ }
+ return iRc;
+}
+
+/************************************************************************/
+//! @brief Read dbf file header information.
+/*!
+ This method assumes the header has been locked appropriately
+ in a multi user environment
+
+
+ \param iPositionOption 0 - Don't fseek to beginning of file before read.<br>
+ 1 - Start from beginning of file.
+
+ \param iReadOption 0 - Read entire 32 byte header<br>
+ 1 - Read first eight bytes which includes the last update date and number of records.
+
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::ReadHeader( xbInt16 iPositionOption, xbInt16 iReadOption ){
+
+ char buf[32];
+ size_t iReadSize;
+
+ if(iPositionOption)
+ xbRewind();
+ if( iReadOption == 1 )
+ iReadSize = 8;
+ else
+ iReadSize = 32;
+
+ if(xbFread(buf, iReadSize, 1) != XB_NO_ERROR)
+ return XB_READ_ERROR;
+ memcpy(&cVersion, buf, 4);
+ ulNoOfRecs = eGetUInt32(&buf[4]);
+ if( iReadOption == 1 )
+ return XB_NO_ERROR;
+
+ uiHeaderLen = eGetUInt16(&buf[8]);
+ uiRecordLen = eGetUInt16(&buf[10]);
+ cTransactionFlag = buf[14];
+ cEncryptionFlag = buf[15];
+ cIndexFlag = buf[28];
+ cLangDriver = buf[29];
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+//! @brief Return record deletion status.
+/*!
+ This routine returns the record deletion status.
+ \param iOpt 0 = Current record buffer, 1 = Original record buffer
+ \returns xbTrue - Record deleted.<br>xbFalse - Record not deleted.
+*/
+xbInt16 xbDbf::RecordDeleted( xbInt16 iOpt ) const {
+ if( !iOpt && RecBuf && RecBuf[0] == 0x2a )
+ return xbTrue;
+ else if( iOpt && RecBuf2 && RecBuf2[0] == 0x2a )
+ return xbTrue;
+ else
+ return xbFalse;
+}
+
+/************************************************************************/
+#ifdef XB_INDEX_SUPPORT
+//! @brief Remove an index from the internal list of indices for this table
+/*
+ The index list is used during any table update process to update any open
+ index file. Index files can contain one or more tags.
+
+ \param ixIn Pointer to index object for a given index file.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::RemoveIndex( xbIx * ixIn ){
+
+ xbIxList *p = ixList;
+ // if index is the first entry in the list
+ if( ixList->ix == ixIn ){
+ ixList = ixList->next;
+ delete p->sFmt;
+ delete p->ix;
+ free( p );
+ return XB_NO_ERROR;
+ }
+
+ // spin down to the correct ix
+ xbIxList *p2 = NULL;
+ while( p && p->ix != ixIn ){
+ p2 = p;
+ p = p->next;
+ }
+ if( p ){
+ p2->next = p->next;
+ delete p->sFmt;
+ delete p->ix;
+ free( p );
+ }
+ return XB_NO_ERROR;
+}
+#endif // XB_INDEX_SUPPORT
+
+/************************************************************************/
+// @brief Reset number of records.
+/*
+ Protected method. Resets number of records to 0.
+ \returns void
+*/
+void xbDbf::ResetNoOfRecords() {
+ ulNoOfRecs = 0UL;
+}
+
+/************************************************************************/
+#ifdef XB_NDXINF_SUPPORT
+// @brief Update .INF data file.
+/*
+ Protected method.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf::SaveNdxInfData(){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbFile fMd( xbase );
+
+ try{
+
+ xbUInt32 llNodeCnt = llNdxInfData.GetNodeCnt();
+
+ xbString sNdxInfFileName;
+ if(( iRc = GetNdxInfFileName( sNdxInfFileName )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ // open the file
+ if(( iRc = fMd.xbFopen( "w", sNdxInfFileName, GetShareMode())) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+
+ xbString s1;
+ xbString s2;
+ s2.Sprintf( "[dbase]%c%c", 0x0d, 0x0a );
+ if(( iRc = fMd.xbFputs( s2 )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+
+
+ // for each entry in the linked list, write a line
+ xbLinkListNode<xbString> * llN = llNdxInfData.GetHeadNode();
+ for( xbUInt32 i = 0; i < llNodeCnt; i++ ){
+ s2 = llN->GetKey();
+ if( i > 0 )
+ s1.Sprintf( "NDX%d=%s%c%c", i, s2.Str(), 0x0d, 0x0a );
+ else
+ s1.Sprintf( "NDX=%s%c%c", s2.Str(), 0x0d, 0x0a );
+
+ if(( iRc = fMd.xbFputs( s1 )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ llN = llN->GetNextNode();
+ }
+
+ // close the file
+ if(( iRc = fMd.xbFclose()) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+
+ } catch( xbInt16 iRc ){
+ if( fMd.FileIsOpen())
+ fMd.xbFclose();
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::SaveNdxInfData() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+#endif // XB_NDXINF_SUPPORT
+/************************************************************************/
+//! @brief Set auto commit.
+/*!
+ This routine sets the auto commit setting for this table.
+ \returns XB_NO_ERROR;
+*/
+xbInt16 xbDbf::SetAutoCommit( xbBool iAutoCommit ) {
+ this->iAutoCommit = iAutoCommit;
+ return XB_NO_ERROR;
+}
+
+
+/************************************************************************/
+//! @brief Set auto lock.
+/*!
+ This routine sets the auto lock setting for this table.
+ There is an overall system level auto lock default setting and each table
+ can have it's own autolock setting. This method controls the table level
+ auto lock setting.
+
+ \param iAutoLock 1 - Use auto lock for this table.<br>
+ 0 - Don't use auto lock for this table.<br>
+ -1 - (minus one) Use system default.<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+void xbDbf::SetAutoLock( xbInt16 iAutoLock ){
+ if( iAutoLock == -1 )
+ this->iAutoLock = xbase->GetDefaultAutoLock();
+ else
+ this->iAutoLock = iAutoLock;
+}
+
+
+
+/************************************************************************/
+#ifdef XB_INDEX_SUPPORT
+//! @brief Set the current tag for the dbf file.
+/*!
+ \param sTagName - Tag Name
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::SetCurTag( const xbString &sTagName ){
+
+ if( sTagName == "" ){
+ SetCurTag( "", 0, 0 );
+ return XB_NO_ERROR;
+
+ } else {
+ xbLinkListNode<xbTag *> *llN = GetTagList();
+ xbTag *pTag;
+ while( llN ){
+ pTag = llN->GetKey();
+ if( pTag->GetTagName() == sTagName ){
+ SetCurTag( pTag->GetType(), pTag->GetIx(), pTag->GetVpTag());
+ return XB_NO_ERROR;
+ }
+ llN = llN->GetNextNode();
+ }
+ }
+
+ return XB_INVALID_TAG;
+}
+
+/************************************************************************/
+//! @brief Set the current tag for the dbf file.
+/*!
+
+ \param sIxType - One of "NDX" or MDX",
+ \param pIx - Pointer to index object.
+ \param vpTag - Pointer to tag object.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+void xbDbf::SetCurTag( const xbString &sIxType, xbIx *pIx, void *vpTag ){
+ pCurIx = pIx;
+ vpCurIxTag = vpTag;
+ sCurIxType.Set( sIxType );
+}
+#endif // XB_INDEX_SUPPORT
+
+/************************************************************************/
+//! @brief Set the header locked status.
+/*!
+ \param bHeaderLocked xbTrue - Locked<br>xbFalse - Not locked.
+ \returns void
+*/
+void xbDbf::SetHeaderLocked( xbBool bHeaderLocked ){
+ this->bHeaderLocked = bHeaderLocked;
+}
+
+/************************************************************************/
+//! @brief Set lock flavor.
+/*!
+ This routine is for future expansion.
+ \param iLockFlavor 1 - Use Dbase (tm) style locking.
+ \returns void
+*/
+
+void xbDbf::SetLockFlavor( xbInt16 iLockFlavor ){
+ this->iLockFlavor = iLockFlavor;
+}
+
+/************************************************************************/
+//! @brief Set table locked status.
+/*!
+ \param bTableLocked - xbTrue Table locked.<br>xbFalse Table unlocked.
+ \returns void
+*/
+
+void xbDbf::SetTableLocked( xbBool bTableLocked ){
+ this->bTableLocked = bTableLocked;
+}
+/************************************************************************/
+//! @brief Undelete all records.
+/*!
+ This routine will remove the deletion flag on any deleted records in the table.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::UndeleteAllRecords(){
+ return DeleteAll( 1 );
+}
+
+/************************************************************************/
+//! @brief Undelete one record.
+/*!
+ This routine will undelete the current record, if it is deleted.
+ \returns XB_NO_ERROR<br>XB_INVALID_RECORD
+*/
+xbInt16 xbDbf::UndeleteRecord()
+{
+ if( RecBuf && ulCurRec > 0 ){
+ if( RecBuf[0] != 0x20 ){
+ if( iDbfStatus != XB_UPDATED ){
+ iDbfStatus = XB_UPDATED;
+ memcpy( RecBuf2, RecBuf, uiRecordLen ); // save off original before making updates
+ }
+ RecBuf[0] = 0x20;
+ }
+ return XB_NO_ERROR;
+ }
+ else
+ return XB_INVALID_RECORD;
+}
+
+/************************************************************************/
+#ifdef XB_MEMO_SUPPORT
+//! @brief Update memo field
+/*!
+ This routine updates a memo field.
+ \param iFieldNo - Memo field number to update.
+ \param sMemoData - Memo data for update.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::UpdateMemoField( xbInt16 iFieldNo, const xbString &sMemoData ){
+ return Memo->UpdateMemoField( iFieldNo, sMemoData );
+}
+/************************************************************************/
+//! @brief Update memo field
+/*!
+ This routine updates a memo field.
+ \param sFieldName - Memo field name to update.
+ \param sMemoData - Memo data for update.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::UpdateMemoField( const xbString & sFieldName, const xbString & sMemoData ){
+ return Memo->UpdateMemoField( GetFieldNo( sFieldName ), sMemoData );
+}
+#endif
+
+
+/************************************************************************/
+#ifdef XB_INDEX_SUPPORT
+//! @brief Update SchemaIxFlag
+/*!
+ This routine can be called from the DeleteTag routine if a tag has been deleted and the flag needs reset
+ \param iFldNo - Which field the index flag needs changed on
+ \param cVal - Value to change it to
+*/
+
+void xbDbf::UpdateSchemaIxFlag( xbInt16 iFldNo, unsigned char cVal ){
+ if( cVal != 0x00 || cVal != 0x01 )
+ SchemaPtr[iFldNo].cIxFlag = cVal;
+}
+
+#endif // XB_INDEX_SUPPORT
+/************************************************************************/
+//! @brief Update tag list.
+/*!
+ This routine updates the internal tag list of open index tags.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::UpdateTagList(){
+
+ xbInt16 iErrorStop = 0;
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt32 lTagCnt;
+
+ try{
+ ClearTagList();
+
+ // For each active index
+ xbIxList *p = GetIxList();
+ xbIx *ixp;
+ while( p ){
+ ixp = p->ix;
+ // for each tag within the file
+ lTagCnt = ixp->GetTagCount();
+ for( xbInt32 l = 0; l < lTagCnt; l++ ){
+ xbTag *pTag = new xbTag( ixp, ixp->GetTag( l ), *p->sFmt, ixp->GetTagName( ixp->GetTag( l )),
+ ixp->GetKeyExpression( ixp->GetTag( l )), ixp->GetKeyFilter( ixp->GetTag( l )),
+ ixp->GetUnique( ixp->GetTag( l )), ixp->GetSortOrder( ixp->GetTag( l )));
+
+ // append it to the llTags list
+ llTags.InsertAtEnd( pTag );
+ }
+ p = p->next;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::UpdateTagList() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/************************************************************************/
+// @brief Write Header
+/*
+ Protected method.
+
+ \param iPositionOption 0 - Don't fseek to beginning of file before read.<br>
+ 1 - Go to beginning of file before read.
+ \param iWriteOption 0 - Write entire 32 byte header.<br>
+ 1 - Write first eight bytes needed for table updates - last update date and number of records.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::WriteHeader( xbInt16 iPositionOption, xbInt16 iWriteOption )
+{
+ char buf[32];
+ xbInt32 lWriteLen;
+
+ if(iPositionOption)
+ xbRewind();
+
+ memset(buf, 0, 32);
+ if( iWriteOption == 1 )
+ lWriteLen = 8;
+ else{
+ lWriteLen = 32;
+ ePutUInt16( &buf[8], uiHeaderLen );
+ ePutUInt16( &buf[10], uiRecordLen );
+ buf[14] = cTransactionFlag;
+ buf[15] = cEncryptionFlag;
+ buf[28] = cIndexFlag;
+ buf[29] = cLangDriver;
+ }
+ memcpy(&buf[0], &cVersion, 4);
+ ePutUInt32( &buf[4], ulNoOfRecs);
+ if(xbFwrite(buf, (size_t) lWriteLen, 1) != XB_NO_ERROR)
+ return XB_WRITE_ERROR;
+
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+//! @brief Zap (remove) everything from the file,
+/*!
+ This routine eliminates everything from the dbf file and dbt memo file.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbDbf::Zap(){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ if( iDbfStatus != XB_OPEN ){
+ iErrorStop = 10;
+ iRc = XB_DBF_FILE_NOT_OPEN;
+ throw iRc;
+ }
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock ){
+ if(( iRc = LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+ #endif
+
+ xbDate d;
+ cUpdateYY = (char) d.YearOf() - 1900;
+ cUpdateMM = (char) d.MonthOf();
+ cUpdateDD = (char) d.DayOf( XB_FMT_MONTH );
+ ulNoOfRecs = 0;
+
+ // rewrite the header record
+ if(( iRc = WriteHeader( 1, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+
+ // truncate the file to the new size
+ if(( iRc = xbTruncate( uiHeaderLen )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ BlankRecord();
+ ulCurRec = 0;
+
+ #ifdef XB_MEMO_SUPPORT
+ if( iMemoFieldCnt ){
+ if(( iRc = Memo->Zap()) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ }
+ #endif
+ #ifdef XB_INDEX_SUPPORT
+ xbLinkListNode<xbTag *> *llN = GetTagList();
+ xbTag *pTag;
+ xbIx *pIx;
+ void *vpTag;
+ while( llN ){
+ pTag = llN->GetKey();
+ pIx = pTag->GetIx();
+ vpTag = pTag->GetVpTag();
+ if(( iRc = pIx->Reindex( &vpTag )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ llN = llN->GetNextNode();
+ }
+
+ #endif // XB_INDEX_SUPPORT
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock ){
+ if(( iRc = LockTable( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw iRc;
+ }
+ }
+ #endif // XB_LOCKING_SUPPORT
+ }
+ catch (xbInt16 iRc ){
+ if( iRc != XB_LOCK_FAILED ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf::Zap() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ }
+ return iRc;
+}
+/************************************************************************/
+} /* namespace */ \ No newline at end of file
diff --git a/src/core/xbdbf3.cpp b/src/core/xbdbf3.cpp
new file mode 100755
index 0000000..cbbff1f
--- /dev/null
+++ b/src/core/xbdbf3.cpp
@@ -0,0 +1,577 @@
+/* xbdbf3.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_DBF3_SUPPORT
+
+namespace xb{
+
+
+/************************************************************************/
+//! @brief Constructor.
+
+xbDbf3::xbDbf3(xbXBase * x) : xbDbf( x ) {
+ #ifdef XB_MEMO_SUPPORT
+ ulCreateMemoBlockSize = 512;
+ #endif
+ iFileVersion = 3;
+};
+
+/************************************************************************/
+//! @brief Destructor.
+
+xbDbf3::~xbDbf3() {};
+
+/************************************************************************/
+//! @brief Create Version 3 table.
+/*!
+ This routine creates a Dbase III Plus (tm) DBF file.
+
+ \param sTableName DBF table name.
+ \param sAlias Table alias
+ \param pSchema Pointer to schema structure with field definitions.
+ \param iOverlay xbTrue - Overlay.<br> xbFalse - Don't overlay.
+ \param iShareMode XB_SINGLE_USER<br>XB_MULTI_USER
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+xbInt16 xbDbf3::CreateTable( const xbString & sTableName, const xbString & sAlias, xbSchema *pSchema, xbInt16 iOverlay, xbInt16 iShareMode ){
+
+ xbInt16 i, k, k2;
+ xbInt16 rc = 0;
+ xbInt16 iErrorStop = 0;
+ iDbfStatus = XB_CLOSED;
+
+ xbString sNfn;
+ try{
+ sNfn = sTableName;
+ xbase->GetLogStatus();
+
+ rc = NameSuffixMissing( sNfn, 1 );
+ if( rc > 0 )
+ sNfn += ".DBF";
+
+ SetFileName( sNfn );
+ this->sAlias = sAlias;
+
+ /* check if the file already exists */
+ if( FileExists( 0 )){
+ if( !iOverlay ){
+ iErrorStop = 10;
+ rc = XB_FILE_EXISTS;
+ throw rc;
+ }
+ #ifdef XB_NDXINF_SUPPORT
+ // remove the metadata file if there is one
+ xbString sMname = sNfn;
+ xbUInt32 iMnameLen = sMname.Len();
+ sMname.PutAt( iMnameLen-2, 'X' );
+ sMname.PutAt( iMnameLen-1, 'B' );
+ sMname.PutAt( iMnameLen, 'M' );
+ xbFile fTemp( xbase );
+ fTemp.SetFileName( sMname );
+ if( fTemp.FileExists() )
+ fTemp.xbRemove();
+ #endif // XB_NDXINF_SUPPORT
+ }
+
+ /* check if we already have a file with this alias */
+ if(( rc = xbase->AddTblToTblList( this, GetFqFileName(), sAlias )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw rc;
+ }
+
+ rc = ValidateSchema( pSchema );
+ if( rc < 0 ){
+ iErrorStop = 30;
+ throw rc;
+ } else
+ iNoOfFields = rc;
+
+ #ifdef XB_MEMO_SUPPORT
+ // if we have memo fields
+ iMemoFieldCnt = 0;
+ i = 0;
+ while( pSchema[i].cType != 0){
+ if( pSchema[i].cType == 'M' )
+ iMemoFieldCnt++; /* number of memo fields in the incoming definition */
+ i++;
+ }
+
+ if( iMemoFieldCnt > 0 ){
+ xbString sMfn = sNfn; /* memo file name, same as filename except ends with a "t", not an "f" */
+ xbUInt32 iMfnLen = sMfn.Len();
+ sMfn.PutAt( iMfnLen, 'T' );
+
+ // dont overlay the memo file if it exists, and Overlay switch is off
+ xbFile fTemp( xbase );
+ fTemp.SetFileName( sMfn );
+ if( fTemp.FileExists() && !iOverlay ){
+ iErrorStop = 40;
+ rc = XB_FILE_EXISTS;
+ throw rc;
+ }
+
+ Memo = new xbMemoDbt3( this, fTemp.GetFqFileName());
+
+ if(( rc = Memo->CreateMemoFile()) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw rc;
+ }
+ }
+ #endif
+
+ /* this is the dBase III version of the class */
+ cVersion = 0x03; // 0x03 for Dbase level 5
+ #ifdef XB_MEMO_SUPPORT
+ if( iMemoFieldCnt > 0 ){
+// cVersion = cVersion |= 0x80; // Version III memo, compiler complaints
+ cVersion |= 0x80; // Version III memo
+ }
+ #endif
+
+ if(( rc = xbFopen( "w+b", iShareMode )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw rc;
+ }
+ uiRecordLen++; /* add one byte for 0x0D */
+
+ if(( RecBuf = (char *) malloc( uiRecordLen )) == NULL ){
+ iErrorStop = 70;
+ throw rc;
+ }
+
+ if(( RecBuf2 = (char *) malloc( uiRecordLen )) == NULL ){
+ iErrorStop = 80;
+ rc = XB_NO_MEMORY;
+ throw rc;
+ }
+
+ /* BlankRecord(); */
+ memset( RecBuf, 0x20, uiRecordLen );
+ memset( RecBuf2, 0x20, uiRecordLen );
+ ulCurRec = 0L;
+ uiHeaderLen = 33 + iNoOfFields * 32;
+ xbDate d;
+ cUpdateYY = (char) (d.YearOf() - 1900);
+ cUpdateMM = (char) d.MonthOf();
+ cUpdateDD = (char) d.DayOf( XB_FMT_MONTH );
+
+ /* write the header prolog */
+ if(( rc = WriteHeader( 0, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 90;
+ rc = XB_WRITE_ERROR;
+ throw rc;
+ }
+ if((SchemaPtr = (xbSchemaRec *) malloc( (size_t) iNoOfFields * sizeof( xbSchemaRec ))) == NULL){
+ iErrorStop = 100;
+ rc = XB_NO_MEMORY;
+ throw rc;
+ }
+
+ /* write the field information into the header */
+ for( i = 0, k = 1; i < iNoOfFields; i++ ){
+
+ memset( SchemaPtr[i].cFieldName, 0x00, 11 );
+ for( int x = 0; x < 10 && pSchema[i].cFieldName[x]; x++ )
+ SchemaPtr[i].cFieldName[x] = pSchema[i].cFieldName[x];
+
+ SchemaPtr[i].cType = pSchema[i].cType;
+ SchemaPtr[i].cFieldLen = (unsigned char) pSchema[i].iFieldLen;
+ SchemaPtr[i].cNoOfDecs = (unsigned char) pSchema[i].iNoOfDecs;
+
+ if( SchemaPtr[i].cNoOfDecs > SchemaPtr[i].cFieldLen ){
+ iErrorStop = 110;
+ rc = XB_WRITE_ERROR;
+ throw rc;
+ }
+
+ k2 = k;
+ k += SchemaPtr[i].cFieldLen;
+
+ if(( xbFwrite( &SchemaPtr[i].cFieldName, 1, 11 )) != XB_NO_ERROR ) {
+ iErrorStop = 110;
+ rc = XB_WRITE_ERROR;
+ throw rc;
+ }
+
+ if(( xbFwrite( &SchemaPtr[i].cType, 1, 1 )) != XB_NO_ERROR ) {
+ iErrorStop = 120;
+ rc = XB_WRITE_ERROR;
+ throw rc;
+ }
+
+ for( int j = 0; j < 4; j++ )
+ xbFputc( 0x00 );
+
+ if(( xbFwrite( &SchemaPtr[i].cFieldLen, 1, 1 )) != XB_NO_ERROR ) {
+ iErrorStop = 130;
+ rc = XB_WRITE_ERROR;
+ throw rc;
+ }
+
+ if(( xbFwrite( &SchemaPtr[i].cNoOfDecs, 1, 1 )) != XB_NO_ERROR ) {
+ iErrorStop = 140;
+ rc = XB_WRITE_ERROR;
+ throw rc;
+ }
+
+ /* 14 bytes reserved */
+ for( int j = 0; j < 14; j++ )
+ xbFputc( 0x00 );
+
+ SchemaPtr[i].pAddress = RecBuf + k2;
+ SchemaPtr[i].pAddress2 = RecBuf2 + k2;
+ }
+
+ /* write the header terminator */
+ if(( xbFputc( XB_CHARHDR )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ rc = XB_WRITE_ERROR;
+ throw rc;
+ }
+ }
+ catch( xbInt16 rc )
+ {
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf3::CreateTable() Exception Caught Error Stop = %d rc = %d", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+
+ sMsg.Sprintf( "Table Name = [%s]", GetFqFileName().Str());
+ xbase->WriteLogMessage( sMsg );
+ sMsg.Sprintf( "Alias Name = [%s]", sAlias.Str());
+ xbase->WriteLogMessage( sMsg );
+
+ xbFclose();
+ if( RecBuf ){
+ free( RecBuf );
+ RecBuf = NULL;
+ }
+ if( RecBuf2 ){
+ free( RecBuf2 );
+ RecBuf2 = NULL;
+ }
+ if( SchemaPtr ){
+ free( SchemaPtr );
+ SchemaPtr = NULL;
+ }
+
+ InitVars();
+ if( rc != XB_FILE_EXISTS )
+ xbase->RemoveTblFromTblList( sAlias );
+ }
+
+ if( rc == XB_NO_ERROR )
+ iDbfStatus = XB_OPEN;
+
+ return rc;
+}
+
+/************************************************************************/
+//! @brief Get version.
+/*!
+ The version info can be retrieved to determine
+ which class is being used for a given dbf instance.
+ \returns 3
+*/
+
+xbInt16 xbDbf3::GetVersion() const {
+ return 3;
+}
+
+
+
+/************************************************************************/
+//! @brief Open dbf file/table.
+/*!
+ \param sTableName DBF table name.
+ \param sAlias Table alias
+ \param iOpenMode XB_READ<br>XB_READ_WRITE
+ \param iShareMode XB_SINGLE_USER<br>XB_MULTI_USER
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf3::Open( const xbString & sTableName, const xbString & sAlias,
+ xbInt16 iOpenMode, xbInt16 iShareMode ){
+ xbInt16 i, j, iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ char buf[33];
+ char *p;
+
+ #ifdef XB_MEMO_SUPPORT
+ iMemoFieldCnt = 0;
+ #endif
+
+ try{
+
+ /* verify the file is not already open */
+ if( iDbfStatus != XB_CLOSED ){
+ iErrorStop = 10;
+ iRc = XB_ALREADY_OPEN;
+ throw iRc;
+ }
+ /* copy the file name to the class variable */
+ SetFileName( sTableName );
+ this->sAlias = sAlias;
+
+ if( !FileExists()){
+ iErrorStop = 20;
+ iRc = XB_FILE_NOT_FOUND;
+ throw iRc;
+ }
+
+ if(( iRc = xbase->AddTblToTblList( this, GetFqFileName(), sAlias )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+
+ /* open the file */
+ if(( iRc = xbFopen( iOpenMode, iShareMode )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+
+ /* copy the header into memory */
+ if(( iRc = ReadHeader( 1, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+
+ /* check the version */
+ if(( cVersion & 0x07 ) != 3 ){
+ // if( xFileVersion != 3 && xFileVersion != 4 ){
+ iErrorStop = 60;
+ iRc = XB_FILE_TYPE_NOT_SUPPORTED;
+ throw iRc;
+ }
+ iFileVersion = 3;
+
+ /* calculate the number of fields */
+ if( cVersion == (char)0x30 ) {
+ iNoOfFields = ( uiHeaderLen - 296 ) / 32 ;
+ } else {
+ iNoOfFields = ( uiHeaderLen - 33 ) / 32;
+ }
+
+ if(( RecBuf = (char *) malloc( (size_t) uiRecordLen )) == NULL ){
+ iErrorStop = 70;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+
+ if(( RecBuf2 = (char *) malloc( uiRecordLen )) == NULL ) {
+ iErrorStop = 80;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+
+ if((SchemaPtr=(xbSchemaRec *)malloc( (size_t) iNoOfFields * sizeof( xbSchemaRec ))) == NULL){
+ iErrorStop = 90;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+
+ memset( SchemaPtr, 0x00, ( (size_t) iNoOfFields * sizeof(xbSchemaRec) ));
+ /* copy field info into memory */
+ for( i = 0, j = 1; i < iNoOfFields; i++ ){
+ xbFseek( ((xbInt64)i*32+32), SEEK_SET );
+ xbFread( &buf, 1, 32 );
+ p = buf;
+ for( int x = 0; x < 10 && buf[x]; x++ ){
+ SchemaPtr[i].cFieldName[x] = buf[x];
+ }
+ p = buf + 11;
+ SchemaPtr[i].cType = *p++;
+ SchemaPtr[i].pAddress = RecBuf + j;
+ SchemaPtr[i].pAddress2 = RecBuf2 + j;
+ SchemaPtr[i].cFieldLen = (unsigned char) *( p + 4 );
+ SchemaPtr[i].cNoOfDecs = (unsigned char) *( p + 5 );
+ j += SchemaPtr[i].cFieldLen;
+ #ifdef XB_MEMO_SUPPORT
+ if( (SchemaPtr[i].cType == 'M' || SchemaPtr[i].cType == 'B' || SchemaPtr[i].cType == 'O' ))
+ iMemoFieldCnt++;
+ #endif
+ }
+ ulCurRec = 0L;
+ iDbfStatus = XB_OPEN;
+ if(( iRc = BlankRecord()) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+ #ifdef XB_MEMO_SUPPORT
+ if( iMemoFieldCnt > 0 ){ /* does this table have memo fields ? */
+
+ // build the file name
+ xbString sMfn = GetFqFileName(); /* memo file name, same as filename except ends with a "t", not an "f" */
+ xbUInt32 ulMfnLen = sMfn.Len();
+ if( sMfn[ulMfnLen] == 'F' )
+ sMfn.PutAt( ulMfnLen, 'T' );
+ else
+ sMfn.PutAt( ulMfnLen, 't' );
+ xbFile fTemp( xbase );
+ fTemp.SetFileName( sMfn );;
+
+ Memo = new xbMemoDbt3( this, fTemp.GetFqFileName());
+
+ if(( iRc = Memo->OpenMemoFile()) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ }
+ #endif
+
+ }
+ catch ( xbInt16 iRc )
+ {
+ xbString sMsg;
+ 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();
+ if( RecBuf ){
+ free( RecBuf );
+ RecBuf = NULL;
+ }
+ if( RecBuf2 ){
+ free( RecBuf2 );
+ RecBuf2 = NULL;
+ }
+ if( SchemaPtr ){
+ free( SchemaPtr );
+ SchemaPtr = NULL;
+ }
+ InitVars();
+
+#ifdef XB_MEMO_SUPPORT
+ if( Memo ){
+ Memo->CloseMemoFile();
+ delete Memo;
+ Memo = NULL;
+ }
+#endif
+ }
+
+ if( iRc == XB_NO_ERROR )
+ iDbfStatus = XB_OPEN;
+
+ return iRc;
+}
+
+/************************************************************************/
+#ifdef XB_MEMO_SUPPORT
+//! @brief Create memo block size.
+/*!
+ This routine sets the memo file block size. This value is used when
+ the memo file is created so you if you want to change it, this must be
+ called before creating the table.
+
+ DBF III Plus uses a block size of 512.
+
+ \param ulBlockSize - Block size, must be evenly divisible by 512.
+ \returns XB_INVALID_BLOCK_SIZE<br>XB_NO_ERROR
+*/
+
+xbInt16 xbDbf3::SetCreateMemoBlockSize( xbUInt32 ulBlockSize ){
+
+ if( ulBlockSize != 512 )
+ return XB_INVALID_BLOCK_SIZE;
+ else
+ ulCreateMemoBlockSize = 512;
+
+ return XB_NO_ERROR;
+}
+#endif
+
+/************************************************************************/
+//! @brief Set version.
+/*!
+ Sets the version to 3. The version info can be retrieved to determine
+ which class is being used for a given dbf instance.
+ \returns 3
+*/
+
+xbInt16 xbDbf3::SetVersion() {
+ iFileVersion = 3;
+ return iFileVersion;
+}
+
+
+/************************************************************************/
+//! @brief Validate schema
+/*!
+ This routine verifies the field types are valid for Dbase III Plus (tm).
+
+ \param s Pointer to schema structure with field definitions.
+
+ \returns Number of fields or XB_INVALID_FIELD_TYPE.
+*/
+
+xbInt16 xbDbf3::ValidateSchema( xbSchema * s ){
+
+// This routine validates an input schema
+// Negative return value is an error
+// Positive return value is the number of fields
+// On success, the class variable uiRecordLen will be updated with the record length of the combined total of the fields
+
+ xbInt16 iFieldCnt = 0;
+ uiRecordLen = 0;
+
+ /* count the number of fields and check paramaters */
+ xbInt16 i = 0;
+ while( s[i].cType != 0 ){
+ iFieldCnt++;
+ // Version 3 field types
+ if( s[i].cType != 'C' &&
+ s[i].cType != 'N' &&
+ s[i].cType != 'D' &&
+#ifdef XB_MEMO_SUPPORT
+ s[i].cType != 'M' &&
+#endif /* XB_MEMO_SUPPORT */
+ s[i].cType != 'L' ){
+ return XB_INVALID_FIELD_TYPE;
+ }
+
+ if(s[i].cType == 'D'){
+ s[i].iFieldLen = 8;
+ s[i].iNoOfDecs = 0;
+ }
+
+ else if(s[i].cType == 'C')
+ s[i].iNoOfDecs = 0;
+
+ // check for numeric fields which are too long
+ else if( s[i].cType == 'N' && s[i].iFieldLen > 19 ){
+ return XB_INVALID_FIELD_LEN;
+ }
+
+#ifdef XB_MEMO_SUPPORT
+ else if(s[i].cType == 'M'){
+ s[i].iFieldLen = 10;
+ s[i].iNoOfDecs = 0;
+ }
+#endif /* XB_MEMO_SUPPORT */
+
+ uiRecordLen += s[i].iFieldLen;
+ i++;
+ }
+ return iFieldCnt;
+}
+
+} /* namespace */
+#endif /* XB_DBF3_SUPPORT */ \ No newline at end of file
diff --git a/src/core/xbdbf4.cpp b/src/core/xbdbf4.cpp
new file mode 100755
index 0000000..c421add
--- /dev/null
+++ b/src/core/xbdbf4.cpp
@@ -0,0 +1,590 @@
+/* xbdbf4.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_DBF4_SUPPORT
+
+namespace xb{
+
+
+/************************************************************************/
+//! @brief Constructor.
+xbDbf4::xbDbf4(xbXBase * x) : xbDbf( x ) {
+
+ iFileVersion = 4;
+ #ifdef XB_MEMO_SUPPORT
+ ulCreateMemoBlockSize = 1024;
+ #endif
+};
+
+/************************************************************************/
+//! @brief Destructor.
+xbDbf4::~xbDbf4() {};
+
+/************************************************************************/
+//! @brief Create Version 4 table.
+/*!
+ This routine creates a Dbase IV (tm) DBF file.
+
+ \param sTableName DBF table name.
+ \param sAlias Table alias
+ \param pSchema Pointer to schema structure with field definitions.
+ \param iOverlay xbTrue - Overlay.<br> xbFalse - Don't overlay.
+ \param iShareMode XB_SINGLE_USER<br>XB_MULTI_USER
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf4::CreateTable( const xbString &sTableName, const xbString &sAlias, xbSchema * pSchema, xbInt16 iOverlay, xbInt16 iShareMode ){
+
+ xbInt16 i, k, k2;
+ xbInt16 rc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ iDbfStatus = XB_CLOSED;
+
+ xbString sNfn;
+
+ try{
+ sNfn = sTableName;
+ xbase->GetLogStatus();
+
+ rc = NameSuffixMissing( sNfn, 1 );
+ if( rc > 0 )
+ sNfn += ".DBF";
+
+ SetFileName( sNfn );
+ this->sAlias = sAlias;
+
+ /* check if the file already exists */
+ if( FileExists( 0 )){
+ if( !iOverlay ){
+ iErrorStop = 10;
+ rc = XB_FILE_EXISTS;
+ throw rc;
+ }
+ #ifdef XB_NDXINF_SUPPORT
+ // remove the metadata file if there is one
+ xbString sMname = sNfn;
+ xbUInt32 iMnameLen = sMname.Len();
+ sMname.PutAt( iMnameLen-2, 'X' );
+ sMname.PutAt( iMnameLen-1, 'B' );
+ sMname.PutAt( iMnameLen, 'M' );
+ xbFile fTemp( xbase );
+ fTemp.SetFileName( sMname );
+ if( fTemp.FileExists() )
+ fTemp.xbRemove();
+ #endif // XB_NDXINF_SUPPORT
+ }
+
+ /* check if we already have a file with this alias */
+ if(( rc = xbase->AddTblToTblList( this, GetFqFileName(), sAlias )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw rc;
+ }
+
+ rc = ValidateSchema( pSchema );
+ if( rc < 0 ){
+ iErrorStop = 30;
+ throw rc;
+ } else
+ iNoOfFields = rc;
+
+ #ifdef XB_MEMO_SUPPORT
+ // if we have memo fields
+ iMemoFieldCnt = 0;
+ i = 0;
+ while( pSchema[i].cType != 0){
+ if( pSchema[i].cType == 'M' )
+ iMemoFieldCnt++; /* number of memo fields in the incoming definition */
+ i++;
+ }
+
+ if( iMemoFieldCnt > 0 ){
+ xbString sMfn = sNfn; /* memo file name, same as filename except ends with a "t", not an "f" */
+ xbUInt32 ulMfnLen = sMfn.Len();
+ sMfn.PutAt( ulMfnLen, 'T' );
+
+ // dont overlay the memo file if it exists, and Overlay switch is off
+ xbFile fTemp( xbase );
+ fTemp.SetFileName( sMfn );
+ if( fTemp.FileExists() && !iOverlay ){
+ iErrorStop = 40;
+ rc = XB_FILE_EXISTS;
+ throw rc;
+ }
+
+ Memo = new xbMemoDbt4( this, fTemp.GetFqFileName());
+
+ if(( rc = Memo->CreateMemoFile()) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw rc;
+ }
+ }
+ #endif
+
+ /* this is the dBase IV version of the class */
+ cVersion = 0x03; // 0x03 for Dbase level 5
+ #ifdef XB_MEMO_SUPPORT
+ if( iMemoFieldCnt > 0 ){
+// cVersion = cVersion |= 0x88; // version IV memos, compiler complains about this
+ cVersion |= 0x88; // version IV memos
+ }
+ #endif
+
+ if(( rc = xbFopen( "w+b", iShareMode )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw rc;
+ }
+ uiRecordLen++; /* add one byte for 0x0D */
+
+ if(( RecBuf = (char *) malloc( uiRecordLen )) == NULL ){
+ iErrorStop = 70;
+ throw rc;
+ }
+
+ if(( RecBuf2 = (char *) malloc( uiRecordLen )) == NULL ){
+ iErrorStop = 80;
+ rc = XB_NO_MEMORY;
+ throw rc;
+ }
+
+ /* BlankRecord(); */
+ memset( RecBuf, 0x20, uiRecordLen );
+ memset( RecBuf2, 0x20, uiRecordLen );
+ ulCurRec = 0L;
+ uiHeaderLen = 33 + iNoOfFields * 32;
+ xbDate d;
+ cUpdateYY = (char) (d.YearOf() - 1900);
+ cUpdateMM = (char) d.MonthOf();
+ cUpdateDD = (char) d.DayOf( XB_FMT_MONTH );
+
+ // Default language driver to 0x1b
+ cLangDriver = 0x1b;
+
+ /* write the header prolog */
+ if(( rc = WriteHeader( 0, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 90;
+ rc = XB_WRITE_ERROR;
+ throw rc;
+ }
+ if((SchemaPtr=(xbSchemaRec *)malloc( (size_t) iNoOfFields * sizeof( xbSchemaRec ))) == NULL){
+ iErrorStop = 100;
+ rc = XB_NO_MEMORY;
+ throw rc;
+ }
+
+ /* write the field information into the header */
+ for( i = 0, k = 1; i < iNoOfFields; i++ ){
+
+ memset( SchemaPtr[i].cFieldName, 0x00, 11 );
+ for( int x = 0; x < 10 && pSchema[i].cFieldName[x]; x++ )
+ SchemaPtr[i].cFieldName[x] = pSchema[i].cFieldName[x];
+
+ SchemaPtr[i].cType = pSchema[i].cType;
+ SchemaPtr[i].cFieldLen = (unsigned char) pSchema[i].iFieldLen;
+ SchemaPtr[i].cNoOfDecs = (unsigned char) pSchema[i].iNoOfDecs;
+
+ if( SchemaPtr[i].cNoOfDecs > SchemaPtr[i].cFieldLen ){
+ iErrorStop = 110;
+ rc = XB_WRITE_ERROR;
+ throw rc;
+ }
+
+ k2 = k;
+ k += SchemaPtr[i].cFieldLen;
+
+ if(( xbFwrite( &SchemaPtr[i].cFieldName, 1, 11 )) != XB_NO_ERROR ) {
+ iErrorStop = 120;
+ rc = XB_WRITE_ERROR;
+ throw rc;
+ }
+
+ if(( xbFwrite( &SchemaPtr[i].cType, 1, 1 )) != XB_NO_ERROR ) {
+ iErrorStop = 130;
+ rc = XB_WRITE_ERROR;
+ throw rc;
+ }
+
+ for( int j = 0; j < 4; j++ )
+ xbFputc( 0x00 );
+
+ if(( xbFwrite( &SchemaPtr[i].cFieldLen, 1, 1 )) != XB_NO_ERROR ) {
+ iErrorStop = 140;
+ rc = XB_WRITE_ERROR;
+ throw rc;
+ }
+
+ if(( xbFwrite( &SchemaPtr[i].cNoOfDecs, 1, 1 )) != XB_NO_ERROR ) {
+ iErrorStop = 150;
+ rc = XB_WRITE_ERROR;
+ throw rc;
+ }
+
+ /* 14 bytes reserved */
+ for( int j = 0; j < 14; j++ )
+ xbFputc( 0x00 );
+
+ SchemaPtr[i].pAddress = RecBuf + k2;
+ SchemaPtr[i].pAddress2 = RecBuf2 + k2;
+ }
+
+ /* write the header terminator */
+ if(( xbFputc( XB_CHARHDR )) != XB_NO_ERROR ){
+ iErrorStop = 160;
+ rc = XB_WRITE_ERROR;
+ throw rc;
+ }
+ }
+ catch( xbInt16 rc )
+ {
+ xbString sMsg;
+ sMsg.Sprintf( "xbdbf4::CreateTable() Exception Caught Error Stop = %d rc = %d", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+
+ sMsg.Sprintf( "Table Name = [%s]", GetFqFileName().Str());
+ xbase->WriteLogMessage( sMsg );
+ sMsg.Sprintf( "Alias Name = [%s]", sAlias.Str());
+ xbase->WriteLogMessage( sMsg );
+
+ xbFclose();
+ if( RecBuf ){
+ free( RecBuf );
+ RecBuf = NULL;
+ }
+ if( RecBuf2 ){
+ free( RecBuf2 );
+ RecBuf2 = NULL;
+ }
+ if( SchemaPtr ){
+ free( SchemaPtr );
+ SchemaPtr = NULL;
+ }
+
+ InitVars();
+ if( rc != XB_FILE_EXISTS )
+ xbase->RemoveTblFromTblList( sAlias );
+ }
+
+ if( rc == XB_NO_ERROR )
+ iDbfStatus = XB_OPEN;
+
+ return rc;
+}
+
+/************************************************************************/
+//! @brief Get version.
+/*!
+ The version info can be retrieved to determine
+ which class is being used for a given dbf instance.
+ \returns 4
+*/
+
+xbInt16 xbDbf4::GetVersion() const {
+ return 4;
+}
+
+/************************************************************************/
+//! @brief Open dbf file/table.
+/*!
+ \param sTableName DBF table name.
+ \param sAlias Table alias
+ \param iOpenMode XB_READ<br>XB_READ_WRITE
+ \param iShareMode XB_SINGLE_USER<br>XB_MULTI_USER
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbDbf4::Open( const xbString & sTableName, const xbString & sAlias,
+ xbInt16 iOpenMode, xbInt16 iShareMode ){
+ xbInt16 i, j, iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ char buf[33];
+ char *p;
+
+ #ifdef XB_MEMO_SUPPORT
+ iMemoFieldCnt = 0;
+ #endif
+
+ try{
+ /* verify the file is not already open */
+ if( iDbfStatus != XB_CLOSED ){
+ iErrorStop = 10;
+ iRc = XB_ALREADY_OPEN;
+ throw iRc;
+ }
+ /* copy the file name to the class variable */
+ SetFileName( sTableName );
+ this->sAlias = sAlias;
+
+ if( !FileExists()){
+ iErrorStop = 20;
+ iRc = XB_FILE_NOT_FOUND;
+ throw iRc;
+ }
+
+ if(( iRc = xbase->AddTblToTblList( this, GetFqFileName(), sAlias )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+
+ /* open the file */
+ if(( iRc = xbFopen( iOpenMode, iShareMode )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+
+ /* copy the header into memory */
+ if(( iRc = ReadHeader( 1, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+
+ /* check the version */
+ //if(( xFileVersion = DetermineXbaseTableVersion( cVersion )) != 4 ){
+ if(( cVersion & 0x07 ) != 3 ){
+ iErrorStop = 60;
+ iRc = XB_FILE_TYPE_NOT_SUPPORTED;
+ throw iRc;
+ }
+ iFileVersion = 4;
+
+ /* calculate the number of fields */
+ if( cVersion == (char)0x30 ) {
+ iNoOfFields = ( uiHeaderLen - 296 ) / 32 ;
+ } else {
+ iNoOfFields = ( uiHeaderLen - 33 ) / 32;
+ }
+
+ if(( RecBuf = (char *) malloc( uiRecordLen )) == NULL ){
+ iErrorStop = 70;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+
+ if(( RecBuf2 = (char *) malloc( uiRecordLen )) == NULL ) {
+ iErrorStop = 80;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+
+ if((SchemaPtr=(xbSchemaRec *)malloc((size_t) iNoOfFields * sizeof( xbSchemaRec ))) == NULL){
+ iErrorStop = 90;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+
+ memset( SchemaPtr, 0x00, (size_t) iNoOfFields * (size_t) sizeof( xbSchemaRec ));
+ /* copy field info into memory */
+ for( i = 0, j = 1; i < iNoOfFields; i++ ){
+ xbFseek( ((xbInt64)i*32+32), SEEK_SET );
+ xbFread( &buf, 1, 32 );
+ p = buf;
+ for( int x = 0; x < 10 && buf[x]; x++ ){
+ SchemaPtr[i].cFieldName[x] = buf[x];
+ }
+ p = buf + 11;
+ SchemaPtr[i].cType = *p++;
+ SchemaPtr[i].pAddress = RecBuf + j;
+ SchemaPtr[i].pAddress2 = RecBuf2 + j;
+ SchemaPtr[i].cFieldLen = (unsigned char) *( p + 4 );
+ SchemaPtr[i].cNoOfDecs = (unsigned char) *( p + 5 );
+ SchemaPtr[i].cIxFlag = (unsigned char) *( p + 19 );
+ j += SchemaPtr[i].cFieldLen;
+ #ifdef XB_MEMO_SUPPORT
+ if( (SchemaPtr[i].cType == 'M' || SchemaPtr[i].cType == 'B' || SchemaPtr[i].cType == 'O' ))
+ iMemoFieldCnt++;
+ #endif
+ }
+ ulCurRec = 0L;
+ iDbfStatus = XB_OPEN;
+ if(( iRc = BlankRecord()) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+
+ #ifdef XB_MEMO_SUPPORT
+ if( iMemoFieldCnt > 0 ){ /* does this table have memo fields ? */
+
+ // build the file name
+ xbString sMfn = GetFqFileName(); /* memo file name, same as filename except ends with a "t", not an "f" */
+ xbUInt32 ulMfnLen = sMfn.Len();
+ if( sMfn[ulMfnLen] == 'F' )
+ sMfn.PutAt( ulMfnLen, 'T' );
+ else
+ sMfn.PutAt( ulMfnLen, 't' );
+ xbFile fTemp( xbase );
+ fTemp.SetFileName( sMfn );
+
+ Memo = new xbMemoDbt4( this, fTemp.GetFqFileName());
+
+ if(( iRc = Memo->OpenMemoFile()) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ }
+ #endif
+
+ #ifdef XB_MDX_SUPPORT
+ if( cIndexFlag ){
+ // create the file name
+ xbString sIxFileName = GetFqFileName();
+ sIxFileName.Trim();
+ xbUInt32 lLen = sIxFileName.Len();
+ sIxFileName.PutAt( lLen-2, 'M' );
+ sIxFileName.PutAt( lLen-1, 'D' );
+ sIxFileName.PutAt( lLen, 'X' );
+ if(( iRc = OpenIndex( "MDX", sIxFileName )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ }
+ #endif
+
+ }
+ catch ( xbInt16 iRc )
+ {
+ xbString sMsg;
+ 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();
+ if( RecBuf ){
+ free( RecBuf );
+ RecBuf = NULL;
+ }
+ if( RecBuf2 ){
+ free( RecBuf2 );
+ RecBuf2 = NULL;
+ }
+ if( SchemaPtr ){
+ free( SchemaPtr );
+ SchemaPtr = NULL;
+ }
+ InitVars();
+
+#ifdef XB_MEMO_SUPPORT
+ if( Memo ){
+ Memo->CloseMemoFile();
+ delete Memo;
+ Memo = NULL;
+ }
+#endif
+ }
+
+ if( iRc == XB_NO_ERROR )
+ iDbfStatus = XB_OPEN;
+
+ return iRc;
+}
+
+
+/************************************************************************/
+#ifdef XB_MEMO_SUPPORT
+
+//! @brief Create memo block size.
+/*!
+ This routine sets the memo file block size. This value is used when
+ the memo file is created so you if you want to change it, this must be
+ called before creating the table.
+
+ The default size for version 4 is 1024.
+
+ \param ulBlockSize - Block size, must be evenly divisible by 512.
+ \returns XB_INVALID_BLOCK_SIZE<br>XB_NO_ERROR
+*/
+
+xbInt16 xbDbf4::SetCreateMemoBlockSize( xbUInt32 ulBlockSize ){
+
+ if( ulBlockSize % 512 )
+ return XB_INVALID_BLOCK_SIZE;
+ else
+ ulCreateMemoBlockSize = ulBlockSize;
+
+ return XB_NO_ERROR;
+}
+#endif // XB_MEMO_SUPPORT
+/************************************************************************/
+//! @brief Set version.
+/*!
+ Sets the version to 4. The version info can be retrieved to determine
+ which class is being used for a given dbf instance.
+ \returns 4
+*/
+xbInt16 xbDbf4::SetVersion() {
+ iFileVersion = 4;
+ return iFileVersion;
+}
+/************************************************************************/
+//! @brief Validate schema
+/*!
+ This routine verifies the field types are valid for Dbase IV (tm).
+
+ \param s Pointer to schema structure with field definitions.
+
+ \returns Number of fields or XB_INVALID_FIELD_TYPE.
+*/
+
+
+xbInt16 xbDbf4::ValidateSchema( xbSchema * s ){
+
+ xbInt16 iFieldCnt = 0;
+ uiRecordLen = 0;
+
+ // Count the number of fields and check paramaters
+ xbInt16 i = 0;
+ while( s[i].cType != 0 ){
+ iFieldCnt++;
+ // Version IV field types
+ if( s[i].cType != 'C' &&
+ s[i].cType != 'N' &&
+ s[i].cType != 'F' &&
+ s[i].cType != 'D' &&
+ #ifdef XB_MEMO_SUPPORT
+ s[i].cType != 'M' &&
+ #endif /* XB_MEMO_SUPPORT */
+ s[i].cType != 'L' ){
+ return XB_INVALID_FIELD_TYPE;
+ }
+
+ if(s[i].cType == 'D'){
+ s[i].iFieldLen = 8;
+ s[i].iNoOfDecs = 0;
+ }
+
+ else if(s[i].cType == 'C')
+ s[i].iNoOfDecs = 0;
+
+ // check for numeric fields which are too long
+ else if((s[i].cType == 'N' || s[i].cType == 'F') && s[i].iFieldLen > 19 ){
+ return XB_INVALID_FIELD_LEN;
+ }
+
+ #ifdef XB_MEMO_SUPPORT
+ else if(s[i].cType == 'M'){
+ s[i].iFieldLen = 10;
+ s[i].iNoOfDecs = 0;
+ }
+ #endif // XB_MEMO_SUPPORT
+
+ uiRecordLen += s[i].iFieldLen;
+ i++;
+ }
+ return iFieldCnt;
+}
+
+} /* namespace */
+#endif /* XB_DBF4_SUPPORT */ \ No newline at end of file
diff --git a/src/core/xbexp.cpp b/src/core/xbexp.cpp
new file mode 100755
index 0000000..d3e8ca8
--- /dev/null
+++ b/src/core/xbexp.cpp
@@ -0,0 +1,2643 @@
+/* xbexp.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2017,2021,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
+
+
+This module is part of the expression logic and has the code
+for parsing various tokens out of an expression
+
+*/
+
+#include "xbase.h"
+
+#ifdef XB_EXPRESSION_SUPPORT
+
+namespace xb{
+
+/*************************************************************************/
+//! Constructor
+/*!
+ \param x Pointer to xbXBase instance.
+*/
+
+xbExp::xbExp( xbXBase *x ){
+ xbase = x;
+ dbf = NULL;
+ nTree = NULL;
+}
+
+/*************************************************************************/
+//! Constructor
+/*!
+ \param x Pointer to xbXBase instance.
+ \param d Pointer to xbDbf instance.
+*/
+xbExp::xbExp( xbXBase *x, xbDbf *d ){
+ xbase = x;
+ dbf = d;
+ nTree = NULL;
+}
+
+/*************************************************************************/
+//! Deconstrucor.
+
+xbExp::~xbExp() {
+
+ if( nTree )
+ delete nTree;
+}
+
+/*************************************************************************/
+//! Calulate expression return length
+/*!
+
+ This function returns the maximum possible length of an expression
+ The create index functions use this for determining the fixed length keys
+ It sets the return length field in the node.
+
+ \param n Start node
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbExp::CalcFunctionResultLen( xbExpNode * n ) const{
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbInt16 iReturnLenCalc = 0;;
+ xbInt32 lReturnLenVal = 0;
+ xbString sNodeText;
+
+
+ try{
+
+ n->GetNodeText( sNodeText );
+ char cReturnType = 0;
+ if(( iRc = xbase->GetFunctionInfo( sNodeText, cReturnType, iReturnLenCalc, lReturnLenVal )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ if( iReturnLenCalc == 1 ){
+ // use the value from iReturnLenVal
+ n->SetResultLen( (xbUInt32) lReturnLenVal );
+ }
+ else if( iReturnLenCalc == 2 ){
+ // use the length from the child node identified in lReturnLenVal
+ xbExpNode *nChild = n->GetChild( (xbUInt32) lReturnLenVal - 1 );
+ if( !nChild ){
+ iErrorStop = 20;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ n->SetResultLen( nChild->GetResultLen());
+ }
+
+ else if( iReturnLenCalc == 3 ){
+ // use the length from the child node identified in lReturnLenVal
+ xbExpNode *nChild = n->GetChild( (xbUInt32) lReturnLenVal - 1 );
+ if( !nChild ){
+ iErrorStop = 30;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ n->SetResultLen( (xbUInt32) nChild->GetNumericResult());
+ }
+ else if( iReturnLenCalc == 4 ){
+ // use the value from the length in parm 1 multiplied by the value in parm 2 (REPLICATE)
+ xbExpNode *nChild1 = n->GetChild( 0 );
+ xbExpNode *nChild2 = n->GetChild( 1 );
+ if( !nChild1 || !nChild2 ){
+ iErrorStop = 40;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ n->SetResultLen( nChild1->GetResultLen() * (xbUInt32) nChild2->GetNumericResult());
+ }
+ else if( iReturnLenCalc == 5 ){
+ // use the larger of the length of the value in parm2 or parm 3 (IIF statement)
+ xbExpNode *nChild2 = n->GetChild( 1 );
+ xbExpNode *nChild3 = n->GetChild( 2 );
+ if( !nChild2 || !nChild3 ){
+ iErrorStop = 50;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ if( nChild2->GetResultLen() >= nChild3->GetResultLen())
+ n->SetResultLen( nChild2->GetResultLen());
+ else
+ n->SetResultLen( nChild3->GetResultLen());
+ }
+
+ else if( iReturnLenCalc == 6 ){
+
+ if( n->GetChildCnt() >= 2 ){
+ xbExpNode *nChild2 = n->GetChild( 1 );
+ n->SetResultLen( (xbUInt32) nChild2->GetNumericResult());
+ } else {
+ n->SetResultLen( (xbUInt32) lReturnLenVal );
+ }
+
+ } else {
+ iErrorStop = 100;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbexp::GetFunctionResultLen() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ }
+ return iRc;
+}
+
+/*************************************************************************/
+//! Check parens and quotes
+/*!
+ This routine looks for unbalanced parens and quotes
+
+ \param sExpression Expression to examine.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+
+xbInt16 xbExp::CheckParensAndQuotes( const xbString &sExpression ){
+
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ xbBool bInQuotes = xbFalse;
+ xbInt16 iLparenCtr = 0;
+ xbInt16 iRparenCtr = 0;
+ xbInt16 iQuoteType = 0;
+ const char *s = sExpression;
+
+ try{
+
+ while( *s ){
+ if( !bInQuotes ){
+ if( *s == '(' ){
+ iLparenCtr++;
+ } else if( *s == ')' ){
+ iRparenCtr++;
+ } else if( *s == '\'' ){
+ bInQuotes++;
+ iQuoteType = 0;
+ } else if( *s == '"' ){
+ bInQuotes++;
+ iQuoteType = 1;
+ }
+ } else {
+ if(( *s == '\'' && iQuoteType == 0 ) || (*s == '"' && iQuoteType == 1 ))
+ bInQuotes--;
+ }
+ s++;
+ }
+ if( iLparenCtr != iRparenCtr ){
+ iErrorStop = 10;
+ iRc = XB_UNBALANCED_PARENS;
+ throw iRc;
+ }
+ if( bInQuotes ){
+ iErrorStop = 20;
+ iRc = XB_UNBALANCED_QUOTES;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbexp::CheckParensAndQuots() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( sExpression );
+ }
+ return iRc;
+}
+/*************************************************************************/
+//! Clear tree handle.
+/*!
+ This routine clears the expression tree and frees any associated memory.
+ \returns void.
+*/
+
+void xbExp::ClearTreeHandle(){
+ if( nTree ){
+ nTree = NULL;
+ }
+}
+
+/*************************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+//! Dump the tree.
+/*!
+ \param iOption - Output opton.
+ \returns void.
+*/
+
+void xbExp::DumpTree( xbInt16 iOption ){
+ nTree->DumpNode( iOption );
+}
+
+//! Dump token
+/*!
+ \param iOption - Output opton.
+ \returns void.
+*/
+
+
+void xbExp::DumpToken( xbExpToken &t, xbInt16 iOption ){
+
+ xbString sMsg;
+ sMsg = "Processing Token";
+ xbase->WriteLogMessage( sMsg.Str(), iOption );
+
+ sMsg.Sprintf( "Expression = [%s]", t.sExpression.Str());
+ xbase->WriteLogMessage( sMsg.Str(), iOption );
+
+ sMsg.Sprintf( "Token = [%s]", t.sToken.Str());
+ xbase->WriteLogMessage( sMsg.Str(), iOption );
+
+ sMsg.Sprintf( "NodeType = [%c]", t.cNodeType );
+ xbase->WriteLogMessage( sMsg.Str(), iOption );
+
+ sMsg.Sprintf( "ReturnType = [%c]", t.cReturnType );
+ xbase->WriteLogMessage( sMsg.Str(), iOption );
+
+ sMsg.Sprintf( "Sts = [%d]", t.iSts );
+ xbase->WriteLogMessage( sMsg.Str(), iOption );
+
+ sMsg.Sprintf( "PrevNodeType = [%c]", t.cPrevNodeType );
+ xbase->WriteLogMessage( sMsg.Str(), iOption );
+
+ sMsg.Sprintf( "PrevReturnType = [%c]", t.cPrevReturnType );
+ xbase->WriteLogMessage( sMsg.Str(), iOption );
+}
+
+#endif
+
+/*************************************************************************/
+//! Get date result.
+/*!
+ If the expression generates a date return type, this method retrieves the date value.
+ \param dtResult - Output date value.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbExp::GetDateResult( xbDate &dtResult ){
+ if( nTree ){
+ dtResult.JulToDate8( (xbInt32) nTree->GetNumericResult() );
+ return XB_NO_ERROR;
+ }
+ else{
+ //dtResult = ?;
+ return XB_PARSE_ERROR;
+ }
+}
+/*************************************************************************/
+//! Get bool result.
+/*!
+ If the expression generates a boolean return type, this method retrieves the boolean value.
+ \param bResult - Output boolean value.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbExp::GetBoolResult( xbBool &bResult){
+ if( nTree ){
+ bResult = nTree->GetBoolResult();
+ return XB_NO_ERROR;
+ }
+ else{
+ return XB_PARSE_ERROR;
+ }
+}
+
+/*************************************************************************/
+//! Get the next node in the tree.
+/*!
+ \param n Node to starting point. To get the first node of the entire tree, set n = NULL
+ \returns Pointer to next node.
+*/
+
+xbExpNode *xbExp::GetNextNode( xbExpNode * n ) const {
+
+ // to get the first node of the entire tree, set n = NULL
+ // std::cout << "In GetNextNode\n";
+
+ if( n == nTree )
+ return NULL;
+
+ else if( !n ){
+ if( !nTree )
+ return NULL;
+ else
+ return nTree->GetFirstNode();
+ }
+ return n->GetNextNode();
+}
+
+/*************************************************************************/
+//! GetNextToken
+/*! This method returns the next token in an expression of one or more tokens
+ \param t Token
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbExp::GetNextToken( xbExpToken &t ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ t.iSts = XB_NO_ERROR;
+ t.sExpression.Ltrim();
+
+ if( t.sExpression.Len() == 0 ){
+ t.iSts = XB_END_OF_EXPRESSION;
+ return XB_NO_ERROR;
+ }
+
+ // Check for date constant
+ if((t.sExpression.Len() >= 10 && t.sExpression[1] == '{' && t.sExpression[4] == '/' && t.sExpression[7] == '/') &&
+ (t.sExpression[10] == '}' || (t.sExpression.Len() >= 12 && t.sExpression[12] == '}'))){
+ if(( iRc = GetTokenDateConstant( t )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ }
+ // Check for parens
+ else if( t.sExpression[1] == '(' || t.sExpression[1] == '{' ){
+ if(( iRc = GetTokenParen( t )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+ // Check for a char constant
+ else if( t.sExpression[1] == '"' || t.sExpression[1] == '\'' ){
+ if(( iRc = GetTokenCharConstant( t )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ }
+ // Check for logical constant
+ else if( IsLogicalConstant( t.sExpression )){
+ if(( iRc = GetTokenLogicalConstant( t )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ }
+ // check for numeric constant
+ else if( IsNumericConstant( t.sExpression, t.cPrevNodeType )){
+ if(( iRc = GetTokenNumericConstant( t )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ }
+ // check for operator
+ else if( IsOperator( t.sExpression )){
+ if(( iRc = GetTokenOperator( t )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ }
+ // check for function
+ else if( IsFunction( t.sExpression, t.cReturnType )){
+ if(( iRc = GetTokenFunction( t )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ }
+ else if(( iRc = GetTokenDatabaseField( t )) != XB_NO_ERROR ){
+ iErrorStop = 80;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ }
+
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+
+ //t.sExpression;
+ // std::cout << ">>>>>>>>>" << sMsg.Str() << "\n";
+ // sMsg.Sprintf( "[%d][%s]", iErrorStop, t.sExpression.Str() );
+ // sMsg.Sprintf( "xbexp::GetNextToken() Exception Caught. Error Stop = [%d] %s", iErrorStop, t.sExpression.Str());
+
+ sMsg.Sprintf( "xbexp::GetNextToken() Exception Caught. Error Stop = [%d] iRc = [%d] Expression = [%s]", iErrorStop, iRc, t.sExpression.Str() );sMsg.Sprintf( "xbexp::GetNextToken() Exception Caught. Error Stop = [%d] iRc = [%d] Expression = [%s]", iErrorStop, iRc, t.sExpression.Str() );sMsg.Sprintf( "xbexp::GetNextToken() Exception Caught. Error Stop = [%d] iRc = [%d] Expression = [%s]", iErrorStop, iRc, t.sExpression.Str() );sMsg.Sprintf( "xbexp::GetNextToken() Exception Caught. Error Stop = [%d] iRc = [%d] Expression = [%s]", iErrorStop, iRc, t.sExpression.Str() );
+ xbase->WriteLogMessage( sMsg.Str() );
+ }
+
+ return iRc;
+}
+
+/*************************************************************************/
+//! Get numeric result.
+/*!
+ If the expression generates a numeric return type, this method retrieves the numeric value.
+ \param dResult - Output numeric value.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbExp::GetNumericResult( xbDouble &dResult){
+ if( nTree ){
+ dResult = nTree->GetNumericResult();
+ return XB_NO_ERROR;
+ }
+ else{
+ dResult = 0;
+ return XB_PARSE_ERROR;
+ }
+}
+
+/*************************************************************************/
+//! Get result length.
+/*!
+ This routine returns the result length.
+ \returns Result length.
+*/
+
+xbInt16 xbExp::GetResultLen() const{
+ if( nTree )
+ return nTree->GetResultLen();
+ else
+ return 0;
+}
+
+/*************************************************************************/
+//! Get return type.
+/*!
+ \returns Expression return type.
+*/
+
+char xbExp::GetReturnType() const{
+ if( nTree )
+ return nTree->GetReturnType();
+ else
+ return ' ';
+}
+
+/*************************************************************************/
+//! Get string result.
+/*!
+ If the expression generates a string return type, this method retrieves the string value.
+ \param sResult - Output string value.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbExp::GetStringResult( xbString &sResult){
+ if( nTree ){
+ sResult = nTree->GetStringResult();
+ return XB_NO_ERROR;
+ }
+ else{
+ sResult = "";
+ return XB_PARSE_ERROR;
+ }
+}
+
+/*************************************************************************/
+//! Get string result.
+/*!
+ If the expression generates a string return type, this method retrieves the string value.
+ \param vpResult - Pointer to user supplied buffer for result.
+ \param ulLen - Max size of buffer.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+
+xbInt16 xbExp::GetStringResult( char * vpResult, xbUInt32 ulLen ){
+ if( nTree ){
+ nTree->GetStringResult().strncpy((char *) vpResult, ulLen );
+ return XB_NO_ERROR;
+ }
+ else{
+ return XB_PARSE_ERROR;
+ }
+}
+
+
+
+/*************************************************************************/
+//! GetTokenCharConstant
+/*! This method returns the character constant in a pair of quotes
+
+ This routine returns the tokens inside a set of matching quotes in sOutToken
+ If there is nothing between the quotes then sOutToken is returned empty
+ sOutRemainder contains whatever remains to the right of the right quote
+
+ \param t Token
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+
+xbInt16 xbExp::GetTokenCharConstant( xbExpToken &t ){
+
+ const char *s = t.sExpression;
+ const char *sToken; // pointer to beginning of token
+ xbInt16 iQuoteType;
+ xbUInt32 ulTokenLen = 0;
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbBool bDone = xbFalse;
+
+ try{
+ if( *s == '"' )
+ iQuoteType = 0;
+ else
+ iQuoteType = 1;
+ s++;
+ sToken = s;
+ while( *s && !bDone ){
+ if(( *s == '"' && iQuoteType == 0 ) || (*s == '\'' && iQuoteType == 1 ))
+ bDone = xbTrue;
+ s++;
+ ulTokenLen++;
+ }
+ if( bDone ){ // found matching paren
+ t.cNodeType = XB_EXP_CONSTANT;
+ t.cReturnType = XB_EXP_CHAR;
+ t.sToken.Set( sToken, ulTokenLen - 1 );
+ t.sExpression.Ltrunc( ulTokenLen + 1 );
+ } else {
+ iRc = XB_PARSE_ERROR;
+ t.iSts = XB_UNBALANCED_QUOTES;
+ iErrorStop = 10;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbexp::GetTokenCharConstant() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ }
+ return iRc;
+}
+
+
+/*************************************************************************/
+//! GetTokenDateConstant
+/*! This method returns the date constant in a pair of {}
+
+ Date format is one of {mm/dd/yy} or {mm/dd/yyyy}
+ \param t Token.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbExp::GetTokenDateConstant( xbExpToken &t ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ char wBuf[13];
+ xbDate dt;
+
+ try{
+ memset( wBuf, 0x00, 13 );
+ t.cNodeType = XB_EXP_CONSTANT;
+ t.cReturnType = XB_EXP_DATE;
+
+ if( t.sExpression[10] == '}' ){
+ for( xbInt16 i = 0; i < 8; i++ )
+ wBuf[i] = t.sExpression[i+2];
+
+ if(( iRc = dt.CTOD( wBuf )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ t.sToken.Set( dt.Str() );
+ t.sExpression.Ltrunc( 10 );
+
+ } else if( t.sExpression[12] == '}' ){
+
+ wBuf[0] = t.sExpression[8];
+ wBuf[1] = t.sExpression[9];
+ wBuf[2] = t.sExpression[10];
+ wBuf[3] = t.sExpression[11];
+ wBuf[4] = t.sExpression[2];
+ wBuf[5] = t.sExpression[3];
+ wBuf[6] = t.sExpression[5];
+ wBuf[7] = t.sExpression[6];
+
+ t.sToken.Set( wBuf );
+ t.sExpression.Ltrunc( 12 );
+ } else {
+ iRc = XB_PARSE_ERROR;
+ t.iSts = XB_INVALID_DATE;
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbexp::GetTokenDateConstant() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ }
+ return iRc;
+}
+
+/*************************************************************************/
+//! GetTokenField
+/*! This method gets a database field token
+
+ Looks for a xbase field in one of the following formats
+
+ FIELDNAME
+ or
+ TABLENAME->FIELDNAME
+
+ \param t Token.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbExp::GetTokenDatabaseField( xbExpToken &t ){
+
+ const char *s = t.sExpression;
+ xbUInt32 ulTokenLen = 0;
+ xbUInt32 ulTokenLen2 = 0;
+
+ while( *s && !IsTokenSeparator( *s ) && !IsWhiteSpace( *s )) {
+ ulTokenLen++;
+ s++;
+ }
+
+ // go past any white space
+ while( *s && !IsTokenSeparator( *s ) && IsWhiteSpace( *s )) {
+ ulTokenLen2++;
+ s++;
+ }
+
+ // look for ->
+ // remove the field name from before the ->
+ if( strncmp( s, "->", 2 ) == 0 ){
+ ulTokenLen2+=2;
+ s+=2;
+ // go past white space
+ while( *s && !IsTokenSeparator( *s ) && IsWhiteSpace( *s )) {
+ ulTokenLen2++;
+ s++;
+ }
+ // go to the end
+ while( *s && !IsTokenSeparator( *s ) && !IsWhiteSpace( *s )) {
+ ulTokenLen2++;
+ s++;
+ }
+ ulTokenLen += ulTokenLen2;
+ }
+ t.cNodeType = XB_EXP_FIELD;
+ t.cReturnType = XB_EXP_UNKNOWN;
+ t.sToken.Set( t.sExpression, ulTokenLen );
+ t.sExpression.Ltrunc( ulTokenLen );
+
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! GetTokenFunction
+/*!
+ This method gets a function and everything between the following quotes
+ \param t Token
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+
+xbInt16 xbExp::GetTokenFunction( xbExpToken &t ){
+
+ xbUInt32 lPos = t.sExpression.Pos( '(' );
+ if( lPos == 0 )
+ return XB_PARSE_ERROR;
+
+ xbBool bDone = xbFalse;
+ xbUInt32 lLen = t.sExpression.Len();
+ xbInt16 iDepthCtr = 1;
+
+ while( ++lPos <= lLen && !bDone ){
+ if( t.sExpression[lPos] == ')' ){
+ iDepthCtr--;
+ if( iDepthCtr == 0 )
+ bDone = xbTrue;
+ } else if( t.sExpression[lPos] == '(' ){
+ iDepthCtr++;
+ }
+ }
+
+ t.cNodeType = XB_EXP_FUNCTION;
+ t.sToken.Set( t.sExpression, lPos-1 );
+ t.sExpression.Ltrunc( lPos-1 );
+
+// std::cout << "lPos = [" << lPos << "] done= [" << bDone << "][" << t.sExpression << "] len=[" << lLen << "] return type = [" << t.cReturnType << "]\n";
+
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! GetTokenCharConstant
+/*! This method returns the character constant in a pair of quotes
+
+ This routine returns the tokens inside a set of matching quotes in sOutToken
+ If there is nothing between the quotes then sOutToken is returned empty
+ sOutRemainder contains whatever remains to the right of the right quote
+
+ \param t Token
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbExp::GetTokenLogicalConstant( xbExpToken &t ){
+
+ t.cNodeType = XB_EXP_CONSTANT;
+ t.cReturnType = XB_EXP_LOGICAL;
+ t.sToken = t.sExpression[2];
+
+ if( t.sExpression[3] == '.' )
+ t.sExpression.Ltrunc( 3 );
+ else if( t.sExpression[6] == '.' )
+ t.sExpression.Ltrunc( 6 );
+ else if( t.sExpression[7] == '.' )
+ t.sExpression.Ltrunc( 7 );
+
+ return XB_NO_ERROR;
+}
+
+
+/*************************************************************************/
+//! GetTokenNumericConstant
+/*! This method returns a numeric constant in
+
+ This routine returns a numeric constant token
+ sOutRemainder contains whatever remains to the right of the right quote
+
+ \param t Token
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbExp::GetTokenNumericConstant( xbExpToken &t ){
+
+ const char * s = t.sExpression;
+ xbUInt32 ulTokenLen = 0;
+ t.sToken = "";
+
+ t.cNodeType = XB_EXP_CONSTANT;
+ t.cReturnType = XB_EXP_NUMERIC;
+
+ // capture the leading sign
+ if( *s == '-' || *s == '+' || *s == '.' ){
+ t.sToken = *s;
+ ulTokenLen++;
+ s++;
+
+ // go past any white space between sign and number
+ while( *s && IsWhiteSpace( *s )){
+ s++;
+ ulTokenLen++;
+ }
+ }
+
+ // add the number to the token
+ while( *s && (isdigit( *s ) || *s == '.' )){
+ t.sToken += *s;
+ s++;
+ ulTokenLen++;
+ }
+ t.sExpression.Ltrunc( ulTokenLen );
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! GetTokenOperator
+/*! This method returns the operator
+
+ \param t Token
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+
+xbInt16 xbExp::GetTokenOperator( xbExpToken &t ){
+
+ const char *s = t.sExpression;
+
+ // Logical operators
+ if((strncmp( s, "<>", 2 ) == 0 ) || (strncmp( s, "!=", 2 ) == 0 ) ||
+ (strncmp( s, "<=", 2 ) == 0 ) || (strncmp( s, ">=", 2 ) == 0 )){
+ t.cReturnType = XB_EXP_LOGICAL;
+ t.sToken.Assign( s, 1, 2 );
+ t.sExpression.Ltrunc( 2 );
+ t.cNodeType = XB_EXP_OPERATOR;
+ return XB_NO_ERROR;
+ }
+
+ if( *s == '=' || *s == '<' || *s == '>' || *s == '$' || *s == '#' ){
+ t.cReturnType = XB_EXP_LOGICAL;
+ t.sToken.Assign( s, 1, 1 );
+ t.sExpression.Ltrunc( 1 );
+ t.cNodeType = XB_EXP_OPERATOR;
+ return XB_NO_ERROR;
+ }
+
+ if( (strncmp( s, ".NOT.", 5 ) == 0 ) || (strncmp( s, ".AND.", 5 ) == 0 )){
+ t.cReturnType = XB_EXP_LOGICAL;
+ t.sToken.Assign( s, 1, 5 );
+ t.sExpression.Ltrunc( 5 );
+ t.cNodeType = XB_EXP_OPERATOR;
+ return XB_NO_ERROR;
+ }
+
+ if( (strncmp( s, "NOT ", 4 ) == 0 ) || (strncmp( s, "AND ", 4 ) == 0 )){
+ t.cReturnType = XB_EXP_LOGICAL;
+ t.sToken.Assign( s, 1, 3 );
+ t.sExpression.Ltrunc( 3 );
+ t.cNodeType = XB_EXP_OPERATOR;
+ return XB_NO_ERROR;
+ }
+
+ if( strncmp( s, ".OR.", 4 ) == 0 ) {
+ t.cReturnType = XB_EXP_LOGICAL;
+ t.sToken.Assign( s, 1, 4 );
+ t.sExpression.Ltrunc( 4 );
+ t.cNodeType = XB_EXP_OPERATOR;
+ return XB_NO_ERROR;
+ }
+
+ if( strncmp( s, "OR ", 3 ) == 0 ) {
+ t.cReturnType = XB_EXP_LOGICAL;
+ t.sToken.Assign( s, 1, 2 );
+ t.sExpression.Ltrunc( 2 );
+ t.cNodeType = XB_EXP_OPERATOR;
+ return XB_NO_ERROR;
+ }
+
+ // Numeric operators
+ if(( strncmp( s, "**", 2 ) == 0 ) || ( strncmp( s, "+=", 2 ) == 0 ) ||
+ ( strncmp( s, "-=", 2 ) == 0 ) || ( strncmp( s, "*=", 2 ) == 0 ) || ( strncmp( s, "/=", 2 ) == 0 )){
+ t.cReturnType = XB_EXP_NUMERIC;
+ t.sToken.Assign( s, 1, 2 );
+ t.sExpression.Ltrunc( 2 );
+ t.cNodeType = XB_EXP_OPERATOR;
+ return XB_NO_ERROR;
+ }
+
+ // Pre/post increment/decrement operators ++ or --
+ if(( strncmp( s, "--", 2 ) == 0 ) || ( strncmp( s, "++", 2 ) == 0 )){
+ t.cReturnType = XB_EXP_NUMERIC;
+ t.sToken.Assign( s, 1, 2 );
+ t.sExpression.Ltrunc( 2 );
+ if( t.sExpression.Len() > 0 && (isdigit( t.sExpression[1] ) || isalpha( t.sExpression[1] )))
+ t.cNodeType = XB_EXP_PRE_OPERATOR;
+ else
+ t.cNodeType = XB_EXP_POST_OPERATOR;
+
+ return XB_NO_ERROR;
+ }
+
+ if( *s == '*' || *s == '/' || *s == '%' || *s == '^' ){
+ t.cReturnType = XB_EXP_NUMERIC;
+ t.sToken.Assign( s, 1, 1 );
+ t.sExpression.Ltrunc( 1 );
+ t.cNodeType = XB_EXP_OPERATOR;
+ return XB_NO_ERROR;
+ }
+
+ // multi return type operators
+ t.cReturnType = XB_EXP_UNKNOWN;
+ if( *s == '+' || *s == '-' ){
+ t.sToken.Assign( s, 1, 1 );
+ t.sExpression.Ltrunc( 1 );
+ t.cNodeType = XB_EXP_OPERATOR;
+ return XB_NO_ERROR;
+ }
+ return XB_PARSE_ERROR;
+}
+
+/*************************************************************************/
+//! GetTokenParen
+/*! This method returns the tokens in a pair of enclosed parens
+
+ This routine returns the tokens inside a set of matching parens in sOutToken
+ If there is nothing between the parens then sOutToken is returned empty
+ sOutRemainder contains whatever remains to the right of the right paren
+
+ \param t Token
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+
+xbInt16 xbExp::GetTokenParen( xbExpToken &t ){
+
+ const char * s = t.sExpression;
+ const char * sToken; // pointer to beginning of token
+ xbInt16 iParenType = 0;
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbInt16 iDepthCtr = 0; // depth inside of nested parens
+ xbUInt32 ulTokenLen = 0;
+ xbBool bDone = xbFalse;
+
+ try{
+ if( *s == '{' )
+ iParenType = 0;
+ else
+ iParenType = 1;
+ iDepthCtr = 1;
+ s++;
+ sToken = s;
+
+ while( *s && !bDone ){
+ if(( *s == ')' && iParenType == 1 ) || (*s == '}' && iParenType == 0 )){
+ iDepthCtr--;
+ if( iDepthCtr == 0 )
+ bDone = xbTrue;
+ } else if(( *s == '(' && iParenType == 1 ) || (*s == '{' && iParenType == 0 )){
+ iDepthCtr++;
+ }
+ s++;
+ ulTokenLen++;
+ }
+
+ if( bDone ){ // found matching paren
+ t.cNodeType = XB_EXP_NOTROOT;
+ t.cReturnType = XB_EXP_UNKNOWN;
+ t.sToken.Set( sToken, ulTokenLen - 1 );
+ t.sExpression.Ltrunc( ulTokenLen + 1 );
+ } else {
+ t.sToken = "";
+ t.cNodeType = XB_EXP_NOTROOT;
+ t.cReturnType = XB_EXP_UNKNOWN;
+ t.iSts = XB_UNBALANCED_PARENS;
+ iRc = XB_PARSE_ERROR;
+ iErrorStop = 10;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbexp::GetTokenParen() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ }
+ return iRc;
+}
+
+/*************************************************************************/
+//! Get the expression tree handle.
+/*!
+ \returns Pointer to the top most node in the expression tree.
+*/
+xbExpNode *xbExp::GetTreeHandle(){
+ return nTree;
+}
+
+/*************************************************************************/
+//! Is Function
+/*! This method determines if the next token is a function.
+
+ \param sExpression - String expression to be evaluated.
+ \param cReturnType Output - Return type.
+ \returns xbTrue - Is a function.<br>
+ xbFalse - Is not a function.
+*/
+
+xbBool xbExp::IsFunction( const xbString & sExpression, char &cReturnType ){
+
+ xbInt16 i = 0;
+ xbInt32 l = 0;
+ if( sExpression.Pos( '(' ) > 0 ){
+ if( xbase->GetFunctionInfo( sExpression, cReturnType, i, l ) == XB_NO_ERROR )
+ return xbTrue;
+ }
+ return xbFalse;
+}
+
+/*************************************************************************/
+//! Is Logical constant
+/*! This method determines if the next token is a logical constant (T/F, etc).
+
+ \param sExpression - String expression to be evaluated.
+ \returns xbTrue - Is a logical constant.<br>
+ xbFalse - Is not a logical constant.
+*/
+
+xbBool xbExp::IsLogicalConstant( const xbString & sExpression ){
+
+ const char *s = sExpression;
+ if(( strncmp( s, ".T.", 3 ) == 0 ) || ( strncmp( s, ".F.", 3 ) == 0 ))
+ return xbTrue;
+ else if( strncmp( s, ".TRUE.", 6 ) == 0 )
+ return xbTrue;
+ else if( strncmp( s, ".FALSE.", 7 ) == 0 )
+ return xbTrue;
+
+ return xbFalse;
+}
+
+/*************************************************************************/
+//! Is Numeric constant
+/*! This method determines if the next token is a numeric constant.
+
+ \param sExpression - String expression to be evaluated.
+ \param cPrevNodeType - Type of previous node.
+ \returns xbTrue - Is a numeric constant.<br>
+ xbFalse - Is not a numeric constant.
+*/
+xbBool xbExp::IsNumericConstant( const xbString & sExpression, char cPrevNodeType ){
+
+ // check for positive, negative or decimal number constants
+
+ const char *s = sExpression;
+ if(( *s == '-' && ( cPrevNodeType == 'O' || cPrevNodeType == 0 )) ||
+ ( *s == '+' && ( cPrevNodeType == 'O' || cPrevNodeType == 0 ))){
+ s++;
+ while( *s && IsWhiteSpace( *s ))
+ s++;
+ }
+ if( *s == '.' )
+ s++;
+
+ if( isdigit( *s ))
+ return xbTrue;
+ else
+ return xbFalse;
+}
+
+/*************************************************************************/
+//! Is Operator.
+/*! This method determines if the next token is an operator.
+
+ \param sExpression - String expression to be evaluated.
+ \returns xbTrue - Is an operator.<br>
+ xbFalse - Is not an operator.
+*/
+xbBool xbExp::IsOperator( const xbString & sExpression ){
+
+ const char *s = sExpression;
+ if( *s == '+' || *s == '-' || *s == '/' || *s == '^' || *s == '=' || *s == '$' ||
+ *s == '#' || *s == '*' || *s == '<' || *s == '>' || *s == '%' )
+ return xbTrue;
+
+ if( strncmp( s, "!=", 2 ) == 0 )
+ return xbTrue;
+
+ if((strncmp( s, ".NOT.", 5 ) == 0 ) || (strncmp( s, ".OR.", 4 ) == 0 ) || (strncmp( s, ".AND.", 5 ) == 0 ))
+ return xbTrue;
+
+ if((strncmp( s, "NOT ", 4 ) == 0 ) || (strncmp( s, "OR ", 3 ) == 0 ) || (strncmp( s, "AND ", 4 ) == 0 ))
+ return xbTrue;
+
+ return xbFalse;
+}
+
+/*************************************************************************/
+//! Is Token seperator
+/*! This method determines if the next token is a seperator.
+
+ \param sExpression - String expression to be evaluated.
+ \returns xbTrue - Is a token seperator.<br>
+ xbFalse - Is not a token seperator.
+*/
+char xbExp::IsTokenSeparator( char c ){
+ if( c == '-' || c == '+' || c == '*' || c == '/' || c == '$' || c == '#' ||
+ c == '<' || c == '>' || c == '^' || c == '=' || c == '.' || c == '!' )
+ return c;
+ else
+ return 0;
+}
+/*************************************************************************/
+//! Is White space
+/*! This method determines if a given character is white space.
+
+ \param c - Character to be evaluated.
+ \returns xbTrue - Is white space.<br>
+ xbFalse - Is not white space.
+*/
+xbBool xbExp::IsWhiteSpace( char c ){
+ return(( c == 0x20 )? 1 : 0 );
+}
+
+/*************************************************************************/
+//! Get operator weight.
+/*!
+ This method determines the priority of an operator
+
+ Operator precendence
+ 10 .AND. .OR. .NOT. (not really an operator)
+ 9 > or < (includes <= or >=)
+ 6 unary plus or minus (+,-) -- not passed this routine
+ 5 prefix increment and/or decrement (++,--)
+ 4 exponentiation ** or ^
+ 3 multiplication,division or modulus (*,/,%)
+ 2 Addition, subtraction (+,-)
+ 1 Postfix increment and/or decrement (++,--)
+
+ \param sOper - Operator.
+ \returns Operator weight
+
+*/
+
+xbInt16 xbExp::OperatorWeight( const xbString &sOper ){
+
+ if( sOper == "" || sOper.Len() > 5 )
+ return 0;
+
+ else if( sOper == "--0" || sOper == "++0" ) // 0 is prefix
+ return 9;
+ else if( sOper == "**" || sOper == "^" )
+ return 8;
+ else if( sOper == "*" || sOper == "/" || sOper == "%" || sOper == "*=" || sOper == "/=" )
+ return 7;
+ else if( sOper == "+" || sOper == "-" || sOper == "+=" || sOper == "-=" )
+ return 6;
+ else if( sOper == "--1" || sOper == "++1" ) // 1 is post fix
+ return 5;
+ else if( sOper == ">" || sOper == ">=" || sOper == "<" || sOper == "<=" ||
+ sOper == "<>" || sOper == "!=" || sOper == "#" || sOper == "$" || sOper == "=" )
+ return 4;
+ else if( sOper == ".NOT." || sOper == "NOT" )
+ return 3;
+ else if( sOper == ".AND." || sOper == "AND" )
+ return 2;
+ else if( sOper == ".OR." || sOper == "OR" )
+ return 1;
+
+ return 0;
+}
+
+
+/*************************************************************************/
+//! Parse expression.
+/*!
+ \param sExpression - Expression to parse.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbExp::ParseExpression( const xbString &sExpression ){
+ return ParseExpression( sExpression, (xbInt16) 0 );
+}
+
+/*************************************************************************/
+//! Parse expression.
+/*!
+ \param dbf - Pointer to xbDbf instance.
+ \param sExpression - Expression to parse.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbExp::ParseExpression( xbDbf *dbf, const xbString &sExpression ){
+ this->dbf = dbf;
+ return ParseExpression( sExpression, (xbInt16) 0 );
+}
+
+/*************************************************************************/
+//! Parse expression.
+/*!
+ \param sExpression - Expression to parse.
+ \param iWeight.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbExp::ParseExpression( const xbString &sExpression, xbInt16 iWeight ){
+
+ xbExpNode *n;
+ xbExpNode *nLastNode = NULL; // pointer to the last node processed
+ xbExpToken t;
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbString s;
+
+ try {
+
+ if( nTree )
+ delete nTree;
+
+ if(( iRc = CheckParensAndQuotes( sExpression )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ t.sExpression = sExpression;
+
+ xbString sOriginalExp;
+ while( t.iSts == XB_NO_ERROR && iRc == XB_NO_ERROR ){
+
+ sOriginalExp = t.sExpression; // test code
+ iRc = GetNextToken( t );
+ if( !iRc && !t.iSts ){
+
+ // comment / uncomment debug / live
+ // DumpToken( t, 0 );
+
+ if( t.cNodeType == XB_EXP_NOTROOT ){
+ xbExp enr( xbase, dbf );
+ if(( iRc = enr.ParseExpression( t.sToken, iWeight + 10 )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ n = enr.GetTreeHandle();
+ enr.ClearTreeHandle();
+
+ } else {
+
+ switch( t.cNodeType ) {
+
+ case XB_EXP_CONSTANT:
+ n = new xbExpNode( t.sToken, t.cNodeType );
+ if(( iRc = ParseExpressionConstant( t, n )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ break;
+
+ case XB_EXP_FUNCTION:
+ n = new xbExpNode( t.cNodeType );
+ if(( iRc = ParseExpressionFunction( t, n, iWeight )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ break;
+
+ case XB_EXP_FIELD:
+ n = new xbExpNode( t.cNodeType );
+ if(( iRc = ParseExpressionField( t, n )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ break;
+
+ case XB_EXP_OPERATOR:
+ case XB_EXP_PRE_OPERATOR:
+ case XB_EXP_POST_OPERATOR:
+ n = new xbExpNode( t.sToken, t.cNodeType );
+ if(( iRc = ParseExpressionOperator( t, n, iWeight )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ break;
+
+ default:
+ iErrorStop = 70;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ // break;
+ }
+ }
+ t.cPrevNodeType = t.cNodeType;
+ t.cPrevReturnType = t.cReturnType;
+
+ // determine where in the expression tree to insert the latest node "n"
+ // Is this the first node to be added to the tree?
+ if( !nTree ){
+ nTree = n;
+ }
+
+ // else if last node was XB_EXB_PRE_OPERATOR then append this as child to last node
+ else if( nLastNode && nLastNode->GetNodeType() == XB_EXP_PRE_OPERATOR ){
+ n->SetParent( nLastNode );
+ nLastNode->AddChild( n );
+ }
+
+ // else if last node was XB_EXB_POST_OPERATOR then append this as child to last node
+ else if( nLastNode && n->GetNodeType() == XB_EXP_POST_OPERATOR ){
+ n->AddChild( nLastNode );
+ nLastNode->SetParent( n );
+ if( nLastNode == nTree ){
+ nTree = n;
+ } else {
+ nLastNode->GetParent()->RemoveLastChild();
+ nLastNode->GetParent()->AddChild( n );
+ n->SetParent( nLastNode->GetParent() );
+ }
+ }
+
+ else if( n->GetNodeType() == XB_EXP_OPERATOR ){
+ xbExpNode * nWorkNode = nLastNode;
+ while( nWorkNode && ( nWorkNode->GetNodeType() != XB_EXP_OPERATOR || n->GetWeight() <= nWorkNode->GetWeight())){
+ nWorkNode = nWorkNode->GetParent();
+ }
+
+ if( !nWorkNode ){ // we are at the top
+ nTree->SetParent( n );
+ n->AddChild( nTree );
+ nTree = n;
+
+ } else if( nWorkNode->GetChildCnt() == 1 ){
+ nWorkNode->AddChild( n );
+ n->SetParent( nWorkNode );
+
+ } else if( nWorkNode->GetChildCnt() == 2 ){
+ xbExpNode * nChild2 = nWorkNode->GetChild(1);
+ n->AddChild( nChild2 );
+ nWorkNode->RemoveLastChild();
+ nWorkNode->AddChild( n );
+ n->SetParent( nWorkNode );
+
+ } else{
+ // should not be stopping on anything but an operator node with one or two children
+ iErrorStop = 80;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ } else {
+ n->SetParent( nLastNode );
+ nLastNode->AddChild( n );
+ }
+ nLastNode = n;
+ n = NULL;
+ }
+ }
+
+ // for each node in the tree, calculate the length if it's not already set
+ xbExpNode * nWork = GetNextNode( NULL );
+ xbExpNode * nChild1;
+ xbExpNode * nChild2;
+
+
+ while( nWork ){
+
+ if( nWork->GetReturnType() == XB_EXP_UNKNOWN ){
+ nWork->GetNodeText( s );
+
+ // std::cout << "XB_EXP_UNKNOWN logic [" << s << "][" << nWork->GetChildCnt() << "]\n";
+ // if this is "-" and child 1 and child 2 are both dates, set this result type to numeric
+ if( s == "-" && nWork->GetChildCnt() == 2 &&
+ nWork->GetChild(0)->GetReturnType() == XB_EXP_DATE && nWork->GetChild(1)->GetReturnType() == XB_EXP_DATE )
+ nWork->SetReturnType( XB_EXP_NUMERIC );
+ else if( nWork->GetChildCnt() > 0 )
+ nWork->SetReturnType( nWork->GetChild(0)->GetReturnType());
+ else{
+ iErrorStop = 90;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ }
+ if( nWork->GetResultLen() == 0 ){
+
+ switch( nWork->GetReturnType() ){
+
+ case XB_EXP_NUMERIC:
+ nWork->SetResultLen( 4 );
+ break;
+
+ case XB_EXP_CHAR:
+ if( nWork->GetNodeType() != XB_EXP_OPERATOR ){
+ iErrorStop = 100;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ if( nWork->GetChildCnt() < 2 ){
+ iErrorStop = 110;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ nChild1 = nWork->GetChild( 0 );
+ nChild2 = nWork->GetChild( 1 );
+ nWork->SetResultLen( nChild1->GetResultLen() + nChild2->GetResultLen());
+ break;
+
+ case XB_EXP_DATE:
+ nWork->SetResultLen( 8 );
+ break;
+
+ case XB_EXP_LOGICAL:
+ nWork->SetResultLen( 1 );
+ break;
+
+ default:
+ iErrorStop = 120;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ // break;
+ }
+ }
+ if( nWork->IsUnaryOperator() ){
+ if( nWork->GetChildCnt() != 1 ){
+ iErrorStop = 130;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ } else if( nWork->IsOperator() && nWork->GetChildCnt() != 2 ){
+ iErrorStop = 140;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ nWork = GetNextNode( nWork );
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbexp::ParseExpression() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ }
+ return iRc;
+}
+/*************************************************************************/
+//! Parse expression constant.
+/*!
+ \param t - Token.
+ \param n - Node.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbExp::ParseExpressionConstant( xbExpToken &t, xbExpNode *n ){
+
+ xbDate dtWork;
+ n->SetReturnType( t.cReturnType );
+
+ // std::cout << "parse expression constant[" << t.sToken << "]\n";
+
+ switch( t.cReturnType ){
+ case XB_EXP_CHAR:
+ n->SetResultLen( t.sToken.Len() );
+ n->SetResult( t.sToken );
+ break;
+
+ case XB_EXP_DATE:
+ n->SetResultLen( 8 );
+ dtWork.Set( t.sToken );
+ n->SetResult( dtWork );
+ break;
+
+ case XB_EXP_LOGICAL:
+ n->SetResultLen( 1 );
+ if( strncmp( t.sToken, "T", 1 ) == 0 )
+ n->SetResult( (xbBool) xbTrue );
+ else
+ n->SetResult( (xbBool) xbFalse );
+ break;
+
+ case XB_EXP_NUMERIC:
+ n->SetResultLen( 4 );
+ n->SetResult( strtod( t.sToken, 0 ));
+ n->SetResult( t.sToken );
+ break;
+
+ default:
+ return XB_PARSE_ERROR;
+ // break;
+ }
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! Parse expression field.
+/*!
+ \param t - Token.
+ \param n - Node.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbExp::ParseExpressionField( xbExpToken &t, xbExpNode *n ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbDbf * pDbf;
+ xbString sFieldName;
+
+ // do the db lookup and set the field number for the field
+
+ try{
+
+ xbUInt32 lPos;
+ if(( lPos = t.sToken.Pos( "->" )) > 0 ){
+ // table name is part of the token
+ xbString sTableName = t.sToken;
+ sTableName.Left( lPos-1 );
+ sFieldName = t.sToken;
+ 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;
+ sFieldName = t.sToken;
+ }
+ if( !pDbf ){
+ iErrorStop = 10;
+ iRc = XB_INVALID_FIELD;
+ throw iRc;
+ }
+ xbInt16 iFieldNo = 0;
+
+ if(( iRc = pDbf->GetFieldNo( sFieldName, iFieldNo )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ char cFieldType;
+ if(( iRc = pDbf->GetFieldType( iFieldNo, cFieldType )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ n->SetDbfInfo( pDbf, iFieldNo );
+ switch( cFieldType ){
+ case XB_CHAR_FLD:
+ n->SetReturnType( XB_EXP_CHAR );
+ break;
+
+ case XB_LOGICAL_FLD:
+ n->SetReturnType( XB_EXP_LOGICAL );
+ break;
+
+ case XB_NUMERIC_FLD:
+ case XB_FLOAT_FLD:
+ n->SetReturnType( XB_EXP_NUMERIC );
+ break;
+
+ case XB_DATE_FLD:
+ n->SetReturnType( XB_EXP_DATE );
+ break;
+
+ case XB_MEMO_FLD:
+ default:
+ iErrorStop = 30;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ // break;
+ }
+ n->SetNodeText( sFieldName );
+ xbInt16 iResultLen = 0;
+ if(( iRc = pDbf->GetFieldLen( iFieldNo, iResultLen )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ n->SetResultLen( (xbUInt32) iResultLen );
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbexp::ParseExpressionField() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ }
+ return iRc;
+}
+
+/*************************************************************************/
+//! Parse expression function.
+/*!
+ \param t - Token.
+ \param n - Node.
+ \param iWeight
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbExp::ParseExpressionFunction( xbExpToken &t, xbExpNode *n, xbInt16 iWeight ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ // find the first "("
+ xbUInt32 lPos = t.sToken.Pos( '(' );
+ if( lPos == 0 ){
+ iErrorStop = 10;
+ iRc = XB_INVALID_FUNCTION;
+ throw iRc;
+ }
+ // Get the function name and look it up in the table
+
+
+ xbString sFunc = t.sToken;
+ sFunc.Left( lPos - 1 ).Trim();
+ char cReturnType;
+ xbInt16 i = 0;
+ xbInt32 l = 0;
+ if(( iRc = xbase->GetFunctionInfo( sFunc, cReturnType, i, l )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ n->SetNodeText( sFunc );
+
+
+ // Get the function parms
+ xbString sParms = t.sToken;
+ sParms.Mid( lPos+1, t.sToken.Len() - lPos );
+ lPos = sParms.GetLastPos( ')' );
+ if( lPos == 0 ){
+ iErrorStop = 30;
+ iRc = XB_INVALID_FUNCTION;
+ throw iRc;
+ }
+
+ // remove the trailing ")" paren
+ sParms.Left( lPos - 1 ).Trim();
+
+ // if this function has parms, put them in the tree
+ if( sParms.Len() > 0 ){
+ xbExp enr( xbase, dbf );
+
+ // create a linked list of parms
+ xbLinkList<xbString> llParms;
+ if(( iRc = ParseExpressionFunctionParms( sParms, llParms )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+
+ // for each function parm, recursively process it
+ xbLinkListNode<xbString> * llN = llParms.GetHeadNode();
+ xbString sParm;
+ while( llN ){
+ sParm = llN->GetKey();
+ if(( iRc = enr.ParseExpression( sParm, iWeight + 10 )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ n->AddChild( enr.GetTreeHandle());
+ enr.ClearTreeHandle();
+ llN = llN->GetNextNode();
+ }
+ llParms.Clear();
+ }
+
+ if( cReturnType == '1' ){
+ if( n->GetChildCnt() > 0 ){
+ xbExpNode *n1 = n->GetChild( 0 );
+ n->SetReturnType( n1->GetReturnType());
+ }
+
+ } else {
+ n->SetReturnType( cReturnType );
+ }
+
+ if(( iRc = CalcFunctionResultLen( n )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbexp::ParseExpressionFunction() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ }
+ return iRc;
+}
+
+/*************************************************************************/
+//! Parse expression function.
+/*!
+
+ Creates a linked list of function parms as xbStrings
+ This function pulls out the parms and addresses embedded parens and quotes within the parms
+
+ \param sParms
+ \param lParms
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbExp::ParseExpressionFunctionParms( const xbString &sParms, xbLinkList<xbString> & llParms ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbInt16 iParenCtr = 0;
+ xbInt16 iInQuotes = 0;
+ xbInt16 iDoubleQuotes = 0;
+ xbInt16 iSingleQuotes = 0;
+ xbInt32 lStartPos = 0;
+ xbInt32 lParmLen = 0;
+
+ xbString sParm;
+
+ try{
+ const char *sp = sParms;
+
+ while( *sp ){
+ if( *sp == '(')
+ iParenCtr++;
+ else if( *sp == ')' )
+ iParenCtr--;
+ else if( !iInQuotes && *sp == '"' ){
+ iInQuotes++;
+ iDoubleQuotes++;
+ } else if( iInQuotes && *sp == '"' ){
+ iInQuotes--;
+ iDoubleQuotes--;
+ }
+ else if( !iInQuotes && *sp == '\'' ){
+ iInQuotes++;
+ iSingleQuotes++;
+ } else if( iInQuotes && *sp == '\'' ){
+ iInQuotes--;
+ iSingleQuotes--;
+
+ } else if( !iInQuotes && !iParenCtr && *sp == ',' ){
+ // found a valid comma - at the end of a parm
+ // add it to the end of the linked list
+ sParm = sParms;
+ sParm.Mid( (xbUInt32) lStartPos + 1, (xbUInt32) lParmLen ).Trim(); // mid is one based
+ llParms.InsertAtEnd( sParm );
+
+ // set the start pos for the next one on the list
+ lStartPos += lParmLen + 1;
+ lParmLen = -1;
+ // lParmLen = 0;
+ }
+ lParmLen++;
+ sp++;
+ }
+ if( lParmLen > 0 ){
+ // get the last parm, it didn't end with a comma
+ sParm = sParms;
+ sParm.Mid( (xbUInt32) lStartPos + 1, (xbUInt32) lParmLen ).Trim();
+ llParms.InsertAtEnd( sParm );
+ }
+
+ }
+ // try / catch not used in this method, structure added for potential future use
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbexp::ParseExpressionFunctionParms() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ }
+ return iRc;
+}
+/*************************************************************************/
+//! Parse expression operator.
+/*!
+ \param t - Token.
+ \param n - Node.
+ \param iWeight
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbExp::ParseExpressionOperator( xbExpToken &t, xbExpNode *n, xbInt16 iWeight ){
+
+ n->SetResult( t.sToken );
+ n->SetWeight( iWeight + OperatorWeight( t.sToken) );
+
+// std::cout << "ParseExpressionOperator [" << t.cPrevNodeType << "][" << t.sToken << "] Weight = [" << iWeight;
+// std::cout << "] PrevReturnType [" << t.cPrevReturnType;
+// std::cout << "] Operator weight [" << OperatorWeight( t.sToken ) << "] getweight [" << n->GetWeight() << "]\n";
+
+ if( t.sToken == "**" || t.sToken == "^" ||
+ t.sToken == "*" || t.sToken == "/" || t.sToken == "%" || t.sToken == "*=" || t.sToken == "/=" )
+ n->SetReturnType( XB_EXP_NUMERIC );
+
+ else if( t.sToken == "--" || t.sToken == "++" || t.sToken == "+=" || t.sToken == "-=" ) // could be date or numeric
+ n->SetReturnType( XB_EXP_UNKNOWN );
+
+ else if( t.cPrevReturnType == XB_EXP_CHAR && ( t.sToken == "+" || t.sToken == "-" ))
+ n->SetReturnType( XB_EXP_CHAR );
+
+ else if( t.sToken == ".AND." || t.sToken == ".OR." || t.sToken == ".NOT." ||
+ t.sToken == "AND" || t.sToken == "OR" || t.sToken == "NOT" ||
+ t.sToken == ">" || t.sToken == ">=" || t.sToken == "<" ||
+ t.sToken == "<=" || t.sToken == "<>" || t.sToken == "!=" ||
+ t.sToken == "$" || t.sToken == "#" || t.sToken == "=" )
+ n->SetReturnType( XB_EXP_LOGICAL );
+
+
+ else if( t.cPrevReturnType == XB_EXP_UNKNOWN )
+ n->SetReturnType( XB_EXP_UNKNOWN );
+
+ // added for date constant logic 10/28/17
+ else if(( t.sToken == "+" || t.sToken == "-" ) && t.cPrevReturnType == XB_EXP_DATE )
+ n->SetReturnType( XB_EXP_DATE );
+
+ else if( t.sToken == "+" || t.sToken == "-" )
+ n->SetReturnType( XB_EXP_NUMERIC );
+
+ return XB_NO_ERROR;
+}
+
+
+/************************************************************************/
+//! ProcessExpression
+/*! This method processes an expression tree leaving the result in the
+ root node of the tree
+*/
+xbInt16 xbExp::ProcessExpression(){
+ return ProcessExpression( 0 );
+}
+/************************************************************************/
+//! ProcessExpression
+/*! This method processes a parsed expression tree leaving the result in the
+ root node of the tree
+ \param iRecBufSw Record buffer to use when evaluating expression.<br>
+ 0 - Current record buffer.<br>
+ 1 - Original record buffer.
+*/
+
+xbInt16 xbExp::ProcessExpression( xbInt16 iRecBufSw ){
+
+// iRecBufSw 0 - Record Buffer
+// 1 - Original Record Buffer
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+
+ xbExpNode * nWork = GetNextNode( NULL );
+ xbExpNode * nChild1;
+ xbDbf * dbf;
+ xbString sWork1;
+ xbString sWork2;
+ xbString sOperator;
+ xbDate dtWork1;
+
+ xbBool bWork;
+ xbDouble dWork;
+
+ while( nWork ){
+ switch( nWork->GetNodeType() ){
+
+ case XB_EXP_CONSTANT:
+ break;
+
+ case XB_EXP_PRE_OPERATOR: // increment value before setting in head node
+ if( nWork->GetChildCnt() != 1 ){
+ iErrorStop = 10;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ nChild1 = nWork->GetChild( 0 );
+ //if( nChild1->GetReturnType() == XB_EXP_DATE )
+ // nChild1->SetResult( (xbDouble) nChild1->GetDateResult().JulianDays());
+
+ nWork->GetNodeText( sWork1 );
+ if( sWork1 == "++" )
+ nChild1->SetResult( nChild1->GetNumericResult() + 1 );
+ else
+ nChild1->SetResult( nChild1->GetNumericResult() - 1 );
+
+ nWork->SetResult( nChild1->GetNumericResult());
+
+ //if( nChild1->GetReturnType() == XB_EXP_DATE ){
+ // dtWork1.JulToDate8( (xbInt32) nChild1->GetNumericResult());
+ // nChild1->SetResult( dtWork1 );
+ // nWork->SetResult( dtWork1 );
+ // }
+ break;
+
+ case XB_EXP_POST_OPERATOR: // increment value after setting in head node
+ if( nWork->GetChildCnt() != 1 ){
+ iErrorStop = 20;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ nChild1 = nWork->GetChild( 0 );
+ //if( nChild1->GetReturnType() == XB_EXP_DATE ){
+ // nWork->SetResult( nChild1->GetDateResult());
+ // nChild1->SetResult( (xbDouble) nChild1->GetDateResult().JulianDays());
+ //}
+ //else
+ nWork->SetResult( nChild1->GetNumericResult());
+
+ nWork->GetNodeText( sWork1 );
+ if( sWork1 == "++" )
+ nChild1->SetResult( nChild1->GetNumericResult() + 1 );
+ else
+ nChild1->SetResult( nChild1->GetNumericResult() - 1 );
+
+ //if( nChild1->GetReturnType() == XB_EXP_DATE ){
+ // dtWork1.JulToDate8( (xbInt32) nChild1->GetNumericResult());
+ // nChild1->SetResult( dtWork1 );
+ // }
+ break;
+
+ case XB_EXP_FIELD:
+
+ if(( dbf = nWork->GetDbf()) == NULL ){
+ iErrorStop = 30;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ switch( nWork->GetReturnType()){
+ case XB_EXP_CHAR:
+ if(( iRc = dbf->GetField( nWork->GetFieldNo(), sWork1, iRecBufSw )) < XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ nWork->SetResult( sWork1 );
+ break;
+
+ case XB_EXP_DATE:
+
+ if(( iRc = dbf->GetField( nWork->GetFieldNo(), sWork1, iRecBufSw )) < XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ if( sWork1 == " " ){
+ nWork->SetResult( (xbDouble) 21474835648 ); // dbase sets a date value in ndx to this if spaces on dbf record
+ } else {
+ dtWork1.Set( sWork1 );
+ nWork->SetResult( (xbDouble) dtWork1.JulianDays() );
+ }
+ break;
+
+ case XB_EXP_LOGICAL:
+ if(( iRc = dbf->GetLogicalField( nWork->GetFieldNo(), bWork, iRecBufSw )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ nWork->SetResult( bWork );
+ break;
+
+ case XB_EXP_NUMERIC:
+ if(( iRc = dbf->GetDoubleField( nWork->GetFieldNo(), dWork, iRecBufSw )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw iRc;
+ }
+ nWork->SetResult( dWork );
+ break;
+
+ default:
+ iErrorStop = 80;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ // break;
+ }
+ break;
+
+
+ case XB_EXP_OPERATOR:
+ if(( iRc = ProcessExpressionOperator( nWork )) != XB_NO_ERROR ){
+ iErrorStop = 300;
+ throw iRc;
+ }
+
+ break;
+
+ case XB_EXP_FUNCTION:
+ if(( iRc = ProcessExpressionFunction( nWork, iRecBufSw )) != XB_NO_ERROR ){
+ iErrorStop = 400;
+ throw iRc;
+ }
+ break;
+
+ default:
+ iErrorStop = 500;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ // break;
+ }
+ nWork = GetNextNode( nWork );
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbexp::ProcessExpression() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ }
+ return iRc;
+}
+/*************************************************************************/
+//! ProcessExpression
+/*! This method processes an expression tree for a given node.
+*/
+
+xbInt16 xbExp::ProcessExpressionFunction( xbExpNode * n, xbInt16 iRecBufSw ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+
+ xbString sFunction;
+ xbString sResult;
+ xbDouble dResult;
+ xbDate dtResult;
+ xbBool bResult;
+
+ n->GetNodeText( sFunction );
+
+ // process functions with no children first
+ xbExpNode * nChild1;
+ if( n->GetChildCnt() == 0 ){
+ if( sFunction == "DATE" ){
+ if(( iRc = xbase->DATE( dtResult )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ n->SetResult( dtResult );
+ } else if( sFunction == "DEL" ){
+ if(( iRc = xbase->DEL( dbf, sResult, iRecBufSw )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "DELETED" ){
+ if(( iRc = xbase->DELETED( dbf, bResult, iRecBufSw )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ n->SetResult( bResult );
+ } else if( sFunction == "RECCOUNT" ){
+ if(( iRc = xbase->RECCOUNT( dbf, dResult )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ } else if( sFunction == "RECNO" ){
+ if(( iRc = xbase->RECNO( dbf, dResult )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ }
+ // process functions with one child
+ } else if( n->GetChildCnt() == 1 ){
+
+ nChild1 = n->GetChild( 0 );
+
+ if( sFunction == "ABS" ){
+ if(( iRc = xbase->ABS( nChild1->GetNumericResult(), dResult )) != XB_NO_ERROR ){
+ iErrorStop = 200;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ } else if( sFunction == "ALLTRIM" ){
+ if(( iRc = xbase->ALLTRIM( nChild1->GetStringResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 210;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "ASC" ){
+ if(( iRc = xbase->ASC( nChild1->GetStringResult(), dResult )) != XB_NO_ERROR ){
+ iErrorStop = 220;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ } else if( sFunction == "CDOW" ){
+ xbDate d( (xbInt32) nChild1->GetNumericResult());
+ if(( iRc = xbase->CDOW( d, sResult )) != XB_NO_ERROR ){
+ iErrorStop = 230;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "CHR" ){
+ if(( iRc = xbase->CHR( nChild1->GetNumericResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 240;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "CMONTH" ){
+ xbDate d( (xbInt32) nChild1->GetNumericResult());
+ if(( iRc = xbase->CMONTH( d, sResult )) != XB_NO_ERROR ){
+ iErrorStop = 250;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "CTOD" ){
+ if(( iRc = xbase->CTOD( nChild1->GetStringResult(), dtResult )) != XB_NO_ERROR ){
+ iErrorStop = 260;
+ throw iRc;
+ }
+ n->SetResult( dtResult );
+ } else if( sFunction == "DAY" ){
+ xbDate d( (xbInt32) nChild1->GetNumericResult());
+ if(( iRc = xbase->DAY( d, dResult )) != XB_NO_ERROR ){
+ iErrorStop = 270;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ } else if( sFunction == "DESCEND" ){
+
+ if( n->GetReturnType() == XB_EXP_CHAR ){
+ if(( iRc = xbase->DESCEND( nChild1->GetStringResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 280;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+
+ } else if( n->GetReturnType() == XB_EXP_DATE ){
+ xbDate d( (xbInt32) nChild1->GetNumericResult());
+ if(( iRc = xbase->DESCEND( d, dtResult )) != XB_NO_ERROR ){
+ iErrorStop = 290;
+ throw iRc;
+ }
+ n->SetResult( dtResult );
+
+ } else if( n->GetReturnType() == XB_EXP_NUMERIC ){
+ if(( iRc = xbase->DESCEND( nChild1->GetNumericResult(), dResult )) != XB_NO_ERROR ){
+ iErrorStop = 300;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+
+ } else {
+ iErrorStop = 310;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+
+ } else if( sFunction == "DOW" ){
+ xbDate d( (xbInt32) nChild1->GetNumericResult());
+ if(( iRc = xbase->DOW( d, dResult )) != XB_NO_ERROR ){
+ iErrorStop = 320;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ } else if( sFunction == "DTOC" ){
+ xbDate d( (xbInt32) nChild1->GetNumericResult());
+ if(( iRc = xbase->DTOC( d, sResult )) != XB_NO_ERROR ){
+ iErrorStop = 330;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "DTOS" ){
+ xbDate d( (xbInt32) nChild1->GetNumericResult());
+ if(( iRc = xbase->DTOS( d, sResult )) != XB_NO_ERROR ){
+ iErrorStop = 340;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "EXP" ){
+ if(( iRc = xbase->EXP( nChild1->GetNumericResult(), dResult )) != XB_NO_ERROR ){
+ iErrorStop = 350;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ } else if( sFunction == "INT" ){
+ if(( iRc = xbase->INT( nChild1->GetNumericResult(), dResult )) != XB_NO_ERROR ){
+ iErrorStop = 360;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ } else if( sFunction == "ISALPHA" ){
+ if(( iRc = xbase->ISALPHA( nChild1->GetStringResult(), bResult )) != XB_NO_ERROR ){
+ iErrorStop = 370;
+ throw iRc;
+ }
+ n->SetResult( bResult );
+ } else if( sFunction == "ISLOWER" ){
+ if(( iRc = xbase->ISLOWER( nChild1->GetStringResult(), bResult )) != XB_NO_ERROR ){
+ iErrorStop = 380;
+ throw iRc;
+ }
+ n->SetResult( bResult );
+ } else if( sFunction == "ISUPPER" ){
+ if(( iRc = xbase->ISUPPER( nChild1->GetStringResult(), bResult )) != XB_NO_ERROR ){
+ iErrorStop = 390;
+ throw iRc;
+ }
+ n->SetResult( bResult );
+ } else if( sFunction == "LEN" ){
+ if(( iRc = xbase->LEN( nChild1->GetStringResult(), dResult )) != XB_NO_ERROR ){
+ iErrorStop = 400;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ } else if( sFunction == "LOG" ){
+ if(( iRc = xbase->LOG( nChild1->GetNumericResult(), dResult )) != XB_NO_ERROR ){
+ iErrorStop = 410;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ } else if( sFunction == "LTRIM" ){
+ if(( iRc = xbase->LTRIM( nChild1->GetStringResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 420;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "LOWER" ){
+ if(( iRc = xbase->LOWER( nChild1->GetStringResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 430;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "MONTH" ){
+ xbDate d( (xbInt32) nChild1->GetNumericResult());
+ if(( iRc = xbase->MONTH( d, dResult )) != XB_NO_ERROR ){
+ iErrorStop = 440;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ } else if( sFunction == "RTRIM" ){
+ if(( iRc = xbase->RTRIM( nChild1->GetStringResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 450;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "STOD" ){
+ if(( iRc = xbase->STOD( nChild1->GetStringResult(), dtResult )) != XB_NO_ERROR ){
+ iErrorStop = 460;
+ throw iRc;
+ }
+ n->SetResult( dtResult );
+ } else if( sFunction == "SPACE" ){
+ if(( iRc = xbase->SPACE( (xbInt32) nChild1->GetNumericResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 470;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "SQRT" ){
+ if(( iRc = xbase->SQRT( nChild1->GetNumericResult(), dResult )) != XB_NO_ERROR ){
+ iErrorStop = 480;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ } else if( sFunction == "STR" ){
+ if(( iRc = xbase->STR( nChild1->GetNumericResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 490;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "TRIM" ){
+ if(( iRc = xbase->TRIM( nChild1->GetStringResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 500;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "UPPER" ){
+ if(( iRc = xbase->UPPER( nChild1->GetStringResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 510;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "VAL" ){
+ if(( iRc = xbase->VAL( nChild1->GetStringResult(), dResult )) != XB_NO_ERROR ){
+ iErrorStop = 520;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ } else if( sFunction == "YEAR" ){
+ xbDate d( (xbInt32) nChild1->GetNumericResult());
+ if(( iRc = xbase->YEAR( d, dResult )) != XB_NO_ERROR ){
+ iErrorStop = 530;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ } else {
+ iErrorStop = 540;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ } else if( n->GetChildCnt() == 2 ){
+ xbExpNode * nChild2;
+ nChild1 = n->GetChild( 0 );
+ nChild2 = n->GetChild( 1 );
+
+ if( sFunction == "AT" ){
+ if(( iRc = xbase->AT( nChild1->GetStringResult(), nChild2->GetStringResult(), dResult )) != XB_NO_ERROR ){
+ iErrorStop = 700;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ } else if( sFunction == "LEFT" ){
+ if(( iRc = xbase->LEFT( nChild1->GetStringResult(), (xbUInt32) nChild2->GetNumericResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 710;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "MAX" ){
+ if(( iRc = xbase->MAX( nChild1->GetNumericResult(), nChild2->GetNumericResult(), dResult )) != XB_NO_ERROR ){
+ iErrorStop = 720;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ } else if( sFunction == "MIN" ){
+ if(( iRc = xbase->MIN( nChild1->GetNumericResult(), nChild2->GetNumericResult(), dResult )) != XB_NO_ERROR ){
+ iErrorStop = 730;
+ throw iRc;
+ }
+ n->SetResult( dResult );
+ }
+ else if( sFunction == "REPLICATE" ){
+ if(( iRc = xbase->REPLICATE( nChild1->GetStringResult(), (xbUInt32) nChild2->GetNumericResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 800;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "RIGHT" ){
+ if(( iRc = xbase->RIGHT( nChild1->GetStringResult(), (xbUInt32) nChild2->GetNumericResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 810;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "STR" ){
+ if(( iRc = xbase->STR( nChild1->GetNumericResult(), (xbUInt32) nChild2->GetNumericResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 820;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else {
+ iErrorStop = 830;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ } else if( n->GetChildCnt() == 3 ){
+ xbExpNode * nChild2;
+ xbExpNode * nChild3;
+ nChild1 = n->GetChild( 0 );
+ nChild2 = n->GetChild( 1 );
+ nChild3 = n->GetChild( 2 );
+
+ if( sFunction == "IIF" ){
+ if(( iRc = xbase->IIF( nChild1->GetBoolResult(), nChild2->GetStringResult(), nChild3->GetStringResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 900;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "STR" ){
+ if(( iRc = xbase->STR( nChild1->GetNumericResult(), (xbUInt32) nChild2->GetNumericResult(), (xbUInt32) nChild3->GetNumericResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 910;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "STRZERO" ){
+ if(( iRc = xbase->STRZERO( nChild1->GetNumericResult(), (xbUInt32) nChild2->GetNumericResult(), (xbUInt32) nChild3->GetNumericResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 920;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else if( sFunction == "SUBSTR" ){
+ if(( iRc = xbase->SUBSTR( nChild1->GetStringResult(), (xbUInt32) nChild2->GetNumericResult(), (xbUInt32) nChild3->GetNumericResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 930;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else {
+ iErrorStop = 950;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ } else if( n->GetChildCnt() == 4 ){
+ xbExpNode * nChild2;
+ xbExpNode * nChild3;
+ xbExpNode * nChild4;
+ nChild1 = n->GetChild( 0 );
+ nChild2 = n->GetChild( 1 );
+ nChild3 = n->GetChild( 2 );
+ nChild4 = n->GetChild( 3 );
+
+ if( sFunction == "STR" ){
+ if(( iRc = xbase->STR( nChild1->GetNumericResult(), (xbUInt32) nChild2->GetNumericResult(),
+ (xbUInt32) nChild3->GetNumericResult(), nChild4->GetStringResult(), sResult )) != XB_NO_ERROR ){
+ iErrorStop = 1000;
+ throw iRc;
+ }
+ n->SetResult( sResult );
+ } else {
+ iErrorStop = 1010;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+
+ } else {
+ iErrorStop = 2000;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbexp::ProcessExpressionFunction() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ }
+ return iRc;
+}
+/*************************************************************************/
+//! Process Expression Operator
+/*! This method processes an expression operator for a given node.
+*/
+
+xbInt16 xbExp::ProcessExpressionOperator( xbExpNode * n ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ xbExpNode * nChild1 = NULL;
+ xbExpNode * nChild2 = NULL;
+ xbString sOperator;
+ xbString sWork1;
+ xbString sWork2;
+ xbDate dtWork1;
+
+ xbString sMsg;
+
+ try{
+
+ n->GetNodeText( sOperator );
+ nChild1 = n->GetChild( 0 );
+ if( !n->IsUnaryOperator())
+ nChild2 = n->GetChild( 1 );
+
+ switch( n->GetReturnType()){
+ case XB_EXP_CHAR:
+ if( sOperator == "+" ){
+ sWork1 = nChild1->GetStringResult();
+ sWork1 += nChild2->GetStringResult();
+ n->SetResult( sWork1 );
+ } else if( sOperator == "-" ){
+ sWork1 = nChild1->GetStringResult();
+ sWork1.Rtrim();
+ sWork1 += nChild2->GetStringResult();
+ sWork1.PadRight( ' ', n->GetResultLen());
+ n->SetResult( sWork1 );
+ } else {
+ iErrorStop = 100;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ break;
+
+ case XB_EXP_NUMERIC:
+ if( sOperator == "+" )
+ n->SetResult( nChild1->GetNumericResult() + nChild2->GetNumericResult());
+ else if( sOperator == "-" ){
+ n->SetResult( nChild1->GetNumericResult() - nChild2->GetNumericResult());
+
+ }
+ else if( sOperator == "*" )
+ n->SetResult( nChild1->GetNumericResult() * nChild2->GetNumericResult());
+ else if( sOperator == "/" )
+ n->SetResult( nChild1->GetNumericResult() / nChild2->GetNumericResult());
+ else if( sOperator == "^" || sOperator == "**" )
+ n->SetResult( pow( nChild1->GetNumericResult(), nChild2->GetNumericResult()));
+ else if( sOperator == "+=" ){
+ n->SetResult( nChild1->GetNumericResult() + nChild2->GetNumericResult());
+ nChild1->SetResult( n->GetNumericResult() );
+ }
+ else if( sOperator == "-=" ){
+ n->SetResult( nChild1->GetNumericResult() - nChild2->GetNumericResult());
+ nChild1->SetResult( n->GetNumericResult() );
+ }
+ else if( sOperator == "*=" ){
+ n->SetResult( nChild1->GetNumericResult() * nChild2->GetNumericResult());
+ nChild1->SetResult( n->GetNumericResult() );
+ }
+ else if( sOperator == "/=" ){
+ n->SetResult( nChild1->GetNumericResult() / nChild2->GetNumericResult());
+ nChild1->SetResult( n->GetNumericResult() );
+ } else {
+ iErrorStop = 200;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ break;
+
+
+ case XB_EXP_DATE:
+ // if date values in the leaf nodes, convert to numeric for operator logic
+
+ if( sOperator == "+" )
+ n->SetResult( nChild1->GetNumericResult() + nChild2->GetNumericResult());
+ else if( sOperator == "-" ){
+ n->SetResult( nChild1->GetNumericResult() - nChild2->GetNumericResult());
+ xbDate d( (xbInt32) n->GetNumericResult());
+ }
+ else if( sOperator == "+=" ){
+ n->SetResult( nChild1->GetNumericResult() + nChild2->GetNumericResult());
+ nChild1->SetResult( n->GetNumericResult() );
+ }
+ else if( sOperator == "-=" ){
+ n->SetResult( nChild1->GetNumericResult() - nChild2->GetNumericResult());
+ nChild1->SetResult( n->GetNumericResult() );
+ } else {
+ iErrorStop = 300;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ break;
+
+ case XB_EXP_LOGICAL:
+
+ if( !n->IsUnaryOperator() && (nChild1->GetReturnType() != nChild2->GetReturnType())){
+ iErrorStop = 400;
+ iRc = XB_INCOMPATIBLE_OPERANDS;
+ throw iRc;
+ }
+
+ if( sOperator == ".AND." || sOperator == "AND" )
+ n->SetResult((xbBool) (nChild1->GetBoolResult() && nChild2->GetBoolResult()) );
+
+ else if( sOperator == ".OR." || sOperator == "OR" )
+ n->SetResult((xbBool) (nChild1->GetBoolResult() || nChild2->GetBoolResult()) );
+
+ else if( sOperator == ".NOT." || sOperator == "NOT" ){
+ if( nChild1->GetBoolResult())
+ n->SetResult((xbBool) xbFalse );
+ else
+ n->SetResult((xbBool) xbTrue );
+ }
+
+ else if( sOperator == ">" ){
+
+ if( nChild1->GetReturnType() == XB_EXP_CHAR )
+ n->SetResult((xbBool)(nChild1->GetStringResult() > nChild2->GetStringResult()));
+ else if( nChild1->GetReturnType() == XB_EXP_NUMERIC || nChild1->GetReturnType() == XB_EXP_DATE )
+ n->SetResult((xbBool)(nChild1->GetNumericResult() > nChild2->GetNumericResult()));
+
+ else {
+ iErrorStop = 410;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ }
+
+ else if( sOperator == ">=" ){
+ if( nChild1->GetReturnType() == XB_EXP_CHAR )
+ n->SetResult((xbBool)(nChild1->GetStringResult() >= nChild2->GetStringResult()));
+
+ else if( nChild1->GetReturnType() == XB_EXP_NUMERIC || nChild1->GetReturnType() == XB_EXP_DATE )
+ n->SetResult((xbBool)(nChild1->GetNumericResult() >= nChild2->GetNumericResult()));
+
+ else {
+ iErrorStop = 420;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ }
+
+ else if( sOperator == "<" ){
+
+ if( nChild1->GetReturnType() == XB_EXP_CHAR )
+ n->SetResult((xbBool)( nChild1->GetStringResult() < nChild2->GetStringResult()));
+
+ else if( nChild1->GetReturnType() == XB_EXP_NUMERIC || nChild1->GetReturnType() == XB_EXP_DATE )
+ n->SetResult((xbBool)( nChild1->GetNumericResult() < nChild2->GetNumericResult()));
+
+ else {
+ iErrorStop = 430;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ }
+
+ else if( sOperator == "<=" ){
+
+ if( nChild1->GetReturnType() == XB_EXP_CHAR )
+ n->SetResult((xbBool)( nChild1->GetStringResult() <= nChild2->GetStringResult()));
+
+ else if( nChild1->GetReturnType() == XB_EXP_NUMERIC || nChild1->GetReturnType() == XB_EXP_DATE )
+ n->SetResult((xbBool)( nChild1->GetNumericResult() <= nChild2->GetNumericResult()));
+
+ else {
+ iErrorStop = 440;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ }
+
+ else if( sOperator == "<>" || sOperator == "#" || sOperator == "!=" ){
+
+ if( nChild1->GetReturnType() == XB_EXP_CHAR )
+ n->SetResult((xbBool)( nChild1->GetStringResult() != nChild2->GetStringResult()));
+
+ else if( nChild1->GetReturnType() == XB_EXP_NUMERIC || nChild1->GetReturnType() == XB_EXP_DATE )
+ n->SetResult((xbBool)( nChild1->GetNumericResult() != nChild2->GetNumericResult()));
+
+ else {
+ iErrorStop = 450;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+ }
+
+ else if( sOperator == "$" ){
+ if( nChild1->GetReturnType() == XB_EXP_CHAR )
+ if( nChild2->GetStringResult().Pos( nChild1->GetStringResult()) > 0 )
+ n->SetResult((xbBool) xbTrue );
+ else
+ n->SetResult((xbBool) xbFalse );
+ else {
+ iErrorStop = 460;
+ iRc = XB_INCOMPATIBLE_OPERANDS;
+ throw iRc;
+ }
+ }
+
+ else if( sOperator == "=" ){
+
+ if( nChild1->GetReturnType() == XB_EXP_CHAR ){
+ xbString sChld1 = nChild1->GetStringResult();
+ xbString sChld2 = nChild2->GetStringResult();
+ sChld1.Rtrim();
+ sChld2.Rtrim();
+ n->SetResult((xbBool)( sChld1 == sChld2 ));
+
+ } else if( nChild1->GetReturnType() == XB_EXP_NUMERIC || nChild1->GetReturnType() == XB_EXP_DATE )
+ n->SetResult((xbBool)( nChild1->GetNumericResult() == nChild2->GetNumericResult()));
+
+ else {
+ iErrorStop = 470;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+
+ } else {
+ iErrorStop = 500;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ }
+
+ break;
+
+ default:
+ iErrorStop = 600;
+ iRc = XB_PARSE_ERROR;
+ throw iRc;
+ // break;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbexp::ProcessExpressionOperator() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ }
+ return iRc;
+}
+
+/*************************************************************************/
+}; // namespace
+#endif // XB_EXPRESSION_SUPPORT
+/*************************************************************************/
diff --git a/src/core/xbexpnode.cpp b/src/core/xbexpnode.cpp
new file mode 100755
index 0000000..77a8c33
--- /dev/null
+++ b/src/core/xbexpnode.cpp
@@ -0,0 +1,562 @@
+/* xbexpnode.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2017,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_EXPRESSION_SUPPORT
+
+namespace xb{
+/************************************************************************/
+//! @brief Constructor
+xbExpNode::xbExpNode(){
+ sNodeText = "";
+ cReturnType = 0;
+ cNodeType = 0;
+ dResult = 0;
+ iFieldNo = 0;
+ ulResultLen = 0;
+ iWeight = 0;
+ nParent = NULL;
+ dbf = NULL;
+}
+
+/************************************************************************/
+//! @brief Constructor
+/*!
+ \param sNodeText Node text.
+ \param cReturnType Return type.
+ \param cNodeType Node type.
+*/
+
+xbExpNode::xbExpNode( xbString &sNodeText, char cReturnType, char cNodeType ){
+ this->sNodeText = sNodeText;
+ this->cReturnType = cReturnType;
+ this->cNodeType = cNodeType;
+ dResult = 0;
+ iFieldNo = 0;
+ ulResultLen = 0;
+ iWeight = 0;
+ nParent = NULL;
+ dbf = NULL;
+}
+
+/************************************************************************/
+//! @brief Constructor
+/*!
+ \param sNodeText Node text.
+ \param cNodeType Node type.
+*/
+xbExpNode::xbExpNode( xbString &sNodeText, char cNodeType ){
+ this->sNodeText = sNodeText;
+ this->cReturnType = 0x00;
+ this->cNodeType = cNodeType;
+ dResult = 0;
+ iFieldNo = 0;
+ ulResultLen = 0;
+ iWeight = 0;
+ nParent = NULL;
+ dbf = NULL;
+}
+
+/************************************************************************/
+//! @brief Constructor
+/*!
+ \param cNodeType Node type.
+*/
+xbExpNode::xbExpNode( char cNodeType ){
+ this->cReturnType = 0x00;
+ this->cNodeType = cNodeType;
+ dResult = 0;
+ iFieldNo = 0;
+ ulResultLen = 0;
+ iWeight = 0;
+ nParent = NULL;
+ dbf = NULL;
+}
+
+/************************************************************************/
+//! @brief Deconstructor
+xbExpNode::~xbExpNode(){
+
+ xbExpNode * n;
+ while( llChildren.GetNodeCnt() > 0 ){
+ llChildren.RemoveFromFront( n );
+ delete n;
+ }
+}
+
+/************************************************************************/
+//! @brief Add child node to linked list.
+/*!
+ \param n Pointer to node to add to linked list.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbExpNode::AddChild( xbExpNode *n ){
+ n->SetParent( this );
+ return llChildren.InsertAtEnd( n );
+}
+
+/************************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+
+//! @brief Dump Node.
+/*!
+ \param iOption xbTrue - Print child info if they exist.<bt>
+ xbFalse - Don't print child info.
+ \returns void.
+*/
+void xbExpNode::DumpNode( xbInt16 iOption ) const {
+ xbString sMsg;
+ std::cout << "Me=[" << this << "] ";
+ if( nParent )
+ std::cout << "Par=[" << nParent << "] ";
+
+ std::cout << "nTyp=[" << cNodeType << "] ";
+ std::cout << "dTyp=[" << cReturnType << "] ";
+ if( iWeight != 0 )
+ std::cout << "W=[" << iWeight << "] ";
+
+ if( cNodeType == XB_EXP_FIELD )
+ std::cout << "FieldNo=[" << iFieldNo << "] ";
+
+ std::cout << "Txt=[" << sNodeText << "] ";
+ if( sResult != "" )
+ std::cout << "sVal=[" << sResult << "] ";
+
+ if( ulResultLen > 0 )
+ std::cout << "Len=[" << ulResultLen << "] ";
+ if( cReturnType == XB_EXP_DATE ){
+ xbDate d( (xbInt32) dResult );
+ std::cout << "dtVal=[" << d.Str() << "] ";
+ }
+
+ if( cReturnType == XB_EXP_DATE || cReturnType == XB_EXP_NUMERIC ){
+ sMsg.Sprintf( "dVal=[%f]\n", dResult );
+ std::cout << sMsg.Str();
+ }
+
+ if( cReturnType == XB_EXP_LOGICAL ){
+ sMsg.Sprintf( "lVal=[%d]\n", (xbInt32) dResult );
+ std::cout << sMsg.Str();
+ }
+
+ if( iOption ){
+ xbLinkListNode<xbExpNode *> *lln = llChildren.GetHeadNode();
+ xbExpNode *n;
+ if( lln ){
+ std::cout << " Children: ";
+ while( lln ){
+ n = lln->GetKey();
+ std::cout << " [" << n << "]";
+ lln = lln->GetNextNode();
+ }
+ std::cout << std::endl;
+
+ lln = llChildren.GetHeadNode();
+ while( lln ){
+ n = lln->GetKey();
+ n->DumpNode( iOption );
+ lln = lln->GetNextNode();
+ }
+ }
+ }
+
+ std::cout << std::endl;
+}
+#endif
+
+/************************************************************************/
+//! @brief Get boolean result.
+/*!
+ \returns Boolean result.
+*/
+
+xbBool xbExpNode::GetBoolResult() const {
+ return (xbBool) dResult;
+}
+
+/************************************************************************/
+//! @brief Get pointer to child.
+/*!
+ \param ulChildNo - Which child? 1,2 or3
+ \returns Pointer to child node or null if none exists.
+*/
+xbExpNode *xbExpNode::GetChild( xbUInt32 ulChildNo ) const {
+
+ xbLinkListNode<xbExpNode *> *lln = llChildren.GetNodeForNo( ulChildNo );
+ if( lln )
+ return lln->GetKey();
+ else
+ return 0x00;
+}
+/************************************************************************/
+//! @brief Get child count.
+/*!
+ \returns Child count.
+*/
+xbUInt32 xbExpNode::GetChildCnt() const{
+ return llChildren.GetNodeCnt();
+}
+
+/************************************************************************/
+//! @brief Get the current child number for this node.
+/*!
+ \returns Child number: 1, 2 or 3.
+*/
+
+xbUInt32 xbExpNode::GetChildNo() const {
+
+ if( !nParent )
+ return 0;
+
+ for( xbUInt32 i = 0; i < nParent->GetChildCnt(); i++ ){
+ if( this == nParent->GetChild( i )){
+ // std::cout << "get child no [" << this << "][" << nParent->GetChild(i) << "]\n";
+ return i;
+ }
+ }
+ return 0;
+}
+
+/************************************************************************/
+//! @brief Get the dbf pointer.
+/*!
+ \returns Pointer to dbf.
+*/
+xbDbf *xbExpNode::GetDbf() const {
+ return dbf;
+}
+/************************************************************************/
+//! @brief Get the field number.
+/*!
+ \returns Field number for field node.
+*/
+
+xbInt16 xbExpNode::GetFieldNo() const {
+ return iFieldNo;
+}
+
+/*************************************************************************/
+//! @brief Get the first node.
+/*!
+ \returns Pointer to left most child node or *this if childless.
+*/
+
+xbExpNode *xbExpNode::GetFirstNode() {
+ xbExpNode *n = this;
+ while( n && n->GetChildCnt() > 0 )
+ n = n->GetChild(0);
+ return n;
+}
+
+/*************************************************************************/
+//! @brief Get the next node.
+/*!
+ \returns Pointer to right node or parent if right node does not exist.
+*/
+
+xbExpNode *xbExpNode::GetNextNode() const {
+
+ if( HasRightSibling())
+ return GetRightSibling()->GetFirstNode();
+ else
+ return nParent;
+}
+
+/************************************************************************/
+//! @brief Get the node text.
+/*!
+ \param sOutText Output string containing node text.
+ \returns void
+*/
+
+void xbExpNode::GetNodeText( xbString &sOutText ) const{
+ sOutText = sNodeText;
+}
+
+/************************************************************************/
+//! @brief Get the node type.
+/*!
+ \returns Node type.
+*/
+
+char xbExpNode::GetNodeType() const{
+ return cNodeType;
+}
+
+/************************************************************************/
+//! @brief Get numeric result.
+/*!
+ \returns Numeric result.
+*/
+
+xbDouble xbExpNode::GetNumericResult() const {
+ return dResult;
+}
+
+/************************************************************************/
+//! @brief Get parent.
+/*!
+ \returns Pointer to parent node.
+*/
+
+xbExpNode *xbExpNode::GetParent() const{
+ return nParent;
+}
+
+/************************************************************************/
+//! @brief Get result length.
+/*!
+ \returns Result length.
+*/
+xbUInt32 xbExpNode::GetResultLen() const{
+ return ulResultLen;
+}
+/************************************************************************/
+//! @brief Get result type.
+/*!
+ \returns Result type.
+*/
+char xbExpNode::GetReturnType() const{
+ return cReturnType;
+}
+
+/*************************************************************************/
+//! @brief Get right sibling.
+/*!
+ \returns Pointer to right sibling.
+*/
+
+xbExpNode *xbExpNode::GetRightSibling() const {
+
+ xbExpNode * nParent;
+ if(( nParent = GetParent()) == NULL )
+ return NULL;
+
+ if( nParent->GetChildCnt() <= 0 )
+ return NULL;
+
+ xbUInt32 ulChildNo = GetChildNo();
+
+ if( ulChildNo < (nParent->GetChildCnt() - 1))
+ return nParent->GetChild( ulChildNo + 1 );
+ else
+ return NULL;
+}
+/************************************************************************/
+//! @brief Get string result.
+/*!
+ \returns String result.
+*/
+xbString &xbExpNode::GetStringResult(){
+ return sResult;
+}
+/************************************************************************/
+//! @brief Get node weight.
+/*!
+ Each node is assigned a weight used internally to detmerine processing sequence.
+ \returns Node weight.
+*/
+
+xbInt16 xbExpNode::GetWeight() const {
+ return iWeight;
+}
+
+/*************************************************************************/
+//! @brief Determine if node has a right sibling.
+/*!
+ \returns xbTrue - Node has right sibling.<br>
+ xbFalse - Node has no right sibling.
+*/
+
+xbBool xbExpNode::HasRightSibling() const {
+
+ // std::cout << "in HasRightSibling [" << sNodeText << "]\n";
+
+ if( nParent == NULL )
+ return xbFalse;
+
+ xbUInt32 ulChildNo = GetChildNo();
+
+ if( ulChildNo < (nParent->GetChildCnt() - 1)){
+ // std::cout << "Has Right Sibling = " << iChildNo << "] of [" << nParent->GetChildCnt() << "]\n";
+ return xbTrue;
+}
+ else
+ return xbFalse;
+}
+
+
+/*************************************************************************/
+//! @brief Determine if node is an operator.
+/*!
+ \returns xbTrue - Node is an operator.<br>
+ xbFalse - Node is not an operator.
+*/
+
+xbBool xbExpNode::IsOperator() const {
+
+ if( cNodeType == XB_EXP_OPERATOR )
+ return xbTrue;
+ else
+ return xbFalse;
+}
+
+/*************************************************************************/
+//! @brief Determine if node is a unary operator.
+/*!
+ \returns xbTrue - Node is a unary operator.<br>
+ xbFalse - Node is not a unary operator.
+*/
+xbBool xbExpNode::IsUnaryOperator() const {
+
+ if( cNodeType == XB_EXP_PRE_OPERATOR || cNodeType == XB_EXP_POST_OPERATOR )
+ return xbTrue;
+ else if( cNodeType == XB_EXP_OPERATOR && (sNodeText == ".NOT." || sNodeText == "NOT" ))
+ return xbTrue;
+ else
+ return xbFalse;
+}
+/************************************************************************/
+//! @brief Remove last child from node.
+/*!
+ \returns void.
+*/
+
+void xbExpNode::RemoveLastChild(){
+ xbExpNode *n;
+ llChildren.RemoveFromEnd( n );
+}
+
+/************************************************************************/
+//! @brief Set dbf info on node.
+/*!
+ \param dbf Pointer to dbf.
+ \param iFieldNo Field number of field.
+ \returns void.
+*/
+void xbExpNode::SetDbfInfo( xbDbf *dbf, xbInt16 iFieldNo ){
+ this->dbf = dbf;
+ this->iFieldNo = iFieldNo;
+}
+
+/************************************************************************/
+//! @brief Set dbf info on node.
+/*!
+ \param dbf Pointer to dbf.
+ \returns void.
+*/
+void xbExpNode::SetDbfInfo( xbDbf *dbf ){
+ this->dbf = dbf;
+}
+/************************************************************************/
+//! @brief Set node type.
+/*!
+ \param cNodeType Node type.
+ \returns void.
+*/
+void xbExpNode::SetNodeType( char cNodeType ){
+ this->cNodeType = cNodeType;
+}
+
+/************************************************************************/
+//! @brief Set node text.
+/*!
+ \param sNodeText Node text.
+ \returns void.
+*/
+void xbExpNode::SetNodeText( xbString & sNodeText ){
+ this->sNodeText = sNodeText;
+}
+
+/************************************************************************/
+//! @brief Set parent.
+/*!
+ \param n Pointer to parent.
+ \returns void.
+*/
+void xbExpNode::SetParent( xbExpNode *n ){
+ this->nParent = n;
+}
+
+/************************************************************************/
+//! @brief Set date result.
+/*!
+ \param dtResult Date result.
+ \returns void.
+*/
+void xbExpNode::SetResult( xbDate &dtResult ){
+ this->dResult = dtResult.JulianDays();
+}
+
+/************************************************************************/
+//! @brief Set boolean result.
+/*!
+ \param bResult Boolean result.
+ \returns void.
+*/
+void xbExpNode::SetResult( xbBool bResult ){
+ this->dResult = bResult;
+}
+/************************************************************************/
+//! @brief Set numeric result.
+/*!
+ \param dResult Double numeric result.
+ \returns void.
+*/
+void xbExpNode::SetResult( xbDouble dResult ){
+ this->dResult = dResult;
+}
+/************************************************************************/
+//! @brief Set string result.
+/*!
+ \param sResult String result.
+ \returns void.
+*/
+void xbExpNode::SetResult( xbString &sResult ){
+ this->sResult = sResult;
+}
+/************************************************************************/
+//! @brief Set result length.
+/*!
+ \param ulResultLen Set result length.
+ \returns void.
+*/
+void xbExpNode::SetResultLen( xbUInt32 ulResultLen ){
+ this->ulResultLen = ulResultLen;
+}
+/************************************************************************/
+//! @brief Set return type.
+/*!
+ \param cReturnType Return Type.
+ \returns void.
+*/
+void xbExpNode::SetReturnType( char cReturnType ){
+ this->cReturnType = cReturnType;
+}
+/************************************************************************/
+//! @brief Set weight.
+/*!
+ \param iWeight Weight to set this node at.
+ \returns void.
+*/
+void xbExpNode::SetWeight( xbInt16 iWeight ){
+ this->iWeight = iWeight;
+}
+/*************************************************************************/
+}; // namespace
+#endif // XB_EXPRESSION_SUPPORT
+/*************************************************************************/
diff --git a/src/core/xbfields.cpp b/src/core/xbfields.cpp
new file mode 100755
index 0000000..8cfb4e6
--- /dev/null
+++ b/src/core/xbfields.cpp
@@ -0,0 +1,1122 @@
+/* xbfields.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"
+
+namespace xb{
+
+/************************************************************************/
+//! @brief Get xbDouble field for field name.
+/*!
+ \param sFieldName Name of field to retrieve.
+ \param dFieldValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetDoubleField( const xbString &sFieldName, xbDouble &dFieldValue ) const {
+ return GetDoubleField( GetFieldNo( sFieldName ), dFieldValue );
+}
+
+/************************************************************************/
+//! @brief Get xbDouble field for field number.
+/*!
+ \param iFieldNo Number of field to retrieve.
+ \param dFieldValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::GetDoubleField( xbInt16 iFieldNo, xbDouble &dFieldValue ) const {
+ xbInt16 iRc = XB_NO_ERROR;
+ char buf[21];
+ memset( buf, 0x00, 21 );
+ if(( iRc = GetRawField( iFieldNo, buf, 21, 0 )) >= XB_NO_ERROR ){
+ dFieldValue = strtod( buf, NULL );
+ return XB_NO_ERROR;
+ } else
+ return iRc;
+}
+/************************************************************************/
+//! @brief Get xbDouble field for field number.
+/*!
+ \param iFieldNo Number of field to retrieve.
+ \param dFieldValue Output field value.
+ \param iRecBufSw 0 - Record buffer with any updates.<br>1 - Record buffer with original data.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetDoubleField( xbInt16 iFieldNo, xbDouble &dFieldValue, xbInt16 iRecBufSw ) const {
+ xbInt16 iRc = XB_NO_ERROR;
+ char buf[21];
+ memset( buf, 0x00, 21 );
+ if(( iRc = GetRawField( iFieldNo, buf, 21, iRecBufSw )) >= XB_NO_ERROR ){
+ dFieldValue = strtod( buf, NULL );
+ return XB_NO_ERROR;
+ } else
+ return iRc;
+}
+
+/************************************************************************/
+//! @brief Get xbDate field for field number.
+/*!
+ \param iFieldNo Number of field to retrieve.
+ \param dtFieldValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetDateField( xbInt16 iFieldNo, xbDate &dtFieldValue ) const{
+ xbString s;
+ xbInt16 iRc;
+ if(( iRc = GetField( iFieldNo, s )) != XB_NO_ERROR )
+ return iRc;
+ dtFieldValue.Set( s );
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+//! @brief Get xbDate field for field name.
+/*!
+ \param sFieldName Name of field to retrieve.
+ \param dtFieldValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetDateField( const xbString &sFieldName, xbDate &dtFieldValue ) const{
+ xbString s;
+ xbInt16 iRc;
+ if(( iRc = GetField( sFieldName, s )) != XB_NO_ERROR )
+ return iRc;
+ dtFieldValue.Set( s );
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+//! @brief Get xbString field for field name.
+/*!
+ \param sFieldName Name of field to retrieve
+ \param sFieldValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetField( const xbString &sFieldName, xbString &sFieldValue ) const{
+ return GetField( GetFieldNo( sFieldName ), sFieldValue, 0 );
+}
+/************************************************************************/
+//! @brief Get field data for field number.
+/*!
+ \param iFieldNo Number of field to retrieve.
+ \param sFieldValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetField( xbInt16 iFieldNo, xbString &sFieldValue ) const{
+ return GetField( iFieldNo, sFieldValue, 0 );
+}
+/************************************************************************/
+//! @brief Get field data for field number.
+/*!
+ \param iFieldNo Number of field to retrieve.
+ \param sFieldValue Output field value.
+ \param iRecBufSw 0 - Record buffer with any updates.<br>1 - Record buffer with original data.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetField( xbInt16 iFieldNo, xbString &sFieldValue, xbInt16 iRecBufSw) const
+{
+ xbUInt32 iLen;
+ if( iFieldNo < 0 || iFieldNo >= iNoOfFields ) {
+ sFieldValue = "";
+ return XB_INVALID_FIELD_NO;
+ }
+ iLen = SchemaPtr[iFieldNo].cFieldLen;
+ sFieldValue = "";
+ if( iRecBufSw )
+ sFieldValue.Append( (char *) SchemaPtr[iFieldNo].pAddress2, iLen ); // original record buffer
+ else
+ sFieldValue.Append( (char *) SchemaPtr[iFieldNo].pAddress, iLen ); // current record buffer
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+//! @brief Get decimal for field name.
+/*!
+ This routine retreives a field's decimal length.
+ \param sFieldName Name of field to retrieve
+ \param iFieldDecimal Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetFieldDecimal( const xbString &sFieldName, xbInt16 & iFieldDecimal ) const {
+ return GetFieldDecimal( GetFieldNo( sFieldName ), iFieldDecimal );
+}
+
+
+/************************************************************************/
+//! @brief Get decimal for field number.
+/*!
+ This routine retreives a field's decimal length.
+ \param iFieldNo Number of field to retrieve
+ \param iFieldDecimal Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetFieldDecimal( xbInt16 iFieldNo, xbInt16 & iFieldDecimal ) const {
+
+ if( iFieldNo < 0 || iFieldNo >= iNoOfFields ) {
+ return XB_INVALID_FIELD_NO;
+ }
+ iFieldDecimal = SchemaPtr[iFieldNo].cNoOfDecs;
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+//! @brief Get field length for field name.
+/*!
+
+ This function retrieves a field's length.
+
+ \param sFieldName Name of field to retrieve
+ \param iFieldLen Output field length value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetFieldLen( const xbString &sFieldName, xbInt16 &iFieldLen ) const {
+ return GetFieldLen( GetFieldNo( sFieldName ), iFieldLen );
+}
+
+
+/************************************************************************/
+//! @brief Get field length for field number.
+/*!
+ This function retrieves a field's length.
+
+ \param iFieldNo Name of field to retrieve
+ \param iFieldLen Output field length value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetFieldLen( xbInt16 iFieldNo, xbInt16 &iFieldLen ) const {
+ if( iFieldNo >= 0 && iFieldNo < iNoOfFields ){
+ iFieldLen = SchemaPtr[iFieldNo].cFieldLen;
+ return XB_NO_ERROR;
+ } else
+ return XB_INVALID_FIELD_NO;
+}
+
+/************************************************************************/
+//! @brief Get the field number for name.
+/*! Returns the field number for the named field.
+
+ All field get/put methods require either a field number or field name as
+ one of the parameters. Using the methods that take the field numbers will
+ yield slightly better performance because the methods that take a name, have
+ to look up the number.
+
+ \param sFieldName Name of field.
+ \param iFieldNo Output field number for the given name.
+ \returns Number of field named fldName.
+*/
+
+xbInt16 xbDbf::GetFieldNo( const xbString & sFieldName, xbInt16 &iFieldNo ) const
+{
+ int i;
+
+ if( sFieldName.Len() > 10 )
+ return XB_INVALID_FIELD_NAME;
+
+ for( i = 0; i < iNoOfFields; i++ ){
+ if( sFieldName == SchemaPtr[i].cFieldName ){
+ iFieldNo = i;
+ return XB_NO_ERROR;
+ }
+ }
+ return XB_INVALID_FIELD_NAME;
+}
+
+/************************************************************************/
+//! Get field ID number for a given field name.
+/*! Returns the field number for the named field.
+
+ \param sFieldName Name of field.
+ \returns Number of field or XB_INVALID_FIELD_NAME.
+*/
+
+xbInt16 xbDbf::GetFieldNo( const xbString &sFieldName ) const {
+ int i;
+
+ if( sFieldName.Len() > 10 )
+ return XB_INVALID_FIELD_NAME;
+
+ for( i = 0; i < iNoOfFields; i++ ){
+ if( sFieldName == SchemaPtr[i].cFieldName )
+ return i;
+ }
+ return XB_INVALID_FIELD_NAME;
+}
+
+/************************************************************************/
+//! Get field type for field number.
+/*!
+ \param iFieldNo Field number.
+ \param cFieldType Output field type.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::GetFieldType( xbInt16 iFieldNo, char & cFieldType ) const{
+
+ if( iFieldNo >= 0 && iFieldNo < iNoOfFields ){
+ cFieldType = SchemaPtr[iFieldNo].cType;
+ return XB_NO_ERROR;
+ }
+ else
+ return XB_INVALID_FIELD_NO;
+}
+
+/************************************************************************/
+//! Get field type for field name.
+/*!
+ \param sFieldName Field name.
+ \param cFieldType Output field type.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetFieldType( const xbString &sFieldName, char & cFieldType ) const{
+ return( GetFieldType( GetFieldNo( sFieldName ), cFieldType));
+}
+
+/************************************************************************/
+//! @brief Returns the name of the specified field.
+/*! Returns a pointer to the name for the field specified by iFieldNo.
+
+ \param iFieldNo Number of field.
+ \param sFieldName Output variable containing the field name.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::GetFieldName( xbInt16 iFieldNo, xbString &sFieldName ) const{
+ if( iFieldNo >= 0 && iFieldNo < iNoOfFields ){
+ sFieldName = SchemaPtr[iFieldNo].cFieldName;
+ return XB_NO_ERROR;
+ }
+ else
+ return XB_INVALID_FIELD_NO;
+}
+
+/************************************************************************/
+//! @brief Get xbFloat field for field number.
+/*!
+ \param iFieldNo Number of field to retrieve.
+ \param fFieldValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::GetFloatField( xbInt16 iFieldNo, xbFloat & fFieldValue ) const {
+
+ char cFieldType;
+ xbInt16 rc = GetFieldType( iFieldNo, cFieldType );
+ if( rc < 0 )
+ return rc;
+
+ if( cFieldType != 'N' && cFieldType != 'F' )
+ return XB_INVALID_FIELD_TYPE;
+
+ xbString sTemp;
+ rc = GetField( iFieldNo, sTemp, 0 );
+ if( rc < 0 )
+ return rc;
+
+ fFieldValue = (xbFloat) atof( sTemp.Str());
+ return XB_NO_ERROR;
+}
+
+
+/************************************************************************/
+//! @brief Get xbFloat field for field name.
+/*!
+ \param sFieldName Number of field to retrieve.
+ \param fFieldValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetFloatField( const xbString & sFieldName, xbFloat & fFieldValue ) const {
+ return GetFloatField( GetFieldNo(sFieldName ), fFieldValue );
+}
+
+/************************************************************************/
+//! @brief Get logical field for field number.
+/*!
+ \param iFieldNo Number of field to retrieve.
+ \param sFieldValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::GetLogicalField( xbInt16 iFieldNo, xbString &sFieldValue ) const {
+
+ char cFieldType;
+ xbInt16 iRc = GetFieldType( iFieldNo, cFieldType );
+ if( iRc < 0 )
+ return iRc;
+ else if( cFieldType != 'L' )
+ return XB_INVALID_FIELD_TYPE;
+
+ if(( iRc = GetField( iFieldNo, sFieldValue )) < XB_NO_ERROR )
+ return iRc;
+ else
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+//! @brief Get logical field for field name.
+/*!
+ \param sFieldName Name of field to retrieve.
+ \param sFieldValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetLogicalField( const xbString &sFieldName, xbString &sFieldValue ) const {
+ return GetLogicalField( GetFieldNo( sFieldName ), sFieldValue );
+}
+
+
+/************************************************************************/
+//! @brief Get logical field for field number.
+/*!
+ \param iFieldNo Number of field to retrieve.
+ \param bFieldValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetLogicalField( xbInt16 iFieldNo, xbBool &bFieldValue ) const {
+ return GetLogicalField( iFieldNo, bFieldValue, 0 );
+}
+
+/************************************************************************/
+//! @brief Get logical field for field number.
+/*!
+ \param iFieldNo Number of field to retrieve.
+ \param bFieldValue Output field value.
+ \param iRecBufSw 0 - Record buffer with any updates.<br>1 - Record buffer with original data.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetLogicalField( xbInt16 iFieldNo, xbBool &bFieldValue, xbInt16 iRecBufSw ) const {
+
+ char cFieldType;
+ xbInt16 iRc = GetFieldType( iFieldNo, cFieldType );
+ if((iRc = GetFieldType( iFieldNo, cFieldType )) != XB_NO_ERROR )
+ return iRc;
+
+ if( cFieldType != 'L' )
+ return XB_INVALID_FIELD_TYPE;
+
+ xbString sFieldValue;
+ if(( iRc = GetField( iFieldNo, sFieldValue, iRecBufSw )) < XB_NO_ERROR )
+ return iRc;
+
+ if( sFieldValue == 'T' || sFieldValue == 't' || sFieldValue == 'Y' || sFieldValue == 'y' )
+ bFieldValue = xbTrue;
+ else
+ bFieldValue = xbFalse;
+
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+//! @brief Get logical field for field name.
+/*!
+ \param sFieldName Name of field to retrieve.
+ \param bFieldValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::GetLogicalField( const xbString &sFieldName, xbBool &bFieldValue ) const {
+ return GetLogicalField( GetFieldNo( sFieldName ), bFieldValue );
+}
+/************************************************************************/
+//! @brief Get long field for field number.
+/*!
+ \param iFieldNo Number of field to retrieve.
+ \param lFieldValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::GetLongField( xbInt16 iFieldNo, xbInt32 & lFieldValue ) const {
+
+ xbInt16 rc = 0;
+ xbInt16 iErrorStop = 0;
+ char cFieldType;
+
+ try{
+
+ if(( rc = GetFieldType( iFieldNo, cFieldType )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw rc;
+ }
+
+ if( cFieldType != 'N' && cFieldType != 'F' && cFieldType != 'M' ){
+ iErrorStop = 20;
+ rc = XB_INVALID_FIELD_TYPE;
+ throw rc;
+ }
+
+ xbString sTemp;
+ if(( rc = GetField( iFieldNo, sTemp, 0 )) < 0 ){
+ iErrorStop = 30;
+ throw rc;
+ }
+
+ if( !sTemp.ValidNumericValue() || ((int) sTemp.Pos( '.' ) > 0)){
+ iErrorStop = 40;
+ rc = XB_INVALID_DATA;
+ throw rc;
+ }
+
+ lFieldValue = atol( sTemp.Str());
+ }
+
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbDbf::GetLongField() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+#ifdef XB_MEMO_SUPPORT
+//! @brief Get memo field for field number.
+/*!
+ \param iFieldNo Number of field to retrieve.
+ \param sMemoValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::GetMemoField( xbInt16 iFieldNo, xbString &sMemoValue ){
+ return Memo->GetMemoField( iFieldNo, sMemoValue );
+}
+/************************************************************************/
+//! @brief Get memo field for field name.
+/*!
+
+ \param sFieldName Name of field to retrieve.
+ \param sMemoValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::GetMemoField( const xbString & sFieldName, xbString & sMemoValue ){
+ return Memo->GetMemoField( GetFieldNo( sFieldName ), sMemoValue );
+}
+
+/************************************************************************/
+//! @brief Get the memo field count for this table.
+/*!
+ \returns Returns the number of memo fields in the table,
+*/
+xbInt16 xbDbf::GetMemoFieldCnt() const {
+ return iMemoFieldCnt;
+}
+/************************************************************************/
+//! @brief Get memo field length for field number.
+/*!
+ \param iFieldNo Number of field to retrieve.
+ \param ulMemoFieldLen Output memo field value length.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetMemoFieldLen( xbInt16 iFieldNo, xbUInt32 & ulMemoFieldLen ){
+ return Memo->GetMemoFieldLen( iFieldNo, ulMemoFieldLen );
+}
+/************************************************************************/
+//! @brief Get memo field length for field name.
+/*!
+ \param sFieldName Name of field to retrieve.
+ \param ulMemoFieldLen Output memo field value length.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::GetMemoFieldLen( const xbString &sFieldName, xbUInt32 &ulMemoFieldLen ){
+ return Memo->GetMemoFieldLen( GetFieldNo( sFieldName ), ulMemoFieldLen );
+}
+
+#endif // XB_MEMO_SUPPORT
+
+/************************************************************************/
+//! @brief Get unsigned long field for field number.
+/*!
+ \param iFieldNo Number of field to retrieve.
+ \param ulFieldValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::GetULongField( xbInt16 iFieldNo, xbUInt32 & ulFieldValue ) const {
+
+ xbInt16 rc = 0;
+ xbInt16 iErrorStop = 0;
+ char cFieldType;
+
+ try{
+
+ if(( rc = GetFieldType( iFieldNo, cFieldType )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw rc;
+ }
+
+ if( cFieldType != 'N' && cFieldType != 'F' && cFieldType != 'M' ){
+ iErrorStop = 20;
+ rc = XB_INVALID_FIELD_TYPE;
+ throw rc;
+ }
+
+ xbString sTemp;
+ if(( rc = GetField( iFieldNo, sTemp, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw rc;
+ }
+ sTemp.Trim();
+ if( !sTemp.ValidNumericValue() || ((int) sTemp.Pos( '.' ) > 0)){
+ iErrorStop = 40;
+ rc = XB_INVALID_DATA;
+ throw rc;
+ }
+ ulFieldValue = strtoul( sTemp.Str(), NULL, 10 );
+ }
+
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbDbf::GetULongField() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+//! @brief Get long field for field name.
+/*!
+ \param sFieldName Number of field to retrieve.
+ \param lFieldValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetLongField( const xbString &sFieldName, xbInt32 &lFieldValue ) const {
+ return GetLongField( GetFieldNo( sFieldName ), lFieldValue );
+}
+
+/************************************************************************/
+//! @brief Get unsigned long field for field name.
+/*!
+ \param sFieldName Number of field to retrieve.
+ \param ulFieldValue Output field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::GetULongField( const xbString &sFieldName, xbUInt32 &ulFieldValue ) const {
+ return GetULongField( GetFieldNo( sFieldName ), ulFieldValue );
+}
+
+/************************************************************************/
+//! @brief Get raw field data for field number.
+/*!
+
+ This is a protected method, used by other methods. This method would be
+ subject to buffer overflows if made public.
+
+ \param iFieldNo Number of field to retrieve.
+ \param cBuf Pointer to buffer area provided by calling application program.
+ \param ulBufSize Size of data to copy
+ \param iRecBufSw 0 - Record buffer with any updates.<br>1 - Record buffer with original data.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+
+xbInt16 xbDbf::GetRawField( xbInt16 iFieldNo, char *cBuf, xbUInt32 ulBufSize, xbInt16 iRecBufSw ) const
+{
+ if( iFieldNo < 0 || iFieldNo >= iNoOfFields ) {
+ return XB_INVALID_FIELD_NO;
+ }
+
+ size_t stCopySize;
+ if( ulBufSize > (size_t) (SchemaPtr[iFieldNo].cFieldLen ))
+ stCopySize = (size_t) (SchemaPtr[iFieldNo].cFieldLen );
+ else
+ stCopySize = ulBufSize - 1;
+
+ if( iRecBufSw )
+ memcpy( cBuf, SchemaPtr[iFieldNo].pAddress2, stCopySize );
+ else
+ memcpy( cBuf, SchemaPtr[iFieldNo].pAddress, stCopySize );
+
+ cBuf[stCopySize] = 0x00;
+ return XB_NO_ERROR;
+}
+
+
+/************************************************************************/
+//! @brief Put double field for field name.
+/*!
+ \param sFieldName Name of field to update.
+ \param dFieldValue Field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::PutDoubleField( const xbString &sFieldName, xbDouble dFieldValue ){
+ return PutDoubleField( GetFieldNo( sFieldName ), dFieldValue );
+}
+
+/************************************************************************/
+//! @brief Put double field for field number.
+/*!
+ \param iFieldNo Number of field to update.
+ \param dFieldValue Field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::PutDoubleField( xbInt16 iFieldNo, xbDouble dFieldValue ){
+
+ xbInt16 rc;
+ xbString sDoubleFmt;
+ xbString sDoubleFmt2;
+ xbString sDoubleVal;
+ xbInt16 iFieldLen;
+ xbInt16 iNoOfDecs;
+
+ if(( rc = GetFieldDecimal( iFieldNo, iNoOfDecs )) != XB_NO_ERROR )
+ return rc;
+
+ if(( rc = GetFieldLen( iFieldNo, iFieldLen )) != XB_NO_ERROR )
+ return rc;
+
+ sDoubleFmt.Sprintf( "%d.%df", iFieldLen, iNoOfDecs );
+ sDoubleFmt2 = "%-";
+ sDoubleFmt2 += sDoubleFmt;
+ sDoubleVal.Sprintf( sDoubleFmt2.Str(), dFieldValue );
+ sDoubleVal.Rtrim();
+ return PutField( iFieldNo, sDoubleVal );
+}
+
+/************************************************************************/
+//! @brief Put date field for field name.
+/*!
+ \param sFieldName Name of field to update.
+ \param dtFieldValue Field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::PutDateField(const xbString &sFieldName, const xbDate &dtFieldValue ){
+ return PutField( GetFieldNo( sFieldName ), dtFieldValue.Str() );
+}
+
+/************************************************************************/
+//! @brief Put date field for field number.
+/*!
+ \param iFieldNo Number of field to update.
+ \param dtFieldValue Field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::PutDateField( xbInt16 iFieldNo, const xbDate &dtFieldValue ){
+ return PutField( iFieldNo, dtFieldValue.Str() );
+}
+
+/************************************************************************/
+//! @brief Put field for field name.
+/*!
+ \param sFieldName Name of field to update.
+ \param sFieldValue Field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::PutField(const xbString &sFieldName, const xbString &sFieldValue ) {
+ return PutField( GetFieldNo( sFieldName ), sFieldValue );
+}
+/************************************************************************/
+//! @brief Put field for field number.
+/*!
+ \param iFieldNo Number of field to update.
+ \param sFieldValue Field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::PutField( xbInt16 iFieldNo, const xbString &sFieldValue ) {
+ xbInt16 iLen;
+ xbInt16 iDecPos; /* Decimal Position */
+ char * startpos;
+ char * tp; /* Target Pointer */
+
+ if( iFieldNo < 0 || iFieldNo >= iNoOfFields )
+ return XB_INVALID_FIELD_NO;
+
+ if( SchemaPtr[iFieldNo].cType == 'L' && !sFieldValue.ValidLogicalValue())
+ return XB_INVALID_DATA;
+
+ else if( SchemaPtr[iFieldNo].cType == 'D' ){
+ xbDate d;
+ if( !d.DateIsValid( sFieldValue ))
+ return XB_INVALID_DATA;
+ iLen = 8;
+ }
+ else
+ {
+ iLen = (xbInt16) sFieldValue.Len();
+ if( SchemaPtr[iFieldNo].cType == 'F' || SchemaPtr[iFieldNo].cType == 'N' || SchemaPtr[iFieldNo].cType == 'M' ){
+ if( !sFieldValue.ValidNumericValue()) {
+ return XB_INVALID_DATA;
+ }
+ else {
+ iDecPos = (xbInt16) sFieldValue.Pos( "." ); // 0 is no decimal
+ int mlod; // max no of digits left of decimal point digit count
+
+
+ if( SchemaPtr[iFieldNo].cNoOfDecs > 0 )
+ mlod = SchemaPtr[iFieldNo].cFieldLen - SchemaPtr[iFieldNo].cNoOfDecs - 1;
+ else
+ mlod = iLen;
+
+ if( iDecPos == 0 ){ // no decimal in incoming data
+
+ // check digits to the left of the decimal
+ if( SchemaPtr[iFieldNo].cNoOfDecs > 0 && iLen > mlod ) /* no decimal in incoming data */
+ return XB_INVALID_DATA;
+
+ else if( SchemaPtr[iFieldNo].cNoOfDecs == 0 && iLen > SchemaPtr[iFieldNo].cFieldLen )
+ return XB_INVALID_DATA;
+
+ }
+ else // decimal in incoming data
+ {
+ if( (iDecPos-1) > mlod ) // too many digits to the left of dec in incoming data
+ return XB_INVALID_DATA;
+
+ // check digits to the right of the decimal
+ else if((iLen - iDecPos) > SchemaPtr[iFieldNo].cNoOfDecs )
+ return XB_INVALID_DATA;
+ }
+ }
+ }
+ }
+
+ // do all field edits before this point
+ if( iDbfStatus != XB_UPDATED ){
+ iDbfStatus = XB_UPDATED;
+ memcpy( RecBuf2, RecBuf, uiRecordLen ); // save the original record bufer before making updates
+ }
+
+ memset( SchemaPtr[iFieldNo].pAddress, 0x20, SchemaPtr[iFieldNo].cFieldLen );
+
+ if( iLen > SchemaPtr[iFieldNo].cFieldLen )
+ iLen = SchemaPtr[iFieldNo].cFieldLen;
+
+ if( SchemaPtr[iFieldNo].cType == 'F' || SchemaPtr[iFieldNo].cType == 'N'
+ || SchemaPtr[iFieldNo].cType == 'M') {
+
+ xbInt16 iDecPos = (xbInt16) sFieldValue.Pos( "." );
+ if( iDecPos == 0 ){
+ iLen = (xbInt16) sFieldValue.Len();
+ iDecPos = 0;
+ }
+ else{
+ iLen = iDecPos - 1;
+ }
+
+ if( SchemaPtr[iFieldNo].cNoOfDecs > 0 ){
+ tp = SchemaPtr[iFieldNo].pAddress;
+ tp += SchemaPtr[iFieldNo].cFieldLen - SchemaPtr[iFieldNo].cNoOfDecs - 1;
+ *tp++ = '.';
+
+ if( iDecPos == 0 ){
+ for( xbInt32 i = 0; i < SchemaPtr[iFieldNo].cNoOfDecs; i++ )
+ *tp++ = '0';
+ } else {
+ xbInt32 j = iDecPos + 1;
+ for( xbInt32 i = 0; i < SchemaPtr[iFieldNo].cNoOfDecs; i++, j++ ){
+ if( j <= (xbInt32) sFieldValue.Len())
+ *tp++ = sFieldValue[j];
+ else
+ *tp++ = '0';
+ }
+ }
+ startpos= SchemaPtr[iFieldNo].pAddress +
+ SchemaPtr[iFieldNo].cFieldLen -
+ SchemaPtr[iFieldNo].cNoOfDecs - iLen - 1;
+
+ }
+ else
+ startpos=SchemaPtr[iFieldNo].pAddress+SchemaPtr[iFieldNo].cFieldLen-iLen;
+ }
+ else
+ startpos = SchemaPtr[iFieldNo].pAddress;
+
+ memcpy( startpos, sFieldValue.Str(), (size_t) iLen );
+ return 0;
+}
+
+/************************************************************************/
+//! @brief Put float field for field number.
+/*!
+ \param iFieldNo Number of field to update.
+ \param fFieldValue Field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::PutFloatField( xbInt16 iFieldNo, xbFloat fFieldValue ){
+
+ xbInt16 rc;
+ xbString sFloatFmt;
+ xbString sFloatFmt2;
+ xbString sFloatVal;
+ xbInt16 iFieldLen;
+ xbInt16 iNoOfDecs;
+
+ if(( rc = GetFieldDecimal( iFieldNo, iNoOfDecs )) != XB_NO_ERROR )
+ return rc;
+
+ if(( rc = GetFieldLen( iFieldNo, iFieldLen )) != XB_NO_ERROR )
+ return rc;
+
+ sFloatFmt.Sprintf( "%d.%df", iFieldLen, iNoOfDecs );
+ sFloatFmt2 = "%-";
+ sFloatFmt2 += sFloatFmt;
+ sFloatVal.Sprintf( sFloatFmt2.Str(), fFieldValue );
+ sFloatVal.Rtrim();
+ return PutField( iFieldNo, sFloatVal );
+}
+
+/************************************************************************/
+//! @brief Put float field for field name.
+/*!
+ \param sFieldName Name of field to update.
+ \param fFieldValue Field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::PutFloatField( const xbString &sFieldName, xbFloat fFieldValue ){
+ return PutFloatField( GetFieldNo( sFieldName ), fFieldValue );
+}
+
+/************************************************************************/
+//! @brief Put logical field for field number.
+/*!
+ \param iFieldNo Number of field to update.
+ \param sFieldValue Field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::PutLogicalField( xbInt16 iFieldNo, const xbString &sFieldValue ) {
+ return PutField( iFieldNo, sFieldValue );
+}
+
+/************************************************************************/
+//! @brief Put logical field for field name.
+/*!
+ \param sFieldName Name of field to update.
+ \param sFieldValue Field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::PutLogicalField( const xbString &sFieldName, const xbString &sFieldValue ) {
+ return PutField( GetFieldNo( sFieldName ), sFieldValue );
+}
+
+/************************************************************************/
+//! @brief Put logical field for field number.
+/*!
+ \param iFieldNo Number of field to update.
+ \param bFieldValue Field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::PutLogicalField( xbInt16 iFieldNo, xbBool bFieldValue ) {
+
+ if( bFieldValue )
+ return PutField( iFieldNo, "T" );
+ else
+ return PutField( iFieldNo, "F" );
+}
+
+/************************************************************************/
+//! @brief Put logical field for field name.
+/*!
+ \param sFieldName Name of field to update.
+ \param bFieldValue Field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+xbInt16 xbDbf::PutLogicalField( const xbString &sFieldName, xbBool bFieldValue ) {
+ return PutLogicalField( GetFieldNo( sFieldName ), bFieldValue );
+}
+
+/************************************************************************/
+//! @brief Put long field for field number.
+/*!
+ \param iFieldNo Number of field to update.
+ \param lFieldValue Field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::PutLongField( xbInt16 iFieldNo, xbInt32 lFieldValue ) {
+ xbString sLong;
+ sLong.Sprintf( "%ld", (xbInt32) lFieldValue );
+ return PutField( iFieldNo, sLong.Str() );
+}
+
+/************************************************************************/
+//! @brief Put long field for field name.
+/*!
+ \param sFieldName Name of field to update.
+ \param lFieldValue Field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::PutLongField( const xbString &sFieldName, xbInt32 lFieldValue ) {
+ return PutLongField( GetFieldNo( sFieldName ), lFieldValue );
+}
+
+/************************************************************************/
+//! @brief Put unsigned long field for field number.
+/*!
+ \param iFieldNo Number of field to update.
+ \param ulFieldValue Field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::PutULongField( xbInt16 iFieldNo, xbUInt32 ulFieldValue ) {
+ xbString sLong;
+ sLong.Sprintf( "%lu", (xbInt32) ulFieldValue );
+ return PutField( iFieldNo, sLong.Str() );
+}
+
+/************************************************************************/
+//! @brief Put unsigned long field for field name.
+/*!
+ \param sFieldName Name of field to update.
+ \param ulFieldValue Field value.
+ \returns The field routines return one of:<br>
+ XB_NO_ERROR<br>XB_INVALID_DATA<br>XB_INVALID_FIELD_NO<br>XB_INVALID_FIELD_NAME<br>
+ XB_INVALID_FIELD_TYPE<br>XB_INVALID_DATA
+*/
+
+xbInt16 xbDbf::PutULongField( const xbString &sFieldName, xbUInt32 ulFieldValue ) {
+ return PutLongField( GetFieldNo( sFieldName ), (xbInt32) ulFieldValue );
+}
+
+/************************************************************************/
+#ifdef XB_MEMO_SUPPORT
+//! @brief Check if memo field exists for field name.
+/*!
+ \param sFieldName Name of field to check.
+ \returns xbTrue Field exists.<br> xbFale Field does not exist.
+*/
+
+xbBool xbDbf::MemoFieldExists( const xbString &sFieldName ) const{
+ return MemoFieldExists( GetFieldNo( sFieldName ));
+}
+
+/************************************************************************/
+//! @brief Check if memo field exists for field number.
+/*!
+ \param iFieldNo Number of field to check.
+ \returns xbTrue Field exists.<br> xbFale Field does not exist.
+*/
+
+xbBool xbDbf::MemoFieldExists( xbInt16 iFieldNo ) const{
+
+ xbInt32 lFld = 0L;
+ GetLongField( iFieldNo, lFld );
+ if( lFld == 0L )
+ return xbFalse;
+ else
+ return xbTrue;
+}
+
+#endif
+} /* namespace */
+
diff --git a/src/core/xbfile.cpp b/src/core/xbfile.cpp
new file mode 100755
index 0000000..a7d5257
--- /dev/null
+++ b/src/core/xbfile.cpp
@@ -0,0 +1,2052 @@
+/* xbfile.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
+
+This module handles all the low level file I/O and is the base class
+for the table, memo and index classes
+
+*/
+
+#include "xbase.h"
+
+namespace xb{
+
+/************************************************************************/
+//! @brief Class Constructor.
+xbFile::xbFile( xbXBase * x ){
+ fp = NULL;
+ bFileOpen = xbFalse;
+ ulBlockSize = 0;
+ iFileNo = 0;
+ xbase = x;
+ if( GetMultiUser() == xbTrue )
+ iShareMode = XB_MULTI_USER;
+ else
+ iShareMode = XB_SINGLE_USER;
+ iOpenMode = 0;
+ #ifdef XB_LOCKING_SUPPORT
+ iLockRetries = -1;
+ #endif
+ #ifdef HAVE_SETENDOFFILE_F
+ fHandle = NULL;
+ #endif
+}
+
+/************************************************************************/
+//! @brief Class Destructor.
+xbFile::~xbFile(){
+ if( bFileOpen )
+ xbFclose();
+}
+
+/************************************************************************/
+//! @brief Create a unique file name.
+/*!
+ Given a directory and file extension as inputs, create a unique file name.
+
+ \param sDirIn Directory
+ \param sExtIn File Extension
+ \param sFqnOut A fully qualifed unique file name as output
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbFile::CreateUniqueFileName( const xbString & sDirIn, const xbString & sExtIn, xbString &sFqnOut ){
+ return CreateUniqueFileName( sDirIn, sExtIn, sFqnOut, 0 );
+}
+
+/************************************************************************/
+//! @brief Create a unique file name.
+/*!
+ Given a directory and file extension as inputs, create a unique file name.
+
+ \param sDirIn Directory
+ \param sExtIn File Extension
+ \param iOption 0 - look only for one file for a given directory and extension<br>
+ 1 - if file name extension is "dbf" or "DBF", verify unique dbt or DBT (memo) file is also available<br>
+ \param sFqnOut A fully qualifed unique file name as output
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::CreateUniqueFileName( const xbString & sDirIn, const xbString & sExtIn, xbString &sFqnOut, xbInt16 iOption ){
+
+ xbBool bUniqueFileNameFound = xbFalse;
+ xbFile f( xbase);
+ xbInt32 l = 1;
+ xbString sMemoFileName;
+
+
+ while( !bUniqueFileNameFound ){
+ sFqnOut.Sprintf( "%sxbTmp%03d.%s", sDirIn.Str(), l, sExtIn.Str());
+ if( iOption == 1 && sExtIn == "DBF" ){
+ sMemoFileName.Sprintf( "%sxbTmp%03d.DBT", sDirIn.Str(), l );
+ }
+ else if( iOption == 1 && sExtIn == "dbf" ){
+ sMemoFileName.Sprintf( "%sxbTmp%03d.dbt", sDirIn.Str(), l );
+ }
+ if( f.FileExists( sFqnOut ) || ( sMemoFileName.Len() > 0 && f.FileExists( sMemoFileName ))){
+ l++;
+ }
+ else
+ {
+ bUniqueFileNameFound = xbTrue;
+ }
+ if( l > 999 )
+ return XB_FILE_EXISTS;
+ }
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Determine which version the memo (dbt) file is.
+/*!
+
+ This routine uses the first byte in the dbf file to determine which memo
+ file version is in use. The main difference between version 3 and 4 is that
+ version 4 will reuse blocks if they become available. Version 3 does not.
+
+ \param cFileTypeByte is an output field and is one of:<br>
+ <br>
+ 0 - none<br>
+ 3 - Dbase III+<br>
+ 4 - Dbase IV<br>
+
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::DetermineXbaseMemoVersion( unsigned char cFileTypeByte ) const {
+
+
+ if( BitSet( cFileTypeByte, 3 ) && BitSet( cFileTypeByte, 7 ))
+ return 4;
+ else if( BitSet( cFileTypeByte, 7 ))
+ return 3;
+
+ return 0;
+}
+/*************************************************************************/
+//! @brief Determine xbase dbf version.
+/*!
+
+ This routine is used to determine which version of the Xbase classes can
+ be used for a given DBF file.<br>
+
+ It attempts to use the highest version compiled into the library.<br>
+
+ References:<br>
+ This routine uses the first byte from the dbf file.<br>
+ Per DBase documentation:<br>
+ Valid dBASE for Windows table file, bits 0-2 indicate version number: 3 for dBASE Level 5, 4 for dBASE Level 7.<br>
+ Bit 3 and bit 7 indicate presence of a dBASE IV or dBASE for Windows memo file;<br>
+ Bits 4-6 indicate the presence of a dBASE IV SQL table;<br>
+ Bit 7 indicates the presence of any .DBT memo file (either a dBASE III PLUS type or a dBASE IV or dBASE for Windows memo file).<br>
+<br>
+ Bachmann spec (used extensively in library build), page 7 - does not match DBase documentation<br>
+<br>
+ returns<br>
+ 0 - unknown<br>
+ 3 - Dbase level 3<br>
+ 4 - Dbase level 4<br>
+ 5 - Dbase Level 5 (future)<br>
+ 7 - Dbase Level 7 (future)<br>
+<br>
+ 1x - Clipper files (future)<br>
+ 2x - Foxbase files (future)<br>
+<br>
+*/
+
+xbInt16 xbFile::DetermineXbaseTableVersion( unsigned char cFileTypeByte ) const {
+
+ xbInt16 iMemoVersion = DetermineXbaseMemoVersion(cFileTypeByte);
+ char cDbfLevel = cFileTypeByte & 0x07;
+
+ #ifdef XB_DBF4_SUPPORT
+ if( cDbfLevel == 3 && iMemoVersion != 3 )
+ return 4;
+ #endif
+
+ #ifdef XB_DBF3_SUPPORT
+ if( cDbfLevel == 3 && iMemoVersion != 4 )
+ return 3;
+ #endif
+
+ return 0;
+}
+
+/*************************************************************************/
+//! @brief Get a portable double value.
+/*!
+
+ This routine returns a double value from an 8 byte character stream,
+ accounting for endian type.
+
+ Converts a double (64 bit floating point) value stored at p from a portable
+ format to the machine format.
+
+ \param p pointer to memory containing the portable double value
+
+ \returns the double value.
+*/
+
+xbDouble xbFile::eGetDouble( const char *p ) const {
+ xbDouble d;
+ const char *sp;
+ char *tp;
+ xbInt16 i;
+
+ tp = (char *) &d;
+ sp = p;
+ if( iEndianType == 'L' )
+ for( i = 0; i < 8; i++ ) *tp++ = *sp++;
+ else
+ {
+ sp+=7;
+ for( i = 0; i < 8; i++ ) *tp++ = *sp--;
+ }
+
+ return d;
+}
+
+/*************************************************************************/
+//! @brief Get a portable long value.
+
+/*!
+ This routine returns a long int value from a 4 byte character stream,
+ accounting for endian type.
+
+ \param p pointer to memory containing the portable long value
+
+ \returns the long value.
+*/
+
+xbInt32 xbFile::eGetInt32( const char *p ) const {
+ xbInt32 l;
+ char *tp;
+ xbInt16 i;
+
+ tp = (char *) &l;
+ if( iEndianType == 'L' )
+ for( i = 0; i < 4; i++ ) *tp++ = *p++;
+ else {
+ p+=3;
+ for( i = 0; i < 4; i++ ) *tp++ = *p--;
+ }
+ return l;
+
+}
+/*************************************************************************/
+//! @brief Get a portable unsigned long value.
+
+/*!
+ This routine returns an unsigned long int value from a 4 byte character stream,
+ accounting for endian type.
+
+ \param p pointer to memory containing the portable long value
+
+ \returns the unsigned long value.
+*/
+
+xbUInt32 xbFile::eGetUInt32( const char *p ) const {
+ xbUInt32 ul;
+ xbInt16 i;
+ char *tp;
+
+ tp = (char *) &ul;
+ if( iEndianType == 'L' )
+ for( i = 0; i < 4; i++ ) *tp++ = *p++;
+ else{
+ p+=3;
+ for( i = 0; i < 4; i++ ) *tp++ = *p--;
+ }
+ return ul;
+}
+
+/*************************************************************************/
+//! @brief Get a portable short value.
+
+/*!
+ This routine returns a short int value from a 2 byte character stream,
+ accounting for endian type.
+
+ \param p pointer to memory containing the portable long value
+
+ \returns the short value.
+*/
+
+xbInt16 xbFile::eGetInt16(const char *p) const {
+ xbInt16 s, i;
+ char *tp;
+ tp = (char *) &s;
+ if( iEndianType == 'L' )
+ for( i = 0; i < 2; i++ ) *tp++ = *p++;
+ else{
+ p++;
+ for( i = 0; i < 2; i++ ) *tp++ = *p--;
+ }
+ return s;
+}
+/*************************************************************************/
+//! @brief Get a portable unsigned short value.
+
+/*!
+ This routine returns a short unsigned int value from a 2 byte character stream,
+ accounting for endian type.
+
+ \param p pointer to memory containing the portable long value
+
+ \returns the short value.
+*/
+
+xbUInt16 xbFile::eGetUInt16(const char *p) const {
+ xbInt16 i;
+ xbUInt16 uI;
+ char *tp;
+
+ tp = (char *) &uI;
+ if( iEndianType == 'L' )
+ for( i = 0; i < 2; i++ ) *tp++ = *p++;
+ else{
+ p++;
+ for( i = 0; i < 2; i++ ) *tp++ = *p--;
+ }
+ return uI;
+}
+
+
+/*************************************************************************/
+//! @brief Write a portable double value to memory location.
+/*!
+ Converts a double (64 bit floating point) value from machine format to a
+ portable format and stores the converted value in the memory referenced
+ by c.
+
+ This routine puts a double value to an 8 byte character stream
+
+ \param c Pointer to memory to hold converted value
+ \param d Input value to be converted
+*/
+
+void xbFile::ePutDouble( char *c, xbDouble d ){
+ const char *sp;
+ char *tp;
+ xbInt16 i;
+
+ tp = c;
+ sp = (const char *) &d;
+ if( iEndianType == 'L' )
+ for( i = 0; i < 8; i++ ) *tp++ = *sp++;
+ else
+ {
+ sp+=7;
+ for( i = 0; i < 8; i++ ) *tp++ = *sp--;
+ }
+ return;
+}
+
+/*************************************************************************/
+//! @brief Write a portable short value to memory location.
+/*!
+ Converts a short (16 bit integer) value from machine format to a
+ portable format and stores the converted value in the memory referenced
+ by c.
+
+ This routine puts a short value to a 2 byte character stream
+
+ \param c Pointer to memory to hold converted value
+ \param s Input value to be converted
+*/
+
+void xbFile::ePutInt16( char * c, xbInt16 s ){
+ const char *sp;
+ char *tp;
+ xbInt16 i;
+
+ tp = c;
+ sp = (const char *) &s;
+
+ if( iEndianType == 'L' )
+ for( i = 0; i < 2; i++ ) *tp++ = *sp++;
+ else{ /* big endian */
+ sp++;
+ for( i = 0; i < 2; i++ ) *tp++ = *sp--;
+ }
+ return;
+}
+/*************************************************************************/
+//! @brief Write a portable unsigned short value to memory location.
+/*!
+ Converts an unsigned short (16 bit integer) value from machine format to a
+ portable format and stores the converted value in the memory referenced
+ by c.
+
+ This routine puts an unsigned short value to a 2 byte character stream
+
+ \param c Pointer to memory to hold converted value
+ \param s Input value to be converted
+*/
+
+void xbFile::ePutUInt16( char * c, xbUInt16 s ){
+ const char *sp;
+ char *tp;
+ xbInt16 i;
+
+ tp = c;
+ sp = (const char *) &s;
+
+ if( iEndianType == 'L' )
+ for( i = 0; i < 2; i++ ) *tp++ = *sp++;
+ else{ /* big endian */
+ sp++;
+ for( i = 0; i < 2; i++ ) *tp++ = *sp--;
+ }
+ return;
+}
+
+/*************************************************************************/
+//! @brief Write a portable long value to memory location.
+/*!
+ Converts a long (32 bit integer) value from machine format to a
+ portable format and stores the converted value in the memory referenced
+ by c.
+
+ This routine puts a long value to a 4 byte character stream.
+
+ \param c Pointer to memory to hold converted value
+ \param l Input value to be converted
+*/
+
+void xbFile::ePutInt32( char * c, xbInt32 l )
+{
+ const char *sp;
+ char *tp;
+ xbInt16 i;
+
+ tp = c;
+ sp = (const char *) &l;
+ if( iEndianType == 'L' )
+ for( i = 0; i < 4; i++ ) *tp++ = *sp++;
+ else {
+ sp+=3;
+ for( i = 0; i < 4; i++ ) *tp++ = *sp--;
+ }
+ return;
+}
+
+
+/*************************************************************************/
+//! @brief Write a portable unsigned long value to memory location.
+/*!
+ Converts an unsigned long (32 bit integer) value from machine format to a
+ portable format and stores the converted value in the memory referenced
+ by c.
+
+ This routine puts an unsigned long value to a 4 byte character stream.
+
+ \param c Pointer to memory to hold converted value
+ \param ul Input value to be converted
+*/
+
+void xbFile::ePutUInt32( char * c, xbUInt32 ul )
+{
+ const char *sp;
+ char *tp;
+ xbInt16 i;
+
+ tp = c;
+ sp = (const char *) &ul;
+ if( iEndianType == 'L' )
+ for( i = 0; i < 4; i++ ) *tp++ = *sp++;
+ else
+ {
+ sp+=3;
+ for( i = 0; i < 4; i++ ) *tp++ = *sp--;
+ }
+ return;
+}
+
+/************************************************************************/
+//! @brief Determines if a file exists.
+/*!
+ \returns xbTrue if file exists<br>
+ xbFalse if file does not exist
+
+*/
+xbBool xbFile::FileExists() const {
+ return FileExists( sFqFileName, 0 );
+}
+/************************************************************************/
+//! @brief Determines if a file exists.
+/*!
+ \param iOption if 1, assume this is a request for a dbf file and
+ check for the a dbt memo file also, returns true if both files are found
+
+ \returns xbTrue if both files exist<br>
+ xbFalse if file does not exist
+
+*/
+xbBool xbFile::FileExists( xbInt16 iOption ) const {
+ return FileExists( sFqFileName, iOption );
+}
+
+/************************************************************************/
+//! @brief Determines if a file exists.
+/*!
+ \param sFileName - file name to check for
+
+ \returns xbTrue if file exists<br>
+ xbFalse if file does not exist
+*/
+
+xbBool xbFile::FileExists(const xbString &sFileName ) const {
+ return FileExists( sFileName, 0 );
+}
+
+/************************************************************************/
+//! @brief Determines if a file exists.
+/*!
+ \param sFileName - file name to check for
+ \param iOption if 1, assume this is a request for a dbf file and
+ check for the a dbt memo file also, returns true if both files are found
+
+ \returns xbTrue if both dbf and dbt files exist<br>
+ xbFalse if file does not exist
+*/
+
+xbBool xbFile::FileExists( const xbString & sFileName, xbInt16 iOption ) const {
+
+ struct stat buffer;
+ if(( stat( sFileName.Str(), &buffer ) != 0 )){
+ return xbFalse;
+ }
+
+ #ifdef XB_MEMO_SUPPORT
+ if( iOption == 1 ){
+ xbString sFileName2 = sFileName;
+
+ if( sFileName2[sFileName2.Len()] == 'F' )
+ sFileName2.PutAt( sFileName2.Len(), 'T' );
+ else
+ sFileName2.PutAt( sFileName2.Len(), 't' );
+
+ if(( stat( sFileName2.Str(), &buffer) != 0 ))
+ return xbFalse;
+ }
+ #endif
+ return xbTrue;
+}
+
+/************************************************************************/
+//! @brief Determines if file is open.
+/*!
+
+ \returns xbTrue if file is open<br>
+ xbFalse if file is not open
+*/
+
+xbBool xbFile::FileIsOpen() const {
+ return bFileOpen;
+}
+/************************************************************************/
+//! @brief Get the block size.
+/*!
+ \returns Block Size
+*/
+
+xbUInt32 xbFile::GetBlockSize() const {
+ return ulBlockSize;
+}
+
+/************************************************************************/
+//! @brief Get the directory name.
+/*!
+ \returns the directory name of the file
+*/
+
+const xbString & xbFile::GetDirectory() const {
+ return sDirectory;
+}
+
+/************************************************************************/
+//! @brief Get the directory part of the file name.
+/*!
+ \param sFileDirPartOut - the returned directory name
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+
+xbInt16 xbFile::GetFileDirPart( xbString & sFileDirPartOut ) const {
+ return GetFileDirPart( sFqFileName, sFileDirPartOut );
+}
+
+/************************************************************************/
+//! @brief Get the directory part of the file name.
+/*!
+ \param sCompleteFileNameIn - a fully qualfied input file name
+ \param sFileDirPartOut - the returned directory name part out of sCompleteFileNameIn
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+
+xbInt16 xbFile::GetFileDirPart( const xbString & sCompleteFileNameIn, xbString & sFileDirPartOut ) const {
+
+ sFileDirPartOut = sCompleteFileNameIn;
+ sFileDirPartOut.SwapChars( '\\', '/' );
+ xbUInt32 iPos = sFileDirPartOut.GetLastPos( '/' );
+
+ if( iPos > 0 ){
+ xbString sTemp = sFileDirPartOut;
+ sFileDirPartOut.Assign( sTemp, 1, iPos );
+ return XB_NO_ERROR;
+ }
+ return XB_INVALID_DATA;
+}
+
+/************************************************************************/
+//! @brief Get the extension part of the file name.
+/*!
+ \param sFileNameExtOut - the returned extension part out of sCompleteFileNameIn
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbFile::GetFileExtPart( xbString & sFileNameExtOut ) const {
+ return GetFileExtPart( sFqFileName, sFileNameExtOut );
+}
+
+/************************************************************************/
+//! @brief Get the extension part of the file name.
+/*!
+ \param sCompleteFileNameIn - a fully qualfied input file name
+
+ \param sFileExtPartOut - the returned directory name part out of sCompleteFileNameIn
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+
+xbInt16 xbFile::GetFileExtPart( const xbString & sCompleteFileNameIn, xbString & sFileExtPartOut ) const {
+
+
+ sFileExtPartOut = sCompleteFileNameIn;
+ xbUInt32 iPos = sFileExtPartOut.GetLastPos( '.' );
+ if( iPos > 0 ){ /* get rid of the directory part of the name */
+ sFileExtPartOut.Ltrunc( iPos );
+ return XB_NO_ERROR;
+ }
+ return XB_INVALID_DATA;
+}
+/************************************************************************/
+//! @brief Get the time of last file modification timestamp as reported by the OS.
+/*!
+ \param mtime - returned time of last file modification
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::GetFileMtime( time_t &mtime ){
+
+ struct stat buffer;
+ if( stat( sFqFileName.Str(), &buffer ))
+ return XB_FILE_NOT_FOUND;
+ else{
+ mtime = buffer.st_mtime;
+ return XB_NO_ERROR;
+ }
+}
+/************************************************************************/
+//! @brief Get the file name.
+/*!
+ \returns the file name portion of the file
+*/
+
+const xbString & xbFile::GetFileName() const {
+ return sFileName;
+}
+
+
+/************************************************************************/
+//! @brief Get the name part of the file name.
+/*!
+ \param sFileNamePartOut - the returned file name part out of sCompleteFileNameIn
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+
+xbInt16 xbFile::GetFileNamePart( xbString & sFileNamePartOut ) const {
+ return GetFileNamePart( sFqFileName, sFileNamePartOut );
+}
+
+/************************************************************************/
+//! @brief Get the name part of the file name.
+/*!
+ \param sCompleteFileNameIn - a fully qualified input file name
+ \param sFileNamePartOut - the returned file name part out of sCompleteFileNameIn
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+//*********** fixme should this be static?????
+
+xbInt16 xbFile::GetFileNamePart( const xbString & sCompleteFileNameIn, xbString & sFileNamePartOut ) const {
+ /* extract the file name part out of the string */
+
+ sFileNamePartOut = sCompleteFileNameIn;
+ sFileNamePartOut.SwapChars( '\\', '/' );
+ xbUInt32 iPos = sFileNamePartOut.GetLastPos( '/' );
+ if( iPos > 0 ) /* get rid of the directory part of the name */
+ sFileNamePartOut.Ltrunc( iPos );
+ iPos = sFileNamePartOut.Pos( '.' );
+ if( iPos > 0 ){ /* get rid of the extension part of the name */
+ xbString sTemp = sFileNamePartOut;
+ sFileNamePartOut.Assign( sTemp, 1, iPos-1 );
+ }
+ return XB_NO_ERROR;
+}
+
+
+/************************************************************************/
+//! @brief Get the size of the file as reported by the OS.
+/*!
+ \param ullFileSize - unsigned long long field as output
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::GetFileSize( xbUInt64 &ullFileSize ){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ try{
+
+ if(( iRc = xbFseek( 0, SEEK_END )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ ullFileSize = xbFtell();
+ }
+
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbFile::GetFileSize() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/************************************************************************/
+//! @brief Get the file type aka Capitalized file extension
+/*!
+ \param sFileTypeOut - the returned extension part out of sCompleteFileNameIn
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbFile::GetFileType( xbString & sFileTypeOut ) const {
+
+ xbInt16 iRc = GetFileExtPart( sFqFileName, sFileTypeOut );
+ sFileTypeOut.ToUpperCase();
+ return iRc;
+}
+/************************************************************************/
+//! @brief Get the fully qualified file name.
+/*!
+ \returns the fully qualfied name of the file
+*/
+
+const xbString & xbFile::GetFqFileName() const {
+ return sFqFileName;
+}
+
+/************************************************************************/
+//! @brief Get the open mode of the file.
+/*!
+ \returns XB_READ<br>
+ XB_READ_WRITE<br>
+ XB_WRITE<BR>
+*/
+
+xbInt16 xbFile::GetOpenMode() const {
+ return iOpenMode;
+}
+
+/************************************************************************/
+//! @brief Get the share mode of the file.
+/*!
+ \returns XB_SINGLE_USER - (file buffering on><br>
+ XB_MULTI_USER - (file buffering off)<br>
+*/
+
+
+xbInt16 xbFile::GetShareMode() const {
+ return iShareMode;
+}
+
+
+/************************************************************************/
+//! @brief Get the file type byte and version of the dbf file.
+/*!
+
+ Pull the first bye off the DBF file for further inspection.
+ First byte has various bits set to determine what the file format is.
+
+ \param sFileName - Name of file to examine
+ \param iVersion - Returned file version
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::GetXbaseFileTypeByte( const xbString &sFileName, xbInt16 &iVersion )
+{
+ unsigned char cFileTypeByte;
+ return GetXbaseFileTypeByte( sFileName, cFileTypeByte, iVersion );
+}
+
+/************************************************************************/
+//! @brief Get the file type byte and version of the dbf file.
+/*!
+ Pull the first bye off the DBF file for further inspection.
+ First byte has various bits set to determine what the file format is.
+
+ \param sFileName - Name of file to examine
+ \param cFileTypeByte - Retruned first byte of dbf file
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+
+xbInt16 xbFile::GetXbaseFileTypeByte( const xbString &sFileName, unsigned char &cFileTypeByte )
+{
+ xbInt16 iVersion;
+ return GetXbaseFileTypeByte( sFileName, cFileTypeByte, iVersion );
+}
+
+/************************************************************************/
+//! @brief Get the file type byte and version of the dbf file.
+/*!
+ Pull the first bye off the DBF file for further inspection.
+ First byte has various bits set to determine what the file format is.
+
+
+ \param sFileName - Name of file to examine
+ \param cFileTypeByte - Returned first byte of dbf file
+ \param iVersion - Returned file version
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::GetXbaseFileTypeByte( const xbString &sFileName, unsigned char &cFileTypeByte, xbInt16 &iVersion ){
+ xbInt16 iErrorStop = 0;
+ xbInt16 iRc = XB_NO_ERROR;
+ size_t stRc;
+ FILE *tfp;
+
+ try{
+
+ iVersion = 0;
+ cFileTypeByte = 0x00;
+ #ifdef HAVE__FSOPEN_F
+ // 0x40 is SH_DENYNO or _SH_DENYNO
+ if(( tfp = _fsopen( sFileName.Str(), "r", 0x40 )) == NULL ){
+ iErrorStop = 20;
+ iRc = XB_OPEN_ERROR;
+ throw iRc;
+ }
+ #else
+ if(( tfp = fopen( sFileName.Str(), "r" )) == NULL ){
+ iErrorStop = 20;
+ iRc = XB_OPEN_ERROR;
+ throw iRc;
+ }
+ #endif
+
+ #ifdef HAVE_FSEEKO_F
+ iRc = fseeko( tfp, 0, SEEK_SET );
+ #else
+ iRc = fseek( tfp, 0, SEEK_SET );
+ #endif
+
+ if( iRc != 0 ){
+ iErrorStop = 30;
+ iRc = XB_SEEK_ERROR;
+ throw iRc;
+ }
+ stRc = fread( &cFileTypeByte, (size_t) 1, (size_t) 1, tfp );
+ if( stRc != (size_t) 1 ){
+ iErrorStop = 40;
+ iRc = XB_READ_ERROR;
+ throw iRc;
+ }
+ iRc = XB_NO_ERROR;
+ fclose( tfp );
+ iVersion = DetermineXbaseTableVersion( cFileTypeByte );
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbFile::GetXbaseFileType() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/************************************************************************/
+//! @brief Determines status of file extension.
+/*!
+
+ \param sFileName - Name of file to examine
+ \param iOption - Inspection type<br>
+ 1 check for DBF<br>
+ 2 check for NDX<br>
+ 3 check for MDX<br>
+ 4 check for NTX<br>
+
+ \returns 0 if suffix found<br>
+ 1 if suffix not found, lower case<br>
+ 2 is suffix not found, upper case<br>
+
+*/
+
+xbInt16 xbFile::NameSuffixMissing( const xbString & sFileName, xbInt16 iOption ) const {
+
+ xbUInt32 ulLen = sFileName.Len();
+ if( ulLen <= 4 ){
+ if( sFileName[ulLen] >= 'A' && sFileName[ulLen] <= 'Z' )
+ return 2;
+ else
+ return 1;
+ }
+ if( iOption == 1 && sFileName[ulLen-3] == '.' &&
+ ( sFileName[ulLen-2] == 'd' || sFileName[ulLen-2] == 'D' ) &&
+ ( sFileName[ulLen-1] == 'b' || sFileName[ulLen-1] == 'B' ) &&
+ ( sFileName[ulLen] == 'f' || sFileName[ulLen] == 'F' )
+ )
+ return 0;
+ if( iOption == 2 && sFileName[ulLen-3] == '.' &&
+ ( sFileName[ulLen-2] == 'n' || sFileName[ulLen-2] == 'N' ) &&
+ ( sFileName[ulLen-1] == 'd' || sFileName[ulLen-1] == 'D' ) &&
+ ( sFileName[ulLen] == 'x' || sFileName[ulLen] == 'X' )
+ )
+ return 0;
+ if( iOption == 3 && sFileName[ulLen-3] == '.' &&
+ ( sFileName[ulLen-2] == 'm' || sFileName[ulLen-2] == 'M' ) &&
+ ( sFileName[ulLen-1] == 'd' || sFileName[ulLen-1] == 'D' ) &&
+ ( sFileName[ulLen] == 'x' || sFileName[ulLen] == 'X' )
+ )
+ return 0;
+ if( iOption == 4 && sFileName[ulLen-3] == '.' &&
+ ( sFileName[ulLen-2] == 'n' || sFileName[ulLen-2] == 'N' ) &&
+ ( sFileName[ulLen-1] == 't' || sFileName[ulLen-1] == 'T' ) &&
+ ( sFileName[ulLen] == 'x' || sFileName[ulLen] == 'X' )
+ )
+ return 0;
+ // next line might be problematic if file naem has mixed case and extension is missing
+ if( sFileName[ulLen-4] >= 'A' && sFileName[ulLen-4] <= 'Z' )
+ return 2;
+ else
+ return 1;
+}
+
+/***********************************************************************/
+//! @brief Read a block of data from file.
+/*!
+
+ \param ulBlockNo - block number to read
+ \param lReadSize - size of data to read at block location, set to 0 to read blocksize
+ \param *buf - pointer to buffer to write output data, assumed to be previosuly allocated
+ and large enough to contain data
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+
+xbInt16 xbFile::ReadBlock( xbUInt32 ulBlockNo, size_t lReadSize, void * buf ){
+ return ReadBlock( ulBlockNo, ulBlockSize, lReadSize, buf );
+}
+
+
+/***********************************************************************/
+//! @brief Read a block of data from file.
+/*!
+
+ \param ulBlockNo - block number to read
+ \param ulBlockSize - block size
+ \param lReadSize - size of data to read at block location, set to 0 to read blocksize
+ \param buf - pointer to buffer to write output data, assumed to be previosuly allocated
+ and large enough to contain data
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+xbInt16 xbFile::ReadBlock( xbUInt32 ulBlockNo, xbUInt32 ulBlockSize, size_t lReadSize, void * buf ){
+
+ xbInt16 iErrorStop = 0;
+ xbInt16 iRc = XB_NO_ERROR;
+
+ try{
+ if( ulBlockSize <= 0 ){
+ iErrorStop = 10;
+ iRc = XB_INVALID_BLOCK_SIZE;
+ throw iRc;
+ }
+
+ if(( iRc = xbFseek(((xbInt64) ulBlockNo*ulBlockSize ), SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ iRc = XB_SEEK_ERROR;
+ throw iRc;
+ }
+
+ if( lReadSize <= 0 )
+ lReadSize = ulBlockSize;
+
+ if(( iRc = xbFread( buf, lReadSize, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ iRc = XB_READ_ERROR;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbFile::ReadBlock() Exception Caught. Error Stop = [%d] iRc = [%d] BlkNo=[%ld] BlkSize=[%ld] ReadSize=[%ld]", iErrorStop, iRc, ulBlockNo, ulBlockSize, lReadSize );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/************************************************************************/
+//! @brief Set the block size.
+/*!
+
+ \param ulBlockSize - unsigned long block size, divisible by 512
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::SetBlockSize( xbUInt32 ulBlockSize ){
+ if( ulBlockSize %512 != 0 )
+ return XB_INVALID_BLOCK_SIZE;
+
+ this->ulBlockSize = ulBlockSize;
+ return XB_NO_ERROR;
+}
+/************************************************************************/
+//! @brief Set the directory.
+/*!
+ \param sDirectory - Valid directory name
+*/
+
+
+void xbFile::SetDirectory( const xbString & sDirectory ){
+
+ this->sDirectory = sDirectory;
+ char cLastChar = sDirectory[sDirectory.Len()];
+ if( cLastChar != '/' && cLastChar != '\\' )
+ sFqFileName.Sprintf( "%s/%s", sDirectory.Str(), sFileName.Str());
+ else
+ sFqFileName.Sprintf( "%s%s", sDirectory.Str(), sFileName.Str());
+
+ #ifdef WIN32
+ sFqFileName.SwapChars( '/', '\\' );
+ #else
+ sFqFileName.SwapChars( '\\', '/' );
+ #endif
+}
+
+/************************************************************************/
+//! @brief Set the filename.
+/*!
+ This routine builds out two internal variables from the input file name<br>
+ sFileName - the file name part<br>
+ sFqFileName - the fully qualified file name<br>
+
+
+ \param sFileName - Input file name
+*/
+void xbFile::SetFileName( const xbString & sFileName ){
+
+ if( sFileName == "" ){
+ sFqFileName = "";
+ return;
+ }
+
+ char cPathSep = sFileName.GetPathSeparator();
+
+ if( cPathSep ){
+
+ xbString sName;
+ xbString sExt;
+ // GetFileDirPart( this->sDirectory );
+ GetFileNamePart( sFileName, sName );
+ GetFileExtPart( sFileName, sExt );
+ this->sFileName.Sprintf( "%s.%s", sName.Str(), sExt.Str());
+ sFqFileName = sFileName;
+
+ } else {
+
+ this->sFileName = sFileName;
+ if( sDirectory.Len() == 0 ){
+ sDirectory = GetDataDirectory();
+ char cLastChar = sDirectory[sDirectory.Len()];
+ if( cLastChar != '/' && cLastChar != '\\' )
+ sFqFileName.Sprintf( "%s/%s", sDirectory.Str(), sFileName.Str() );
+ else
+ sFqFileName = sDirectory + sFileName;
+ }
+ else{
+ char cLastChar = sDirectory[sDirectory.Len()];
+ if( cLastChar != '/' && cLastChar != '\\' )
+ sFqFileName.Sprintf( "%s/%s", sDirectory.Str(), sFileName.Str() );
+ else
+ sFqFileName = sDirectory + sFileName;
+ }
+ }
+
+ #ifdef WIN32
+ sFqFileName.SwapChars( '/', '\\' );
+ #else
+ sFqFileName.SwapChars( '\\', '/' );
+ #endif
+}
+
+/************************************************************************/
+//! @brief Set the fully qualifed filename.
+/*!
+ \param sFqFileName - Fully qualifed input file name
+*/
+
+void xbFile::SetFqFileName( const xbString & sFqFileName ){
+ this->sFqFileName = sFqFileName;
+
+ xbString sDir;
+ xbString sName;
+ xbString sExt;
+
+ GetFileDirPart ( sFqFileName, sDir );
+ GetFileNamePart( sFqFileName, sName );
+ GetFileExtPart ( sFqFileName, sExt );
+
+ sDirectory = sDir;
+ sFileName.Sprintf( "%s.%s", sName.Str(), sExt.Str() );
+
+ #ifdef WIN32
+ this->sDirectory.SwapChars ( '/', '\\' );
+ this->sFqFileName.SwapChars( '/', '\\' );
+ #else
+ this->sDirectory.SwapChars ( '\\', '/' );
+ this->sFqFileName.SwapChars( '\\', '/' );
+ #endif
+}
+
+/************************************************************************/
+//! @brief Write a block of data to file.
+/*!
+
+ \param ulBlockNo - block number to write
+ \param lWriteSize - size of data to write, set to 0 to write blocksize
+ \param *buf - pointer to buffer of data to be written
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+xbInt16 xbFile::WriteBlock( xbUInt32 ulBlockNo, size_t lWriteSize, void * buf ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+
+ if( ulBlockSize == 0 ){
+ iErrorStop = 10;
+ iRc = XB_INVALID_BLOCK_SIZE;
+ throw iRc;
+ }
+ if( lWriteSize <= 0 )
+ lWriteSize = ulBlockSize;
+ if(( iRc = xbFseek(( (xbInt64) ulBlockNo*ulBlockSize), SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ if(( iRc = xbFwrite( buf, lWriteSize, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbFile::WriteBlock() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/************************************************************************/
+//! @brief Xbase wrapper for standard libary fclose.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::xbFclose(){
+
+ int iRc = 0;
+ if( bFileOpen ){
+ iRc = fclose( fp );
+ if( iRc != 0 ){
+ return XB_CLOSE_ERROR;
+ }
+ else{
+ bFileOpen = xbFalse;
+ }
+ iFileNo = 0;
+ }
+ return XB_NO_ERROR;
+}
+
+
+
+/************************************************************************/
+//! @brief Xbase wrapper for standard libary feof.
+/*!
+ \returns non zero if end-of-file is set for the stream.
+*/
+xbInt16 xbFile::xbFeof(){
+ return feof( fp );
+}
+
+/************************************************************************/
+//! @brief Xbase wrapper for standard libary fflush.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::xbFflush() {
+
+ if( fflush( fp ) )
+ return XB_WRITE_ERROR;
+ else
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+//! @brief Xbase wrapper for standard libary fgetc.
+/*!
+ \param c - output integer returned by fgetc
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::xbFgetc( xbInt32 &c ) {
+
+ int i;
+
+ i = fgetc( fp );
+ if( i == EOF )
+ return XB_EOF;
+
+ c = i;
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+//! @brief Xbase wrapper for standard libary fgetc.
+/*!
+ \param c - output character returned by fgetc
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::xbFgetc( char &c ) {
+
+ int i;
+ i = fgetc( fp );
+ if( i == EOF )
+ return XB_EOF;
+
+ c = (char) i;
+ return XB_NO_ERROR;
+}
+/************************************************************************/
+//! @brief Xbase wrapper for standard libary fgets.
+/*!
+ \param lSize - reads in at most, one character less than lSize
+ \param s - an xbString containing data returned by fseek
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::xbFgets( size_t lSize, xbString &s ) {
+
+ s = "";
+ if( feof( fp ))
+ return XB_EOF;
+
+ char *sBuf = (char *) malloc( lSize + 1 );
+
+ if( fgets( sBuf, (xbInt32) lSize, fp ) == NULL ){
+ free( sBuf );
+ return XB_EOF;
+ }
+ s.Set( sBuf );
+ free( sBuf );
+ return XB_NO_ERROR;
+}
+/************************************************************************/
+//! @brief Xbase wrapper for standard libary fopen.
+/*!
+
+ This routine supports all the standard C library open modes. The Xbase routines only
+ use "r" and "r+b".
+
+ \param sOpenMode
+ <table>
+ <tr><th>OpenMode<th>Description
+ <tr><td>r<td>Reading
+ <tr><td>r+<td>Reading and Writing
+ <tr><td>w<td>Open for writing. Truncate to zero bytes if it exists
+ <tr><td>w+<td>Open for reading and writing, truncate to zero bytes if it exists
+ <tr><td>a<td>Open for append
+ <tr><td>a+<td>Open for reading and writing (at end).
+ </table>
+ The mode can also include the letter "b" for binary ie; "r+b". The "b" is ignored on
+ POSIX compliant systems, but is included for cross platform compatibility.
+ \param sFileName File name to open
+ \param iShareMode
+ XB_SINGLE_USER<br>
+ XB_MULTI_USER<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::xbFopen( const xbString &sOpenMode, const xbString &sFileName, xbInt16 iShareMode ) {
+ if( sFileName == "" || sFqFileName == "" )
+ SetFileName( sFileName );
+ return xbFopen( sOpenMode, iShareMode );
+}
+
+/************************************************************************/
+//! @brief Xbase wrapper for standard libary fopen.
+/*!
+
+ This routine supports all the standard C library open modes. The Xbase routines only
+ use "r" and "r+".
+
+
+ \param sOpenMode
+ <table>
+ <tr><th>OpenMode<th>Description
+ <tr><td>r<td>Reading
+ <tr><td>r+<td>Reading and Writing
+ <tr><td>w<td>Open for writing. Truncate to zero bytes if it exists
+ <tr><td>w+<td>Open for reading and writing, truncate to zero bytes if it exists
+ <tr><td>a<td>Open for append
+ <tr><td>a+<td>Open for reading and writing (at end).
+ </table>
+ The mode can also include the letter "b" for binary ie; "r+b". The "b" is ignored on
+ POSIX compliant systems, but is included for cross platform compatibility.
+ \param iShareMode
+ XB_SINGLE_USER<br>
+ XB_MULTI_USER<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::xbFopen( const xbString & sOpenMode, xbInt16 iShareMode ) {
+
+ #ifdef HAVE__FSOPEN_F
+ if(( fp = _fsopen( sFqFileName.Str(), sOpenMode.Str(), 0x40 )) != NULL ){
+ #else
+ if(( fp = fopen( sFqFileName.Str(), sOpenMode.Str())) != NULL ){
+ #endif
+
+ if( sOpenMode == "r" )
+ iOpenMode = XB_READ;
+ else if( sOpenMode == "w" )
+ iOpenMode = XB_WRITE;
+ else
+ iOpenMode = XB_READ_WRITE;
+
+ bFileOpen = xbTrue;
+ this->iShareMode = iShareMode;
+
+ #ifdef HAVE__FILENO_F
+ iFileNo = _fileno( fp );
+ #else
+ iFileNo = fileno( fp );
+ #endif
+
+ #ifdef HAVE_SETENDOFFILE_F
+ //used by visual studio, 32 bit
+ fHandle = (HANDLE) _get_osfhandle( iFileNo );
+ #endif
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( iShareMode )
+ xbFTurnOffFileBuffering();
+ #endif
+
+ return XB_NO_ERROR;
+ }
+ else
+ return XB_OPEN_ERROR;
+}
+/************************************************************************/
+//! @brief Xbase wrapper for standard libary fopen.
+/*!
+ \param iOpenMode
+ XB_READ<br>
+ XB_READ_WRITE<br>
+ \param iShareMode
+ XB_SINGLE_USER<br>
+ XB_MULTI_USER<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::xbFopen( xbInt16 iOpenMode, xbInt16 iShareMode ) {
+ this->iOpenMode = iOpenMode;
+ if( iOpenMode == XB_READ_WRITE )
+ return xbFopen( "r+b", iShareMode );
+ else if( iOpenMode == XB_READ )
+ return xbFopen( "r", iShareMode );
+ else
+ return XB_INVALID_OPTION;
+}
+
+/************************************************************************/
+//! @brief Xbase wrapper for standard libary fputc.
+/*!
+ \param c Character to write
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+
+xbInt16 xbFile::xbFputc( xbInt32 c ) {
+ return xbFputc( c, 1 );
+}
+
+/************************************************************************/
+//! @brief Xbase wrapper for standard libary fputc.
+/*!
+ \param c Character to write
+ \param iNoOfTimes Number of times to write the character
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+
+xbInt16 xbFile::xbFputc( xbInt32 c, xbInt32 iNoOfTimes ) {
+
+ for( xbInt32 l = 0; l < iNoOfTimes; l++ )
+ if( fputc( c, fp ) != (int) c )
+ return XB_WRITE_ERROR;
+
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+//! @brief Xbase wrapper for standard libary fputs.
+/*!
+ \param s xbString to write to file
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::xbFputs( const xbString & s ){
+ if( fputs( s.Str(), fp ) < 0 )
+ return XB_WRITE_ERROR;
+ else
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+//! @brief Xbase wrapper for standard libary fread.
+/*!
+ \param p Pointer to data to write
+ \param size size of write
+ \param nmemb Number of times to write it
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::xbFread( void *p, size_t size, size_t nmemb ) {
+
+ size_t iRc;
+ iRc = fread( p, size, nmemb, fp );
+ if( iRc == nmemb )
+ return XB_NO_ERROR;
+ else
+ return XB_READ_ERROR;
+}
+
+/************************************************************************/
+//! @brief Xbase wrapper for standard libary fseek.
+/*!
+ \param lOffset Position in file to seek to
+ \param iWhence SEEK_SET - from beginning of file<br>
+ SEEK_CUR - from current position<br>
+ SEEK_END - from end of file<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::xbFseek( xbInt64 lOffset, xbInt32 iWhence ) {
+
+ xbInt32 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try {
+
+ #if defined(HAVE_FSEEKO_F)
+ iRc = fseeko( fp, lOffset, iWhence );
+ if( iRc != 0 ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+ #elif defined(HAVE__FSEEKI64_F)
+ iRc = _fseeki64( fp, lOffset, iWhence );
+ if( iRc != 0 ){
+ iErrorStop = 200;
+ throw iRc;
+ }
+ #else
+ #ifdef XB_PLATFORM_32
+ /* if request is larger than 2 gig,this is a part of a locking request,
+ assuming offset is less than 4 gig, split the request into 2 fseek calls */
+ if( lOffset > 2147483647 && iWhence == SEEK_SET ){
+ /* move forward max amt - 2G */
+ if(( iRc = fseek( fp, 2147483647, SEEK_SET )) != 0 ){
+ iErrorStop = 300;
+ throw iRc;
+ }
+ lOffset -= 2147483647;
+ iWhence = SEEK_CUR;
+ }
+ #endif
+ iRc = fseek( fp, (long) lOffset, iWhence );
+ if( iRc != 0 ){
+ iErrorStop = 310;
+ throw iRc;
+ }
+ #endif
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbFile::xbFseek() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ iRc = XB_SEEK_ERROR;
+ }
+ return iRc;
+}
+
+/************************************************************************/
+//! @brief Xbase wrapper for standard libary ftell.
+/*!
+ Returns the current file position.
+ \returns Current file position.
+*/
+
+size_t xbFile::xbFtell() {
+ return (size_t) ftell( fp );
+}
+
+/************************************************************************/
+//! @brief Turn off file buffering.
+/*!
+ Turns off file buffering. File buffering can't be used while in multi user mode.
+
+*/
+
+void xbFile::xbFTurnOffFileBuffering() {
+ setvbuf( fp, NULL, _IONBF, 0 );
+}
+
+/************************************************************************/
+//! @brief Xbase wrapper for standard libary fwrite.
+/*!
+ \param p Pointer to data buffer to write
+ \param size Size of data to write
+ \param nmemb Number of times to write data buffer
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbFile::xbFwrite( const void *p, size_t size, size_t nmemb ) {
+
+ size_t iRc;
+ iRc = fwrite( p, size, nmemb, fp );
+ if( iRc == nmemb )
+ return XB_NO_ERROR;
+ else
+ return XB_READ_ERROR;
+}
+
+/************************************************************************/
+//! @brief Read file until a particular character is encountered on input stream.
+/*!
+ This routine will read until cDelim is encountered or eof, which ever occurs first.
+
+ \param cDelim Delimiter to stop writing at.
+ \param sOut Output xbString containing data read
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::xbReadUntil( const char cDelim, xbString &sOut ){
+
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ char c;
+
+ try{
+ sOut = "";
+ if(( iRc = xbFgetc( c )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ sOut = c;
+ while( iRc == XB_NO_ERROR && c != cDelim ){
+ if(( iRc = xbFgetc( c )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ sOut += c;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbFile::xbReadUntil() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/************************************************************************/
+//! @brief Delete file.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbFile::xbRemove() {
+ return xbRemove( sFqFileName.Str(), 0 );
+}
+
+/************************************************************************/
+//! @brief Delete file.
+/*!
+ \param sFileNameIn Name of file to delete
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::xbRemove( const xbString & sFileNameIn ) {
+ return xbRemove( sFileNameIn, 0 );
+}
+
+
+/************************************************************************/
+//! @brief Delete file.
+/*!
+ \param sFileNameIn Name of file to delete
+ \param iOption If Set to 1, assume this is a delete request for a dbf file, and should rename the dbt file also
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbFile::xbRemove( const xbString & sFileNameIn, xbInt16 iOption ) {
+
+ xbInt32 iRc = remove( sFileNameIn.Str());
+ if( iRc != 0 )
+ return XB_DELETE_FAILED;
+
+ if( iOption == 1 ){
+ xbString sFileName2 = sFileNameIn;
+
+ if( sFileName2[sFileName2.Len()] == 'F' )
+ sFileName2.PutAt( sFileName2.Len(), 'T' );
+ else
+ sFileName2.PutAt( sFileName2.Len(), 't' );
+
+ iRc = remove( sFileName2.Str());
+ if( iRc != 0 )
+ return XB_DELETE_FAILED;
+ }
+
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+//! @brief Rename file.
+/*!
+ \param sOldName Original file name
+ \param sNewName New file name
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbFile::xbRename( const xbString & sOldName, const xbString & sNewName ){
+ return xbRename( sOldName, sNewName, 0 );
+}
+
+/************************************************************************/
+//! @brief Rename file.
+/*!
+ \param sOldName Original file name
+ \param sNewName New file name
+ \param iOption If Set to 1, assume this is a rename request for a dbf file, and should rename the dbt file also
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbFile::xbRename( const xbString & sOldName, const xbString & sNewName, xbInt16 iOption ){
+
+
+ if( rename( sOldName.Str(), sNewName.Str())){
+ return XB_RENAME_ERROR;
+ }
+ if( iOption == 1 ){
+ xbString sOldName2 = sOldName;
+ xbString sNewName2 = sNewName;
+
+ if( sOldName2[sOldName2.Len()] == 'F' )
+ sOldName2.PutAt( sOldName2.Len(), 'T' );
+ else
+ sOldName2.PutAt( sOldName2.Len(), 't' );
+
+ if( sNewName2[sNewName2.Len()] == 'F' )
+ sNewName2.PutAt( sNewName2.Len(), 'T' );
+ else
+ sNewName2.PutAt( sNewName2.Len(), 't' );
+
+ if( rename( sOldName2.Str(), sNewName2.Str()))
+ return XB_RENAME_ERROR;
+ }
+ return XB_NO_ERROR;
+}
+
+
+/************************************************************************/
+//! @brief Xbase wrapper for rewind.
+/*!
+ Set file pointer at beginning of file.
+*/
+
+void xbFile::xbRewind() {
+ rewind( fp );
+}
+
+/************************************************************************/
+//! @brief Xbase wrapper for ftruncate.
+/*!
+ Set file size to llSize
+ \param llSize New file size.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbFile::xbTruncate( xbInt64 llSize ) {
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ try{
+ #ifdef HAVE_FTRUNCATE_F
+ if(( iRc = ftruncate( iFileNo, llSize )) != 0 ){
+ iErrorStop = 10;
+ iRc = XB_WRITE_ERROR;
+ throw iRc;
+ }
+ #elif defined(HAVE_SETENDOFFILE_F)
+ if(( iRc = xbFseek( llSize, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ if(( iRc = SetEndOfFile( fHandle )) == 0 ){
+ iErrorStop = 30;
+ iRc = XB_WRITE_ERROR;
+ throw iRc;
+ } else {
+ iRc = XB_NO_ERROR;
+ }
+ #else
+
+ // check that cmake can find function SetEndOfFile -
+ // cmake could not find for Borland 5.5
+ FATAL_COMPILE_ERROR
+ CANT_LOCATE_FUNCTION_ftruncate_or_SetEndOfFile
+
+ #endif
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbFile::xbTruncate() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+
+#ifdef XB_LOCKING_SUPPORT
+
+//! @brief Lock / unlock file.
+/*!
+ \param iFunction XB_LOCK<br>
+ XB_UNLOCK<br>
+ \param lOffset Position in file to lock
+ \param stLen Length to lock
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbFile::xbLock( xbInt16 iFunction, xbInt64 lOffset, size_t stLen ){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbInt16 iTries = 0;
+
+ try{
+ #ifdef HAVE_FCNTL_F
+ /* Unix lock function */
+
+ if(( iRc = xbFseek( lOffset, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ struct flock fl;
+ switch( iFunction ){
+ case( XB_LOCK ):
+ fl.l_type = F_WRLCK;
+ break;
+ case( XB_UNLOCK ):
+ fl.l_type = F_UNLCK;
+ break;
+ default:
+ iErrorStop = 20;
+ iRc = XB_INVALID_LOCK_OPTION;
+ throw iRc;
+ break;
+ }
+ fl.l_whence = SEEK_CUR;
+ fl.l_start = 0;
+ fl.l_len = (xbInt32) stLen;
+ do{
+ iRc = fcntl( iFileNo, F_SETLK, &fl );
+ if( iRc && (errno == EACCES || errno == EAGAIN )){
+ iTries++;
+ xbase->xbSleep( GetDefaultLockWait() );
+ } else if( iRc ){
+ iErrorStop = 30;
+ iRc = XB_LOCK_FAILED;
+ throw iRc;
+ }
+ } while( iRc && iTries < GetLockRetryCount());
+ if( iRc )
+ iRc = XB_LOCK_FAILED; // lock failed, don't log an exception
+
+ #elif defined(HAVE_LOCKFILE_F)
+ /* Windows 64 byte lock functions */
+ /* split a quad word into two double words */
+ typedef union{
+ size_t Qword;
+ xbUInt32 Dword[2];
+ } Qsplit;
+
+ Qsplit lPos;
+ Qsplit lLen;
+ lPos.Qword = lOffset;
+ lLen.Qword = stLen;
+
+ do{
+ if( iFunction == XB_LOCK ){
+ if(( iRc = LockFile( fHandle, lPos.Dword[0], lPos.Dword[1], lLen.Dword[0], lLen.Dword[1] )) == 0 ){
+ iTries++;
+ xbase->xbSleep( GetDefaultLockWait() );
+ }
+ }
+ else if( iFunction == XB_UNLOCK ){
+ if(( iRc = UnlockFile( fHandle, lPos.Dword[0], lPos.Dword[1], lLen.Dword[0], lLen.Dword[1] )) == 0 ){
+ iTries++;
+ xbase->xbSleep( GetDefaultLockWait() );
+ }
+ }
+ else
+ {
+ iErrorStop = 30;
+ iRc = XB_INVALID_LOCK_OPTION;
+ throw iRc;
+ }
+ } while( iRc == 0 && iTries < GetLockRetryCount());
+ if( iRc == 0 )
+ iRc = XB_LOCK_FAILED; // lock failed, don't log an exception
+ else
+ iRc = XB_NO_ERROR;
+
+ #elif defined(HAVE_LOCKING_F) || defined(HAVE__LOCKING_F)
+
+ /* older 32 bit locking functions */
+ xbInt32 iLockType;
+ if( iFunction == XB_LOCK ){
+ iLockType = 2;
+ } else if( iFunction == XB_UNLOCK ){
+ iLockType = 0;
+ } else {
+ iErrorStop = 50;
+ iRc = XB_INVALID_LOCK_OPTION;
+ throw iRc;
+ }
+
+ if(( iRc = xbFseek( lOffset, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ iRc = XB_SEEK_ERROR;
+ throw iRc;
+ }
+
+ do{
+ #ifdef HAVE__LOCKING_F
+ if(( iRc = _locking( iFileNo, iLockType, stLen )) != 0 ){
+ #else
+ if(( iRc = locking( iFileNo, iLockType, stLen )) != 0 ){
+ #endif
+ iTries++;
+ xbase->xbSleep( GetDefaultLockWait() );
+ }
+ } while( iRc != 0 && iTries < GetLockRetryCount());
+
+ if( iRc != 0 )
+ iRc = XB_LOCK_FAILED; // lock failed, don't log an exception
+ else
+ iRc = XB_NO_ERROR;
+
+ #else
+
+ FATAL ERROR - CANT BUILD LIBRARY IN CURRENT CONFIG - MISSING - no file locking function defined in xbfile.cpp
+
+ #endif
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbFile::xbLock() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+
+ return iRc;
+
+
+}
+
+//! @brief Return the locking retry setting.
+/*!
+
+ \returns The lock retry setting for this file or ths system default setting if the lock retry for the file
+ has not been set.
+*/
+
+xbInt16 xbFile::GetLockRetryCount() const {
+
+ if( iLockRetries == -1 )
+ return xbase->GetDefaultLockRetries();
+ else
+ return iLockRetries;
+}
+
+//! @brief Set the lock retry countr for this specific file.
+/*!
+ \param iLockRetries The number of retries to attempt before returning failure for this file
+*/
+
+void xbFile::SetLockRetryCount( xbInt16 iLockRetries ) {
+ this->iLockRetries = iLockRetries;
+}
+
+#endif
+/***********************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+//! @brief Debugging routine - dump a block to the log file.
+/*!
+ This routine dumps a block to a file in 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{
+ iErrorStop = 10;
+
+ if( ulBlockNo == 0 ){
+ ulStartBlock = 0;
+ xbUInt64 ullFileSizeulBlockNo;
+ if(( iRc = GetFileSize( ullFileSizeulBlockNo )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ ulEndBlock = (xbUInt32) (ullFileSizeulBlockNo / lBlkSize);
+ } else {
+ ulStartBlock = ulBlockNo;
+ ulEndBlock = ulBlockNo;
+ }
+
+ if(( buf = (char *) malloc( lBlkSize )) == NULL ){
+ iErrorStop = 30;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+
+ sDir = GetDefaultLogDirectory();
+ char cLastChar = sDir[sDir.Len()];
+
+ for( xbUInt32 l = ulStartBlock; l < ulEndBlock; l++ ){
+
+ if(( iRc = ReadBlock( l, lBlkSize, buf )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ 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 = 50;
+ 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 = 60;
+ iRc = XB_WRITE_ERROR;
+ throw iRc;
+ }
+ p++;
+ }
+ // close the dump file
+ fclose( fpd );
+ }
+
+ // free the buffer
+ if( buf )
+ free( buf );
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ if( iErrorStop == 60 )
+ 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 );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ if( buf )
+ free( buf );
+ if( fpd )
+ fclose( fpd );
+ }
+ return iRc;
+
+}
+#endif
+/***********************************************************************/
+} /* namespace xb */
+
+
+
diff --git a/src/core/xbfilter.cpp b/src/core/xbfilter.cpp
new file mode 100755
index 0000000..e75f583
--- /dev/null
+++ b/src/core/xbfilter.cpp
@@ -0,0 +1,569 @@
+/* xbfilter.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
+
+
+This module handles uda (user data area) methods
+
+
+*/
+
+#include "xbase.h"
+
+
+// might need to change thisto XB_EXPRESSION_SUPPORT
+#ifdef XB_FILTER_SUPPORT
+
+
+namespace xb{
+
+/************************************************************************/
+xbFilter::xbFilter( xbXBase *xbase, xbDbf *dbf ) {
+ this->xbase = xbase;
+ this->dbf = dbf;
+ this->exp = NULL;
+ lLimit = 0; // max number of responses
+ lCurQryCnt = 0; // current number, this query + = moving fwd
+ // - = moving backwards
+
+ #ifdef XB_INDEX_SUPPORT
+ pIx = NULL; // if index is set, the class uses the index tag, otherwise table
+ vpTag = NULL;
+ #endif // XB_INDEX_SUPPORT
+
+}
+/************************************************************************/
+xbFilter::~xbFilter() {
+ if( exp )
+ delete exp;
+}
+/************************************************************************/
+xbInt32 xbFilter::GetLimit() const {
+ return lLimit;
+}
+/************************************************************************/
+xbInt32 xbFilter::GetQryCnt() const {
+ return lCurQryCnt;
+}
+/************************************************************************/
+void xbFilter::SetLimit( xbInt32 lLimit ){
+ this->lLimit = lLimit;
+}
+/************************************************************************/
+void xbFilter::ResetQryCnt(){
+ this->lCurQryCnt = 0;
+}
+
+/************************************************************************/
+xbInt16 xbFilter::Set( xbString &sFilter ) {
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try{
+
+ if( exp )
+ delete exp;
+
+ exp = new xbExp( xbase, dbf );
+ if(( iRc = exp->ParseExpression( sFilter.Str() )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ if( exp->GetReturnType() != XB_EXP_LOGICAL ){
+ iErrorStop = 20;
+ iRc = XB_INVALID_EXPRESSION;
+ delete exp;
+ exp = NULL;
+ throw iRc;
+ }
+ }
+ 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 ));
+ }
+ return iRc;
+}
+/************************************************************************/
+xbInt16 xbFilter::GetFirstRecord( xbInt16 iOption ) {
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try{
+
+ if( !exp ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ #ifdef XB_INDEX_SUPPORT
+ if( dbf->GetCurIx() && dbf->GetCurTag() )
+ return GetFirstRecordIx( iOption );
+ #endif
+
+ lCurQryCnt = 0;
+ if(( iRc = dbf->GetFirstRecord( iOption )) != XB_NO_ERROR ){
+ if( iRc == XB_EMPTY || iRc == XB_EOF )
+ return iRc;
+ else{
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+
+ xbBool bFound = xbFalse;
+ while( !bFound && iRc == XB_NO_ERROR ){
+ if(( iRc = exp->ProcessExpression()) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ if(( iRc = exp->GetBoolResult( bFound )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ if( !bFound ){
+ if(( iRc = dbf->GetNextRecord( iOption )) != XB_NO_ERROR ){
+ if( iRc == XB_EOF ){
+ return iRc;
+ } else {
+ iErrorStop = 50;
+ throw iRc;
+ }
+ }
+ }
+ }
+ lCurQryCnt++;
+ }
+ 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 ));
+ }
+ return iRc;
+}
+/************************************************************************/
+xbInt16 xbFilter::GetNextRecord( xbInt16 iOption ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try{
+
+ if( !exp ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ #ifdef XB_INDEX_SUPPORT
+ if( dbf->GetCurIx() && dbf->GetCurTag())
+ return GetNextRecordIx( iOption );
+ #endif
+
+ if( lLimit != 0 && abs( lCurQryCnt ) >= lLimit )
+ return XB_LIMIT_REACHED;
+
+ if(( iRc = dbf->GetNextRecord( iOption )) != XB_NO_ERROR ){
+ if( iRc == XB_EOF )
+ return iRc;
+ else{
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+
+ xbBool bFound = xbFalse;
+ while( !bFound && iRc == XB_NO_ERROR ){
+ if(( iRc = exp->ProcessExpression()) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ if(( iRc = exp->GetBoolResult( bFound )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ if( !bFound ){
+ if(( iRc = dbf->GetNextRecord( iOption )) != XB_NO_ERROR ){
+ if( iRc == XB_EOF ){
+ return iRc;
+ } else {
+ iErrorStop = 50;
+ throw iRc;
+ }
+ }
+ }
+ }
+ lCurQryCnt++;
+ }
+ 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 ));
+ }
+ return iRc;
+}
+/************************************************************************/
+xbInt16 xbFilter::GetPrevRecord( xbInt16 iOption ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try{
+
+ if( !exp ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ #ifdef XB_INDEX_SUPPORT
+ //if( pIx && vpTag )
+ if( dbf->GetCurIx() && dbf->GetCurTag())
+ return GetPrevRecordIx( iOption );
+ #endif
+
+ if( lLimit != 0 && abs( lCurQryCnt ) >= lLimit )
+ return XB_LIMIT_REACHED;
+
+ if(( iRc = dbf->GetPrevRecord( iOption )) != XB_NO_ERROR ){
+ if( iRc == XB_BOF )
+ return iRc;
+ else{
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+
+ xbBool bFound = xbFalse;
+ while( !bFound && iRc == XB_NO_ERROR ){
+ if(( iRc = exp->ProcessExpression()) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ if(( iRc = exp->GetBoolResult( bFound )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ if( !bFound ){
+ if(( iRc = dbf->GetPrevRecord( iOption )) != XB_NO_ERROR ){
+ if( iRc == XB_BOF ){
+ return iRc;
+ } else {
+ iErrorStop = 50;
+ throw iRc;
+ }
+ }
+ }
+ }
+ lCurQryCnt--;
+ }
+ 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 ));
+ }
+ return iRc;
+}
+/************************************************************************/
+xbInt16 xbFilter::GetLastRecord( xbInt16 iOption ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try{
+
+ if( !exp ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ #ifdef XB_INDEX_SUPPORT
+ if( dbf->GetCurIx() && dbf->GetCurTag())
+ return GetLastRecordIx( iOption );
+ #endif
+
+ lCurQryCnt = 0;
+ if(( iRc = dbf->GetLastRecord( iOption )) != XB_NO_ERROR ){
+ if( iRc == XB_EOF )
+ return iRc;
+ else{
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+
+ xbBool bFound = xbFalse;
+ while( !bFound && iRc == XB_NO_ERROR ){
+ if(( iRc = exp->ProcessExpression()) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ if(( iRc = exp->GetBoolResult( bFound )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ if( !bFound ){
+ if(( iRc = dbf->GetPrevRecord( iOption )) != XB_NO_ERROR ){
+ if( iRc == XB_BOF ){
+ return iRc;
+ } else {
+ iErrorStop = 50;
+ throw iRc;
+ }
+ }
+ }
+ }
+ lCurQryCnt--;
+ }
+ 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 ));
+ }
+ return iRc;
+}
+
+/************************************************************************/
+
+#ifdef XB_INDEX_SUPPORT
+
+//void xbFilter::Set( xbIx *pIx, void *vpTag ) {
+// this->pIx = pIx;
+// this->vpTag = vpTag;
+//}
+
+/************************************************************************/
+xbInt16 xbFilter::GetFirstRecordIx( xbInt16 iOption ) {
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try{
+
+ if( !exp ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ lCurQryCnt = 0;
+ if(( iRc = dbf->GetCurIx()->GetFirstKey( dbf->GetCurTag(), iOption )) != XB_NO_ERROR ){
+ if( iRc == XB_EMPTY || iRc == XB_EOF )
+ return iRc;
+ else{
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+
+ xbBool bFound = xbFalse;
+ while( !bFound && iRc == XB_NO_ERROR ){
+ if(( iRc = exp->ProcessExpression()) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ if(( iRc = exp->GetBoolResult( bFound )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ if( !bFound ){
+ // if(( iRc = pIx->GetNextKey( vpTag, iOption )) != XB_NO_ERROR ){
+ if(( iRc = dbf->GetCurIx()->GetNextKey( dbf->GetCurTag(), iOption )) != XB_NO_ERROR ){
+ if( iRc == XB_EOF ){
+ return iRc;
+ } else {
+ iErrorStop = 50;
+ throw iRc;
+ }
+ }
+ }
+ }
+ lCurQryCnt++;
+ }
+ 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 ));
+ }
+ return iRc;
+}
+/************************************************************************/
+xbInt16 xbFilter::GetNextRecordIx( xbInt16 iOption ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try{
+
+ if( !exp ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ if( lLimit != 0 && abs( lCurQryCnt ) >= lLimit )
+ return XB_LIMIT_REACHED;
+
+ if(( iRc = dbf->GetCurIx()->GetNextKey( dbf->GetCurTag(), iOption )) != XB_NO_ERROR ){
+ if( iRc == XB_EOF )
+ return iRc;
+ else{
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+
+ xbBool bFound = xbFalse;
+ while( !bFound && iRc == XB_NO_ERROR ){
+ if(( iRc = exp->ProcessExpression()) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ if(( iRc = exp->GetBoolResult( bFound )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ if( !bFound ){
+ // if(( iRc = pIx->GetNextKey( vpTag, iOption )) != XB_NO_ERROR ){
+ if(( iRc = dbf->GetCurIx()->GetNextKey( dbf->GetCurTag(), iOption )) != XB_NO_ERROR ){
+ if( iRc == XB_EOF ){
+ return iRc;
+ } else {
+ iErrorStop = 50;
+ throw iRc;
+ }
+ }
+ }
+ }
+ lCurQryCnt++;
+ }
+ 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 ));
+ }
+ return iRc;
+}
+/************************************************************************/
+xbInt16 xbFilter::GetPrevRecordIx( xbInt16 iOption ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try{
+
+ if( !exp ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ if( lLimit != 0 && abs( lCurQryCnt ) >= lLimit )
+ return XB_LIMIT_REACHED;
+
+ if(( iRc = dbf->GetCurIx()->GetPrevKey( dbf->GetCurTag(), iOption )) != XB_NO_ERROR ){
+ if( iRc == XB_BOF )
+ return iRc;
+ else{
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+
+ xbBool bFound = xbFalse;
+ while( !bFound && iRc == XB_NO_ERROR ){
+ if(( iRc = exp->ProcessExpression()) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ if(( iRc = exp->GetBoolResult( bFound )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ if( !bFound ){
+ //if(( iRc = pIx->GetPrevKey( vpTag, iOption )) != XB_NO_ERROR ){
+ if(( iRc = dbf->GetCurIx()->GetPrevKey( dbf->GetCurTag(), iOption )) != XB_NO_ERROR ){
+ if( iRc == XB_BOF ){
+ return iRc;
+ } else {
+ iErrorStop = 50;
+ throw iRc;
+ }
+ }
+ }
+ }
+ lCurQryCnt--;
+ }
+ 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 ));
+ }
+ return iRc;
+}
+/************************************************************************/
+xbInt16 xbFilter::GetLastRecordIx( xbInt16 iOption ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try{
+
+ if( !exp ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ lCurQryCnt = 0;
+ if(( iRc = dbf->GetCurIx()->GetLastKey( dbf->GetCurTag(), iOption )) != XB_NO_ERROR ){
+ if( iRc == XB_EOF )
+ return iRc;
+ else{
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+
+ xbBool bFound = xbFalse;
+ while( !bFound && iRc == XB_NO_ERROR ){
+ if(( iRc = exp->ProcessExpression()) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ if(( iRc = exp->GetBoolResult( bFound )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ if( !bFound ){
+ if(( iRc = dbf->GetCurIx()->GetPrevKey( dbf->GetCurTag(), iOption )) != XB_NO_ERROR ){
+ if( iRc == XB_BOF ){
+ return iRc;
+ } else {
+ iErrorStop = 50;
+ throw iRc;
+ }
+ }
+ }
+ }
+ lCurQryCnt--;
+ }
+ 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 ));
+ }
+ return iRc;
+}
+
+#endif // XB_INDEX_SUPPORT
+
+
+/************************************************************************/
+} /* namespace */
+#endif /* XB_FILTER_SUPPORT */ \ No newline at end of file
diff --git a/src/core/xbfuncs.cpp b/src/core/xbfuncs.cpp
new file mode 100755
index 0000000..a038611
--- /dev/null
+++ b/src/core/xbfuncs.cpp
@@ -0,0 +1,850 @@
+/* xbfuncs.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2017,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_FUNCTION_SUPPORT
+
+namespace xb{
+
+
+// All funtions have a similar structure, return an xbInt16 return code
+// Have a variable number of input operands and one output operand
+
+/************************************************************************/
+//! @brief Calculate absolute value of a numeric expression.
+/*!
+ Expression function ABS().
+ \param dIn Input - Numeric expression.
+ \param dOut Output - Absolute value.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbXBase::ABS( xbDouble dIn, xbDouble &dOut ){
+ if( dIn < 0 )
+ dOut = dIn * -1;
+ else
+ dOut = dIn;
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Trim leading and trailing white space from a string.
+/*!
+ Expression function ALLTRIM().
+ \param sIn Input - Input string to trim.
+ \param sOut Output - Trimmed string.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbXBase::ALLTRIM( const xbString &sIn, xbString &sOut ){
+ sOut = sIn;
+ sOut.Trim();
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Return ASCII code for the first character in a string.
+/*!
+ Expression function ASC().
+ \param sIn Input - Input character string.
+ \param dAscOut Output - Ascii code of first character in string.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbXBase::ASC( const xbString &sIn, xbDouble &dAscOut ){
+ if( sIn == "" )
+ return XB_PARSE_ERROR;
+
+ dAscOut = sIn[1];
+ return XB_NO_ERROR;
+}
+/*************************************************************************/
+//! @brief Return number indicating starting position of string within a string.
+/*!
+ Expression function AT().
+ \param s1 Input - Input string to search for.
+ \param s2 Input - Input string to search.
+ \param dPos Output - Position of string s1 within s2.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbXBase::AT( const xbString &s1, const xbString &s2, xbDouble &dPos ){
+ /* looks for s1 in s2 */
+ xbInt32 lCnt = 0;
+ const char *p;
+ const char *p2 = s2;
+ if( strlen( s1 ) > strlen( s2 )) return 0;
+ if(( p = strstr( s2, s1 )) == NULL )
+ return XB_NO_ERROR;
+ while( p2++ != p ) lCnt++;
+ dPos = lCnt + 1;
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Return character weekday name for date.
+/*!
+ Expression function CDOW().
+ \param dInDate Input - Input date.
+ \param sOutDow Output - Character day of week.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbXBase::CDOW( xbDate &dInDate, xbString &sOutDow ){
+ return dInDate.CharDayOf( sOutDow );
+}
+
+/*************************************************************************/
+//! @brief Convert numeric expression to a character.
+/*!
+ Expression function CHR().
+ \param dAsciCd Input - Numeric expression.
+ \param sOut Output - Character result.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbXBase::CHR( xbDouble dAsciCd, xbString &sOut ){
+ static char buf[2];
+ buf[0] = (char) dAsciCd;
+ buf[1] = 0x00;
+ sOut = buf;
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Return character month name for date.
+/*!
+ Expression function CMONTH().
+ \param dInDate Input - Input date.
+ \param sOutMonth Output - Character month.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbXBase::CMONTH( xbDate &dInDate, xbString &sOutMonth ){
+ return dInDate.CharMonthOf( sOutMonth );
+}
+/*************************************************************************/
+//! @brief Return date from character input date.
+/*!
+ Expression function CTOD().
+ \param sInDate Input - Input date in MM/DD/YY format.
+ \param dOutDate Output - Output date.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbXBase::CTOD( const xbString &sInDate, xbDate &dOutDate ){
+ return dOutDate.CTOD( sInDate );
+}
+/*************************************************************************/
+//! @brief Return system date.
+/*!
+ Expression function DATE().
+ \param dOutDate Output - Output date.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbXBase::DATE( xbDate &dOutDate ){
+ return dOutDate.Sysdate();
+}
+/*************************************************************************/
+//! @brief Return the day of the month from a date.
+/*!
+ Expression function DAY().
+ \param dInDate Input - Input date.
+ \param dOutDay Output - Output day of month.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbXBase::DAY( const xbDate &dInDate, xbDouble &dOutDay ){
+ xbInt16 iOutDay;;
+ iOutDay = dInDate.DayOf( XB_FMT_MONTH );
+ if( iOutDay < 0 ){
+ return iOutDay;
+ }else{
+ dOutDay = iOutDay;
+ return XB_NO_ERROR;
+ }
+}
+/*************************************************************************/
+//! @brief Return record deletion status for current record.
+/*!
+ Expression function DEL().
+ \param dbf Input - Table to check record deletion status.
+ \param iRecBufSw Input - Which buffer. 0 = Current record buffer, 1 = Original record buffer
+ \param sOut Output - "*" if record is deleted, otherise space.
+ \returns XB_NO_ERROR<br>XB_PARSE_ERROR.
+
+*/
+xbInt16 xbXBase::DEL( xbDbf *dbf , xbString &sOut, xbInt16 iRecBufSw ) {
+
+ if( dbf ){
+ if( dbf->RecordDeleted( iRecBufSw ))
+ sOut = "*";
+ else
+ sOut = " ";
+ return XB_NO_ERROR;
+ } else {
+ return XB_PARSE_ERROR;
+ }
+}
+
+/*************************************************************************/
+//! @brief Return record deletion status for current record.
+/*!
+ Expression function DELETED().
+ \param dbf Input - Table to check record deletion status for.
+ \param iRecBufSw Input - Which buffer. 0 = Current record buffer, 1 = Original record buffer
+ \param bOut Output - xbTrue if record is deleted.<br>xbFalse if record is not deleted.
+ \returns XB_NO_ERROR<br>XB_PARSE_ERROR.
+*/
+xbInt16 xbXBase::DELETED( xbDbf *dbf , xbBool &bOut, xbInt16 iRecBufSw ) {
+
+ if( dbf ){
+ bOut = dbf->RecordDeleted( iRecBufSw );
+ return XB_NO_ERROR;
+ } else {
+ return XB_PARSE_ERROR;
+ }
+}
+
+/*************************************************************************/
+//! @brief Clipper DESCEND function.
+/*!
+ Expression function DESCEND().
+ \param dtInDate Input - Input date.
+ \param dtOutDate Output - Output date.
+ \returns XB_NO_ERROR.
+*/
+xbInt16 xbXBase::DESCEND( const xbDate &dtInDate, xbDate &dtOutDate ){
+ xbDate d( "29991231" );
+ dtOutDate.JulToDate8( 2415021 + d.JulianDays() - dtInDate.JulianDays());
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Clipper DESCEND function.
+/*!
+ Expression function DESEND().
+ \param dIn Input - Input number.
+ \param dOut Output - Output number.
+ \returns XB_NO_ERROR.
+*/
+xbInt16 xbXBase::DESCEND( xbDouble dIn, xbDouble &dOut ){
+ dOut = dIn * -1;
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Clipper DESCEND function.
+/*!
+ Expression function DESEND().
+ \param sIn Input - Input string.
+ \param sOut Output - Output string.
+ \returns XB_NO_ERROR.
+*/
+xbInt16 xbXBase::DESCEND( const xbString &sIn, xbString &sOut ){
+
+ sOut = sIn;
+ for( xbUInt32 l = 0; l < sIn.Len(); l++ )
+ sOut.PutAt( l+1, (char) (255 - sOut[l+1]));
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Return number of day of week.
+/*!
+ Expression function DOW().
+ \param dtInDate Input - Input date.
+ \param dDowOut Output - Output day of week.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbXBase::DOW( const xbDate &dtInDate, xbDouble &dDowOut ){
+ xbInt16 iDow;
+ iDow = dtInDate.DayOf( XB_FMT_WEEK );
+ if( iDow < 0 ){
+ return XB_PARSE_ERROR;
+ }else{
+ dDowOut = iDow;
+ return XB_NO_ERROR;
+ }
+}
+
+/*************************************************************************/
+//! @brief Return character date from input date.
+/*!
+ Expression function DTOC().
+ \param dInDate Input - Input date.
+ \param sOutFmtDate Output - Output date.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbXBase::DTOC( xbDate &dInDate, xbString &sOutFmtDate ){
+ return dInDate.FormatDate( "MM/DD/YY", sOutFmtDate );
+}
+/*************************************************************************/
+//! @brief Return char CCYYMMDD date from input date.
+/*!
+ Expression function DTOS().
+ \param dtInDate Input - Input date.
+ \param sOutFmtDate Output - Output date.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbXBase::DTOS( xbDate &dtInDate, xbString &sOutFmtDate ){
+ return dtInDate.FormatDate( "YYYYMMDD", sOutFmtDate );
+}
+/*************************************************************************/
+//! @brief Return exponent value.
+/*!
+ Expression function EXP().
+ This function returns e**x where e is approximately 2.71828 and x is dIn.
+
+ \param dIn Input - exp value.
+ \param dOut Output - value.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbXBase::EXP( xbDouble dIn, xbDouble &dOut )
+{
+ dOut = exp( dIn );
+ return XB_NO_ERROR;
+}
+/*************************************************************************/
+//! @brief Immediate if.
+/*!
+ Expression function IIF().
+ \param bResult Input - boolean expression.
+ \param sTrueResult Input - value if boolean expression is true.
+ \param sFalseResult Input - value if boolean expression is false.
+ \param sResult Output - sTrueResult or sFalseResult depending on bResultvalue.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbXBase::IIF( xbBool bResult, const xbString &sTrueResult, const xbString &sFalseResult, xbString &sResult )
+{
+ if( sFalseResult.Len() != sTrueResult.Len())
+ return XB_INCONSISTENT_PARM_LENS;
+ if( bResult )
+ sResult = sTrueResult;
+ else
+ sResult = sFalseResult;
+ return XB_NO_ERROR;
+}
+/*************************************************************************/
+//! @brief Convert number to integer, truncate any decimals.
+/*!
+ Expression function INT().
+ \param dIn Input - Input number.
+ \param dOut Output - integer.
+ \returns XB_NO_ERROR
+*/
+
+xbInt16 xbXBase::INT( xbDouble dIn, xbDouble &dOut )
+{
+ xbInt64 ll = (xbInt64) dIn;
+ dOut = (xbDouble) ll;
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Check if string begins with alpha character.
+/*!
+ Expression function ISALPHA().
+ \param sIn Input - Input string.
+ \param bResult Output - xbTrue if string begins with alpha character.<br>xbFalse if string does not begin with alpha character.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbXBase::ISALPHA( const xbString &sIn, xbBool &bResult ){
+ if( isalpha(sIn[1]))
+ bResult = 1;
+ else
+ bResult = 0;
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Check if string begins with lower case alpha character.
+/*!
+ Expression function ISLOWER().
+ \param sIn Input - Input string.
+ \param bResult Output - xbTrue if string begins with lower case alpha character.<br>
+ xbFalse if string does not begin with lower case alpha character.
+ \returns XB_NO_ERROR
+*/
+
+xbInt16 xbXBase::ISLOWER( const xbString &sIn, xbBool &bResult ){
+ if( islower(sIn[1]))
+ bResult = 1;
+ else
+ bResult = 0;
+ return XB_NO_ERROR;
+}
+/*************************************************************************/
+//! @brief Check if string begins with upper case alpha character.
+/*!
+ Expression function ISUPPER().
+ \param sIn Input - Input string.
+ \param bResult Output - xbTrue if string begins with upper case alpha character.<br>
+ xbFalse if string does not begin with upper case alpha character.
+ \returns XB_NO_ERROR
+*/
+
+xbInt16 xbXBase::ISUPPER( const xbString &sIn, xbBool &bResult ){
+ if( isupper(sIn[1]))
+ bResult = 1;
+ else
+ bResult = 0;
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Return left characters from string.
+/*!
+ Expression function LEFT().
+ \param sIn Input - string.
+ \param ulCharCnt Input - number of characters to extract from string.
+ \param sOut Output - resultant string.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbXBase::LEFT( const xbString &sIn, xbUInt32 ulCharCnt, xbString &sOut ){
+ sOut.Assign( sIn, 1, ulCharCnt );
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Return length of string.
+/*!
+ Expression function LEN().
+ \param sIn Input - Input string.
+ \param dOut Output - string length.
+ \returns XB_NO_ERROR
+*/
+
+xbInt16 xbXBase::LEN( const xbString &sIn, xbDouble &dOut ){
+ dOut = sIn.Len();
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Calculate logarithm.
+/*!
+ Expression function LOG().
+ \param dIn Input - numeric expression.
+ \param dOut Output - numeric log value.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbXBase::LOG( xbDouble dIn, xbDouble &dOut ){
+ dOut = log( dIn );
+ return XB_NO_ERROR;
+}
+/*************************************************************************/
+//! @brief Trim left side of string.
+/*!
+ Expression function LTRIM().
+ \param sIn Input - string.
+ \param sOut Output - string result.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbXBase::LTRIM( const xbString &sIn, xbString &sOut ){
+ sOut = sIn;
+ sOut.Ltrim();
+ return XB_NO_ERROR;
+}
+/*************************************************************************/
+//! @brief Convert upper case to lower case.
+/*!
+ Expression function LOWER().
+ \param sIn Input - string.
+ \param sOut Output - string result.
+ \returns XB_NO_ERROR
+*/
+
+xbInt16 xbXBase::LOWER( const xbString &sIn, xbString &sOut ){
+ sOut = sIn;
+ sOut.ToLowerCase();
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Return higher of two values.
+/*!
+ Expression function MAX().
+ \param d1 Input - Numeric value 1.
+ \param d2 Input - Numeric value 2.
+ \param dOut Output - Higher of d1 or d2.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbXBase::MAX( xbDouble d1, xbDouble d2, xbDouble &dOut )
+{
+ if( d1 > d2 )
+ dOut = d1;
+ else
+ dOut = d2;
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Return lessor of two values.
+/*!
+ Expression function MIN().
+ \param d1 Input - Numeric value 1.
+ \param d2 Input - Numeric value 2.
+ \param dOut Output - Lessor of d1 or d2.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbXBase::MIN( xbDouble d1, xbDouble d2, xbDouble &dOut )
+{
+ if( d1 < d2 )
+ dOut = d1;
+ else
+ dOut = d2;
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Return number of month for a given date.
+/*!
+ Expression function MONTH().
+ \param dInDate Input date.
+ \param dOutMonth - Month number.
+ \returns XB_NO_ERROR.<br>XB_PARSE_ERROR.
+*/
+xbInt16 xbXBase::MONTH( xbDate &dInDate, xbDouble &dOutMonth ){
+
+ xbInt16 iRc = dInDate.MonthOf();
+ if( iRc < 0 )
+ return XB_PARSE_ERROR;
+ else{
+ dOutMonth = iRc;
+ return XB_NO_ERROR;
+ }
+}
+
+/*************************************************************************/
+//! @brief Return number of records in a given table.
+/*!
+ Expression function RECCOUNT().
+ \param dbf - Table.
+ \param dOut - Number of records.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbXBase::RECCOUNT( xbDbf *dbf , xbDouble &dOut ) {
+
+ xbUInt32 ulRecCnt;
+ xbInt16 iRc = dbf->GetRecordCnt( ulRecCnt );
+ dOut = (xbDouble) ulRecCnt;
+ return iRc;
+
+}
+
+/*************************************************************************/
+//! @brief Return current record number for a given table.
+/*!
+ Expression function RECNO().
+ \param dbf - Table.
+ \param dOut - Record number.
+ \returns XB_NO_ERROR.<br>XB_PARSE_ERROR.
+*/
+
+xbInt16 xbXBase::RECNO( xbDbf *dbf , xbDouble &dOut ) {
+ if( dbf ){
+ dOut = (xbDouble) dbf->GetCurRecNo();
+ return XB_NO_ERROR;
+ } else {
+ dOut = -1;
+ return XB_PARSE_ERROR;
+ }
+}
+
+/*************************************************************************/
+//! @brief Repeat character expression N times.
+/*!
+ Expression function REPLICATE().
+ \param sIn Inout - String to replicate.
+ \param ulRepCnt Input - Number of times to repeat.
+ \param sOut Output - String result.
+ \returns XB_NO_ERROR.<br>XB_PARSE_ERROR.
+*/
+xbInt16 xbXBase::REPLICATE( const xbString &sIn, xbUInt32 ulRepCnt, xbString &sOut ){
+ sOut = "";
+ for( xbUInt32 i = 0; i < ulRepCnt; i++ )
+ sOut += sIn;
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Return right characters from string.
+/*!
+ Expression function RIGHT().
+ \param sIn Input - string.
+ \param ulCharCnt Input - number of characters to extract from string.
+ \param sOut Output - resultant string.
+ \returns XB_NO_ERROR
+*/
+
+xbInt16 xbXBase::RIGHT( const xbString &sIn, xbUInt32 ulCharCnt, xbString &sOut ){
+ if( sIn.Len() < ulCharCnt )
+ sOut = sIn;
+ else
+ sOut.Assign( sIn, sIn.Len() - ulCharCnt + 1, ulCharCnt );
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Trim right side of string.
+/*!
+ Expression function RTRIM().
+ \param sIn Input - string.
+ \param sOut Output - string result.
+ \returns XB_NO_ERROR
+*/
+
+xbInt16 xbXBase::RTRIM( const xbString &sIn, xbString &sOut ){
+ sOut = sIn;
+ sOut.Rtrim();
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Generate a string of N spaces.
+/*!
+ Expression function SPACE().
+ \param lCnt Input - Number of spaces.
+ \param sOut Output - Output String.
+ \returns XB_NO_ERROR.
+*/
+xbInt16 xbXBase::SPACE( xbInt32 lCnt, xbString &sOut ){
+ sOut = "";
+ sOut.PadLeft( ' ', (xbUInt32) lCnt );
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Calculate a square root.
+/*!
+ Expression function SQRT().
+ \param dBase Input - Base number.
+ \param dSqrRoot Output - Square root.
+ \returns XB_NO_ERROR.
+*/
+
+xbInt16 xbXBase::SQRT( xbDouble dBase, xbDouble &dSqrRoot )
+{
+ dSqrRoot = sqrt( dBase );
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Converts a valid 8 byte (CCYYMMDD) input date into a date class.
+/*!
+ Expression function STOD().
+ \param sInDate Input - Input date.
+ \param dtOutDate Output - Output date.
+ \returns XB_NO_ERROR.<br>XB_INVALID_DATE.
+*/
+
+xbInt16 xbXBase::STOD( const xbString &sInDate, xbDate &dtOutDate ){
+
+ if( dtOutDate.DateIsValid( sInDate )){
+ dtOutDate = sInDate;
+ return XB_NO_ERROR;
+ } else {
+ return XB_INVALID_DATE;
+ }
+}
+
+/*************************************************************************/
+//! @brief Convert number to a character string.
+/*!
+ Expression function STR().
+ \param dIn Input - Number.
+ \param sOut Output - String.
+ \returns XB_NO_ERROR.
+*/
+
+xbInt16 xbXBase::STR( xbDouble dIn, xbString &sOut) {
+ xbString sPadChar = " ";
+ return STR( dIn, 10, 0, sPadChar, sOut );
+}
+
+/*************************************************************************/
+//! @brief Convert number to a character string.
+/*!
+ Expression function STR().
+ \param dIn Input - Number.
+ \param ulLen Input - Length.
+ \param sOut Output - String.
+ \returns XB_NO_ERROR.
+*/
+xbInt16 xbXBase::STR( xbDouble dIn, xbUInt32 ulLen, xbString &sOut) {
+ xbString sPadChar = " ";
+ return STR( dIn, ulLen, 0, sPadChar, sOut );
+}
+
+/*************************************************************************/
+//! @brief Convert number to a character string.
+/*!
+ Expression function STR().
+ \param dIn Input - Number.
+ \param ulLen Input - Length.
+ \param ulDec Input - Number of decimals.
+ \param sOut Output - String.
+ \returns XB_NO_ERROR.
+*/
+
+xbInt16 xbXBase::STR( xbDouble dIn, xbUInt32 ulLen, xbUInt32 ulDec, xbString &sOut) {
+ xbString sPadChar = " ";
+ return STR( dIn, ulLen, ulDec, sPadChar, sOut );
+}
+
+/*************************************************************************/
+//! @brief Convert number to a character string.
+/*!
+ Expression function STR().
+ \param dIn Input - Number.
+ \param ulLen Input - Length.
+ \param ulDec Input - Number of decimals.
+ \param sPadChar Input - Left pad character, typically zero or space.
+ \param sOut Output - String.
+ \returns XB_NO_ERROR.
+*/
+
+xbInt16 xbXBase::STR( xbDouble dIn, xbUInt32 ulLen, xbUInt32 ulDec, xbString &sPadChar, xbString &sOut) {
+
+ xbString sFmt;
+ sFmt.Sprintf( "%c%d.%df", '%', ulLen, ulDec );
+ sOut.Sprintf( sFmt.Str(), dIn, 0 );
+
+ // convert to all "*" if result is too long
+ if( sOut.Len() > ulLen ){
+ sOut = "*";
+ do{
+ sOut += "*";
+ } while( ulLen > sOut.Len());
+ } else if( sPadChar.Len() > 0 && sPadChar != " " ){
+ // this logic doesn't make sense when processing negative numbers,
+ // but it does behave like the original dbase
+ // you could end up with something like 0000-12.17 when you really want -000012.17
+ // that is probably why the STRZERO function came into being
+ xbUInt32 l = 1;
+ while( sOut[l] == ' ' ){
+ sOut.PutAt( l, sPadChar[1]);
+ l++;
+ }
+ }
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Convert number to a character string with leading zeroes.
+/*!
+ Expression function STRZERO().
+ \param dIn Input - Number.
+ \param ulLen Input - Length.
+ \param ulDec Input - Number of decimals.
+ \param sOut Output - String.
+ \returns XB_NO_ERROR.
+*/
+xbInt16 xbXBase::STRZERO( xbDouble dIn, xbUInt32 ulLen, xbUInt32 ulDec, xbString &sOut){
+
+ xbString sFmt;
+ if( dIn < 0 )
+ sFmt.Sprintf( "%c+0%d.%df", '%', ulLen, ulDec );
+ else
+ sFmt.Sprintf( "%c0%d.%df", '%', ulLen, ulDec );
+ sOut.Sprintf( sFmt.Str(), dIn );
+
+ // convert to all "*" if result is too long
+ if( sOut.Len() > ulLen ){
+ sOut = "*";
+ do{
+ sOut += "*";
+ } while( ulLen > sOut.Len());
+ }
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Extract a portion of a string from another string.
+/*!
+ Expression function SUBSTR().
+ \param sIn Input - Source string.
+ \param ulStartPos Input - Starting position for string extraction.
+ \param ulLen Input - Number of characters to extract.
+ \param sOut Output - String.
+ \returns XB_NO_ERROR.
+*/
+xbInt16 xbXBase::SUBSTR( const xbString &sIn, xbUInt32 ulStartPos, xbUInt32 ulLen, xbString &sOut ){
+ sOut = sIn;
+ sOut.Mid( ulStartPos, ulLen );
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Trim left and right sides of string.
+/*!
+ Expression function TRIM().
+ \param sIn Input - string.
+ \param sOut Output string result.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbXBase::TRIM( const xbString &sIn, xbString &sOut ){
+ return RTRIM( sIn, sOut );
+}
+
+/*************************************************************************/
+//! @brief Convert lower case to upper case.
+/*!
+ Expression function UPPER().
+ \param sIn Input - string.
+ \param sOut Output - string result.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbXBase::UPPER( const xbString &sIn, xbString &sOut ){
+ sOut = sIn;
+ sOut.ToUpperCase();
+ return XB_NO_ERROR;
+}
+
+/*************************************************************************/
+//! @brief Convert numeric characters to number.
+/*!
+ Expression function VAL().
+ \param sIn Input - string.
+ \param dOut Output - numeric result.
+ \returns XB_NO_ERROR
+*/
+
+xbInt16 xbXBase::VAL( const xbString &sIn, xbDouble &dOut )
+{
+ if( sIn )
+ // strtod(nptr,NULL);
+ dOut = atof( sIn );
+ else
+ dOut = 0;
+ return XB_NO_ERROR;
+}
+/*************************************************************************/
+//! @brief Return year for a given date.
+/*!
+ Expression function YEAR().
+ \param dInDate Input date.
+ \param dOutYear - Year.
+ \returns XB_NO_ERROR.<br>XB_PARSE_ERROR.
+*/
+
+xbInt16 xbXBase::YEAR( xbDate &dInDate, xbDouble &dOutYear ){
+
+ xbInt16 iRc = dInDate.YearOf();
+ if( iRc < 0 )
+ return XB_PARSE_ERROR;
+ else{
+ dOutYear = iRc;
+ return XB_NO_ERROR;
+ }
+}
+/*************************************************************************/
+}; // namespace
+#endif // XB_FUNCTION_SUPPORT
+/*************************************************************************/
diff --git a/src/core/xbixbase.cpp b/src/core/xbixbase.cpp
new file mode 100755
index 0000000..40c1563
--- /dev/null
+++ b/src/core/xbixbase.cpp
@@ -0,0 +1,792 @@
+/* xbixbase.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
+
+ Base index class
+
+*/
+
+#include "xbase.h"
+#ifdef XB_INDEX_SUPPORT
+
+namespace xb{
+
+/***********************************************************************/
+//! @brief Class constructor.
+/*!
+ /param dbf Pointer to dbf instance.
+*/
+xbIx::xbIx( xbDbf *dbf ) : xbFile( dbf->GetXbasePtr()) {
+ this->dbf = dbf;
+ vpCurTag = NULL;
+ cNodeBuf = NULL;
+ bLocked = xbFalse;
+}
+/***********************************************************************/
+//! @brief Class Destructor.
+xbIx::~xbIx(){}
+
+
+/***********************************************************************/
+//! @brief Add Keys for record number
+/*!
+ For a given a record number, add keys to each tag in the index file
+ if it was updated
+
+ \param ulRecNo Record number to add keys for
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIx::AddKeys( xbUInt32 ulRecNo ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbInt16 i = 0;
+ xbInt16 iKeySts;
+// std::cout << "xbIx::AddKeys\n";
+
+ try{
+ void * vpTag;
+ xbInt16 iTagCount = GetTagCount();
+
+ for( i = 0; i < iTagCount; i++ ){
+ vpTag = GetTag( i );
+
+ iKeySts = GetKeySts( vpTag );
+// std::cout << "AddKeys() KeySts = " << iKeySts << "\n";
+
+ if( iKeySts == 1 || iKeySts == 2 ){
+ if(( iRc = UpdateTagKey( 'A', vpTag, ulRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ }
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIx::AddKeys() Exception Caught. Error Stop = [%d] iRc = [%d] Tag=[%d]", iErrorStop, iRc, i );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Allocate memory for index node.
+/*!
+ Allocate an index node.
+
+ \param ulBufSize Size of buffer to allocate
+ \returns null on error<br>Pointer to newly allocated xbIxNode on success
+*/
+xbIxNode * xbIx::AllocateIxNode( xbUInt32 ulBufSize, xbInt16 )
+{
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ xbIxNode * pNode = (xbIxNode *) calloc( 1, sizeof( xbIxNode ));
+ if( pNode == NULL ){
+ iErrorStop = 100;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+ if( ulBufSize == 0 )
+ ulBufSize = GetBlockSize();
+
+ pNode->ulBufSize = ulBufSize;
+ pNode->cpBlockData = (char *) calloc( 1, ulBufSize );
+ if( pNode->cpBlockData == NULL ){
+ free( pNode );
+ iErrorStop = 110;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+ return pNode;
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIx::AllocateIxNode() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return NULL;
+}
+
+
+/***********************************************************************/
+//! @brief Binary search for given value on an index node.
+/*!
+
+ Binary search for key lookups
+ \param cKeyType Key type
+ \param npNode Pointer to index node for search
+ \param lKeyItemLen Lenth of key plus pointer values
+ \param vpKey Pointer to key value
+ \param lSearchKeyLen length of key to search
+ \param iCompRc output return code from the CompareKey routine. CompareKey returns an
+ integer value less than, equal to or greater than zero in when comparing values
+
+ \param bDescending xbTrue for descending index key lookup.<br>
+ xbFalse for ascending index key lookup.
+ \return The position in the node the key was found, if multiples it returns the first occurrence.
+ If the key is not found, it returns the slot it should be in.
+*/
+
+xbInt16 xbIx::BSearchBlock( char cKeyType, xbIxNode *npNode, xbInt32 lKeyItemLen, const void *vpKey,
+ xbInt32 lSearchKeyLen, xbInt16 &iCompRc, xbBool bDescending ) const {
+ xbInt32 lLo = 0;
+ xbInt32 lHi = 0;
+ xbInt32 lMid = 0;
+ xbInt32 lKeyCnt = GetKeyCount( npNode );
+
+
+ if( !bDescending ){
+ lHi = lKeyCnt - 1;
+
+ while( lLo <= lHi ){
+ lMid = (lLo + lHi) / 2;
+ iCompRc = CompareKey( cKeyType, GetKeyData( npNode, lMid, lKeyItemLen ), vpKey, (size_t) lSearchKeyLen );
+ if( iCompRc > 0 )
+ lHi = lMid - 1;
+ else if( iCompRc < 0 )
+ lLo = lMid + 1;
+ else{ // found match, look for leftmost occurrence
+
+ xbInt32 lFoundPos = lMid;
+ lMid--;
+ while( lMid >= 0 && CompareKey( cKeyType, GetKeyData( npNode, lMid, lKeyItemLen ), vpKey, (size_t) lSearchKeyLen ) == 0 ){
+ lFoundPos = lMid;
+ lMid--;
+ }
+ iCompRc = 0;
+ lLo = lFoundPos;
+ lHi = -1;
+ }
+ }
+ // update the compare key results
+ if( lMid != lLo ){
+ if( lLo >= lKeyCnt )
+ iCompRc = 1;
+ else
+ iCompRc = CompareKey( cKeyType, GetKeyData( npNode, lLo, lKeyItemLen ), vpKey, (size_t) lSearchKeyLen );
+ }
+ return (xbInt16) lLo;
+
+ } else { // descending key
+
+ lLo = lKeyCnt - 1;
+ while( lLo >= lHi && lHi != -1 ){
+ lMid = (lLo + lHi) / 2;
+ iCompRc = CompareKey( cKeyType, GetKeyData( npNode, lMid, lKeyItemLen ), vpKey, (size_t) lSearchKeyLen );
+
+ if( iCompRc > 0 ) {
+ lHi = lMid + 1;
+ }
+ else if( iCompRc < 0) {
+ lLo = lMid - 1;
+ }
+ else{ // found match, look for leftmost occurrence
+
+ xbInt32 lFoundPos = lMid;
+ lMid--;
+ while( lMid >= 0 && CompareKey( cKeyType, GetKeyData( npNode, lMid, lKeyItemLen ), vpKey, (size_t) lSearchKeyLen ) == 0 ){
+ lFoundPos = lMid;
+ lMid--;
+ }
+ iCompRc = 0;
+ lHi = lFoundPos;
+ lLo = -1;
+ }
+ }
+
+ // std::cout << "BSB1 lo = " << lLo << " mid = " << lMid << " hi = " << lHi << " keycnt = " << lKeyCnt << " iCompRc = " << iCompRc << "\n"; // key=" << (char *) vpKey << "\n";
+ if( lLo < 0 && iCompRc < 0 )
+ iCompRc = 1;
+ else if( iCompRc != 0 ) {
+ iCompRc = CompareKey( cKeyType, GetKeyData( npNode, (lLo < 0 ? 0 : lLo), lKeyItemLen ), vpKey, (size_t) lSearchKeyLen );
+ }
+ // std::cout << "BSB2 lo = " << lLo << " mid = " << lMid << " hi = " << lHi << " keycnt = " << lKeyCnt << " iCompRc = " << iCompRc << "\n"; // key=" << (char *) vpKey << "\n";
+ return (xbInt16) lHi;
+ }
+
+ // should never get here
+ // return (xbInt16) 0;
+}
+
+/***********************************************************************/
+//! @brief Check for duplicate keys.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIx::CheckForDupKeys(){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbInt16 i = 0;
+
+ try{
+ void * vpTag;
+ xbInt16 iTagCount = GetTagCount();
+ for( i = 0; i < iTagCount; i++ ){
+ vpTag = GetTag( i );
+ if(( iRc = CheckForDupKey( vpTag )) < XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ }
+ }
+ catch (xbInt16 iRc ){
+ if( iRc != XB_KEY_NOT_UNIQUE ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxBase::CheckForDupKeys() Exception Caught. Error Stop = [%d] iRc = [%d] Tag=[%d]", iErrorStop, iRc, i );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Close index file.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIx::Close(){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ if(( iRc = xbFclose()) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIx::Close() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Compare keys.
+/*!
+ \param cKeyType C - Character compare.<br>
+ N - Numeric BCD compare.<br>
+ D - Numeric compare.<br>
+ F - Numeric compare.<br>
+ \param v1 Left compare.<br>v2 - Right Compare.
+ \param iSearchKeyLen Length of key compare.
+ \returns 1 - Left operand is greater then right operand.<br>
+ 0 - Left operand is equal to right operand.<br>
+ -1 - Left operand is less than right operand.
+*/
+inline xbInt16 xbIx::CompareKey( char cKeyType, const void *v1, const void *v2, size_t iSearchKeyLen ) const{
+ if( cKeyType == 'C' ){ // character compare
+ return memcmp( v1, v2, iSearchKeyLen );
+ } else if( cKeyType == 'N' ){ // numeric bcd compare, mdx bcd numeric indices
+ xbBcd bcdk1( v1 );
+ return bcdk1.Compare( v2 );
+ } else if( cKeyType == 'D' || cKeyType == 'F' ){ // julian date compare, ndx float numeric indices
+ xbDouble *d1 = (xbDouble *) v1;
+ xbDouble *d2 = (xbDouble *) v2;
+ if( *d1 < *d2 )
+ return -1;
+ else if( *d1 > *d2 )
+ return 1;
+ else
+ return 0;
+ } else {
+// std::cout << "Unhandled key type [" << cKeyType << "]\n";
+ }
+ return XB_NO_ERROR;
+}
+/***********************************************************************/
+//! @brief Create Keys for record number
+/*!
+ \param iOpt 0 Build a key for FindKey usage, only rec buf 0.<br>
+ 1 Append Mode, Create key for an append, only use rec buf 0, set updated switch.<br>
+ 2 Update Mode, Create old version and new version keys, check if different, set update switch appropriately.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIx::CreateKeys( xbInt16 iOpt ) {
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbInt16 i = 0;
+
+ try{
+ void * vpTag;
+ xbInt16 iTagCount = GetTagCount();
+
+ for( i = 0; i < iTagCount; i++ ){
+ vpTag = GetTag( i );
+ if(( iRc = CreateKey( vpTag, iOpt )) < XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIx::CreateKeys() Exception Caught. Error Stop = [%d] iRc = [%d] Tag=[%d]", iErrorStop, iRc, i );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return XB_NO_ERROR;
+}
+/***********************************************************************/
+//! @brief Delete keys for record number
+/*!
+ Delete keys to each tag in the index file if it was updated as determined
+ by CreateKeys function
+
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+//xbInt16 xbIx::DeleteKeys( xbUInt32 ulRecNo ){
+
+xbInt16 xbIx::DeleteKeys(){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbInt16 i = 0;
+
+ try{
+ void * vpTag;
+ xbInt16 iTagCount = GetTagCount();
+
+ for( i = 0; i < iTagCount; i++ ){
+ vpTag = GetTag( i );
+ if( GetKeySts( vpTag ) > 1 ){ // 0 = no update 1 = add 2 = update, 3 = delete
+ if(( iRc = UpdateTagKey( 'D', vpTag )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ }
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIx::DeleteKeys() Exception Caught. Error Stop = [%d] iRc = [%d] Tag=[%d]", iErrorStop, iRc, i );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+//! @brief Dump anode for debug purposes.
+/*!
+ \param pNode Pointer to node to dump.
+ \param iOption 0 = stdout<br>
+ 1 = Syslog<br>
+ 2 = Both<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIx::DumpNode( void *, xbIxNode *pNode, xbInt16 iOption ) const
+{
+ xbString s;
+ s.Sprintf( "Dump Node Block=[%d] CurKey=[%d]", pNode->ulBlockNo, pNode->iCurKeyNo );
+ xbase->WriteLogMessage( s, iOption );
+
+ return XB_NO_ERROR;
+}
+#endif // XB_DEBUG_SUPPORT
+
+/***********************************************************************/
+//! @brief Find double key
+/*!
+ \param vpTag Pointer to tag to search.
+ \param dKey Double value to search for.
+ \param iRetrieveSw xbTrue - Retrieve the record if key found.<br>
+ xbFalse - Don't retrieve record, check for key existence only.
+ \returns XB_NO_ERROR - Key found.<br>
+ XB_NOT_FOUND - Key not found.<br>
+ <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIx::FindKey( void *vpTag, xbDouble dKey, xbInt16 iRetrieveSw ){
+ return FindKey( vpTag, &dKey, 8, iRetrieveSw );
+}
+/***********************************************************************/
+//! @brief Find string key
+/*!
+ \param vpTag Pointer to tag to search.
+ \param sKey String data to search for.
+ \param iRetrieveSw xbTrue - Retrieve the record if key found.<br>
+ xbFalse - Don't retrieve record, check for key existence only.
+ \returns XB_NO_ERROR - Key found.<br>
+ XB_NOT_FOUND - Key not found.<br>
+ <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIx::FindKey( void *vpTag, const xbString &sKey, xbInt16 iRetrieveSw ){
+ return FindKey( vpTag, sKey.Str(), (xbInt32) sKey.Len(), iRetrieveSw );
+}
+/***********************************************************************/
+//! @brief Find character key
+/*!
+ \param vpTag Pointer to tag to search.
+ \param cKey String data to search for.
+ \param lKeyLen Length of key to search for.
+ \param iRetrieveSw xbTrue - Retrieve the record if key found.<br>
+ xbFalse - Don't retrieve record, check for key existence only.
+ \returns XB_NO_ERROR - Key found.<br>
+ XB_NOT_FOUND - Key not found.<br>
+ <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIx::FindKey( void *vpTag, const char *cKey, xbInt32 lKeyLen, xbInt16 iRetrieveSw ){
+ return FindKey( vpTag, (void *) cKey, lKeyLen, iRetrieveSw );
+}
+/***********************************************************************/
+//! @brief Find bcd key
+/*!
+ \param vpTag Pointer to tag to search.
+ \param bcd BCD data to search for.
+ \param iRetrieveSw xbTrue - Retrieve the record if key found.<br>
+ xbFalse - Don't retrieve record, check for key existence only.
+
+ \returns XB_NO_ERROR - Key found.<br>
+ XB_NOT_FOUND - Key not found.<br>
+ <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIx::FindKey( void *vpTag, const xbBcd &bcd, xbInt16 iRetrieveSw ){
+ return FindKey( vpTag, bcd.GetBcd(), 12, iRetrieveSw );
+}
+/***********************************************************************/
+//! @brief Find date key
+/*!
+ \param vpTag Pointer to tag to search.
+ \param dtKey Date data to search for.
+ \param iRetrieveSw xbTrue - Retrieve the record if key found.<br>
+ xbFalse - Don't retrieve record, check for key existence only.
+ \returns XB_NO_ERROR - Key found.<br>
+ XB_NOT_FOUND - Key not found.<br>
+ <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIx::FindKey( void *vpTag, const xbDate &dtKey, xbInt16 iRetrieveSw ){
+ xbDouble d = (xbDouble) dtKey.JulianDays();
+ return FindKey( vpTag, &d, 8, iRetrieveSw );
+}
+/***********************************************************************/
+//! @brief Free all nodes in a linked list.
+/*!
+ \param np Pointer to first node in linked list to free.
+ \returns NULL.
+*/
+xbIxNode *xbIx::FreeNodeChain( xbIxNode *np ){
+
+ // routine returns NULL
+ if( np ){
+ // free memory for a given chain of nodes
+ xbIxNode * np2;
+
+ // Clear the previous node's next pointer
+ if( np->npPrev )
+ np->npPrev->npNext = NULL;
+
+ // Clear out the tree
+ while( np ){
+ np2 = np->npNext;
+ NodeFree( np );
+ np = NULL;
+ np = np2;
+ }
+ }
+ return NULL;
+}
+/***********************************************************************/
+//! @brief Read block for block number.
+/*!
+ Routine to read a node/block out of an index file and store in xbIxNode structure
+ \param vpTag Pointer to tag.
+ \param ulBlockNo Block number to read off disk.
+ \param iOpt
+ 0 = Node is read into block buffer, not added to the node chain<br>
+ 1 = Node is read into new xbIxNode, then added to the node chain, and sets CurNode with new node<br>
+ 2 = Node is read into new xbIxNode, not added to the node chain<br>
+ CurNode points to new node<br>
+ \param ulAddlBuf Additional buffer size added to memory
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+
+xbInt16 xbIx::GetBlock( void *vpTag, xbUInt32 ulBlockNo, xbInt16 iOpt, xbUInt32 ulAddlBuf ){
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbIxNode *np = NULL;
+ try{
+
+ if( !vpTag && iOpt == 1 ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+ // set target location of block read to read
+ char *cp;
+ if( iOpt == 0 )
+ cp = cNodeBuf;
+ else{
+ if(( np = AllocateIxNode(GetBlockSize() + ulAddlBuf )) == NULL ){
+ iErrorStop = 110;
+ iRc = XB_NO_MEMORY;
+ throw( iRc );
+ }
+ cp = np->cpBlockData;
+ }
+ if(( iRc = ReadBlock( ulBlockNo, GetBlockSize(), cp )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ if( iOpt == 0 )
+ return iRc;
+ np->ulBlockNo = ulBlockNo;
+ np->iCurKeyNo = 0;
+ if( iOpt == 1 )
+ AppendNodeChain( vpTag, np );
+ else if( iOpt == 2 ){
+ std::cout << "Future use stub. xbIxbase::GetBlock() option 2 not coded.\n";
+ iErrorStop = 130;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ // SetCurNode( vpTag, np );
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIx::GetBlock() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ if( np ) NodeFree( np );
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Get pointer to current tag.
+/*!
+ \returns Pointer to current tag.
+*/
+
+void *xbIx::GetCurTag() const {
+ return vpCurTag;
+}
+/***********************************************************************/
+//! @brief Get pointer to dbf.
+/*!
+ \returns Pointer to dbf.
+*/
+xbDbf *xbIx::GetDbf() const {
+ return this->dbf;
+}
+/***********************************************************************/
+//! @brief Get the first key for the current tag.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIx::GetFirstKey(){
+ return GetFirstKey( vpCurTag, 0 );
+}
+
+/***********************************************************************/
+//! @brief Get the first key for a given tag.
+/*!
+ \param vpTag Tag for get first key operation.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIx::GetFirstKey( void *vpTag ){
+ return GetFirstKey( vpTag, 0 );
+}
+/***********************************************************************/
+//! @brief Get the last key for the current tag.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIx::GetLastKey(){
+ return GetLastKey( 0, vpCurTag, 0 );
+}
+/***********************************************************************/
+//! @brief Get the last key for a given tag.
+/*!
+ \param vpTag Tag for get last key operation.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIx::GetLastKey( void *vpTag ){
+ return GetLastKey( 0, vpTag, 0 );
+}
+
+/***********************************************************************/
+//! @brief Get the file lock status.
+/*!
+ \returns xbTrue - Index file is locked.<br>xbFalse - Index file is not locked.
+*/
+xbBool xbIx::GetLocked() const {
+ return bLocked;
+}
+
+/***********************************************************************/
+//! @brief Get the key count for number of keys on a node.
+/*!
+ \param np Given node for key count.
+ \returns Number of keys on the node.
+*/
+xbInt32 xbIx::GetKeyCount( xbIxNode *np ) const {
+ // assumes the first four bytes of the block is a four byte number
+ // representing the number of keys contained on the block
+ return eGetInt32( np->cpBlockData );
+}
+/***********************************************************************/
+//! @brief Get key data for a given key number.
+/*!
+ \param np Given node for key retrieval.
+ \param iKeyNo Which key to pull.
+ \param iKeyItemLen Length of key plus pointers.
+ \returns Pointer to a given key.
+*/
+char * xbIx::GetKeyData( xbIxNode *np, xbInt16 iKeyNo, xbInt16 iKeyItemLen ) const {
+ if( !np ) return NULL;
+ char *p = np->cpBlockData;
+ xbUInt32 ulKeyCnt = eGetUInt32( p );
+ if( iKeyNo < 0 || iKeyNo > (xbInt16) ulKeyCnt ) return NULL;
+ xbInt16 iOffset = 12 + (iKeyNo * iKeyItemLen);
+ p+=iOffset;
+ return p;
+}
+/***********************************************************************/
+//! @brief Get the next key for the current tag.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIx::GetNextKey(){
+ return GetNextKey( vpCurTag, 0 );
+}
+/***********************************************************************/
+//! @brief Get the next key for the given tag.
+/*!
+ \param vpTag Tag for next key operation.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIx::GetNextKey( void *vpTag ){
+ return GetNextKey( vpTag, 0 );
+}
+/***********************************************************************/
+//! @brief Get the prev key for the current tag.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIx::GetPrevKey(){
+ return GetPrevKey( vpCurTag, 0 );
+}
+/***********************************************************************/
+//! @brief Get the previous key for the given tag.
+/*!
+ \param vpTag Tag for previous key operation.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIx::GetPrevKey( void *vpTag ){
+ return GetPrevKey( vpTag, 0 );
+}
+/***********************************************************************/
+//! @brief Free an index node
+/*!
+ \param ixNode Pointer to index node to free.
+ \returns void
+*/
+void xbIx::NodeFree( xbIxNode *ixNode ){
+ if( ixNode ){
+ if( ixNode->cpBlockData ){
+ free( ixNode->cpBlockData );
+ ixNode->cpBlockData = NULL;
+ }
+ free( ixNode );
+ ixNode = NULL;
+ }
+}
+/***********************************************************************/
+//! @brief Open an index file.
+/*!
+ MDX files are opened automatically and don't need opened.
+ NDX files that are associated with the DBF file are opened automatically.
+
+ Non production indexes that haven't been opened will need to be opened to be used.
+ \param sFileName Index file name to open.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIx::Open( const xbString & sFileName ){
+
+ // There are no locking requirements when opening an NDX index
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ /* copy the file name to the class variable */
+ this->SetFileName( sFileName );
+
+ if( !FileExists()){
+ iErrorStop = 10;
+ iRc = XB_FILE_NOT_FOUND;
+ throw iRc;
+ }
+ /* open the file */
+ if(( iRc = xbFopen( dbf->GetOpenMode(), dbf->GetShareMode())) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ if(( iRc = ReadHeadBlock()) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ SetCurTag( (xbInt16) 0 ); // default the first tag as the current tag
+ }
+
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIx::Open( %s ) Exception Caught. Error Stop = [%d] iRc = [%d]", sFileName.Str(), iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Set the current tag.
+/*!
+ \param vpCurTag Pointer to tag to set as current.
+ \returns void
+*/
+void xbIx::SetCurTag( void *vpCurTag ){
+ this->vpCurTag = vpCurTag;
+}
+/***********************************************************************/
+//! @brief Set the dbf pointer.
+/*!
+ \param dbf Dbf pointer to set.
+ \returns void
+*/
+void xbIx::SetDbf( xbDbf *dbf ){
+ this->dbf = dbf;
+}
+/***********************************************************************/
+//! @brief Set the file lock status.
+/*!
+ \param bLocked xbTrue - Set to locked.<br>xbFalse - Set to unlocked.
+ \returns void
+*/
+void xbIx::SetLocked( xbBool bLocked ){
+ this->bLocked = bLocked;
+}
+/***********************************************************************/
+} /* namespace */
+#endif /* XB_INDEX_SUPPORT */
diff --git a/src/core/xbixmdx.cpp b/src/core/xbixmdx.cpp
new file mode 100755
index 0000000..53d7053
--- /dev/null
+++ b/src/core/xbixmdx.cpp
@@ -0,0 +1,5067 @@
+/* xbixmdx.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
+
+
+ MDX indices are comprised of blocks and pages.
+ A page is 512 bytes.
+ A Block is one or more pages.
+ The default block size is two 512 byte pages per block.
+ Nodes are used for storing block images in memory
+
+*/
+
+#include "xbase.h"
+
+#ifdef XB_MDX_SUPPORT
+
+namespace xb{
+
+/***********************************************************************/
+xbIxMdx::xbIxMdx( xbDbf *dbf ) : xbIx( dbf ){
+ Init();
+}
+/***********************************************************************/
+//void xbIxMdx::Init( xbInt16 iOpt ){
+void xbIxMdx::Init( xbInt16 ){
+
+ cVersion = 0;
+ cCreateYY = 0;
+ cCreateMM = 0;
+ cCreateDD = 0;
+ sFileName = "";
+ iBlockFactor = 0;
+ cProdIxFlag = 0;
+ cTagEntryCnt = 0;
+ iTagLen = 0;
+ iTagUseCnt = 0;
+ cNextTag = 0;
+ c1B = 0x0b;
+ ulPageCnt = 0;
+ ulFirstFreePage = 0;
+ ulNoOfBlockAvail = 0;
+ cUpdateYY = 0;
+ cUpdateMM = 0;
+ cUpdateDD = 0;
+ mdxTagTbl = NULL;
+ cNodeBuf = NULL;
+ bReuseEmptyNodes = xbTrue;
+}
+/***********************************************************************/
+xbIxMdx::~xbIxMdx(){
+ if( cNodeBuf )
+ free( cNodeBuf );
+
+ if( FileIsOpen())
+ Close();
+}
+/***********************************************************************/
+//! @brief Add key.
+/*!
+ Add key. If this is a unique index, this logic assumes the duplicate
+ check logic was already done.
+
+ \param vpTag Tag to update.
+ \param ulRecNo Record number to add key for.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxMdx::AddKey( void * vpTag, xbUInt32 ulRecNo ){
+
+ xbMdxTag * npTag = (xbMdxTag *) vpTag;
+ if( GetUniqueKeyOpt() == XB_EMULATE_DBASE && npTag->bFoundSts )
+ return XB_NO_ERROR;
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbInt16 iHeadNodeUpdateOpt = 2;
+ xbIxNode * npRightNode = NULL;
+ xbUInt32 ulNewRightChild = 0;
+
+ try{
+ if(( iRc = xbIxMdx::KeySetPosAdd( npTag, ulRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+ xbInt32 lKeyCnt = GetKeyCount( npTag->npCurNode );
+
+ // std::cout << "xbIxMdx::AddKeys() lKeyCnt = " << lKeyCnt << " KeysPerBlock = " << npTag->iKeysPerBlock << " npBlockNo = " << npTag->npCurNode->ulBlockNo << "\n";
+
+ if( lKeyCnt < npTag->iKeysPerBlock ){
+ // Section A - add key to appropriate position if space available
+ // std::cout << "AddKey Section A begin\n";
+ if(( iRc = InsertNodeL( npTag, npTag->npCurNode, npTag->npCurNode->iCurKeyNo, npTag->cpKeyBuf, ulRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ //std::cout << "AddKey Section A end\n";
+ } else {
+
+ // land here with a full leaf node
+ //std::cout << "Section B begin split leaf node\n";
+
+ iHeadNodeUpdateOpt = 1;
+ npRightNode = AllocateIxNode( npTag, GetBlockSize() + (xbUInt32) npTag->iKeyItemLen, npTag->npCurNode->ulBlockNo * (xbUInt32) iBlockFactor );
+ if( !npRightNode ){
+ iErrorStop = 120;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+
+ if(( npTag->npCurNode->ulBlockNo * (xbUInt32) iBlockFactor ) == npTag->ulRightChild ){
+ ulNewRightChild = npRightNode->ulBlockNo * (xbUInt32) iBlockFactor;
+ }
+
+ //std::cout << "ulNewRightChild = " << ulNewRightChild << "\n";
+
+ if(( iRc = xbIxMdx::SplitNodeL( npTag, npTag->npCurNode, npRightNode, npTag->npCurNode->iCurKeyNo, npTag->cpKeyBuf, ulRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ xbUInt32 ulTempBlockNo = npRightNode->ulBlockNo;
+
+
+ //std::cout << "ulTempBlockNo = " << ulTempBlockNo << "\n";
+ //std::cout << "key count left block " << GetKeyCount( npTag->npCurNode ) << "\n";
+ //std::cout << "key count right block " << GetKeyCount( npRightNode ) << "\n";
+
+
+ //std::cout << "Section B end\n";
+
+ // section C - go up the tree, splitting nodes as necessary
+ xbIxNode * npParent = npTag->npCurNode->npPrev;
+
+
+ while( npParent && GetKeyCount( npParent ) >= npTag->iKeysPerBlock ){
+ //std::cout << "Section C begin interior node is full\n";
+ npRightNode = FreeNodeChain( npRightNode );
+ npRightNode = AllocateIxNode( npTag, GetBlockSize() + (xbUInt32) npTag->iKeyItemLen, npParent->ulBlockNo * (xbUInt32) iBlockFactor );
+ //std::cout << "Section C - B new right node block number for interior node split= " << npRightNode->ulBlockNo << "\n";
+
+ if( !npRightNode ){
+ iErrorStop = 140;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+ //std::cout << "Section C - going to split interior node C\n";
+
+ if(( iRc = SplitNodeI( npTag, npParent, npRightNode, npParent->iCurKeyNo, BlockToPage( ulTempBlockNo ))) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+ // std::cout << "Section C - interior node split \n";
+ ulTempBlockNo = npRightNode->ulBlockNo;
+ npTag->npCurNode = npParent;
+ npParent = npParent->npPrev;
+ }
+
+ // std::cout << "Past Section C Cur Node Block No = " << npTag->npCurNode->ulBlockNo << " root page = " << npTag->ulRootPage << "\n";
+ // 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";
+
+ if(( iRc = AddKeyNewRoot( npTag, npTag->npCurNode, npRightNode )) != XB_NO_ERROR ){
+ iErrorStop = 160;
+ throw iRc;
+ }
+
+ if( npRightNode )
+ npRightNode = FreeNodeChain( npRightNode );
+
+ //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;
+ throw iRc;
+ }
+ }
+ }
+
+ // update the header
+ if(( iRc = WriteHeadBlock( iHeadNodeUpdateOpt )) != XB_NO_ERROR ){
+ iErrorStop = 180;
+ throw iRc;
+ }
+
+ // if adding the first key, set the cHasKeys field
+ if( !npTag->cHasKeys ){
+ npTag->cHasKeys = 0x01;
+ if(( iRc = xbFseek( ((npTag->ulTagHdrPageNo * 512) + 246), SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 190;
+ throw iRc;
+ }
+ if(( iRc = xbFwrite( &npTag->cHasKeys, 1, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 200;
+ throw iRc;
+ }
+ }
+
+ if( ulNewRightChild > 0 ){
+
+// std::cout << "ulRightChild was = " << npTag->ulRightChild << " changed to " << ulNewRightChild << "\n";
+
+ char cBuf[4];
+ ePutUInt32( cBuf, ulNewRightChild );
+ if(( iRc = xbFseek( ((npTag->ulTagHdrPageNo * 512) + 252), SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 210;
+ throw iRc;
+ }
+ if(( iRc = xbFwrite( &cBuf, 4, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 220;
+ throw iRc;
+ }
+// std::cout << "setting right child\n";
+ npTag->ulRightChild = ulNewRightChild;
+ }
+
+ if( npRightNode )
+ npRightNode = FreeNodeChain( npRightNode );
+ npTag->npNodeChain = FreeNodeChain( npTag->npNodeChain );
+ npTag->npCurNode = NULL;
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::AddKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+void xbIxMdx::AppendNodeChain( void *vpTag, xbIxNode * npNode ){
+ xbMdxTag * mdxTag = (xbMdxTag *) vpTag;
+ if( mdxTag->npNodeChain == NULL ){
+ mdxTag->npNodeChain = npNode;
+ mdxTag->npCurNode = npNode;
+ } else {
+ npNode->npPrev = mdxTag->npCurNode;
+ mdxTag->npCurNode->npNext = npNode;
+ mdxTag->npCurNode = npNode;
+ }
+ // time stamp the node chain
+ GetFileMtime( mdxTag->tNodeChainTs );
+}
+
+/***********************************************************************/
+//! @brief Add new root node.
+/*!
+ \param mpTag Tag to update.
+ \param npLeft Left node.
+ \param npRight Right node.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxMdx::AddKeyNewRoot( xbMdxTag *npTag, xbIxNode *npLeft, xbIxNode *npRight ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ char *pLastKey = NULL;
+
+ try{
+ xbIxNode *npRoot = AllocateIxNode( npTag, GetBlockSize() + (xbUInt32) npTag->iKeyItemLen, npRight->ulBlockNo * (xbUInt32) iBlockFactor );
+ if( !npRoot ){
+ iErrorStop = 100;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+ npTag->ulRootPage = npRoot->ulBlockNo;
+
+ // std::cout << "AddKeyNewRoot - RootBlock = " << npRoot->ulBlockNo << "\n";
+ // std::cout << "AddKeyNewRoot - LeftBlock = " << npLeft->ulBlockNo << "\n";
+ // std::cout << "AddKeyNewRoot - RightBlock = " << npRight->ulBlockNo << "\n";
+
+ pLastKey = (char *) malloc( (size_t) npTag->iKeyLen );
+
+ if(( iRc = GetLastKeyForBlockNo( npTag, npLeft->ulBlockNo, pLastKey )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ char * pTrg = npRoot->cpBlockData;
+
+ // set no of keys to 1
+ ePutUInt32( pTrg, 1 );
+
+ // set the left node number
+ pTrg += 8;
+ ePutUInt32( pTrg, npLeft->ulBlockNo * (xbUInt32) iBlockFactor );
+
+ // set the key
+ pTrg+= 4;
+ memcpy( pTrg, pLastKey, (size_t) npTag->iKeyLen );
+
+ // set the right node number
+ pTrg+= (npTag->iKeyLen);
+ ePutUInt32( pTrg, npRight->ulBlockNo * (xbUInt32) iBlockFactor );
+
+ // write out the new block
+ if(( iRc = WriteBlock( npRoot->ulBlockNo, GetBlockSize(), npRoot->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+
+ // write out the new root node number in the tag header
+ // position the file
+ xbUInt32 ulPagePos = npTag->ulTagHdrPageNo * 512;
+
+ // std::cout << "ulPagePos = " << ulPagePos << " root block no = " << npRoot->ulBlockNo << " \n";
+
+ // save the number to a buffer
+ char cBuf[4];
+ ePutUInt32( cBuf, npRoot->ulBlockNo * ((xbUInt32) iBlockFactor ));
+
+ if(( iRc = xbFseek( ulPagePos, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ if(( iRc = xbFwrite( &cBuf, 4, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+
+ if( pLastKey )
+ free( pLastKey );
+
+ npRoot = FreeNodeChain( npRoot );
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::AddKeyNewRoot() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ if( pLastKey )
+ free( pLastKey );
+ }
+ return iRc;
+}
+
+
+
+/***********************************************************************/
+//! @brief Allocate a node.
+/*!
+ \param mpTag Pointer to mdx tag
+ \param ulBufSize Buffer size.
+ \param ulBlock2 Value to load in ulBlock2 field, bytes 4-7 in the first page of the block
+ \returns Pointer to new node.
+*/
+xbIxNode * xbIxMdx::AllocateIxNode( xbMdxTag * mpTag, xbUInt32 ulBufSize, xbUInt32 ulBlock2 ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbIxNode *n = NULL;
+
+ try{
+
+ // std::cout << "xbIxMdx::AllocateIxNode()\n";
+
+ if(( n = xbIx::AllocateIxNode( ulBufSize )) == NULL ){
+ iRc = XB_NO_MEMORY;
+ iErrorStop = 100;
+ throw iRc;
+ }
+ char *p = n->cpBlockData;
+ p += 4;
+
+ if( ulFirstFreePage > 0 && bReuseEmptyNodes ){
+ // we have an empty node we can reuse
+
+ // std::cout << "Reusing node " << ulFirstFreePage << "\n";
+
+ n->ulBlockNo = PageToBlock( ulFirstFreePage );
+ if(( iRc = ReadBlock( n->ulBlockNo, GetBlockSize(), n->cpBlockData )) != XB_NO_ERROR ){
+ iRc = 110;
+ throw iRc;
+ }
+ // update ulFirstFreePage
+ ulFirstFreePage = eGetUInt32( p );
+ if(( iRc = xbFseek( 36, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ if(( iRc = xbFwrite( p, 4, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ // memset cpBlockData to zeroes
+ memset( n->cpBlockData, 0x00, GetBlockSize());
+
+
+ } else {
+ n->ulBlockNo = ulPageCnt / (xbUInt32) iBlockFactor;
+ ulPageCnt += (xbUInt32) iBlockFactor;
+ }
+
+ mpTag->ulTagSize += (xbUInt32) iBlockFactor;
+ if( ulBlock2 > 0 ){
+ ePutUInt32( p, ulBlock2 );
+ }
+
+ // std::cout << "AllocateIxNode incremented the block to " << ulPageCnt << "\n";
+ // std::cout << "AllocateIxNode new block number = " << n->ulBlockNo << "\n";
+ }
+ catch( xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::AllocateIxNode() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ if( n )
+ n = FreeNodeChain( n );
+ }
+
+ return n;
+
+}
+/***********************************************************************/
+//! @brief Calculate B-tree pointers.
+/*!
+ Set binary tree pointer value. The MDX tags are stored with binary
+ tree positions. This routine calculates the value in memory.
+ \returns void
+*/
+
+void xbIxMdx::CalcBtreePointers(){
+
+ xbInt16 iaLeftChild[48];
+ xbInt16 iaRightChild[48];
+ xbInt16 iaParent[48];
+
+ for( xbInt16 i = 0; i < 48; i++ ){
+ iaLeftChild[i] = 0;
+ iaRightChild[i] = 0;
+ iaParent[i] = 0;
+ }
+
+ // anything to do?
+ if( iTagUseCnt > 1 ){
+ xbString sBaseTag;
+ xbString sThisTag;
+ xbString sWorkTag;
+ xbInt16 iWorkTagNo;
+ xbBool bDone;
+ sBaseTag = GetTagName( GetTag( 0 ));
+
+ for( xbInt16 iThisTagNo = 1; iThisTagNo < iTagUseCnt; iThisTagNo++ ){
+ iWorkTagNo = 0;
+ sWorkTag.Set( sBaseTag );
+ sThisTag = GetTagName( GetTag( iThisTagNo ));
+ bDone = xbFalse;
+ while( !bDone ){
+ if( sThisTag < sWorkTag ){
+ if( iaLeftChild[iWorkTagNo] == 0 ) {
+ iaLeftChild[iWorkTagNo] = iThisTagNo + 1;
+ iaParent[iThisTagNo] = iWorkTagNo + 1;
+ bDone = xbTrue;
+ } else {
+ iWorkTagNo = iaLeftChild[iWorkTagNo]-1;
+ sWorkTag = GetTagName( GetTag( iWorkTagNo));
+ }
+ } else {
+ if( iaRightChild[iWorkTagNo] == 0 ) {
+ iaRightChild[iWorkTagNo] = iThisTagNo + 1;
+ iaParent[iThisTagNo] = iWorkTagNo + 1;
+ bDone = xbTrue;
+ } else {
+ iWorkTagNo = iaRightChild[iWorkTagNo]-1;
+ sWorkTag = GetTagName( GetTag( iWorkTagNo ));
+ }
+ }
+ }
+ }
+ }
+
+ xbString s;
+ xbMdxTag *mpTag = mdxTagTbl;
+ for( xbInt16 i = 0; i < iTagUseCnt; i++ ){
+// s.Sprintf( "tag = [%d] parent = [%d] left = [%d] right = [%d]\n", i, iaParent[i], iaLeftChild[i], iaRightChild[i]);
+// std::cout << s;
+ mpTag->cLeftChild = (char ) iaLeftChild[i];
+ mpTag->cRightChild = (char ) iaRightChild[i];
+ mpTag->cParent = (char ) iaParent[i];
+ mpTag = mpTag->next;
+ }
+}
+
+/**************************************************************************************************************/
+//! @brief Calculate the page number for a given block
+/*!
+ This routine is called by any function needing to calculate the page number for a given block.
+ Page numbers are stored internally in the physical file, and the library reads and writes in
+ blocks of one or more pages.
+
+ Assumes valid data input
+
+ \param ulBlockNo Block Number
+ \returns Calculated page number.
+*/
+
+inline xbUInt32 xbIxMdx::BlockToPage( xbUInt32 ulBlockNo ){
+ return ulBlockNo * (xbUInt32) iBlockFactor;
+}
+/***********************************************************************/
+char xbIxMdx::CalcTagKeyFmt( xbExp &exp ){
+
+ xbExpNode *n = exp.GetTreeHandle();
+ if( n->GetChildCnt() == 0 && n->GetNodeType() == XB_EXP_FIELD )
+ return 0x01;
+ else
+ return 0;
+}
+/***********************************************************************/
+//! @brief Check for duplicate key.
+/*!
+ \param vpTag Tag to check.
+ \returns XB_KEY_NOT_UNIQUE<br>XB_NO_ERROR
+*/
+
+xbInt16 xbIxMdx::CheckForDupKey( void *vpTag )
+{
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbMdxTag *mpTag = (xbMdxTag *) vpTag;
+ mpTag->bFoundSts = xbFalse;
+ try{
+ if( GetUnique( mpTag )){
+ if( mpTag->iKeySts == XB_ADD_KEY || mpTag->iKeySts == XB_UPD_KEY )
+ if( KeyExists( mpTag )){
+ if( GetUniqueKeyOpt() == XB_EMULATE_DBASE ){
+ mpTag->bFoundSts = xbTrue;
+ return 0;
+ } else {
+ return XB_KEY_NOT_UNIQUE;
+ }
+ }
+ }
+ return 0;
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::CheckForDupKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Check tag integrity.
+/*!
+ Check a tag for accuracy.
+
+ \param vpTag Tag to create key for.
+ \param iOpt Output message destination<br>
+ 0 = stdout<br>
+ 1 = Syslog<br>
+ 2 = Both<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxMdx::CheckTagIntegrity( void *vpTag, xbInt16 iOpt ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iRc2;
+ xbInt16 iRc3;
+ xbInt16 iErrorStop = 0;
+ xbUInt32 ulIxCnt = 0;
+ xbUInt32 ulThisRecNo = 0;
+ xbUInt32 ulPrevRecNo = 0;
+ xbBool bDone = false;
+ xbString sMsg;
+ char cKeyType;
+ char *pPrevKeyBuf = NULL;
+ xbMdxTag *npTag = (xbMdxTag *) vpTag;
+ xbInt16 iAutoLock;
+ xbBool bDescending = npTag->cKeyFmt2 & 0x08;
+
+ try{
+// xbase->WriteLogMessage( "xbIxMdx::CheckTagIntegrity()", iOpt );
+
+ #ifdef XB_LOCKING_SUPPORT
+ iAutoLock = dbf->GetAutoLock();
+ if( iAutoLock && !dbf->GetTableLocked() ){
+ if(( iRc = dbf->LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ }
+ #endif
+
+ memset( npTag->cpKeyBuf2, 0x00, (size_t) npTag->iKeyLen );
+ cKeyType = GetKeyType( vpTag );
+
+ // sMsg.Sprintf( "Checking index type [%c]", cKeyType );
+ // xbase->WriteLogMessage( sMsg, iOpt );
+
+ 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
+ while( iRc == XB_NO_ERROR && !bDone ){
+ ulIxCnt++;
+
+ iRc = GetNextKey( vpTag, 0 );
+ if( iRc == XB_NO_ERROR ){
+
+ // compare this key to prev key
+ iRc2 = CompareKey( cKeyType, GetKeyData( npTag->npCurNode, npTag->npCurNode->iCurKeyNo, npTag->iKeyItemLen ),
+ pPrevKeyBuf, (size_t) npTag->iKeyLen );
+
+ if(( iRc2 < 0 && !bDescending ) || ( iRc2 > 0 && bDescending )){
+ sMsg.Sprintf( "Key sequence error at key number [%ld].", ulIxCnt );
+ xbase->WriteLogMessage( sMsg, iOpt );
+ iErrorStop = 110;
+ iRc = XB_INVALID_INDEX;
+ throw iRc;
+ }
+
+ ulThisRecNo = 0;
+ if(( iRc3 = GetDbfPtr( vpTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulThisRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc3;
+ }
+
+ if( iRc2 == 0 && (ulThisRecNo <= ulPrevRecNo )){
+ sMsg.Sprintf( "Dbf record number sequence error at key number [%ld].", iOpt );
+ xbase->WriteLogMessage( sMsg, iOpt );
+ iErrorStop = 130;
+ iRc = XB_INVALID_INDEX;
+ throw iRc;
+ }
+ // save this key info to prev key
+ memcpy( pPrevKeyBuf, GetKeyData( npTag->npCurNode, npTag->npCurNode->iCurKeyNo, npTag->iKeyItemLen ), (size_t) npTag->iKeyLen );
+ ulPrevRecNo = ulThisRecNo;
+ }
+ }
+
+ xbUInt32 ulDbfCnt = 0;
+ if(( iRc = dbf->GetRecordCnt( ulDbfCnt )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+
+ xbUInt32 ulFiltCnt = 0;
+ xbBool bFiltered = xbTrue;
+ // verify each record in the dbf file has a corresponding index entry
+ xbUInt32 j = 0;
+ while( j < ulDbfCnt ){
+
+ if(( iRc = dbf->GetRecord( ++j )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+ if( npTag->cHasFilter ){
+ if(( iRc = npTag->filter->ProcessExpression( 0 )) != XB_NO_ERROR ){
+ iErrorStop = 160;
+ throw iRc;
+ }
+ if(( iRc = npTag->filter->GetBoolResult( bFiltered )) != XB_NO_ERROR ){
+ iErrorStop = 170;
+ throw iRc;
+ }
+ }
+
+ if( bFiltered ){
+ if(( iRc = FindKeyForCurRec( vpTag )) != XB_NO_ERROR ){
+ ulThisRecNo = j;
+ iErrorStop = 180;
+ throw iRc;
+ }
+ ulFiltCnt++;
+ }
+ }
+
+ if((GetUniqueKeyOpt() == XB_EMULATE_DBASE) && (GetUnique( vpTag ))){
+ // can't compare counts if using XB_EMULATE_DBASE and it's a unique index
+ } else {
+ if( ulIxCnt != ulFiltCnt && GetUniqueKeyOpt() == XB_HALT_ON_DUPKEY ){
+ if( npTag->cHasFilter )
+ sMsg.Sprintf( "xbIxMdx::CheckTagIntegrity() Filtered index entry count [%ld] does not match dbf record count [%ld] for tag [%s]", ulIxCnt, ulFiltCnt, npTag->cTagName );
+ else
+ sMsg.Sprintf( "xbIxMdx::CheckTagIntegrity() Index entry count [%ld] does not match dbf record count [%ld] for tag [%s]", ulIxCnt, ulFiltCnt, npTag->cTagName );
+
+ xbase->WriteLogMessage( sMsg, iOpt );
+ iErrorStop = 190;
+ iRc = XB_INVALID_INDEX;
+ throw iRc;
+ }
+ if( npTag->cHasFilter )
+ sMsg.Sprintf( "xbIxMdx::CheckTagIntegrity() Filtered index entry count [%ld] matches dbf record count [%ld] for tag [%s]", ulIxCnt, ulFiltCnt, npTag->cTagName );
+ else
+ sMsg.Sprintf( "xbIxMdx::CheckTagIntegrity() Index entry count [%ld] matches dbf record count [%ld] for tag [%s]", ulIxCnt, ulFiltCnt, npTag->cTagName );
+ xbase->WriteLogMessage( sMsg, iOpt );
+ }
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock && dbf->GetTableLocked() ){
+ if(( iRc = dbf->LockTable( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 200;
+ throw iRc;
+ }
+ }
+ #endif
+
+ if( pPrevKeyBuf )
+ free( pPrevKeyBuf );
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::CheckTagIntegrity() Exception Caught. Error Stop = [%d] iRc = [%d] Tag = [%s]", iErrorStop, iRc, npTag->cTagName );
+ xbase->WriteLogMessage( sMsg, iOpt );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ), iOpt );
+ if( pPrevKeyBuf )
+ free( pPrevKeyBuf );
+
+ if( iErrorStop == 160 ){
+ sMsg.Sprintf( "xbIxNdx::CheckTagIntegrity() Missing index entry for record [%d]", ulThisRecNo );
+ xbase->WriteLogMessage( sMsg, iOpt );
+ }
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+xbMdxTag *xbIxMdx::ClearTagTable(){
+
+ // clear the list of tags
+ xbMdxTag *tt = mdxTagTbl;
+ xbMdxTag *tt2;
+ while( tt ){
+ tt2 = tt;
+ tt = tt->next;
+ tt2->npNodeChain = FreeNodeChain( tt2->npNodeChain );
+ tt2->npCurNode = NULL;
+ if( tt2->cpKeyBuf )
+ free( tt2->cpKeyBuf );
+ if( tt2->cpKeyBuf2 )
+ free( tt2->cpKeyBuf2 );
+ if( tt2->exp )
+ delete tt2->exp;
+ if( tt2->filter )
+ delete tt2->filter;
+ if( tt2->sKeyExp )
+ delete tt2->sKeyExp;
+ if( tt2->sTagName )
+ delete tt2->sTagName;
+ if( tt2->sFiltExp )
+ delete tt2->sFiltExp;
+ free( tt2 );
+ }
+ return NULL;
+}
+/***********************************************************************/
+xbInt16 xbIxMdx::Close(){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ mdxTagTbl = ClearTagTable();
+ if(( iRc = xbIx::Close()) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::Close() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+
+/***********************************************************************/
+//! @brief Create key.
+/*!
+
+ \param vpTag Tag
+ \param iOpt 1 = Append, 2 = Update
+ \returns XB_KEY_NOT_UNIQUE<br>XB_NO_ERROR
+
+ iKeySts 0 - No Updates
+ 1 - Add Key XB_ADD_KEY
+ 2 - Update Key XB_UPD_KEY
+ 3 - Delete Key XB_DEL_KEY
+
+ bKeyFiltered xbFalse - Key filtered out
+ xbTrue - Key filtered in
+
+ cpKeyBuf - Key buffer for add
+ cpKeyBuf2 - Key buffer for delete
+
+*/
+
+xbInt16 xbIxMdx::CreateKey( void *vpTag, xbInt16 iOpt ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ xbBool bFilter0 = xbFalse; // filter against RecBuf, updated record buffer
+ xbBool bFilter1 = xbFalse; // filter against recBuf2, original record buffer
+
+ try{
+
+ xbMdxTag *npTag = (xbMdxTag *) vpTag;
+ npTag->iKeySts = 0;
+
+ // char *p0 = dbf->GetRecordBuf(0);
+ // char *p1 = dbf->GetRecordBuf(1);
+
+ // do tag filter logic
+ if( npTag->cHasFilter ){
+ if(( iRc = npTag->filter->ProcessExpression( 0 )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ if(( iRc = npTag->filter->GetBoolResult( bFilter0 )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ // std::cout << "cp1 f0 = " << bFilter0 << "\n";
+ // printf( "del byte 0 [%x] 1 [%x]\n", *p0, *p1 );
+ } else {
+ bFilter0 = xbTrue;
+ }
+
+ // if add request and filtered out, we're done
+ if( iOpt == 1 && !bFilter0 )
+ return XB_NO_ERROR;
+
+ if(( iRc = npTag->exp->ProcessExpression( 0 )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ if( npTag->exp->GetReturnType() == XB_EXP_CHAR )
+ npTag->exp->GetStringResult( npTag->cpKeyBuf, (xbUInt32) npTag->iKeyLen );
+ else if( npTag->exp->GetReturnType() == XB_EXP_NUMERIC ){
+ xbDouble d;
+ npTag->exp->GetNumericResult( d );
+ xbBcd bcd( d );
+ bcd.ToChar( npTag->cpKeyBuf );
+ }
+ else if( npTag->exp->GetReturnType() == XB_EXP_DATE ){
+ xbDouble d;
+ npTag->exp->GetNumericResult( d );
+ memcpy( npTag->cpKeyBuf, &d, 8 );
+ }
+
+ if( iOpt == 1 ) // Append
+ npTag->iKeySts = XB_ADD_KEY;
+
+ else if( iOpt == 2 ){ // Update
+ if( npTag->cHasFilter ){
+ if(( iRc = npTag->filter->ProcessExpression( 1 )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ if(( iRc = npTag->filter->GetBoolResult( bFilter1 )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+ } else {
+ bFilter1 = xbTrue;
+ }
+
+ if(( iRc = npTag->exp->ProcessExpression( 1 )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+
+ if( npTag->exp->GetReturnType() == XB_EXP_CHAR ){
+ npTag->exp->GetStringResult( npTag->cpKeyBuf2, (xbUInt32) npTag->iKeyLen );
+
+ } else if( npTag->exp->GetReturnType() == XB_EXP_NUMERIC ){
+ xbDouble d;
+ npTag->exp->GetNumericResult( d );
+ xbBcd bcd( d );
+ bcd.ToChar( npTag->cpKeyBuf2 );
+
+ } else if( npTag->exp->GetReturnType() == XB_EXP_DATE ){
+ xbDouble d;
+ npTag->exp->GetNumericResult( d );
+ memcpy( npTag->cpKeyBuf2, &d, 8 );
+
+ }
+
+ if( bFilter1 ){ // original key was indexed
+ if( bFilter0 ){ // new key s/b indexed, update it if changed
+ if( memcmp( npTag->cpKeyBuf, npTag->cpKeyBuf2, (size_t) npTag->iKeyLen )){
+ npTag->iKeySts = XB_UPD_KEY;
+ }
+ } else { // original key indexed, new key not indexed, delete it
+ npTag->iKeySts = XB_DEL_KEY;
+ }
+ } else { // original key not indexed
+ if( bFilter0 )
+ npTag->iKeySts = XB_ADD_KEY;
+ }
+ }
+
+// std::cout << "xbIxMdx::CreateKey key sts = " << npTag->iKeySts << " iOpt = " << iOpt << " type = " << npTag->exp->GetReturnType() << " name = " << npTag->cTagName;
+// std::cout << " f0 = " << bFilter0 << " f1 = " << bFilter1 << "\n";
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::CreateKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Create new tag.
+/*!
+ This routine creates a new tag. When complete, sets the cur tag pointer to
+ the newly created tag.
+
+ \param sName Tag Name, including .MDX suffix
+ \param sKey Key Expression
+ \param sFilter Filter expression.
+ \param iDescending
+ \param iUnique xbtrue - Unique.<br>xbFalse - Not unique.
+ \param iOverLay xbTrue - Overlay if file already exists.<br>xbFalse - Don't overlay.
+ \param vpTag Output from method Pointer to vptag pointer.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+
+xbInt16 xbIxMdx::CreateTag( const xbString &sName, const xbString &sKey, const xbString &sFilter, xbInt16 iDescending, xbInt16 iUnique, xbInt16 iOverlay, void **vpTag ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbMdxTag *tte = NULL;
+
+
+ // std::cout << "CreateTag() name=[" << sName.Str() << "] key=[" << sKey.Str() << "] sFilter=[" << sFilter.Str() << "]\n";
+ // std::cout << "TagUseCnt = " << iTagUseCnt << std::endl;
+
+
+ try{
+ // verify room for new tag
+ if( !( iTagUseCnt < 47 )){
+ iErrorStop = 100;
+ iRc = XB_LIMIT_REACHED;
+ throw iRc;
+ }
+
+ // verify valid tag name
+ xbString sWorker = sName;
+ sWorker.Trim();
+ if( sWorker.Len() > 10 ){
+ iErrorStop = 110;
+ iRc = XB_INVALID_TAG;
+ throw iRc;
+ }
+
+ // verify tag not already defined
+ if( iTagUseCnt > 0 ){
+ if( GetTag( sWorker )){
+ iErrorStop = 120;
+ iRc = XB_INVALID_TAG;
+ throw iRc;
+ }
+ }
+
+ // allocate a tag structure here
+ if(( tte = (xbMdxTag *) calloc( 1, (size_t) sizeof( xbMdxTag ))) == NULL ){
+ iErrorStop = 130;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+ *vpTag = tte;
+ tte->sTagName = new xbString( sWorker );
+
+ //set up the key expression
+ sWorker = sFilter;
+ sWorker.Trim();
+ if( sWorker.Len() > 0 ){
+ if( sWorker.Len() == 0 || sWorker.Len() > 220 ){
+ iRc = XB_INVALID_TAG;
+ iErrorStop = 140;
+ throw iRc;
+ }
+ tte->sFiltExp = new xbString( sWorker );
+ tte->filter = new xbExp( dbf->GetXbasePtr());
+ if(( iRc = tte->filter->ParseExpression( dbf, sWorker )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+
+ // tte->filter->DumpTree( 1 );
+
+ if((tte->filter->GetReturnType()) != 'L' ){
+ iRc = XB_INVALID_TAG;
+ iErrorStop = 160;
+ throw iRc;
+ }
+ tte->cHasFilter = 0x01;
+ }
+
+ //set up the key expression
+ sWorker = sKey;
+ sWorker.Trim();
+ if( sWorker.Len() == 0 || sWorker.Len() > 100 ){
+ iRc = XB_INVALID_TAG;
+ iErrorStop = 170;
+ throw iRc;
+ }
+ tte->sKeyExp = new xbString( sWorker );
+ tte->exp = new xbExp( dbf->GetXbasePtr());
+ if(( iRc = tte->exp->ParseExpression( dbf, sWorker )) != XB_NO_ERROR ){
+ iErrorStop = 180;
+ throw iRc;
+ }
+
+ xbDate d;
+
+ if( iTagUseCnt == 0 ){
+ // first tag, new mdx file
+ // create the file name
+ xbString sIxFileName = dbf->GetFqFileName();
+ sIxFileName.Trim();
+ xbUInt32 lLen = sIxFileName.Len();
+ sIxFileName.PutAt( lLen-2, 'M' );
+ sIxFileName.PutAt( lLen-1, 'D' );
+ sIxFileName.PutAt( lLen, 'X' );
+
+ // copy the file name to the class variable
+ this->SetFileName( sIxFileName );
+ if( FileExists() && !iOverlay ){
+ iErrorStop = 190;
+ iRc = XB_FILE_EXISTS;
+ throw iRc;
+ }
+
+ // first tag, need to create the file
+ if(( iRc = xbFopen( "w+b", dbf->GetShareMode())) != XB_NO_ERROR ){
+ iErrorStop = 200;
+ throw iRc;
+ }
+ cVersion = 2;
+ cCreateYY = (char) d.YearOf() - 1900;
+ cCreateMM = (char) d.MonthOf();
+ cCreateDD = (char) d.DayOf( XB_FMT_MONTH );
+
+ GetFileNamePart( sFileName );
+ sFileName.ToUpperCase();
+
+ SetBlockSize( (xbUInt32) dbf->GetCreateMdxBlockSize());
+ iBlockFactor = GetBlockSize() / 512;
+
+ cProdIxFlag = 1;
+ cTagEntryCnt = 48;
+ iTagLen = 32;
+ ulPageCnt = 4;
+ ulFirstFreePage = 0;
+ ulNoOfBlockAvail = 0;
+ cNextTag = 1;
+ c1B = 0x1B;
+ cUpdateYY = cCreateYY;
+ cUpdateMM = cCreateMM;
+ cUpdateDD = cCreateDD;
+
+ if(( iRc = WriteHeadBlock( 0 )) != XB_NO_ERROR ){
+ iErrorStop = 210;
+ throw iRc;
+ }
+ }
+
+ // populate the tag table entry structure
+ tte->ulTagHdrPageNo = ulPageCnt;
+ ulPageCnt += (xbUInt32) iBlockFactor;
+ tte->sTagName->strncpy( tte->cTagName, 10 );
+
+ // cKeyFmt is always 0x10;
+ // tested 2+ZIPCD CITY+STATE or just standalone field - always 0x10
+ tte->cKeyFmt = 0x10; // = CalcTagKeyFmt( *tte->exp );
+
+ switch( tte->exp->GetReturnType()){
+ case XB_EXP_CHAR:
+ tte->cKeyType = 'C';
+ tte->iKeyLen = tte->exp->GetResultLen();
+ tte->iSecKeyType = 0;
+ break;
+
+ case XB_EXP_NUMERIC:
+ tte->cKeyType = 'N';
+ tte->iKeyLen = 12;
+ tte->iSecKeyType = 0;
+ break;
+
+ case XB_EXP_DATE:
+ tte->cKeyType = 'D';
+ tte->iKeyLen = 8;
+ tte->iSecKeyType = 1;
+ break;
+
+ default:
+ iErrorStop = 200;
+ iRc = XB_INVALID_INDEX;
+ throw iRc;
+ }
+
+ tte->cpKeyBuf = (char *) malloc( (size_t) tte->iKeyLen + 1 );
+ tte->cpKeyBuf2 = (char *) malloc( (size_t) tte->iKeyLen + 1 );
+
+// if( 0 ){
+// printf( "ulTagHdrPageNo=[%d] cTagName=[%-11s], cLeftChild=[%d] cRightChild=[%d] cParent=[%d] cKeyType=[%c]\n\n",
+// tte->ulTagHdrPageNo, tte->cTagName, tte->cLeftChild, tte->cRightChild, tte->cParent, tte->cKeyType );
+// }
+
+ // write the new tte entry here
+ char tteBuf[21];
+ memset( tteBuf, 0x00, 21 );
+
+ ePutUInt32( &tteBuf[0], tte->ulTagHdrPageNo );
+ for( xbUInt32 l = 0; l < tte->sTagName->Len() && l < 10; l++ ){
+ tteBuf[l+4] = tte->sTagName->GetCharacter(l+1);
+ }
+ tteBuf[15] = tte->cKeyFmt;
+ tteBuf[19] = 0x02; // appears to always be a 0x02
+ tteBuf[20] = tte->cKeyType;
+
+ if(( iRc = xbFseek( (iTagUseCnt * 32) + 544, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 210;
+ throw iRc;
+ }
+ if(( iRc = xbFwrite( tteBuf, 21, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 220;
+ throw iRc;
+ }
+
+
+ // Begin Tag Header
+ tte->ulRootPage = ulPageCnt;
+ tte->ulTagSize = (xbUInt32) iBlockFactor;
+ ulPageCnt += 2;
+ tte->cKeyFmt2 = 0x10;
+ if( iDescending )
+ tte->cKeyFmt2 += 0x08;
+ if( iUnique ){
+ tte->cKeyFmt2 += 0x40;
+ tte->cUnique = 0x01;
+ }
+
+ tte->cTag11 = 0x1B; // always 0x1b ?
+ tte->cSerialNo = 0x01; // version incremented with each tag update
+ tte->ulLeftChild = tte->ulRootPage;
+ tte->ulRightChild = tte->ulRootPage;
+
+ tte->cTagYY = (char) d.YearOf() - 1900;
+ tte->cTagMM = (char) d.MonthOf();
+ tte->cTagDD = (char) d.DayOf( XB_FMT_MONTH );
+
+ tte->cKeyType2 = tte->cKeyType;
+ tte->iKeyItemLen = tte->iKeyLen + 4;
+
+ tte->iKeysPerBlock = (xbInt16) (GetBlockSize() - 12) / tte->iKeyItemLen;
+ 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 );
+// printf( "iSecKeyType=[%d] iKeyItemLen=[%d] cUnique=[%d] \n", tte->iSecKeyType, tte->iKeyItemLen, tte->cUnique );
+
+ char *pBuf;
+ if(( pBuf = (char *) calloc( 1, (size_t) GetBlockSize())) == NULL ){
+ iErrorStop = 230;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+ char *wPtr;
+ wPtr = pBuf;
+ ePutUInt32( wPtr, tte->ulRootPage );
+
+ wPtr += 4;
+ ePutUInt32( wPtr, tte->ulTagSize );
+
+ wPtr += 4;
+ *wPtr = tte->cKeyFmt2;
+
+ wPtr++;
+ *wPtr = tte->cKeyType2;
+
+ wPtr += 2;
+ *wPtr = tte->cTag11;
+
+ wPtr += 1;
+ ePutInt16( wPtr, tte->iKeyLen );
+
+ wPtr += 2;
+ ePutInt16( wPtr, tte->iKeysPerBlock );
+
+ wPtr += 2;
+ ePutInt16( wPtr, tte->iSecKeyType );
+
+ wPtr += 2;
+ ePutInt16( wPtr, tte->iKeyItemLen );
+
+ wPtr += 2;
+ *wPtr = tte->cSerialNo;
+
+ wPtr += 3;
+ *wPtr = tte->cUnique;
+
+ wPtr++;
+ for( xbUInt32 l = 0; l < tte->sKeyExp->Len(); l++ )
+ *wPtr++ = tte->sKeyExp->GetCharacter(l+1);
+
+ wPtr = pBuf;
+
+ tte->cHasKeys = 0x00;
+ pBuf[246] = tte->cHasKeys;
+
+ wPtr += 248;
+ ePutUInt32( wPtr, tte->ulLeftChild );
+ wPtr += 4;
+ ePutUInt32( wPtr, tte->ulRightChild );
+
+ pBuf[257] = tte->cTagYY;
+ pBuf[258] = tte->cTagMM;
+ pBuf[259] = tte->cTagDD;
+ pBuf[480] = tte->cKeyFmt3;
+
+ if( sFilter.Len() > 0 ){
+ pBuf[245] = tte->cHasFilter;
+ wPtr = pBuf;
+ wPtr += 762;
+ for( xbUInt32 l = 0; l < sFilter.Len(); l++ )
+ *wPtr++ = sFilter.GetCharacter(l+1);
+ }
+
+ if(( iRc = xbFseek( tte->ulTagHdrPageNo * 512, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 240;
+ throw iRc;
+ }
+
+ if(( iRc = xbFwrite( pBuf, GetBlockSize(), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 250;
+ throw iRc;
+ }
+
+ memset( pBuf, 0x00, GetBlockSize() );
+ if(( iRc = xbFwrite( pBuf, GetBlockSize(), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 260;
+ throw iRc;
+ }
+
+ iTagUseCnt++;
+ cNextTag++;
+
+
+ if(( iRc = WriteHeadBlock( 1 )) != XB_NO_ERROR ){
+ iErrorStop = 270;
+ throw iRc;
+ }
+
+ // update the dbf file if needed - discreet field, has no filter
+ // 10/15/22 - dbase 7 does not update this field on index creation
+ if( tte->cKeyFmt3 == 0x01 && !tte->cHasFilter ){
+ // printf( "cKeyFmt3 = [%x]\n", tte->cKeyFmt3 );
+ xbInt16 iFldNo;
+ if(( iRc = dbf->GetFieldNo( sKey, iFldNo )) != XB_NO_ERROR ){
+ iErrorStop = 280;
+ throw iRc;
+ }
+ xbInt64 lOffset = 31 + ((iFldNo + 1) * 32 );
+
+ if(( iRc = dbf->xbFseek( lOffset, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 290;
+ iRc = XB_SEEK_ERROR;
+ throw iRc;
+ }
+ char cBuf[2];
+ cBuf[0] = 0x01;
+ cBuf[1] = 0x00;
+
+ if(( iRc = dbf->xbFwrite( cBuf, 1, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 300;
+ throw iRc;
+ }
+ dbf->UpdateSchemaIxFlag( iFldNo, 0x01 );
+ }
+
+ // add the new entry to the end of the list of tags
+ if( mdxTagTbl == NULL ){
+ mdxTagTbl = tte;
+ } else {
+ xbMdxTag *tteL = mdxTagTbl;
+ while( tteL->next )
+ tteL = tteL->next;
+ tteL->next = tte;
+ }
+
+ /* update the btree pointers */
+ CalcBtreePointers();
+ char bBuf[3];
+ xbMdxTag *tteWork = mdxTagTbl;
+
+ if(( iRc = xbFseek( 560, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 310;
+ throw iRc;
+ }
+ while( tteWork ){
+ bBuf[0] = tteWork->cLeftChild;
+ bBuf[1] = tteWork->cRightChild;
+ bBuf[2] = tteWork->cParent;
+
+ if(( iRc = xbFwrite( bBuf, 3, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 320;
+ throw iRc;
+ }
+ if( tteWork->next ){
+ if(( iRc = xbFseek( 29, SEEK_CUR )) != XB_NO_ERROR ){
+ iErrorStop = 330;
+ throw iRc;
+ }
+ }
+ tteWork = tteWork->next;
+ }
+ free( pBuf );
+
+// xbIx::SetCurTag( ( void *) tte );
+
+ }
+
+ catch (xbInt16 iRc ){
+ if( tte ){
+ if( tte->cpKeyBuf )
+ free( tte->cpKeyBuf );
+ if( tte->cpKeyBuf2 )
+ free( tte->cpKeyBuf2 );
+ if( tte->exp )
+ delete tte->exp;
+ if( tte->filter )
+ delete tte->filter;
+ if( tte->sKeyExp )
+ delete tte->sKeyExp;
+ if( tte->sFiltExp )
+ delete tte->sFiltExp;
+ if( tte->sTagName )
+ delete tte->sTagName;
+ free( tte );
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::CreateTag() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+
+ return iRc;
+};
+
+/***********************************************************************/
+//! @brief Delete a key from a node.
+/*!
+ This routine deletes a key from a supplied node.
+ \param vpTag Tag to delete key on.
+ \param npNode Node to delete key on.
+ \param iSlotNo Slot number of key to delete.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxMdx::DeleteFromNode( void *vpTag, xbIxNode * npNode, xbInt16 iSlotNo )
+{
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbMdxTag * npTag = (xbMdxTag *) vpTag;
+
+ try{
+ xbInt32 lKeyCnt = GetKeyCount( npNode );
+ xbInt16 iLen = (lKeyCnt - iSlotNo - 1) * npTag->iKeyItemLen;
+ xbBool bLeaf = IsLeaf( vpTag, npNode );
+ if( !bLeaf )
+ iLen += 4;
+
+ char *pTrg = npNode->cpBlockData;
+ if( iLen > 0 ){
+ pTrg += (8 + (npTag->iKeyItemLen * (iSlotNo)) ); //lTrgPos;
+ // std::cout << "TrgSpot = " << (8 + (npTag->iKeyItemLen * (iSlotNo)) ) << "\n";
+ char *pSrc = pTrg;
+ pSrc += npTag->iKeyItemLen;
+ memmove( pTrg, pSrc, (size_t) iLen );
+ }
+
+ // zap out the right most key
+ pTrg = npNode->cpBlockData;
+ if( bLeaf ){
+ pTrg += (8 + (npTag->iKeyItemLen * ( lKeyCnt-1 )));
+
+ } else {
+ pTrg += (12 + (npTag->iKeyItemLen * ( lKeyCnt-1 )));
+
+ }
+
+ for( xbInt16 i = 0; i < npTag->iKeyItemLen; i++ )
+ *pTrg++ = 0x00;
+
+ // set the new number of keys
+ ePutUInt32( npNode->cpBlockData, (xbUInt32) lKeyCnt - 1 );
+
+ // if node empty, add it to the free node chain
+ if( lKeyCnt < 2 ){
+ if( bReuseEmptyNodes ){
+ if( bLeaf && lKeyCnt == 1 ){
+ if(( iRc = HarvestEmptyNode( npTag, npNode, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ }
+ }
+ }
+
+ // write out the block
+ if(( iRc = WriteBlock( npNode->ulBlockNo, GetBlockSize(), npNode->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ // do any empty node processing here
+// if( bReuseEmptyNodes ){
+// if( bLeaf && lKeyCnt == 1 ){
+// std::cout << "Empty node ready for reuse\n";
+// }
+// }
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::DeleteFromNode() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return XB_NO_ERROR;
+}
+
+/***********************************************************************/
+//! @brief Delete a key.
+/*!
+ This routine deletes a key. It assumes the key to delete
+ is the current key in the node chain.
+
+ \param vpTag Tag to delete key on.
+
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxMdx::DeleteKey( void *vpTag ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbMdxTag * npTag = (xbMdxTag *) vpTag;
+
+ // save copy of node chain to reset to after delete completed
+ xbIxNode *npSaveNodeChain = npTag->npNodeChain;
+ npTag->npNodeChain = NULL;
+ xbIxNode * npSaveCurNode = npTag->npCurNode;
+
+ // std::cout << "xbIxMdx::DeleteKey()\n";
+
+ try{
+ xbString sMsg;
+
+ if(( iRc = xbIxMdx::KeySetPosDel( npTag )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ // Delete key needs to handle two scenarios
+ // 1 - if delete is on the only key of leaf,
+ // traverse up tree, trim as needed
+ // 2 - if last key on node is deleted, and key value is not the same
+ // as prev key, ascend tree looking for an interior node needing
+ // updated key value
+
+
+ xbInt32 lOrigKeyCnt = GetKeyCount( npTag->npCurNode );
+ if(( iRc = DeleteFromNode( npTag, npTag->npCurNode, npTag->npCurNode->iCurKeyNo )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ if( lOrigKeyCnt == 1 ){
+
+ // scenario 1
+ xbBool bDone = xbFalse;
+ xbBool bIsLeaf = xbFalse;
+ xbInt32 lKeyCnt;
+ npTag->npCurNode = npTag->npCurNode->npPrev;
+
+ while( npTag->npCurNode && !bDone ){
+ lKeyCnt = GetKeyCount( npTag->npCurNode );
+ bIsLeaf = IsLeaf( npTag, npTag->npCurNode );
+ if( lKeyCnt > 0 ){
+ if(( iRc = DeleteFromNode( npTag, npTag->npCurNode, npTag->npCurNode->iCurKeyNo )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ } else if(( iRc = HarvestEmptyNode( npTag, npTag->npCurNode, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+
+ if( (bIsLeaf && lKeyCnt > 1) || (!bIsLeaf && lKeyCnt > 0) )
+ bDone = xbTrue;
+ else
+ npTag->npCurNode = npTag->npCurNode->npPrev;
+ }
+
+ } else if( npTag->npCurNode->iCurKeyNo == (xbUInt32) lOrigKeyCnt - 1 ){
+
+ // scenario 2
+ // if last two keys identical, then nothing to do, else go up looking for a key to change
+ if( memcmp( GetKeyData( npTag->npCurNode, npTag->npCurNode->iCurKeyNo, npTag->iKeyItemLen ),
+ GetKeyData( npTag->npCurNode, npTag->npCurNode->iCurKeyNo-1, npTag->iKeyItemLen ),
+ (size_t) npTag->iKeyLen )){
+
+ xbIxNode *pNode = npTag->npCurNode->npPrev;
+ char *pSrc = GetKeyData( npTag->npCurNode, npTag->npCurNode->iCurKeyNo-1, npTag->iKeyItemLen );
+
+ while( pNode && pNode->ulBlockNo != npTag->ulRootPage && pNode->iCurKeyNo == (xbUInt32) GetKeyCount( pNode ) )
+ pNode = pNode->npPrev;
+
+ if( pNode ){
+ if( pNode->iCurKeyNo < (xbUInt32) GetKeyCount( pNode )){
+ char *pTrg = pNode->cpBlockData;
+ pTrg += 12 + (pNode->iCurKeyNo * (xbUInt32) npTag->iKeyItemLen);
+ for( xbInt16 i = 0; i < npTag->iKeyLen; i++ )
+ *pTrg++ = *pSrc++;
+ // write out the block
+ if(( iRc = WriteBlock( pNode->ulBlockNo, GetBlockSize(), pNode->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+ }
+ }
+ }
+ }
+ // restore node chain to pre delete status (which should be post add status)
+ npTag->npNodeChain = FreeNodeChain( npTag->npNodeChain );
+ npTag->npNodeChain = npSaveNodeChain;
+ npTag->npCurNode = npSaveCurNode;
+
+ // update the serial number
+ if(( iRc = TagSerialNo( 3, npTag )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::DeleteKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ if( npSaveNodeChain ){
+ npTag->npNodeChain = npSaveNodeChain;
+ npSaveNodeChain = FreeNodeChain( npSaveNodeChain );
+ npTag->npCurNode = npSaveCurNode;
+ }
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Dump a given block for a tag
+/*!
+ \param vpTag Input tag ptr for tag to be deleted<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a><br>
+ 1 = Deleted entire MDX file, only had one tag
+
+*/
+
+xbInt16 xbIxMdx::DeleteTag( void *vpTag ){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbMdxTag * mpTag = (xbMdxTag *) vpTag;
+ xbIxNode *n = NULL;
+ xbBool bLoneTag = xbFalse;
+
+ try{
+
+ if( !vpTag ){
+ iErrorStop = 100;
+ iRc = XB_INVALID_TAG;
+ throw iRc;
+ }
+
+ char cSaveHasFilter = mpTag->cHasFilter;
+ char cSaveKeyFmt3 = mpTag->cKeyFmt3;
+ xbString sSaveKey = mpTag->sKeyExp->Str();
+
+ if( iTagUseCnt == 1 ){
+ // std::cout << "xbIxMdx::DeleteTag - one tag found, delete the mdx file\n";
+
+ // close the mdx file
+ if(( iRc = xbIxMdx::Close()) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ // delete the file
+ xbRemove();
+
+ // init variables - needed?
+ // Init();
+ // iRc > 0 defines this as the only tag in an MDX file, MDX file deleted.
+ // signals to the calling process to drop the MDX file from the
+ // list of updateable indices.
+ bLoneTag = xbTrue;
+
+ } else {
+
+ // harvest tag nodes
+
+ if(( iRc = HarvestTagNodes( mpTag, xbTrue )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+
+ // remove an entry from tag table
+ // which tag is this?
+ xbInt16 iTagNo = 0;
+ xbMdxTag *mp = mdxTagTbl;
+ xbMdxTag *mpPrev = NULL;
+ while( mp && mp->ulTagHdrPageNo != mpTag->ulTagHdrPageNo ){
+ iTagNo++;
+ mpPrev = mp;
+ mp = mp->next;
+ }
+
+ // remove it from the linked list of tags
+ if( !mpPrev ){
+ mdxTagTbl = mp->next;
+ } else {
+ mpPrev->next = mp->next;
+ }
+ if( mp ){
+ if( mp->cpKeyBuf ) free( mp->cpKeyBuf );
+ if( mp->cpKeyBuf2 ) free( mp->cpKeyBuf2 );
+ if( mp->exp ) delete mp->exp;
+ if( mp->filter ) delete mp->filter;
+ if( mp->sKeyExp ) delete mp->sKeyExp;
+ if( mp->sFiltExp ) delete mp->sFiltExp;
+ if( mp->sTagName ) delete mp->sTagName;
+ free( mp );
+ }
+ xbInt32 iTarg = iTagNo * 32;
+ xbInt32 iSrc = iTarg + 32;
+ xbInt32 iLen = (iTagUseCnt - iTagNo) * 32;
+
+ if(( iRc = xbFseek( 544, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 160;
+ throw iRc;
+ }
+ char Buf[1536]; // 47 tags + 1 in case tag #47 is deleted
+ memset( Buf, 0x00, 1536 );
+ if(( iRc = xbFread( Buf, 1504, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 170;
+ throw iRc;
+ }
+ char *pTrg = Buf;
+ pTrg += iTarg;
+ char *pSrc = Buf;
+ pSrc += iSrc;
+ for( xbInt32 i = 0; i < iLen; i++ )
+ *pTrg++ = *pSrc++;
+
+ if(( iRc = xbFseek( 544, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 180;
+ throw iRc;
+ }
+ if(( iRc = xbFwrite( Buf, 1504, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 190;
+ throw iRc;
+ }
+
+ iTagUseCnt--;
+ if(( iRc = WriteHeadBlock( 1 )) != XB_NO_ERROR ){
+ iErrorStop = 200;
+ throw iRc;
+ }
+
+ /* update the btree pointers */
+ CalcBtreePointers();
+ char bBuf[3];
+ xbMdxTag *tteWork = mdxTagTbl;
+
+ if(( iRc = xbFseek( 560, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 210;
+ throw iRc;
+ }
+ while( tteWork ){
+ bBuf[0] = tteWork->cLeftChild;
+ bBuf[1] = tteWork->cRightChild;
+ bBuf[2] = tteWork->cParent;
+
+ if(( iRc = xbFwrite( bBuf, 3, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 320;
+ throw iRc;
+ }
+ if( tteWork->next ){
+ if(( iRc = xbFseek( 29, SEEK_CUR )) != XB_NO_ERROR ){
+ iErrorStop = 330;
+ throw iRc;
+ }
+ }
+ tteWork = tteWork->next;
+ }
+ }
+
+ // update the dbf file if needed, if discreet field with no filter
+ // printf( "cSaveKeyFmt3 = [%x] cSaveHasFilter=[%x] SaveKey = [%s]\n", cSaveKeyFmt3, cSaveHasFilter, sSaveKey.Str());
+
+ if( cSaveKeyFmt3 == 0x01 && !cSaveHasFilter ){
+ xbInt16 iFldNo;
+ if(( iRc = dbf->GetFieldNo( sSaveKey, iFldNo )) != XB_NO_ERROR ){
+ iErrorStop = 340;
+ throw iRc;
+ }
+ xbInt64 lOffset = 31 + ((iFldNo + 1) * 32 );
+
+ if(( iRc = dbf->xbFseek( lOffset, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 350;
+ iRc = XB_SEEK_ERROR;
+ throw iRc;
+ }
+ char cBuf[2];
+ cBuf[0] = 0x00;
+ cBuf[1] = 0x00;
+ if(( iRc = dbf->xbFwrite( cBuf, 1, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 360;
+ throw iRc;
+ }
+ dbf->UpdateSchemaIxFlag( iFldNo, 0x00 );
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::DeleteTag() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ if( n )
+ free( n );
+ }
+ if( bLoneTag && !iRc )
+ return 1;
+ else
+ return iRc;
+}
+
+/***********************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+
+
+//! @brief Dump a given block for a tag
+/*!
+ \param iOpt Output message destination<br>
+ 0 = stdout<br>
+ 1 = Syslog<br>
+ 2 = Both<br>
+ \param ulBlockNo Block number to dump
+ \param mpTag Index tag pointer
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+
+xbInt16 xbIxMdx::DumpBlock( xbInt16 iOpt, xbUInt32 ulBlockNo, xbMdxTag *mpTag ){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbString s, s2;
+ xbBool bLeaf;
+ char *p;
+
+ try{
+ if(( iRc = GetBlock( mpTag, ulBlockNo, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ p = cNodeBuf;
+ xbInt32 lNoOfKeys = eGetInt32( p );
+ p+=4;
+ xbUInt32 ulNode2 = eGetUInt32( p );
+
+ if( !mpTag ){
+ // if no tag info, print what is available without tag info and exit
+ s.Sprintf( "--- BlkNo = %ld Page = %ld NoOfKeys = %ld Node2 (opt NextFreePage) = %ld", ulBlockNo, BlockToPage( ulBlockNo ), lNoOfKeys, ulNode2 );
+ xbase->WriteLogMessage( s, iOpt );
+ return XB_NO_ERROR;
+ }
+
+ p+=4;
+ p+= mpTag->iKeyItemLen * lNoOfKeys;
+ if( eGetUInt32( p ) == 0 ){
+ bLeaf = xbTrue;
+ // std::cout << "No of keys = " << lNoOfKeys << "\n";
+ s.Sprintf( "--- Leaf Node KeyCnt %d\t Page %d\t Block %d", lNoOfKeys, BlockToPage( ulBlockNo ), ulBlockNo );
+ } else {
+ bLeaf = xbFalse;
+ s.Sprintf( "--- Interior Node KeyCnt %d\t Page %d\t Block %d", lNoOfKeys, BlockToPage( ulBlockNo ), ulBlockNo );
+ }
+ if( ulNode2 > 0 )
+ s.Sprintf( "%s Node2 (opt NextFreePage) = %d", s.Str(), ulNode2 );
+
+ xbase->WriteLogMessage( s, iOpt );
+
+ xbInt32 l;
+ for( l = 0; l < lNoOfKeys; l++ ){
+ p = cNodeBuf + (8 + (l * mpTag->iKeyItemLen ));
+ s.Sprintf( "%08ld\t", eGetUInt32( p ));
+ p+=4;
+ if( mpTag->cKeyType2 == 'C' ){ //CHAR
+ for( xbInt32 l = 0; l < (mpTag->iKeyItemLen-4); l++ )
+ s += *p++;
+ s.Trim();
+ } else if( mpTag->cKeyType2 == 'N' ){ // NUMERIC
+ xbBcd bcd( p );
+ bcd.ToString( s2 );
+ s += s2;
+ } else if( mpTag->cKeyType2 == 'D' ){ // DATE
+ xbInt32 lDate = (xbInt32) eGetDouble( p );
+ xbDate d( lDate );
+ s.Sprintf( "%s\t%ld\t(%s)", s.Str(), lDate, d.Str());
+ } else {
+ s.Sprintf( "Unknown key type [%c]", mpTag->cKeyType2 );
+ }
+ xbase->WriteLogMessage( s, iOpt );
+ }
+ if( !bLeaf ){
+ // interior node has one extra key at the right most position
+ p = cNodeBuf + (8 + (l * mpTag->iKeyItemLen ));
+ s.Sprintf( "\t%08ld", eGetUInt32( p ));
+ xbase->WriteLogMessage( s, iOpt );
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::DumpBlock() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/**************************************************************************************************************/
+//! @brief Dump free blocks.
+/*!
+ Dump free blocks for index debugging purposes.
+
+ \param iOpt Output message destination<br>
+ 0 = stdout<br>
+ 1 = Syslog<br>
+ 2 = Both<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+xbInt16 xbIxMdx::DumpFreeBlocks( xbInt16 iOpt ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbString s;
+ char *pBuf = NULL;
+ char *pNextPage;
+ xbUInt32 ulNextPage;
+
+ try{
+
+ if(( iRc = ReadHeadBlock( 1 )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+ xbUInt32 ulLastBlock = PageToBlock( ulPageCnt );
+
+ pBuf = (char *) malloc( (size_t) GetBlockSize());
+ if( !pBuf ){
+ iErrorStop = 110;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+
+ if( ulFirstFreePage > 0 ){
+ xbUInt32 ulThisFreePage = ulFirstFreePage;
+ xbUInt32 ulNextFreePage = 0;
+ xbUInt32 ulCnt = 0;
+ xbase->WriteLogMessage( "*** Free Blocks ***", iOpt );
+ s.Sprintf( "File Header - FirstFreePage = %ld Block = %ld", ulFirstFreePage, PageToBlock( ulFirstFreePage ));
+ xbase->WriteLogMessage( s, iOpt );
+ while( ulThisFreePage > 0 ){
+ if(( iRc = ReadBlock( PageToBlock( ulThisFreePage ), GetBlockSize(), pBuf )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ pNextPage = pBuf;
+ pNextPage+=4;
+ ulNextFreePage = eGetUInt32( pNextPage );
+ s.Sprintf( "Free Page# = %ld\t(Block# = %ld)\tNext Free Page = %ld\t(Block = %ld)", ulThisFreePage, PageToBlock( ulThisFreePage ), ulNextFreePage, PageToBlock( ulNextFreePage ));
+ xbase->WriteLogMessage( s, iOpt );
+ ulThisFreePage = ulNextFreePage;
+ ulCnt++;
+ }
+ s.Sprintf( "%ld free blocks (%ld pages)", ulCnt, BlockToPage( ulCnt ));
+ xbase->WriteLogMessage( s, iOpt );
+ xbase->WriteLogMessage( "*** End Of Free Blocks ***", iOpt );
+ }
+
+ pNextPage = pBuf;
+ pNextPage+=4;
+
+ s = "*** Beginning of Block2 Info ***";
+ xbase->WriteLogMessage( s, iOpt );
+ s = "ulBlock2 info. ulBlock2 is either one of a linked list of free nodes, or the id of the original node that this node was split from.";
+ xbase->WriteLogMessage( s, iOpt );
+ s = "Stored in physical file as pages, processed in blocks";
+ xbase->WriteLogMessage( s, iOpt );
+
+ xbUInt32 ulFirstBlock = 3;
+
+ for( xbUInt32 ul = ulFirstBlock; ul < ulLastBlock; ul++ ){
+ if(( iRc = ReadBlock( ul, GetBlockSize(), pBuf )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ ulNextPage = eGetUInt32( pNextPage );
+ if( ulNextPage > 0 ){
+ s.Sprintf( " Block# = %ld\tPage# = %ld\tulBlock2 = %ld\tulBlock2(Page) = %ld", ul, BlockToPage( ul ), PageToBlock( ulNextPage ), ulNextPage );
+ xbase->WriteLogMessage( s, iOpt );
+ }
+ }
+ s = "*** End of Block2 Info ***";
+ xbase->WriteLogMessage( s, iOpt );
+
+ if( pBuf ) free( pBuf );
+ }
+
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::DumpFreeBlocks() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ if( pBuf ) free( pBuf );
+ }
+ return iRc;
+}
+
+/**************************************************************************************************************/
+
+//! @brief Dump interior and leaf blocks for a given tag.
+/*!
+ Dump blocks for given tag for index debugging purposes.
+
+ A page is 512 bytes<br>
+ A block is one or more pages<br>
+ The default mdx block size is 2 pages, or 1024 bytes<br>
+ The first four pages or header pages<br>
+
+ \param iOpt Output message destination<br>
+ 0 = stdout<br>
+ 1 = Syslog<br>
+ 2 = Both<br>
+ \param vpTag Index tag pointer, defaults to all tags if null.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+
+xbInt16 xbIxMdx::DumpTagBlocks( xbInt16 iOpt, void * vpTag ){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbInt16 iCurTag = 0;
+ xbString s;
+ xbInt16 iBlockCtr = 0;
+
+ try{
+
+ xbMdxTag * mpTag;
+ if( vpTag == NULL )
+ mpTag = (xbMdxTag *) GetTag( iCurTag++ );
+ else
+ mpTag = (xbMdxTag *) vpTag;
+
+ if( mpTag == NULL ){
+ iErrorStop = 100;
+ iRc = XB_INVALID_TAG;
+ throw iRc;
+ }
+
+ xbIxNode *n;
+ xbString s;
+ xbString s2;
+ xbBool bDone = xbFalse;
+
+ xbUInt32 ulBlkNo;
+ xbLinkListOrd<xbUInt32> ll;
+ xbLinkListNode<xbUInt32> * llN;
+
+ ll.SetDupKeys( xbFalse );
+
+ s.Sprintf( "%s Root Page %ld (Block %ld)", mpTag->cTagName, mpTag->ulRootPage, PageToBlock( mpTag->ulRootPage ) );
+ xbase->WriteLogMessage( s, iOpt );
+
+ // for each tag
+ while( !bDone ){
+
+ // clear out any history
+ ll.Clear();
+ if( mpTag->npNodeChain ){
+ mpTag->npNodeChain = FreeNodeChain( mpTag->npNodeChain );
+ mpTag->npCurNode = NULL;
+ }
+
+ while( GetNextKey( mpTag, 0 ) == 0 ){
+ n = mpTag->npNodeChain;
+
+ while(n){
+ ll.InsertKey( n->ulBlockNo, (xbUInt32) n->iCurKeyNo );
+ n = n->npNext;
+ }
+ }
+ llN = ll.GetHeadNode();
+
+ while( llN ){
+
+ ulBlkNo = llN->GetKey();
+ xbIxMdx::DumpBlock( iOpt, ulBlkNo, mpTag );
+ llN = llN->GetNextNode();
+ iBlockCtr++;
+ }
+
+ if( vpTag || iCurTag >= GetTagCount())
+ bDone = xbTrue;
+ else
+ mpTag = (xbMdxTag *) GetTag( iCurTag++ );
+ }
+
+ s.Sprintf( "\nTotal Blocks: %d", iBlockCtr );
+ xbase->WriteLogMessage( s, iOpt );
+
+ if( mpTag->npNodeChain ){
+ mpTag->npNodeChain = FreeNodeChain( mpTag->npNodeChain );
+ mpTag->npCurNode = NULL;
+ }
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::DumpTagBlocks() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Dump index file header.
+/*!
+ Dump a index file header for debugging purposes.
+ \param iOpt Output message destination<br>
+ 0 = stdout<br>
+ 1 = Syslog<br>
+ 2 = Both<br>
+ \param iFmtOpt Output Format<br>
+ 0, 1 = Header info only<br>
+ 2 = Tag info<br>
+ 3 = Header && Tag info<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxMdx::DumpHeader( xbInt16 iOpt, xbInt16 iFmtOpt )
+{
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbString s;
+ if(( iRc = ReadHeadBlock( 1 )) != XB_NO_ERROR )
+ return iRc;
+
+// std::cout << "xbIxMdx::DumpHeader options - " << iDestOpt << " fmtopt = " << iFmtOpt << "\n";
+
+ char c, tfv, cDisplayMask = 1;
+ cDisplayMask = cDisplayMask << 7;
+ if( iFmtOpt != 2 && iFmtOpt != 4 ){
+ s = "*** MDX Index Header ***";
+ xbase->WriteLogMessage( s, iOpt );
+ s = "Version = ";
+ tfv = cVersion;
+ for( c = 1; c<= 8; c++ ){
+ //std::cout << (tfv & cDisplayMask ? '1' : '0');
+ s+= (tfv & cDisplayMask ? '1' : '0');
+ tfv <<= 1;
+ }
+ xbase->WriteLogMessage( s, iOpt );
+
+
+// std::cout << std::endl;
+// std::cout <<
+ s.Sprintf( "Create Date = %d/%d/%d", (int) cCreateMM, (int) cCreateDD, (int) cCreateYY % 100 );
+ xbase->WriteLogMessage( s, iOpt );
+
+ s.Sprintf( "File Name = %s", sFileName.Str() );
+ xbase->WriteLogMessage( s, iOpt );
+
+ s.Sprintf( "Block Factor = %d", iBlockFactor );
+ xbase->WriteLogMessage( s, iOpt );
+
+ s.Sprintf( "Block Size = %d", GetBlockSize() );
+ xbase->WriteLogMessage( s, iOpt );
+
+ s.Sprintf( "Prod Ix Flag = %d", (xbInt16) cProdIxFlag );
+ xbase->WriteLogMessage( s, iOpt );
+
+ s.Sprintf( "Tag Entry Cnt = %d", (xbInt16) cTagEntryCnt );
+ xbase->WriteLogMessage( s, iOpt );
+
+ s.Sprintf( "Tag Len = %d", iTagLen );
+ xbase->WriteLogMessage( s, iOpt );
+
+ s.Sprintf( "Next Tag = %d", (xbInt16) cNextTag );
+ xbase->WriteLogMessage( s, iOpt );
+
+ s.Sprintf( "Tag Use Cnt = %d", iTagUseCnt );
+ xbase->WriteLogMessage( s, iOpt );
+
+ s.Sprintf( "Page Cnt = %d", ulPageCnt );
+ xbase->WriteLogMessage( s, iOpt );
+
+ s.Sprintf( "First Free Page = %d", ulFirstFreePage );
+ xbase->WriteLogMessage( s, iOpt );
+
+ s.Sprintf( "No Of Block Avail = %d\n", ulNoOfBlockAvail );
+ xbase->WriteLogMessage( s, iOpt );
+
+ s.Sprintf( "Last update date = %d/%d/%d", (int) cCreateMM, (int) cCreateDD, (int) cCreateYY % 100 );
+ xbase->WriteLogMessage( s, iOpt );
+
+ if( ulFirstFreePage > 0 ){
+ xbString s;
+ xbUInt32 ulNfp = ulFirstFreePage; // next free page
+ xbInt16 lc = 0;
+ while( ulNfp && lc++ < 5 ){
+ if( s.Len() > 0 )
+ s += ",";
+ s.Sprintf( "%s%ld", s.Str(), ulNfp );
+ if(( iRc = GetBlock( NULL, (xbUInt32) (ulNfp / (xbUInt32) iBlockFactor), 0 )) != 0 )
+ return iRc;
+ ulNfp = eGetUInt32( cNodeBuf+4 );
+ }
+ xbase->WriteLogMessage( s, iOpt );
+ }
+ }
+ if( iFmtOpt > 1 ){
+ xbMdxTag *tt = mdxTagTbl;
+ xbString s;
+ xbInt16 i = 0;
+
+ if( tt ){
+ while( tt ){
+ i++;
+ if(( iRc = LoadTagDetail( 2, tt )) != XB_NO_ERROR )
+ return iRc;
+
+ s.Sprintf( "TTE (%d)\tName HdrPage\tFormat\tLeftChild\tRightChild\tParent\tKeyType", i );
+ xbase->WriteLogMessage( s, iOpt );
+ s.Sprintf( "TTE (%d)\t%-12s %d\t\t%d\t%d\t\t%d\t\t%d\t%c\n", i, tt->cTagName, tt->ulTagHdrPageNo, tt->cKeyFmt, tt->cLeftChild, tt->cRightChild, tt->cParent, tt->cKeyType );
+ xbase->WriteLogMessage( s, iOpt );
+
+ s.Sprintf( "TTH (%d)\tRoot\tTagSize\tKeyFmt2\tType2\tKeyLen\tKeysPerBlock\tSecType\tKeyItemLen\tSerial#\tHasKeys\tFilter\tDesc\tUnique\tLchild\tRchild\tKeyFmt3\tTagDate", i );
+ xbase->WriteLogMessage( s, iOpt );
+
+ s.Sprintf( "TTH (%d)\t%d\t%d\t%d\t%c\t%d\t%d\t\t%d\t%d\t\t%x\t%x\t%d\t%d\t%d\t%d\t%d\t%d\t%d/%d/%d",
+ i, tt->ulRootPage, tt->ulTagSize, tt->cKeyFmt2, tt->cKeyType2, tt->iKeyLen, tt->iKeysPerBlock, tt->iSecKeyType, tt->iKeyItemLen, tt->cSerialNo, tt->cHasKeys, tt->cHasFilter,
+ (((tt->cKeyFmt2 & 0x08) > 0) ? 1 : 0), // descending?
+ tt->cUnique, tt->ulLeftChild, tt->ulRightChild, tt->cKeyFmt3, (int) tt->cTagMM, (int) tt->cTagDD, (int) tt->cTagYY % 100 );
+
+ xbase->WriteLogMessage( s, iOpt );
+
+ s.Sprintf( "Key (%d) %s", i, tt->sKeyExp->Str());
+ xbase->WriteLogMessage( s, iOpt );
+
+ if( tt->cHasFilter ){
+ s.Sprintf( "Flt (%d) %s", i, tt->sFiltExp->Str());
+ xbase->WriteLogMessage( s, iOpt );
+ }
+ xbase->WriteLogMessage( "", iOpt );
+ tt = tt->next;
+
+ }
+ }
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+xbInt16 xbIxMdx::DumpIxForTag( void *vpTag, xbInt16 iOutputOpt )
+{
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbInt16 iDepth = 0;
+ xbUInt32 lKeyCtr = 0;
+ xbInt32 iMinDepth = 999999;
+ xbInt32 iMaxDepth = 0;
+
+ try{
+ /*
+ get first node
+ while interior node
+ print the left key
+ level++
+ go down one on the left
+ */
+
+ xbMdxTag * mpTag = (xbMdxTag *) vpTag;
+ if( mpTag->npNodeChain ){
+ mpTag->npNodeChain = FreeNodeChain( mpTag->npNodeChain );
+ mpTag->npCurNode = NULL;
+ }
+
+ // Get the root
+ if(( iRc = LoadTagDetail( 2, mpTag )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ // lRootBlock is now available
+ if(( iRc = GetBlock( vpTag, (mpTag->ulRootPage / (xbUInt32) iBlockFactor), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ // if no keys on this node, then the index is empty
+ xbUInt32 ulKeyPtr = eGetUInt32( mpTag->npCurNode->cpBlockData );
+ if( ulKeyPtr == 0 ){
+ iErrorStop = 120;
+ iRc = XB_EMPTY;
+ throw iRc;
+ }
+ while( !IsLeaf( vpTag, mpTag->npCurNode )){ // go down the chain looking for a leaf node
+ PrintKey( vpTag, mpTag->npCurNode , 0, iDepth++, 'I', iOutputOpt );
+ if(( iRc = GetKeyPtr( vpTag, 0, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ if(( iRc = GetBlock( vpTag, (ulKeyPtr / (xbUInt32) iBlockFactor), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+ }
+ if(( iRc = GetKeyPtr( vpTag, 0, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+ // loop through the leaf entries of left most leaf
+ if( iDepth < iMinDepth ) iMinDepth = iDepth;
+ if( iDepth > iMaxDepth ) iMaxDepth = iDepth;
+ xbUInt32 ulNoOfKeys = eGetUInt32( mpTag->npCurNode->cpBlockData );
+ for( xbUInt32 ul = 0; ul < ulNoOfKeys; ul++ ){
+ PrintKey( vpTag, mpTag->npCurNode , ul, iDepth, 'L', iOutputOpt );
+ lKeyCtr++;
+ }
+
+ // if head node = start node, return
+ if( mpTag->npCurNode->ulBlockNo == ( mpTag->ulRootPage / (xbUInt32) iBlockFactor ))
+ return XB_NO_ERROR;
+
+ xbBool bEof = false;
+ while( !bEof ){
+
+ // go up the chain, looking for an interior node with more keys on it
+ xbIxNode * TempIxNode = mpTag->npCurNode;
+ mpTag->npCurNode = mpTag->npCurNode->npPrev;
+ mpTag->npCurNode->npNext = NULL;
+ TempIxNode->npPrev = NULL;
+ TempIxNode = FreeNodeChain( TempIxNode );
+ iDepth--;
+
+ while( mpTag->npCurNode->iCurKeyNo >= eGetUInt32( mpTag->npCurNode->cpBlockData ) &&
+ mpTag->npCurNode->ulBlockNo != ( mpTag->ulRootPage / (xbUInt32) iBlockFactor) ){
+ TempIxNode = mpTag->npCurNode;
+ mpTag->npCurNode = mpTag->npCurNode->npPrev;
+ mpTag->npCurNode->npNext = NULL;
+ TempIxNode->npPrev = NULL;
+ TempIxNode = FreeNodeChain( TempIxNode );
+ iDepth--;
+ }
+ // if head node && right most key, return
+ if( mpTag->npCurNode->ulBlockNo == (mpTag->ulRootPage / (xbUInt32) iBlockFactor) &&
+ mpTag->npCurNode->iCurKeyNo == eGetUInt32( mpTag->npCurNode->cpBlockData ))
+ bEof = true;
+
+ if( !bEof ){
+ mpTag->npCurNode->iCurKeyNo++;
+ if(( iRc = GetKeyPtr( vpTag, mpTag->npCurNode->iCurKeyNo, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 160;
+ throw iRc;
+ }
+ PrintKey( vpTag, mpTag->npCurNode , mpTag->npCurNode->iCurKeyNo, iDepth++, 'I', iOutputOpt );
+
+ if(( iRc = GetBlock( vpTag, (ulKeyPtr / (xbUInt32) iBlockFactor), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 170;
+ throw iRc;
+ }
+
+ // traverse down the left side of the tree
+ while( !IsLeaf( vpTag, mpTag->npCurNode )) // go down the chain looking for a leaf node
+ {
+ PrintKey( vpTag, mpTag->npCurNode , 0, iDepth++, 'I', iOutputOpt );
+ if(( iRc = GetKeyPtr( vpTag, 0, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 180;
+ throw iRc;
+ }
+ if(( iRc = GetBlock( vpTag, (ulKeyPtr / (xbUInt32) iBlockFactor), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 190;
+ throw iRc;
+ }
+ }
+ if( iDepth < iMinDepth ) iMinDepth = iDepth;
+ if( iDepth > iMaxDepth ) iMaxDepth = iDepth;
+ ulNoOfKeys = eGetUInt32( mpTag->npCurNode->cpBlockData );
+ for( xbUInt32 ul = 0; ul < ulNoOfKeys; ul++ ){
+ PrintKey( vpTag, mpTag->npCurNode , ul, iDepth, 'L', iOutputOpt );
+ lKeyCtr++;
+ }
+ }
+ }
+ xbString s;
+ s.Sprintf( "Total keys = [%ld] Min Depth = [%d] Max Depth = [%d]", lKeyCtr, iMinDepth, iMaxDepth );
+ xbase->WriteLogMessage( s.Str(), 2 );
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::DumpIxForTag() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/**************************************************************************************************************/
+void xbIxMdx::DumpIxNodeChain( void *vpTag, xbInt16 iOutputOpt ) const
+{
+ xbMdxTag * mpTag = (xbMdxTag *) vpTag;
+ xbString s( "Dump Node Chain" );
+ xbase->WriteLogMessage( s, 2 );
+
+ if( mpTag->npNodeChain ){
+ xbIxNode *n = mpTag->npNodeChain;
+ xbInt16 iCtr = 0;
+ char cLeaf;
+ s.Sprintf( "Cnt\tThis Prev Next CurKeyNo BlockNo Page NoOfKeys Type" );
+ xbase->WriteLogMessage( s, iOutputOpt );
+ while( n ){
+ IsLeaf( vpTag, n ) ? cLeaf = 'L' : cLeaf = 'I';
+ s.Sprintf( "%d\t%08x %08x %08x %08d %08d %08d %08ld %c",
+ iCtr++, n, n->npPrev, n->npNext, n->iCurKeyNo,
+ n->ulBlockNo, n->ulBlockNo * (xbUInt32) iBlockFactor,
+ eGetUInt32( n->cpBlockData ), cLeaf );
+ xbase->WriteLogMessage( s, 2 );
+ n = n->npNext;
+ }
+ } else {
+ s = "Empty Node Chain";
+ xbase->WriteLogMessage( s, 2 );
+ }
+}
+#endif
+
+/***********************************************************************************************/
+xbInt16 xbIxMdx::FindKey( void *vpTag, xbDouble dKey, xbInt16 iRetrieveSw ){
+
+ xbMdxTag * mpTag = (xbMdxTag *) vpTag;
+ if( mpTag->cKeyType2 == 'N' ){ // mdx indices store numeric keys as bcd values
+ xbBcd bcd( dKey );
+ return xbIx::FindKey( vpTag, bcd, iRetrieveSw );
+ } else // this would be a julian date inquiry
+ return FindKey( vpTag, &dKey, 8, iRetrieveSw );
+}
+
+/***********************************************************************************************/
+// iRetrieveSw = 1 - position db file to index position
+// 0 - do not position dbf file
+
+xbInt16 xbIxMdx::FindKey( void *vpTag, const void * vpKey,
+ xbInt32 lSearchKeyLen, xbInt16 iRetrieveSw ){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ // clean up any previous table updates before moving on
+ if( iRetrieveSw ){
+ if( dbf->GetDbfStatus() == XB_UPDATED ){
+ if( dbf->GetAutoCommit() == 1 ){
+ if(( iRc = dbf->Commit()) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ } else {
+ if(( iRc = dbf->Abort()) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ }
+ }
+ }
+
+ xbUInt32 ulNoOfKeys;
+ xbMdxTag * mpTag = (xbMdxTag *) vpTag;
+ char cKeyType = GetKeyType( vpTag );
+ xbBool bDescending = mpTag->cKeyFmt2 & 0x08;
+
+ if( mpTag->npNodeChain ){
+
+ // determine if the index has been updated since the last time it was used
+ time_t tFileTs;
+ if(( iRc = GetFileMtime( tFileTs )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ if( mpTag->tNodeChainTs < tFileTs ){
+ mpTag->npNodeChain = FreeNodeChain( mpTag->npNodeChain );
+ mpTag->npCurNode = NULL;
+
+ } else {
+ // pop up the chain looking for appropriate starting point
+ xbBool bDone = false;
+ xbIxNode * TempIxNode;
+ while( mpTag->npCurNode && !bDone &&
+ (mpTag->npCurNode->ulBlockNo != ( mpTag->ulRootPage / (xbUInt32) iBlockFactor ))){ // not root node
+ //if no keys on the node, pop up one
+ ulNoOfKeys = eGetUInt32( mpTag->npCurNode->cpBlockData );
+ if( ulNoOfKeys == 0 ){
+ TempIxNode = mpTag->npCurNode;
+ mpTag->npCurNode = mpTag->npCurNode->npPrev;
+ TempIxNode = FreeNodeChain( TempIxNode );
+
+ } else {
+
+ iRc = CompareKey( cKeyType, vpKey, GetKeyData( mpTag->npCurNode, 0, mpTag->iKeyItemLen ), (size_t) lSearchKeyLen );
+ if( (!bDescending && iRc <= 0) || (bDescending && iRc >= 0 )){
+ TempIxNode = mpTag->npCurNode;
+ mpTag->npCurNode = mpTag->npCurNode->npPrev;
+ TempIxNode = FreeNodeChain( TempIxNode );
+ } else {
+ // get the number of keys on the block and compare the key to the rightmost key
+ xbUInt32 ulKeyCtr = eGetUInt32( mpTag->npCurNode->cpBlockData ) - 1; // IsLeaf( vpTag, mpTag->npCurNode );
+ iRc = CompareKey( cKeyType, vpKey, GetKeyData( mpTag->npCurNode, ulKeyCtr, mpTag->iKeyItemLen), (size_t) lSearchKeyLen );
+
+ if( (!bDescending && iRc > 0) || (bDescending && iRc < 0 )){
+ TempIxNode = mpTag->npCurNode;
+ mpTag->npCurNode = mpTag->npCurNode->npPrev;
+ TempIxNode = FreeNodeChain( TempIxNode );
+ } else {
+ bDone = true;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ // either started empty, or cleared due to file time diff
+ if( !mpTag->npNodeChain ){
+ // Get the root
+ if(( iRc = LoadTagDetail( 2, mpTag )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ // lRootBlock is now available
+ if(( iRc = GetBlock( vpTag, (mpTag->ulRootPage / (xbUInt32) iBlockFactor), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+ // if this is a leaf node and no keys on this node, then the index is empty
+ ulNoOfKeys = eGetUInt32( mpTag->npCurNode->cpBlockData );
+ if( ulNoOfKeys == 0 && IsLeaf( vpTag, mpTag->npCurNode )){
+// iRc = XB_EMPTY;
+ iRc = XB_NOT_FOUND;
+ return iRc;
+ }
+ }
+
+ // should be in the appropriate position in the node chain to continue the search from here
+ // run down through the interior nodes
+ xbInt16 iSearchRc = 0;
+ xbUInt32 ulKeyPtr = 0;
+
+ while( vpTag && !IsLeaf( vpTag, mpTag->npCurNode ) ){
+ // get the number of keys on the block and compare the key to the rightmost key
+ ulNoOfKeys = eGetUInt32( mpTag->npCurNode->cpBlockData );
+
+ if( ulNoOfKeys == 0 ){
+ mpTag->npCurNode->iCurKeyNo = 0;
+
+ } else {
+
+ iRc = CompareKey( cKeyType, vpKey, GetKeyData( mpTag->npCurNode, ulNoOfKeys - 1, mpTag->iKeyItemLen), (size_t) lSearchKeyLen );
+ if( (!bDescending && iRc > 0) || (bDescending && iRc < 0)){
+ mpTag->npCurNode->iCurKeyNo = ulNoOfKeys;
+ }
+ else
+ {
+ mpTag->npCurNode->iCurKeyNo = (xbUInt32) BSearchBlock( cKeyType, mpTag->npCurNode,
+ (xbInt32) mpTag->iKeyItemLen, vpKey, (xbInt32) lSearchKeyLen, iSearchRc, bDescending );
+ }
+ }
+
+ if(( iRc = GetKeyPtr( vpTag, mpTag->npCurNode->iCurKeyNo, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+
+ if(( iRc = GetBlock( vpTag, (ulKeyPtr / (xbUInt32)iBlockFactor), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 160;
+ throw iRc;
+ }
+ }
+
+ ulNoOfKeys = eGetUInt32( mpTag->npCurNode->cpBlockData );
+ xbInt16 iCompRc = 0;
+
+ if( ulNoOfKeys == 0 ){
+ // iCompRc = -1;
+ // iRc = XB_EMPTY;
+ iRc = XB_NOT_FOUND;
+ return iRc;
+
+ } else {
+
+ iRc = BSearchBlock( cKeyType, mpTag->npCurNode, mpTag->iKeyItemLen, vpKey, lSearchKeyLen, iCompRc, bDescending );
+ // iCompRc
+ // 0 found
+ // < 0 eof encountered, search key > last key in file
+ // > 0 not found, positioned to next key
+
+ if( iCompRc >= 0 ){
+ mpTag->npCurNode->iCurKeyNo = (xbUInt32) iRc;
+
+
+ if( iRetrieveSw ){
+
+ xbUInt32 ulKey = mpTag->npCurNode->iCurKeyNo;
+ if( ulKey >= ulNoOfKeys ) // if position past end of keys, need to go back one and position to last key
+ ulKey--;
+
+ // if(( iRc = GetKeyPtr( vpTag, mpTag->npCurNode->iCurKeyNo, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+
+ if(( iRc = GetKeyPtr( vpTag, ulKey, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 170;
+ throw iRc;
+ }
+ if(( iRc = dbf->GetRecord( ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 180;
+ throw iRc;
+ }
+ }
+ }
+ }
+
+ if( iCompRc == 0 )
+ return XB_NO_ERROR;
+ else if( iCompRc > 0 )
+ return XB_NOT_FOUND;
+ else
+ return XB_EOF;
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::FindKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+xbInt16 xbIxMdx::FindKeyForCurRec( void * vpTag )
+{
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbInt16 i = 0;
+
+ try{
+ if(( iRc = CreateKey( vpTag, 0 )) < XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::FindKeyForCurRec() Exception Caught. Error Stop = [%d] iRc = [%d] Tag=[%d]", iErrorStop, iRc, i );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return XB_NO_ERROR;
+}
+
+/***********************************************************************/
+//! @brief Get dbf record number for given key number.
+/*!
+ \param vpTag Tag to retrieve dbf rec number on.
+ \param iKeyNo Key number for retrieval
+ \param np Pointer to node
+ \param ulDbfPtr- Output dbf record number
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxMdx::GetDbfPtr( void *vpTag, xbInt16 iKeyNo, xbIxNode *np, xbUInt32 &ulDbfPtr ) const {
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ #ifdef XB_DEBUG_SUPPORT
+ // turn this off in production mode for better performance
+ xbUInt32 ulNoOfKeys = eGetUInt32 ( np->cpBlockData );
+ if( iKeyNo < 0 || iKeyNo > (xbInt16) --ulNoOfKeys ){
+ iErrorStop = 100;
+ throw XB_INVALID_KEYNO;
+ }
+ #endif
+
+ xbMdxTag * mpTag = (xbMdxTag *) vpTag;
+ char *p = ( np->cpBlockData);
+ p += (8 + (iKeyNo * mpTag->iKeyItemLen));
+ ulDbfPtr = eGetUInt32 ( p );
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::GetDbfPtr() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+/*!
+ \param vpTag Tag to retrieve first key on.
+ \param iRetrieveSw xbTrue - Retrieve the record on success.<br>
+ xbFalse - Don't retrieve record.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxMdx::GetFirstKey( void *vpTag, xbInt16 iRetrieveSw = 0 ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ // convert the tag pointer to mdx tag pointer
+ xbMdxTag * mpTag = (xbMdxTag *) vpTag;
+
+ try{
+ // clear out any history
+ if( mpTag->npNodeChain ){
+ mpTag->npNodeChain = FreeNodeChain( mpTag->npNodeChain );
+ mpTag->npCurNode = NULL;
+ }
+ // Get the root
+ if(( iRc = LoadTagDetail( 2, mpTag )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ // lRootPage is available
+ if(( iRc = GetBlock( vpTag, (mpTag->ulRootPage / (xbUInt32) iBlockFactor), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ // if no keys on this node, then the index is empty
+ // this is not true
+
+ xbUInt32 ulKeyPtr = eGetUInt32( mpTag->npCurNode->cpBlockData );
+ if( ulKeyPtr == 0 && IsLeaf( vpTag, mpTag->npCurNode )){
+ iRc = XB_EMPTY;
+ return iRc;
+ }
+
+ 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;
+ }
+
+ if(( iRc = GetBlock( vpTag, (ulKeyPtr / (xbUInt32) iBlockFactor), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ }
+
+ // retrieve record to data buf
+ if( iRetrieveSw ){
+ if(( iRc = GetKeyPtr( vpTag, 0, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+ if(( iRc = dbf->GetRecord( ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+ }
+ // else {
+ // throw iRc;
+ // }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::GetFirstKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//xbBool xbIxMdx::GetIndexUpdated() const {
+// std::cout << "xbIxMdx::GetIndexUpdate() FIX ME \n";
+// return xbFalse;
+//}
+
+/***********************************************************************/
+//! @brief Get the key expression for the given tag.
+/*!
+ \param vpTag Tag to retrieve key expression from tag.
+ \returns Key expression.
+*/
+
+xbString &xbIxMdx::GetKeyExpression( const void * vpTag ) const{
+ xbMdxTag *mpTag = (xbMdxTag *) vpTag;
+ return *mpTag->sKeyExp;
+}
+
+/***********************************************************************/
+//! @brief Get the key expression for the given tag.
+/*!
+ \param vpTag Tag to retrieve filter expression from tag (if it exists).
+ \returns Key filter.
+*/
+
+xbString &xbIxMdx::GetKeyFilter( const void * vpTag ) const{
+
+ xbMdxTag * mpTag = (xbMdxTag *) vpTag;
+
+ // std::cout << "GetKeyFilter() ";
+ if( mpTag->sFiltExp )
+ return *mpTag->sFiltExp;
+// std::cout << " not null\n";
+ else
+ return sNullString;
+ // std::cout << " null\n";
+
+// next line causes seg faults
+// return *mpTag->sFiltExp;
+
+}
+/**************************************************************************************************/
+xbInt16 xbIxMdx::GetKeyPtr( void *vpTag, xbInt16 iKeyNo, xbIxNode *np, xbUInt32 &ulKeyPtr ) const {
+
+ xbInt16 iRc = XB_NO_ERROR;
+
+ xbInt16 iErrorStop = 0;
+
+ try{
+
+ xbMdxTag *mdxTag = (xbMdxTag *) vpTag;
+ char *p = np->cpBlockData;
+ xbUInt32 ulKeyCnt = eGetUInt32( p );
+ if( iKeyNo < 0 || iKeyNo > (xbInt16) ulKeyCnt ){
+ iErrorStop = 100;
+ iRc = XB_INVALID_KEYNO;
+ throw iRc;
+ }
+ p+=8; // skip past first two four byte numeric fields
+ p+= (iKeyNo * mdxTag->iKeyItemLen);
+ ulKeyPtr = eGetUInt32( p );
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::GetKeyPtr() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Returns key update status.
+/*!
+ \param vpTag Tag to check status on.
+ \returns XB_UPD_KEY Key updated.<br>
+ XB_DEL_KEY Key deleted.<br>
+ XB_ADD_KEY Key added.<br>
+ 0 No key updates
+
+*/
+inline xbInt16 xbIxMdx::GetKeySts( void *vpTag ) const{
+
+ xbMdxTag *mpTag = (xbMdxTag *) vpTag;
+ return mpTag->iKeySts;
+}
+
+/***********************************************************************/
+char xbIxMdx::GetKeyType( const void *vpTag ) const {
+ xbMdxTag * mpTag = (xbMdxTag *) vpTag;
+ return mpTag->cKeyType;
+}
+
+/***********************************************************************/
+//! @brief Get the last key for the given tag.
+/*!
+ \param vpTag Tag to retrieve last key on.
+ \param iRetrieveSw xbTrue - Retrieve the record on success.<br>
+ xbFalse - Don't retrieve record.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxMdx::GetLastKey( void *vpTag, xbInt16 iRetrieveSw ){
+ return GetLastKey( 0, vpTag, iRetrieveSw );
+}
+
+/***********************************************************************/
+//! @brief Get the last key for the given tag and starting node.
+/*!
+ \param ulBlockNo Starting node
+ \param vpTag Tag to retrieve last key on.
+ \param iRetrieveSw xbTrue - Retrieve the record if key found.<br>
+ xbFalse - Don't retrieve record.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxMdx::GetLastKey( xbUInt32 ulBlockNo, void *vpTag, xbInt16 iRetrieveSw ){
+
+ // if UlNodeNo is zero, start at head node, otherwise start at ulNodeNo
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ // convert the tag pointer to mdx tag pointer
+ xbMdxTag * mpTag = (xbMdxTag *) vpTag;
+
+ try{
+ xbUInt32 ulNoOfKeys = 0;
+ // clear out any history
+ if( mpTag->npNodeChain ){
+ mpTag->npNodeChain = FreeNodeChain( mpTag->npNodeChain );
+ mpTag->npCurNode = NULL;
+ }
+ // Get the root
+ if( ulBlockNo == 0 ){
+ if(( iRc = LoadTagDetail( 2, mpTag )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ //if(( iRc = GetBlock( vpTag, (mpTag->ulRootPage / (xbUInt32) iBlockFactor), 1 )) != XB_NO_ERROR ){
+ if(( iRc = GetBlock( vpTag, PageToBlock( mpTag->ulRootPage ), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ } else {
+ if(( iRc = GetBlock( vpTag, ulBlockNo, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ }
+
+ ulNoOfKeys = eGetUInt32( mpTag->npCurNode->cpBlockData );
+
+ if( ulNoOfKeys == 0 && IsLeaf( vpTag, mpTag->npCurNode )){
+ iRc = XB_EMPTY;
+ return iRc;
+ }
+
+ mpTag->npCurNode->iCurKeyNo = ulNoOfKeys;
+ ulNoOfKeys = eGetUInt32( mpTag->npCurNode->cpBlockData );
+
+ xbUInt32 ulKeyPtr = 0;
+ while( !IsLeaf( vpTag, mpTag->npCurNode )){ // go down the chain looking for a leaf node
+ // std::cout << "Considered an interior node\n";
+ if(( iRc = GetKeyPtr( vpTag, ulNoOfKeys, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ if(( iRc = GetBlock( vpTag, (ulKeyPtr / (xbUInt32) iBlockFactor), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+
+ ulNoOfKeys = eGetUInt32( mpTag->npCurNode->cpBlockData );
+ mpTag->npCurNode->iCurKeyNo = ulNoOfKeys;
+ }
+ // leaf node has one fewer keys than the interior node
+ mpTag->npCurNode->iCurKeyNo--;
+ ulNoOfKeys = eGetUInt32( mpTag->npCurNode->cpBlockData );
+
+ // retrieve record to data buf
+ if( iRetrieveSw ){
+ if(( iRc = GetKeyPtr( vpTag, (ulNoOfKeys-1), mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+ if(( iRc = dbf->GetRecord( ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 160;
+ throw iRc;
+ }
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::GetLastKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Get the last key for a block number.
+/*!
+ \param vpTag Tag to retrieve first key on.
+ \param ulBlockNo Block number for key retrieval.
+ \param cpBuf output buffer for key placement
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxMdx::GetLastKeyForBlockNo( void *vpTag, xbUInt32 ulBlockNo, char *cpBuf ){
+
+ // returns the last key for a given block number
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ xbMdxTag * npTag = (xbMdxTag *) vpTag;
+
+ try{
+ xbIxNode * npSaveNodeChain = npTag->npNodeChain;
+ xbIxNode * npSaveCurNode = npTag->npCurNode;
+ npTag->npNodeChain = NULL;
+
+ if(( iRc = GetLastKey( ulBlockNo, npTag, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ memcpy( cpBuf, GetKeyData( npTag->npCurNode, GetKeyCount( npTag->npCurNode ) - 1, npTag->iKeyItemLen ), (size_t) npTag->iKeyLen );
+
+ // free memory
+ FreeNodeChain( npTag->npNodeChain );
+ npTag->npNodeChain = npSaveNodeChain;
+ npTag->npCurNode = npSaveCurNode;
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::GetLastKeyForBlockNo() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ) );
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Get the next key for the given tag.
+/*!
+ \param vpTag Tag to retrieve next key on.
+ \param iRetrieveSw xbTrue - Retrieve the record on success.<br>
+ xbFalse - Don't retrieve record.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxMdx::GetNextKey( void * vpTag, xbInt16 iRetrieveSw ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ // convert the tag pointer to mdx tag pointer
+ xbMdxTag * mpTag = (xbMdxTag *) vpTag;
+
+ try{
+ if( !mpTag->npCurNode )
+ return GetFirstKey( vpTag, iRetrieveSw );
+
+ // more keys on this node?
+ xbUInt32 ulKeyPtr;
+ if( (eGetUInt32( mpTag->npCurNode->cpBlockData ) - 1) > mpTag->npCurNode->iCurKeyNo ){
+ mpTag->npCurNode->iCurKeyNo++;
+
+ if(( iRc = GetKeyPtr( vpTag, mpTag->npCurNode->iCurKeyNo, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ if( iRetrieveSw ){
+ if(( iRc = dbf->GetRecord( ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ } else {
+ return iRc;
+ }
+ } else {
+ return iRc;
+ }
+ }
+
+ // if at end head node, then at eof
+ if( mpTag->npCurNode->ulBlockNo == ( mpTag->ulRootPage / (xbUInt32) iBlockFactor ))
+ return XB_EOF;
+
+ // This logic assumes that interior nodes have n+1 left node no's where n is the number of keys in the node
+ xbIxNode * TempIxNode = mpTag->npCurNode;
+ mpTag->npCurNode = mpTag->npCurNode->npPrev;
+ TempIxNode = FreeNodeChain( TempIxNode );
+
+ // While no more right keys && not head node, pop up one node
+ while( mpTag->npCurNode->iCurKeyNo >= eGetUInt32( mpTag->npCurNode->cpBlockData ) &&
+ mpTag->npCurNode->ulBlockNo != ( mpTag->ulRootPage / (xbUInt32) iBlockFactor) ){
+
+ TempIxNode = mpTag->npCurNode;
+ mpTag->npCurNode = mpTag->npCurNode->npPrev;
+ TempIxNode = FreeNodeChain( TempIxNode );
+ }
+
+ // if head node && right most key, return eof
+ if( mpTag->npCurNode->ulBlockNo == (mpTag->ulRootPage / (xbUInt32) iBlockFactor) &&
+ mpTag->npCurNode->iCurKeyNo == eGetUInt32( mpTag->npCurNode->cpBlockData ))
+ return XB_EOF;
+
+ // move one to the right
+ mpTag->npCurNode->iCurKeyNo++;
+ if(( iRc = GetKeyPtr( vpTag, mpTag->npCurNode->iCurKeyNo, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+
+ if(( iRc = GetBlock( vpTag, (ulKeyPtr / (xbUInt32) iBlockFactor), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+
+ // traverse down the left side of the tree
+ 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 = 140;
+ throw iRc;
+ }
+ if(( iRc = GetBlock( vpTag, (ulKeyPtr / (xbUInt32) iBlockFactor), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+ }
+ // retrieve record to data buf
+ if( iRetrieveSw ){
+ if(( iRc = GetKeyPtr( vpTag, 0, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 160;
+ throw iRc;
+ }
+ if(( iRc = dbf->GetRecord( ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 170;
+ throw iRc;
+ }
+ } else {
+ return iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::GetNextKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Get the previous key for the given tag.
+/*!
+ \param vpTag Tag to retrieve previous key on.
+ \param iRetrieveSw xbTrue - Retrieve the record on success.<br>
+ xbFalse - Don't retrieve record.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxMdx::GetPrevKey( void * vpTag, xbInt16 iRetrieveSw ){
+
+ xbString s;
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ // convert the tag pointer to mdx tag pointer
+ xbMdxTag * mpTag = (xbMdxTag *) vpTag;
+
+ try{
+ if( !mpTag->npCurNode ){
+ return GetLastKey( 0, vpTag, iRetrieveSw );
+ }
+
+ xbUInt32 ulKeyPtr = 0;
+ // more keys on this assumed-leaf node?
+
+ if( mpTag->npCurNode->iCurKeyNo > 0 ){
+ mpTag->npCurNode->iCurKeyNo--;
+
+ if(( iRc = GetKeyPtr( vpTag, mpTag->npCurNode->iCurKeyNo, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+ if( iRetrieveSw ){
+ if(( iRc = dbf->GetRecord( ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ } else {
+ return iRc;
+ }
+ } else {
+ return iRc;
+ }
+ }
+
+ //if head node = start node, at eof
+ if( mpTag->npCurNode->ulBlockNo == ( mpTag->ulRootPage / (xbUInt32) iBlockFactor ))
+ return XB_BOF;
+
+ // This logic assumes that interior nodes have n+1 left node no's where n is the number of keys in the node
+ xbIxNode * TempIxNode = mpTag->npCurNode;
+ mpTag->npCurNode = mpTag->npCurNode->npPrev;
+ TempIxNode = FreeNodeChain( TempIxNode );
+
+ // While no more left keys && not head node, pop up one node
+ while( mpTag->npCurNode->iCurKeyNo == 0 &&
+ mpTag->npCurNode->ulBlockNo != ( mpTag->ulRootPage / (xbUInt32) iBlockFactor) ){
+ TempIxNode = mpTag->npCurNode;
+ mpTag->npCurNode = mpTag->npCurNode->npPrev;
+ TempIxNode = FreeNodeChain( TempIxNode );
+ }
+
+ //if head node && left most key, return bof
+ if( mpTag->npCurNode->ulBlockNo == ( mpTag->ulRootPage / (xbUInt32) iBlockFactor) && mpTag->npCurNode->iCurKeyNo == 0 )
+ return XB_BOF;
+
+ // move one to the left
+ mpTag->npCurNode->iCurKeyNo--;
+ if(( iRc = GetKeyPtr( vpTag, mpTag->npCurNode->iCurKeyNo, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+
+ if(( iRc = GetBlock( vpTag, (ulKeyPtr / (xbUInt32) iBlockFactor), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+
+ // traverse down the right side of the tree
+ xbUInt32 ulNoOfKeys;
+ while( !IsLeaf( vpTag, mpTag->npCurNode )) // go down the chain looking for a leaf node
+ {
+ ulNoOfKeys = eGetUInt32( mpTag->npCurNode->cpBlockData );
+ mpTag->npCurNode->iCurKeyNo = ulNoOfKeys;
+
+ if(( iRc = GetKeyPtr( vpTag, ulNoOfKeys, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+ if(( iRc = GetBlock( vpTag, (ulKeyPtr / (xbUInt32) iBlockFactor), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+ }
+
+ // ulNoOfKeys = eGetUInt32( mpTag->npCurNode->cpBlockData );
+ mpTag->npCurNode->iCurKeyNo = eGetUInt32( mpTag->npCurNode->cpBlockData ) - 1;
+
+ // retrieve record to data buf
+ if( iRetrieveSw ){
+ if(( iRc = GetKeyPtr( vpTag, mpTag->npCurNode->iCurKeyNo, mpTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 160;
+ throw iRc;
+ }
+ if(( iRc = dbf->GetRecord( ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 170;
+ throw iRc;
+ }
+ } else {
+ return iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::GetPrevKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief GetReuseEmptyNode swuitch setting.
+/*!
+ \returns xbFalse - Do not reuse empty MDX index nodes (Dbase 6. behavior).
+ xbTrue - Reuse empty MDX index nodes.
+*/
+
+xbBool xbIxMdx::GetReuseEmptyNodesSw() const {
+ return bReuseEmptyNodes;
+}
+/***********************************************************************/
+xbBool xbIxMdx::GetSortOrder( void *vpTag ) const {
+
+ // return true if descending
+ xbMdxTag *mTag = (xbMdxTag *) vpTag;
+ if( mTag->cKeyFmt2 & 0x08 )
+ return 0x01;
+ else
+ return 0x00;
+}
+
+/***********************************************************************/
+//! @brief Get tag for tag number.
+/*!
+ \param iTagNo - Zero based, which tag to retrieve.
+ \returns Pointer to mdx tag for a given tag number.
+*/
+
+void * xbIxMdx::GetTag( xbInt16 iTagNo ) const {
+
+ xbMdxTag *tt = mdxTagTbl;
+ xbInt16 i = 0;
+
+ while( i < iTagNo && tt->next ){
+ tt = tt->next;
+ i++;
+ }
+ if( i == iTagNo )
+ return (void *) tt;
+ else
+ return NULL;
+}
+
+/***********************************************************************/
+//! @brief Get tag for tag name.
+/*!
+ \sTagName - Tag name to retrieve.
+ \returns Pointer to mdx tag for a given tag number.
+*/
+
+void * xbIxMdx::GetTag( xbString &sTagName ) const {
+
+ xbMdxTag *tt = mdxTagTbl;
+
+ while( sTagName != tt->cTagName && tt->next ){
+ tt = tt->next;
+ }
+
+ if( sTagName == tt->cTagName )
+ return (void *) tt;
+ else
+ return NULL;
+}
+/***********************************************************************/
+xbInt16 xbIxMdx::GetTagCount() const {
+ return iTagUseCnt;
+}
+
+/***********************************************************************/
+void xbIxMdx::GetTagName( void *vpTag, xbString &sTagName ){
+
+ xbMdxTag *mpTag = (xbMdxTag *) vpTag;
+ sTagName = mpTag->sTagName->Str();
+}
+
+/***********************************************************************/
+//const char *xbIxMdx::GetTagName( void *vpTag, xbInt16 iOpt ) const {
+
+const char *xbIxMdx::GetTagName( void *vpTag, xbInt16 ) const {
+ xbMdxTag *mpTag = (xbMdxTag *) vpTag;
+ return mpTag->cTagName;
+}
+
+/***********************************************************************/
+xbString &xbIxMdx::GetTagName( void *vpTag ) const {
+
+ xbMdxTag *mpTag = (xbMdxTag *) vpTag;
+ return *mpTag->sTagName;
+}
+
+/***********************************************************************/
+void *xbIxMdx::GetTagTblPtr() const {
+ return (void *) mdxTagTbl;
+}
+
+/***********************************************************************/
+xbBool xbIxMdx::GetUnique( void *vpTag ) const {
+//! @brief Determine unique setting for given tag.
+/*!
+ \param vpTag Tag to retrieve expression from.
+ \returns xbTrue if unique key.
+*/
+ xbMdxTag *mTag = (xbMdxTag *) vpTag;
+ return mTag->cUnique;
+}
+
+/***********************************************************************/
+//! @brief Harvest Empty Node.
+/*!
+ Harvest empty MDX node and add it to the chain of link nodes
+
+ \param mpTag Tag to harvest.
+ \param iOpt - 0 Don't write the node info to disk, handled elsewhere (don't write it twice)
+ 1 Write the update into to disk
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxMdx::HarvestEmptyNode( xbMdxTag *mpTag, xbIxNode *npNode, xbInt16 iOpt, xbBool bHarvestRoot ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbBool bRootPage = xbFalse;
+ xbInt32 iOffset = 0;
+
+ try{
+
+// std::cout << "xbIxMdx::HarvestEmptyNode() page= " << BlockToPage( npNode->ulBlockNo );
+// std::cout << " block = " << npNode->ulBlockNo << "\n";
+
+ if( mpTag->ulRootPage == BlockToPage( npNode->ulBlockNo ) && !bHarvestRoot ){
+ bRootPage = xbTrue;
+
+// std::cout << "special root page processing *****************\n";
+ }
+
+ memset( npNode->cpBlockData, 0x00, GetBlockSize());
+
+ char *pTrg = npNode->cpBlockData;
+ if( !bRootPage ){
+ pTrg += 4;
+ ePutUInt32( pTrg, ulFirstFreePage );
+ }
+
+
+ if( bRootPage ){
+ if( mpTag->cHasKeys ){
+
+ // std::cout << "setting has keys\n";
+
+ mpTag->cHasKeys = 0x00;
+ if(( iRc = xbFseek( ((mpTag->ulTagHdrPageNo * 512) + 246), SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ if(( iRc = xbFwrite( &mpTag->cHasKeys, 1, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ // might need to update left sibling and right sibling here.
+ // Fields don't seem to be updated consistently by other xbase tools,
+ // for now, not updating
+
+ }
+
+ } else {
+
+ // update header
+ // seek to position byte 13
+ ulFirstFreePage = BlockToPage( npNode->ulBlockNo );
+ if(( iRc = xbFseek( 36, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ // write it
+ char c4[4];
+ ePutUInt32( c4, ulFirstFreePage );
+ if(( iRc = xbFwrite( c4, 4, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+
+ }
+
+ if( iOpt == 1 ){
+ if(( iRc = xbFseek( (xbInt64) ((npNode->ulBlockNo * GetBlockSize() )) + iOffset, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+ // write out the block
+ if(( iRc = xbFwrite( npNode->cpBlockData, GetBlockSize(), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+ }
+ }
+
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::HarvestEmptyNodeI() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+
+
+/***********************************************************************/
+//! @brief Harvest Tag Nodes.
+/*!
+ Save all nodes for a given tag into the free node chain.
+ Used for reindexing or deleting a given tag.
+
+ \param mpTag Tag for harvesting nodes
+ \param bHarvestRoot Set to True when deleting tag
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxMdx::HarvestTagNodes( xbMdxTag *mpTag, xbBool bHarvestRoot ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ xbUInt32 ulBlkNo;
+ xbLinkListOrd<xbUInt32> ll;
+ xbLinkListNode<xbUInt32> * llN;
+ xbIxNode * n;
+
+ try{
+
+ ll.SetDupKeys( xbFalse );
+
+ // clear out any history
+ if( mpTag->npNodeChain ){
+ mpTag->npNodeChain = FreeNodeChain( mpTag->npNodeChain );
+ mpTag->npCurNode = NULL;
+ }
+
+ while( GetNextKey( mpTag, 0 ) == 0 ){
+ n = mpTag->npNodeChain;
+ while(n){
+ ll.InsertKey( n->ulBlockNo, (xbUInt32) n->iCurKeyNo );
+ n = n->npNext;
+ }
+ }
+
+ if( bHarvestRoot )
+ ll.InsertKey( PageToBlock( mpTag->ulTagHdrPageNo ), 0 );
+
+ llN = ll.GetHeadNode();
+ if(( n = xbIx::AllocateIxNode( GetBlockSize())) == NULL ){
+ iErrorStop = 100;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+
+ while( llN ){
+ ulBlkNo = llN->GetKey();
+
+ // read in a block for the block number
+ if(( iRc = ReadBlock( ulBlkNo, GetBlockSize(), n->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ // harvest it
+ n->ulBlockNo = ulBlkNo;
+ if(( iRc = HarvestEmptyNode( mpTag, n, 1, bHarvestRoot )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ llN = llN->GetNextNode();
+ }
+ n = FreeNodeChain( n );
+ mpTag->npNodeChain = FreeNodeChain( mpTag->npNodeChain );
+ mpTag->npCurNode = NULL;
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::HarvestTagNodes() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Insert key into interior node.
+/*!
+ Insert key into non-full interior node.<br>
+ Assumes valid inputs
+
+ \param vpTag Tag in play.
+ \param npNode Node for insertion.
+ \param iSlotNo Slot number to insert key.
+ \param ulPtr Page number to insert.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxMdx::InsertNodeI( void *vpTag, xbIxNode *npNode, xbInt16 iSlotNo, xbUInt32 ulPtr ){
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ char *pNewKeyPos;
+ char *pTrg;
+ char *pLastKey = NULL;
+ xbMdxTag * npTag;
+ npTag = (xbMdxTag *) vpTag;
+ xbInt16 iCopyLen;
+ xbInt16 iNewKeyPos = 8;
+
+
+ try{
+
+ xbInt32 lKeyCnt = GetKeyCount( npNode );
+ iNewKeyPos += (iSlotNo * npTag->iKeyItemLen);
+ char *pSrc = npNode->cpBlockData;
+
+ if( iSlotNo < lKeyCnt )
+ iCopyLen = ((lKeyCnt - iSlotNo) * npTag->iKeyItemLen) + 4;
+ else
+ iCopyLen = 0;
+
+ xbUInt32 ulRqdBufSize = (xbUInt32) ((lKeyCnt + 1) * npTag->iKeyItemLen) + 12;
+ if( ulRqdBufSize > npNode->ulBufSize ){
+ npNode->ulBufSize += (xbUInt32) npTag->iKeyItemLen;
+ npNode->cpBlockData = (char *) realloc( npNode->cpBlockData, (size_t) npNode->ulBufSize );
+ if( !npNode->cpBlockData ){
+ iErrorStop = 100;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+ }
+
+ // if not appending to the end of the node, make some room, move things to the right
+ pNewKeyPos = npNode->cpBlockData;
+ pNewKeyPos += iNewKeyPos;
+
+ if( iSlotNo < lKeyCnt ){
+ pTrg = pNewKeyPos;
+ pTrg += npTag->iKeyItemLen;
+ memmove( pTrg, pNewKeyPos, (size_t) iCopyLen );
+ }
+
+ // get the right most key for the left part of the split node
+ xbUInt32 ulKeyPtr2;
+ if(( iRc = GetKeyPtr( vpTag, npNode->iCurKeyNo, npNode, ulKeyPtr2 )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ // get the new right key value for the freshly split node
+ pLastKey = (char *) malloc((size_t) npTag->iKeyLen);
+ if(( iRc = GetLastKeyForBlockNo( vpTag, PageToBlock( ulKeyPtr2 ), pLastKey )) != XB_NO_ERROR ){
+ iRc = 120;
+ throw iRc;
+ }
+
+ // write the key values
+ pTrg = pNewKeyPos;
+ pTrg += 4;
+ pSrc = pLastKey;
+ for( xbInt16 i = 0; i < npTag->iKeyLen; i++ )
+ *pTrg++ = *pSrc++;
+ ePutUInt32( pTrg, ulPtr);
+ ePutInt32( npNode->cpBlockData, ++lKeyCnt );
+
+ // write out the updated block to disk
+ if(( iRc = WriteBlock( npNode->ulBlockNo, GetBlockSize(), npNode->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ if( pLastKey )
+ free( pLastKey );
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::InsertNodeI() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ if( pLastKey )
+ free( pLastKey );
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Insert key into leaf node.
+/*!
+ Insert key into non-full leaf node.<br>
+ Assumes valid inputs
+
+ \param vpTag Tag in play.
+ \param npNode Node for insertion.
+ \param iSlotNo Slot number to insert key.
+ \param ulPtr Pointer number to insert.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxMdx::InsertNodeL( void *vpTag, xbIxNode *npNode, xbInt16 iSlotNo, char * cpKeyBuf, xbUInt32 ulPtr ){
+
+ // format of block data is
+ // 4 bytes number of keys on block
+ // 4 bytes - next free block or split block num
+ // repeating
+ // 4 bytes record number
+ // x bytes key data
+
+ // Special processing note: when splitting node, new key is first inserted into full left node before
+ // the node is split. This routine will make additional room in the buffer for that scenario
+
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ char *pNewKeyPos; // pointer to position in record for new key composite
+ char *pTrg;
+
+ xbInt16 iNewKeyPos = 8; // position in data block where new key begins.
+ // is the position of the record number, where the fmt is
+ // [four byte rec number][actual key data] repeats
+
+ xbMdxTag * npTag = (xbMdxTag *) vpTag;
+ xbInt16 iCopyLen;
+
+ try{
+ xbInt32 lKeyCnt = GetKeyCount( npNode );
+
+// std::cout << "InsertNodeL Keycount = " << lKeyCnt << "\n";
+// next line is correct, this aligns with db7
+// "4" is the four byte record number stored to the left of the key
+// xbInt16 iKeyPos = 4 + iSlotNo * npTag->iKeyItemLen;
+
+ iNewKeyPos += (iSlotNo * npTag->iKeyItemLen);
+
+ // length of number of keys that need to be moved to the right
+ if( iSlotNo < lKeyCnt )
+ iCopyLen = (lKeyCnt - iSlotNo) * npTag->iKeyItemLen;
+ else
+ iCopyLen = 0;
+
+ // +8 is to include the first two 4 byte fields in the block
+ // xbUInt32 ulRqdBufSize = (xbUInt32) (iKeyPos + (npTag->iKeyItemLen * 2) + iCopyLen + 8);
+ xbUInt32 ulRqdBufSize = (xbUInt32) ((lKeyCnt + 1) * npTag->iKeyItemLen) + 8;
+
+/*
+ std::cout << "InsertNodeL CopyLen = " << iCopyLen << "\n";
+ std::cout << "InsertNodeL iNewKeyPos = " << iNewKeyPos << "\n";
+ std::cout << "InsertNodeL SlotNo = " << iSlotNo << "\n";
+ std::cout << "InsertNodeL lKeyCnt = " << lKeyCnt << "\n";
+ std::cout << "InsertNodeL node buf size = " << npNode->ulBufSize << "\n";
+ std::cout << "InsertNodeL key item len = " << npTag->iKeyItemLen << "\n";
+ std::cout << "InsertNodeL key len = " << npTag->iKeyLen << "\n";
+ std::cout << "required buf size = " << ulRqdBufSize << "\n";
+ std::cout << "InsertNodeL key buf strlen = " << strlen( npTag->cpKeyBuf ) << "\n";
+*/
+
+ if( ulRqdBufSize > npNode->ulBufSize ){
+ npNode->ulBufSize += (xbUInt32) npTag->iKeyItemLen;
+ npNode->cpBlockData = (char *) realloc( npNode->cpBlockData, (size_t) npNode->ulBufSize );
+ if( !npNode->cpBlockData ){
+ iErrorStop = 100;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+ }
+
+ // if not appending to end, move things right
+
+ pNewKeyPos = npNode->cpBlockData;
+ pNewKeyPos += iNewKeyPos;
+
+ if( iSlotNo < lKeyCnt ) {
+ // pKeyPos = npNode->cpBlockData;
+ // pKeyPos += iKeyPos;
+ // pKeyPos += iNewKeyPos;
+ // pTrg = pKeyPos;
+ pTrg = pNewKeyPos;
+ pTrg += npTag->iKeyItemLen;
+ memmove( pTrg, pNewKeyPos, (size_t) iCopyLen );
+
+ }
+
+ // write rec number
+ ePutUInt32( pNewKeyPos, ulPtr );
+
+ // write the key value
+ pTrg = pNewKeyPos;
+ pTrg += 4;
+ char * pSrc = cpKeyBuf;
+ for( xbInt16 i = 0; i < npTag->iKeyLen; i++ )
+ *pTrg++ = *pSrc++;
+
+ // update number of keys on the node
+ ePutInt32( npNode->cpBlockData, ++lKeyCnt );
+// std::cout << "lKeyCntA = " << GetKeyCount( npNode ) << "\n";
+
+
+ // determine length of node, zap everything to the right of it
+ xbUInt32 iStartPos = 8 + ((xbUInt32) lKeyCnt * (xbUInt32) npTag->iKeyItemLen );
+ xbUInt32 iClearLen = npNode->ulBufSize - iStartPos;
+
+// std::cout << "InsertNodeL SP = " << iStartPos << " clear len = " << iClearLen << " ulBufsize = " << npNode->ulBufSize << "\n";
+ char *p = npNode->cpBlockData;
+ p += iStartPos;
+ memset( p, 0x00, iClearLen );
+
+ // write out the updated block to disk
+ if(( iRc = WriteBlock( npNode->ulBlockNo, GetBlockSize(), npNode->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+// std::cout << "lKeyCntB = " << GetKeyCount( npNode ) << "\n";
+
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::InsertNodeL() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+inline xbBool xbIxMdx::IsLeaf( void *vpTag, xbIxNode *npNode ) const{
+
+ // for performance reasons, does no data checking
+ // will result in potentially hard to find segfaults if passing invalid npNode
+
+ xbMdxTag *mTag = (xbMdxTag *) vpTag;
+ char *p = npNode->cpBlockData;
+
+ xbInt32 lNoOfKeys = eGetInt32( p );
+ // mdx interior nodes have a sibling number to the right of the right most key in the node
+ p+=8;
+ p+= mTag->iKeyItemLen * lNoOfKeys;
+
+ // printf( "IsLeaf p = [%d] b1 = [%x] keylen = [%d]\n", eGetUInt32( p ), *p, mTag->iKeyItemLen );
+
+ if( eGetUInt32( p ) == 0 ){
+ // std::cout << "leaf node\n";
+ return true;
+ } else {
+ // std::cout << "interior node\n";
+ return false;
+ }
+}
+
+/***********************************************************************/
+xbInt16 xbIxMdx::KeyExists( void * vpTag )
+{
+ // this method assumes the key has already been built
+
+ xbMdxTag *mpTag = (xbMdxTag *) vpTag;
+ xbInt16 iRc = FindKey( vpTag, mpTag->cpKeyBuf, mpTag->iKeyLen, 0 );
+
+ // iRc == 0 ? return 1 : return 0;
+
+ if( iRc == 0 )
+ return 1;
+ else
+ return 0;
+
+}
+
+/***********************************************************************/
+//! @brief Set position for key add.
+/*!
+ This routine is called by the AddKey() method and is used to position
+ the node chain to the position the new key should be added to the index.
+
+ \param npTag Pointer to npTag.
+ \param ulAddRecNo Record number to add.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxMdx::KeySetPosAdd( xbMdxTag *mpTag, xbUInt32 ulAddRecNo ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try{
+
+ iRc = FindKey( mpTag, mpTag->cpKeyBuf, mpTag->iKeyLen, 0 );
+ if( iRc == XB_NOT_FOUND || iRc == XB_EMPTY )
+ return XB_NO_ERROR; // good position
+ else if( iRc != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ // get here if key was found, get the right most instance of any non unique key for append, find correct spot for update
+ if( GetUnique( mpTag ) == 0 ){
+
+ xbUInt32 ulCurRecNo;
+ if(( iRc = GetDbfPtr( mpTag, mpTag->npCurNode->iCurKeyNo, mpTag->npCurNode, ulCurRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ xbBool bKeysMatch = xbTrue;
+
+ while( bKeysMatch && ulAddRecNo > ulCurRecNo && iRc == XB_NO_ERROR ){
+ if(( iRc = GetNextKey( mpTag, 0 )) == XB_NO_ERROR ){
+ if( memcmp( GetKeyData( mpTag->npCurNode, mpTag->npCurNode->iCurKeyNo, mpTag->iKeyItemLen ), mpTag->cpKeyBuf, (size_t) mpTag->iKeyLen ))
+ bKeysMatch = xbFalse;
+ else{
+ if(( iRc = GetDbfPtr( mpTag, mpTag->npCurNode->iCurKeyNo, mpTag->npCurNode, ulCurRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ }
+ }
+ }
+ }
+ if( iRc == XB_EOF ){ // eof condition
+ if(( iRc = GetLastKey( 0, mpTag, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ mpTag->npCurNode->iCurKeyNo++;
+ return XB_NO_ERROR;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::KeySetPosAdd() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Set position for key delete.
+/*!
+ This routine is called by the DeleteKey() method and is used to position
+ the node chain to the position the old key should be deleted from the index.
+
+ \param npTag Pointer to npTag.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxMdx::KeySetPosDel( xbMdxTag *npTag ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbString sMsg;
+
+ try{
+
+ iRc = FindKey( npTag, npTag->cpKeyBuf2, npTag->iKeyLen, 0 );
+ if( iRc == XB_NOT_FOUND || iRc == XB_EMPTY )
+ return XB_NO_ERROR; // good pos ition
+ else if( iRc != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+ xbUInt32 ulIxRecNo;
+ if(( iRc = GetDbfPtr( npTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulIxRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ if( ulIxRecNo == dbf->GetCurRecNo())
+ return XB_NO_ERROR;
+
+ if( GetUnique( npTag ) == 1 ){
+ iErrorStop = 120;
+ iRc = XB_NOT_FOUND;
+ throw iRc;
+ }
+
+ xbBool bFound = xbFalse;
+ xbBool bKeysMatch = xbTrue;
+ while( bKeysMatch && !bFound && iRc == XB_NO_ERROR ){
+
+ if(( iRc = GetNextKey( npTag, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ if( memcmp( GetKeyData( npTag->npCurNode, npTag->npCurNode->iCurKeyNo, npTag->iKeyItemLen ), npTag->cpKeyBuf2, (size_t) npTag->iKeyLen )){
+ bKeysMatch = xbFalse;
+ } else {
+ if(( iRc = GetDbfPtr( npTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulIxRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+ if( ulIxRecNo == dbf->GetCurRecNo())
+ bFound = xbTrue;
+ }
+ }
+
+ if( bFound )
+ return XB_NO_ERROR;
+ else
+ return XB_NOT_FOUND;
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::KeySetPosDel() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Returns key update status.
+/*!
+ \param vpTag Tag to check status on.
+ \returns xbtrue - Key was updated.<br>xbFalse - Key not updated.
+*/
+/*
+inline xbBool xbIxMdx::KeyFiltered( void *vpTag ) const{
+
+ xbMdxTag *mpTag = (xbMdxTag *) vpTag;
+ return mpTag->bKeyFiltered;
+}
+*/
+/***********************************************************************/
+xbInt16 xbIxMdx::LoadTagDetail( xbInt16 iOption, xbMdxTag *tte ){
+
+ // option 1 - Load the entire tag detail
+ // option 2 - Load the dynamic variables only
+
+ // std::cout << "LoadTagDetail() iOption = " << iOption << "\n";
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ size_t iReadSize;
+ char *buf = NULL;
+ char *p;
+
+ try{
+ // set the read length based on the option
+ if( iOption == 1 )
+ iReadSize = 1024;
+
+ else if( iOption == 2 )
+ // iReadSize = 4;
+ iReadSize = 260;
+ else{
+ iRc = XB_INVALID_OPTION;
+ iErrorStop = 100;
+ throw iRc;
+ }
+ if(( buf = (char *) calloc( 1, (size_t) iReadSize )) == NULL ){
+ iErrorStop = 110;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+ if(( iRc = ReadBlock( tte->ulTagHdrPageNo,(xbUInt32) (GetBlockSize() / (xbUInt16) iBlockFactor),
+ iReadSize, buf )) != XB_NO_ERROR ){
+ free( buf );
+ iErrorStop = 30;
+ throw iRc;
+ }
+
+ p = buf;
+ tte->ulRootPage = eGetUInt32( p );
+
+ if( iOption == 1 ){
+ p+=4;
+ tte->ulTagSize = eGetUInt32( p );
+ p+=4;
+ tte->cKeyFmt2 = *p;
+ p++;
+ tte->cKeyType2 = *p;
+ p+=3;
+ tte->iKeyLen = eGetInt16( p );
+ p+=2;
+ tte->iKeysPerBlock = *p;
+ p+=2;
+ tte->iSecKeyType = eGetInt16( p );
+ p+=2;
+ tte->iKeyItemLen = eGetInt16( p );
+ p+=2;
+ tte->cSerialNo = *p;
+ p+=3;
+ tte->cUnique = *p;
+ p++;
+
+ // next line assumes expression is a null terminated string in the block
+ tte->sKeyExp = new xbString();
+ tte->sKeyExp->Sprintf( "%s", p );
+
+ p+=221;
+ tte->cHasFilter = *p;
+ p+=1;
+ tte->cHasKeys = *p;
+ p+=2;
+ tte->ulLeftChild = eGetUInt32( p );
+ p+=4;
+ tte->ulRightChild = eGetUInt32( p );
+ p+=5;
+ tte->cTagYY = *p;
+ p++;
+ tte->cTagMM = *p;
+ p++;
+ tte->cTagDD = *p;
+ // p+=223;
+
+ p+=221;
+ tte->cKeyFmt3 = *p;
+
+//for( int i = 0; i < 5; i++ )
+// printf( "%d [%x]\n", i, *p++ );
+// p+=2;
+
+ if( tte->cHasFilter ){
+ p+=282;
+ tte->sFiltExp = new xbString();
+ tte->sFiltExp->Sprintf( "%s", p );
+ tte->filter = new xbExp( xbase, dbf );
+ if(( iRc = tte->filter->ParseExpression( tte->sFiltExp->Str())) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ }
+ tte->npNodeChain = NULL;
+ tte->npCurNode = NULL;
+ tte->cpKeyBuf = (char *) malloc( (size_t) tte->iKeyLen + 1 );
+ tte->cpKeyBuf2 = (char *) malloc( (size_t) tte->iKeyLen + 1 );
+ tte->exp = new xbExp( xbase, dbf );
+ if(( iRc = tte->exp->ParseExpression( tte->sKeyExp->Str() )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ } else if( iOption == 2 ){
+ // refresh the dynamic tag variables
+ p+=4;
+ tte->ulTagSize = eGetUInt32( p );
+ p+= 16;
+ tte->cSerialNo = *p;
+ p+= 226;
+ tte->cHasKeys = *p;
+ p+=2;
+ tte->ulLeftChild = eGetUInt32( p );
+ p+=4;
+ tte->ulRightChild = eGetUInt32( p );
+ p+=5;
+ tte->cTagYY = *p;
+ p++;
+ tte->cTagMM = *p;
+ p++;
+ tte->cTagDD = *p;
+ }
+ if( buf )
+ free( buf );
+
+ }
+ catch (xbInt16 iRc ){
+ if( buf )
+ free( buf );
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::LoadTagDetail() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+xbInt16 xbIxMdx::LoadTagTable()
+{
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ char * buf = NULL;
+
+ //std::cout << "xbIxMdx::LoadTagTable() tag use cnt = " << iTagUseCnt << "\n";
+
+ try{
+
+ if( iTagUseCnt > 46 ){
+ iErrorStop = 100;
+ iRc = XB_INVALID_INDEX;
+ throw iRc;
+ }
+
+ xbInt16 iBufSize = (xbInt16) iTagLen * iTagUseCnt;
+
+ if(( buf = (char *) malloc( (size_t) iBufSize )) == NULL ){
+ iErrorStop = 110;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+
+ if(( iRc = xbFseek( 544, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+
+ if(( iRc = xbFread( buf, (size_t) iBufSize, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+
+ xbInt16 iPos;
+ char *p;
+ xbMdxTag *tte;
+ xbMdxTag *ttel = NULL;
+
+ for( xbInt16 i = 0; i < iTagUseCnt; i++ ){
+ iPos = i * iTagLen;
+ p = buf + iPos;
+
+ if(( tte = (xbMdxTag *) calloc( 1, (size_t) sizeof( xbMdxTag ))) == NULL ){
+ iErrorStop = 140;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+
+ // set the current tag to the first tag in the table
+ if( !vpCurTag )
+ xbIx::SetCurTag( (void *) tte );
+
+ if( mdxTagTbl )
+ ttel->next = tte;
+ else
+ mdxTagTbl = tte;
+ // tte->sKeyExp = new xbString();
+
+ ttel = tte;
+ tte->next = NULL;
+ tte->ulTagHdrPageNo = eGetUInt32( p );
+
+ p += 4;
+ for( xbUInt32 i = 0; i < 11; i ++ )
+ tte->cTagName[i] = *p++;
+
+ tte->cTagName[11] = 0x00;
+ tte->cKeyFmt = *p++;
+ tte->cLeftChild = *p++;
+ tte->cRightChild = *p++;
+ tte->cParent = *p++;
+ tte->c2 = *p++;
+ tte->cKeyType = *p;
+ tte->sTagName = new xbString();
+ tte->sTagName->Set( tte->cTagName );
+ tte->sTagName->Trim();
+
+ if(( iRc = LoadTagDetail( 1, tte )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+ }
+ if( buf )
+ free( buf );
+ }
+ catch (xbInt16 iRc ){
+ if( buf )
+ free( buf );
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::LoadTagTable() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ if( iErrorStop == 100 ){
+ sMsg.Sprintf( "xbIxMdx::LoadTagTable() Invalid Tag Count: %d", iTagUseCnt );
+ xbase->WriteLogMessage( sMsg.Str());
+ }
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/**************************************************************************************************************/
+//! @brief Calculate the block number for a given page.
+/*!
+ This routine is called by any function needing to calculate the block number for a given page.
+ Page numbers are stored internally in the physical file, and the library reads and writes in
+ blocks of one or more pages.
+
+ Assumes valid data input
+
+ \param ulPageNo Page Number
+ \returns Calculated block number.
+*/
+
+inline xbUInt32 xbIxMdx::PageToBlock( xbUInt32 ulPageNo ){
+ return ulPageNo / (xbUInt32) iBlockFactor;
+}
+
+
+
+/**************************************************************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+xbInt16 xbIxMdx::PrintKey( void *vpTag, xbIxNode *npNode, xbInt16 iKeyNo, xbInt16 iDepth, char cType, xbInt16 iOutputOpt ){
+
+ xbString sPre;
+ sPre.Sprintf( "%c ", cType );
+ for( xbInt16 i = 0; i < iDepth; i++ )
+ sPre += "|";
+
+ xbString sPost;
+ sPost.Sprintf( "\tThisBlock=[%ld] KeyNo=[%d] Depth=[%d]", npNode->ulBlockNo, iKeyNo, iDepth );
+
+ xbMdxTag * mpTag = (xbMdxTag *) vpTag;
+ char *p = npNode->cpBlockData + (8 + (iKeyNo * mpTag->iKeyItemLen ));
+
+ xbString sKeyPtr;
+ xbUInt32 ulNoOfKeys = 0;
+ if( cType == 'I' ) { // interior
+ sKeyPtr.Sprintf( " ptr=[%ld]", eGetUInt32( p ));
+ ulNoOfKeys = eGetUInt32( mpTag->npCurNode->cpBlockData );
+ }
+ else if( cType == 'L' ) // leaf
+ sKeyPtr.Sprintf( " rec=[%ld]", eGetUInt32( p ));
+ p += 4;
+
+ xbString s;
+ if(( cType == 'I' && iKeyNo < (xbInt16) ulNoOfKeys) || cType == 'L' ){
+ if( mpTag->cKeyType2 == 'C' ){ //CHAR
+ for( xbInt32 l = 0; l < (mpTag->iKeyItemLen-4); l++ )
+ s += *p++;
+
+ } else if( mpTag->cKeyType2 == 'N' ){ // NUMERIC
+ xbBcd bcd( p );
+ xbString s2;
+ bcd.ToString( s2 );
+ s += s2;
+
+ } else if( mpTag->cKeyType2 == 'D' ){ // DATE
+ xbInt32 lDate = (xbInt32) eGetDouble( p );
+ xbDate d( lDate );
+ //xbString s2;
+ //d.JulToDate8( lDate, s2 );
+ s.Sprintf( "%s%s", s.Str(), d.Str());
+ }
+ } else {
+ s = "Rightmost InteriorNode Pointer";
+ }
+
+ xbString sOut( sPre );
+ sOut += s;
+ sOut += sPost;
+ sOut += sKeyPtr;
+
+ xbase->WriteLogMessage( sOut, iOutputOpt );
+ return XB_NO_ERROR;
+}
+#endif
+
+/***********************************************************************/
+//! @brief ReadHeadBlock.
+/*!
+ Read values off head block in MDX file
+ \param iOpt 0 - Read entire block, initialize as needed.<br>
+ 1 - Read in only dynamic section of block<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+*/
+
+xbInt16 xbIxMdx::ReadHeadBlock( xbInt16 iOpt )
+{
+
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+// std::cout << "ReadHeadBlock() option = " << iOpt << "\n";
+
+ try{
+ if( !FileIsOpen()){
+ iRc = XB_NOT_OPEN;
+ iErrorStop = 100;
+ throw iRc;
+ }
+ char sBuf[48];
+ memset( sBuf, 0x00, 48 );
+
+ if( iOpt == 0 ){
+ if(( iRc = xbFseek( 0, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ if(( iRc = xbFread( sBuf, 47, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ } else {
+
+ if(( iRc = xbFseek( 28, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+
+ if(( iRc = xbFread( sBuf, 19, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+ }
+
+ char *p = sBuf;
+ if( iOpt == 0 ){
+ cVersion = *p++;
+ cCreateYY = *p++;
+ cCreateMM = *p++;
+ cCreateDD = *p++;
+ sFileName.Assign( p, 1, 16 );
+ p+=16;
+ iBlockFactor = eGetInt16( p );
+ p+=2;
+ SetBlockSize( (xbUInt32) eGetInt16( p ));
+ p+=2;
+ cProdIxFlag = *p++;
+ cTagEntryCnt = *p++;
+ iTagLen = *p;
+ p+=2;
+
+ iTagUseCnt = eGetInt16( p );
+ //lTagUseCnt = eGetInt32( p );
+ //p+=4;
+ p+=2;
+ cNextTag = *p++;
+ c1B = *p++;
+
+ ulPageCnt = eGetUInt32( p );
+ p+=4;
+ ulFirstFreePage = eGetUInt32( p );
+ p+=4;
+ ulNoOfBlockAvail = eGetUInt32( p );
+ p+=4;
+ cUpdateYY = *p++;
+ cUpdateMM = *p++;
+ cUpdateDD = *p;
+
+ if( cNodeBuf )
+ free( cNodeBuf );
+
+ if(( cNodeBuf = (char *) malloc( (size_t) GetBlockSize())) == NULL ){
+ iErrorStop = 40;
+ throw XB_NO_MEMORY;
+ }
+
+ if(( iRc = xbIxMdx::LoadTagTable()) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+
+ } else {
+ iTagUseCnt = eGetInt16( p );
+ p+=4;
+ ulPageCnt = eGetUInt32( p );
+ p+=4;
+ ulFirstFreePage = eGetUInt32( p );
+ p+=4;
+ ulNoOfBlockAvail = eGetUInt32( p );
+ p+=4;
+ cUpdateYY = *p++;
+ cUpdateMM = *p++;
+ cUpdateDD = *p;
+ }
+
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::ReadHeadBlock() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ if( cNodeBuf )
+ free( cNodeBuf );
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Reindex
+/*!
+ Reindex specifed tag or all tags
+ \param **vpTag &tag - Tag to reindex.<br>
+ NULL - Reindex all tags<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+
+ If this method fails, the index is left in an undefined state
+
+*/
+
+xbInt16 xbIxMdx::Reindex( void **vpTag ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbMdxTag * mpTag;
+ #ifdef XB_LOCKING_SUPPORT
+ xbInt16 iAutoLock = 0;
+ #endif
+
+ if( vpTag )
+ mpTag = (xbMdxTag *) *vpTag;
+ else
+ mpTag = NULL;
+
+ struct tagInfo{
+ xbBool bUnique;
+ xbBool bDesc;
+ char sTagName[11];
+ xbString *sKeyExp;
+ xbString *sFiltExp;
+ tagInfo *next;
+ };
+ tagInfo *ti = NULL;
+
+ try{
+
+ #ifdef XB_LOCKING_SUPPORT
+ iAutoLock = dbf->GetAutoLock();
+ if( iAutoLock && !dbf->GetTableLocked() ){
+ if(( iRc = dbf->LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ }
+ #endif
+
+ if( mpTag == NULL ){
+ // do all tags
+ xbMdxTag *tt = mdxTagTbl;
+ tagInfo *pHead = NULL;
+ tagInfo *pEnd = NULL;
+
+ if( tt ){
+ while( tt ){
+ ti = (tagInfo *) calloc( 1, sizeof( tagInfo ));
+ ti->bUnique = tt->cUnique ? 1 : 0;
+ ti->bDesc = (((tt->cKeyFmt2 & 0x08) > 0) ? 1 : 0);
+ memcpy( ti->sTagName, tt->cTagName, 11 );
+ ti->sKeyExp = new xbString( tt->sKeyExp->Str());
+ if( tt->cHasFilter )
+ ti->sFiltExp = new xbString( tt->sFiltExp->Str());
+ else
+ ti->sFiltExp = new xbString( "" );
+ if( !pHead )
+ pHead = ti;
+ else
+ pEnd->next = ti;
+ pEnd = ti;
+ tt = tt->next;
+ }
+ }
+
+ // get the file name and save it
+ xbString sMdxFileName = GetFqFileName();
+
+ // close the mdx file
+ if(( iRc = xbIxMdx::Close()) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ // delete the file
+ xbRemove();
+
+ // init variables
+ Init();
+
+ tagInfo *p = pHead;
+ tagInfo *pDel;
+
+ // create new file & add the tags
+ while( p ){
+
+ //std::cout << "Reindex() linked list extract\n";
+ //std::cout << "Tag Name = [" << p->sTagName << "]\n";
+ //std::cout << "Key Exp = [" << p->sKeyExp->Str() << "]\n";
+ //std::cout << "Filt Exp = [" << p->sFiltExp->Str() << "]\n";
+ //std::cout << "bDesc = [" << p->bDesc << "]\n";
+ //std::cout << "bUnique = [" << p->bUnique << "]\n";
+
+ if(( iRc = CreateTag( p->sTagName, p->sKeyExp->Str(), p->sFiltExp->Str(), p->bDesc, p->bUnique, xbTrue, vpTag )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ delete p->sKeyExp;
+ delete p->sFiltExp;
+ pDel = p;
+ p = p->next;
+ free( pDel );
+ }
+ } else {
+ if(( iRc = HarvestTagNodes( mpTag )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ }
+
+ xbUInt32 ulRecCnt = 0;
+ if(( iRc = dbf->GetRecordCnt( ulRecCnt )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+ xbInt16 iCurTag = 0;
+ xbBool bDone = xbFalse;
+
+ for( xbUInt32 ulRec = 1; ulRec <= ulRecCnt; ulRec++ ){
+ if(( iRc = dbf->GetRecord( ulRec )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+
+ bDone = xbFalse;
+ iCurTag = 0;
+ if( !vpTag )
+ mpTag = (xbMdxTag *) GetTag( iCurTag++ );
+
+ while( !bDone ){
+ // do the tag things
+ // CreateKey
+ if(( iRc = CreateKey( mpTag, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 160;
+ throw iRc;
+ }
+ if( mpTag->iKeySts == XB_ADD_KEY ){
+ if( mpTag->cUnique ){
+ if(( iRc = CheckForDupKey( mpTag )) != XB_NO_ERROR ){
+ iErrorStop = 170;
+ throw iRc;
+ }
+ }
+ if(( iRc = AddKey( mpTag, ulRec )) != XB_NO_ERROR ){
+ iErrorStop = 180;
+ throw iRc;
+ }
+ }
+ if( vpTag || iCurTag >= GetTagCount())
+ bDone = xbTrue;
+ else
+ mpTag = (xbMdxTag *) GetTag( iCurTag++ );
+ }
+ }
+
+ // unlock as necessary
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock && dbf->GetTableLocked() ){
+ if(( iRc = dbf->LockTable( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 190;
+ throw iRc;
+ }
+ }
+ #endif
+
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::ReIndex() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+
+ // unlock as necessary
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock && dbf->GetTableLocked() ){
+ dbf->LockTable( XB_UNLOCK );
+ }
+ #endif
+ }
+ return iRc;
+
+}
+
+/***********************************************************************/
+xbInt16 xbIxMdx::SetCurTag( xbString &sTagName ) {
+
+ xbMdxTag *tt = (xbMdxTag *) GetTag( sTagName );
+ if( tt ){
+ xbIx::SetCurTag((void *) tt );
+ return XB_NO_ERROR;
+ } else
+ return XB_INVALID_TAG;
+}
+
+/***********************************************************************/
+xbInt16 xbIxMdx::SetCurTag( xbInt16 iTagNo ) {
+
+ xbMdxTag *tt = (xbMdxTag *) GetTag( iTagNo );
+ if( tt ){
+ xbIx::SetCurTag((void *) tt );
+ return XB_NO_ERROR;
+ } else
+ return XB_INVALID_TAG;
+}
+
+/***********************************************************************/
+//! @brief SetReuseEmptyNode switch setting.
+/*!
+ \param bEmptyNodeSw xbFalse - Do not reuse empty MDX index nodes (Dbase 6. behavior).
+ xbTrue - Reuse empty MDX index nodes.
+*/
+
+void xbIxMdx::SetReuseEmptyNodesSw( xbBool bEmptyNodesSw ) {
+ bReuseEmptyNodes = bEmptyNodesSw;
+}
+
+/***********************************************************************/
+//! @brief Set Tag Pointer.
+/*!
+ Set binary tree pointer value. The MDX tags are stored with binary
+ tree positions. This routine sets the value in memory.
+ \param cPtr L - Left child.<br>
+ R - Right child.<br>
+ P - Parent.
+ \param iWhich - Which tag to update
+ \param cVal - Value to set.
+ \returns void
+*/
+
+/*
+void xbIxMdx::SetTagPtr( char cPtr, xbInt16 iWhich, char cVal ){
+
+ xbMdxTag *mpTag = (xbMdxTag *) GetTag( iWhich );
+ if( mpTag ){
+ switch( cPtr ){
+ case 'L':
+ mpTag->cLeftChild = cVal;
+ break;
+ case 'R':
+ mpTag->cRightChild = cVal;
+ break;
+ case 'P':
+ mpTag->cParent = cVal;
+ break;
+ }
+ }
+}
+*/
+
+/***********************************************************************/
+//! @brief Split an interior node
+/*!
+
+ This routine splits an interior node into two nodes, divided by dSplitFactor.<br>
+ This behaves differently than V7 Dbase. V7 does not balance the nodes.<br>
+ For V7, if adding a key to the end of a node, it will create a right node
+ with only one key, and the left node is still full.<br><br>
+
+ Possible performance improvement options.<br>
+ Two modes when splitting:<br>
+ a) Split nodes in the middle - good for random access applications<br>
+ b) Split off right node with only one key - good for applications with
+ expectation of ascending keys added moving forward.<br>
+
+ This routine first inserts the key into the left node in the appropriate location
+ then splits the node based on the split factor setting.
+
+ \param vpTag Tag in play.
+ \param npLeft Left node to split.
+ \param npRight Right node to split.
+ \param iSlotNo Slot number for split.
+ \param ulPtr Pointer number to insert.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxMdx::SplitNodeI( void *vpTag, xbIxNode * npLeft, xbIxNode *npRight, xbInt16 iSlotNo, xbUInt32 ulPtr ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbMdxTag * npTag = (xbMdxTag *) vpTag;
+ xbDouble dSplitFactor = .5; // split the nodes 50/50
+ xbInt16 iLen;
+ char *pSrc;
+ char *pTrg;
+
+
+ try{
+ xbInt32 lKeyCnt = GetKeyCount( npLeft );
+ xbInt32 lNewLeftKeyCnt = (xbInt32) ((lKeyCnt + 1) * dSplitFactor);
+ xbInt32 lNewRightKeyCnt = lKeyCnt - lNewLeftKeyCnt;
+ if(( iRc = InsertNodeI( vpTag, npLeft, iSlotNo, ulPtr )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+ // move the right half of the left node to the right node
+ pSrc = npLeft->cpBlockData;
+ pSrc += 8 + ((lNewLeftKeyCnt+1) * npTag->iKeyItemLen);
+ pTrg = npRight->cpBlockData;
+ pTrg += 8;
+ iLen = (lNewRightKeyCnt * npTag->iKeyItemLen) + 4;
+ memmove( pTrg, pSrc, (size_t) iLen );
+
+ // eliminate chattle on the right
+ iLen = 12 + (lNewLeftKeyCnt * npTag->iKeyItemLen);
+ pSrc = npLeft->cpBlockData;
+ pSrc += iLen;
+ memset( pSrc, 0x00, npLeft->ulBufSize - (xbUInt32) iLen );
+
+ // write the new key counts into the nodes
+ pTrg = npLeft->cpBlockData;
+ ePutInt32( pTrg, lNewLeftKeyCnt );
+ pTrg = npRight->cpBlockData;
+ ePutInt32( pTrg, lNewRightKeyCnt );
+
+ // write out the block
+ if(( iRc = WriteBlock( npLeft->ulBlockNo, GetBlockSize(), npLeft->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ // write out the block
+ if(( iRc = WriteBlock( npRight->ulBlockNo, GetBlockSize(), npRight->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::SplitNodeI() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Split a leaf node.
+/*!
+ This routine splits an index leaf into two nodes, divided by dSplitFactor.<br>
+
+ Possible performance improvement options.<br>
+ Two modes when splitting:<br>
+ a) Split nodes in the middle - good for random access applications<br>
+ b) Split off right node with only one key - good for applications with
+ expectation of ascending keys added moving forward.<br>
+
+ This routine first inserts the key into the left node in the appropriate location
+ then splits the node based on the split factor setting.
+
+ \param vpTag Tag in play.
+ \param npLeft Left node to split.
+ \param npRight Right node to split.
+ \param iSlotNo Slot number for split.
+ \param ulPtr Pointer number to insert.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxMdx::SplitNodeL( void *vpTag, xbIxNode * npLeft, xbIxNode *npRight,
+ xbInt16 iSlotNo, char * cpKeyBuf, xbUInt32 ulPtr ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbDouble dSplitFactor = .5; // can adjust performance with this number
+ xbMdxTag *mpTag = (xbMdxTag *) vpTag;
+ xbString sMsg;
+
+ xbInt16 iLen;
+ char *pSrc;
+ char *pTrg;
+
+ // std::cout << "In xbIxMdx::SplitNodeL()\n";
+ try{
+ xbInt32 lKeyCnt = GetKeyCount( npLeft );
+ xbInt32 lNewLeftKeyCnt = (xbInt32) ((lKeyCnt + 1) * dSplitFactor) + 1;
+ xbInt32 lNewRightKeyCnt = lKeyCnt + 1 - lNewLeftKeyCnt;
+
+ if(( iRc = InsertNodeL( vpTag, npLeft, iSlotNo, cpKeyBuf, ulPtr )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+ // move right half off of left node to the right node
+ pSrc = npLeft->cpBlockData;
+ pSrc += 8 + (lNewLeftKeyCnt * mpTag->iKeyItemLen);
+ pTrg = npRight->cpBlockData;
+ pTrg += 8;
+ iLen = lNewRightKeyCnt * mpTag->iKeyItemLen;
+ memmove( pTrg, pSrc, (size_t) iLen );
+
+ // write the new key counts into the nodes
+ pTrg = npLeft->cpBlockData;
+ ePutInt32( pTrg, lNewLeftKeyCnt );
+ pTrg = npRight->cpBlockData;
+ ePutInt32( pTrg, lNewRightKeyCnt );
+
+ // zero out the next key number so this node is not confused with interior node
+ iLen = 8 + (lNewLeftKeyCnt * mpTag->iKeyItemLen);
+ pSrc = npLeft->cpBlockData;
+ pSrc += iLen;
+ memset( pSrc, 0x00, npLeft->ulBufSize - (xbUInt32) iLen );
+
+ // write out the left block
+ if(( iRc = WriteBlock( npLeft->ulBlockNo, GetBlockSize(), npLeft->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ // write out the right block
+ if(( iRc = WriteBlock( npRight->ulBlockNo, GetBlockSize(), npRight->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::SplitNodeL() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/**************************************************************************************************************/
+//! @brief TagSerialNo.
+/*!
+ This routine is used internally for reading or updating the serial number on a given tag when the tag.
+
+ \param iOption 1 - Read tag serial number off disk, save in structure<br>
+ 2 - Write serial number from memory to disk<br>
+ 3 - Read serial number off disk, increment, write updated number to disk<br>
+ mpTag - Pointer to tag for serial number update
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxMdx::TagSerialNo( xbInt16 iOption, xbMdxTag * mpTag ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+
+ xbInt64 lPos = (mpTag->ulTagHdrPageNo * 512) + 20;
+
+// std::cout << "UpdateSerialNo offset = " << lPos << " option = " << iOption << "\n";
+
+ if( iOption != 2 ){
+ if(( iRc = xbFseek( lPos, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ if(( iRc = xbFgetc( mpTag->cSerialNo )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ }
+
+ if( iOption == 3 )
+ mpTag->cSerialNo++;
+
+ if( iOption != 1 ){
+ if(( iRc = xbFseek( lPos, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ if(( iRc = xbFwrite( &mpTag->cSerialNo, 1, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ }
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::UpdateSerialNo() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+
+/***********************************************************************/
+//! @brief UpdateTagKey
+/*!
+ This routine updates a key or a given tag.
+ The file header is considered to be the first 2048 bytes in the file.
+
+ \param cAction A - Add a key.<br>
+ D - Delete a key.<br>
+ R - Revise a key.<br>
+ \param vpTg - Pointer to tag.<br>
+ \param ulRecNo - Record number association with the action.<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxMdx::UpdateTagKey( char cAction, void *vpTag, xbUInt32 ulRecNo ){
+
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbMdxTag *npTag = (xbMdxTag *) vpTag;
+
+ try{
+ // save off any needed fields for updating
+ xbUInt32 ulTagSizeSave = npTag->ulTagSize;
+ // std::cout << "old size = " << ulTagSizeSave << " new size = " << npTag->ulTagSize << "\n";
+ //std::cout << "UpdateTagKey - tag size was updated need to do something here - test \n";
+
+
+ if( cAction == 'D' || cAction == 'R' ){
+ // std::cout << "UpdateTagKey-delete going to DeleteKey \n";
+ if(( iRc = DeleteKey( vpTag )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ //std::cout << "UpdateTagKey-delete back from DeleteKey \n";
+ }
+
+ if( cAction == 'A' || cAction == 'R' ){
+ if(( iRc = AddKey( vpTag, ulRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ }
+ if( ulTagSizeSave != npTag->ulTagSize ){
+ if(( iRc = UpdateTagSize( npTag, npTag->ulTagSize )) != XB_NO_ERROR) {
+ iErrorStop = 120;
+ throw iRc;
+ }
+ }
+ // update the serial number
+ if(( iRc = TagSerialNo( 3, npTag )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::UpdateTagKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/**************************************************************************************************************/
+//! @brief Write head block.
+/*!
+ This routine updates the MDX file header and commits changes to disk.
+ The file header is considered to be the first 2048 bytes in the file.
+
+ \param iOption 0 - Entire 2048 byte header, used for creating a new mdx file.<br>
+ 1 - Bytes 28 through 46, used when adding or deleting a tag.<br>
+ 2 - Bytes 32 through 46, used after updating keys in the file.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+
+xbInt16 xbIxMdx::WriteHeadBlock( xbInt16 iOption ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ xbDate d; // default is system date, today
+ cUpdateYY = (char) d.YearOf() - 1900;
+ cUpdateMM = (char) d.MonthOf();
+ cUpdateDD = (char) d.DayOf( XB_FMT_MONTH );
+
+ if( iOption > 0 ){
+ char buf[48];
+ memset( buf, 0x00, 48 );
+ xbUInt32 ulStartPos = 0;
+ xbUInt32 ulLen = 0;
+
+ if( iOption == 1 ){
+ ePutInt16( &buf[28], iTagUseCnt );
+ buf[30] = cNextTag;
+ buf[31] = 0x1b;
+ ulStartPos = 28;
+ ulLen = 19;
+ } else {
+ ulStartPos = 32;
+ ulLen = 16;
+ }
+
+ ePutUInt32( &buf[32], ulPageCnt );
+ ePutUInt32( &buf[36], ulFirstFreePage );
+ ePutUInt32( &buf[40], ulNoOfBlockAvail );
+ buf[44] = cUpdateYY;
+ buf[45] = cUpdateMM;
+ buf[46] = cUpdateDD;
+
+ if(( iRc = xbFseek( ulStartPos, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+ if(( iRc = xbFwrite( &buf[ulStartPos], ulLen, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ } else if( iOption == 0 ){
+ char buf[2048];
+ memset( buf, 0x00, 2048 );
+
+ buf[0] = cVersion;
+ cCreateYY = cUpdateYY;
+ cCreateMM = cUpdateMM;
+ cCreateDD = cUpdateDD;
+ buf[1] = cCreateYY;
+ buf[2] = cCreateMM;
+ buf[3] = cCreateDD;
+
+
+ for( xbUInt32 l = 0; l < sFileName.Len() && l < 10; l++ ){
+ buf[l+4] = sFileName[l+1];
+ }
+
+ ePutInt16( &buf[20], iBlockFactor );
+ ePutInt16( &buf[22], (xbInt16) GetBlockSize() );
+
+ buf[24] = cProdIxFlag;
+ buf[25] = cTagEntryCnt;
+ ePutInt16 ( &buf[26], iTagLen );
+ ePutInt16 ( &buf[28], iTagUseCnt );
+ buf[30] = cNextTag;
+ buf[31] = c1B;
+ ePutUInt32( &buf[32], ulPageCnt );
+ ePutUInt32( &buf[36], ulFirstFreePage );
+ ePutUInt32( &buf[40], ulNoOfBlockAvail );
+ buf[44] = cUpdateYY;
+ buf[45] = cUpdateMM;
+ buf[46] = cUpdateDD;
+
+ // not sure what the following "1" is for in a sea of zeroes....
+ // maybe it's current tag or default tag or something along those lines?
+ buf[529] = 0x01;
+
+ xbRewind();
+ if(( iRc = xbFwrite( buf, 2048, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ } else {
+ iErrorStop = 130;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::WriteHeadBlock() Exception Caught. Error Stop = [%d] iRc = [%d] option = [%d]", iErrorStop, iRc, iOption );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+xbInt16 xbIxMdx::UpdateTagSize( xbMdxTag *mpTag, xbUInt32 ulTagSz ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ char buf[4];
+ try{
+ ePutUInt32( &buf[0], ulTagSz );
+ if(( iRc = xbFseek( (xbInt64) ((mpTag->ulTagHdrPageNo *512 )+ 4), SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ if(( iRc = xbFwrite( &buf[0], 4, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxMdx::UpdateTagSize() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+
+/***********************************************************************/
+//void xbIxMdx::TestStub( char *s, void *vpTag ){
+void xbIxMdx::TestStub( char *, void * ){
+}
+/***********************************************************************/
+} /* namespace */
+#endif /* XB_MDX_SUPPORT */
+
diff --git a/src/core/xbixndx.cpp b/src/core/xbixndx.cpp
new file mode 100755
index 0000000..097bd22
--- /dev/null
+++ b/src/core/xbixndx.cpp
@@ -0,0 +1,2840 @@
+/* xbixndx.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_NDX_SUPPORT
+
+namespace xb{
+
+
+/***********************************************************************/
+//! @brief Class constructor.
+/*!
+ \param dbf Pointer to dbf instance.
+*/
+
+xbIxNdx::xbIxNdx( xbDbf *dbf ) : xbIx( dbf ){
+ ndxTag = (xbNdxTag *) calloc( 1, sizeof( xbNdxTag ));
+ SetBlockSize( XB_NDX_BLOCK_SIZE );
+ cNodeBuf = (char *) malloc( XB_NDX_BLOCK_SIZE );
+}
+/***********************************************************************/
+//! @brief Class Destructor.
+xbIxNdx::~xbIxNdx(){
+ if( ndxTag ){
+ ndxTag->npNodeChain = FreeNodeChain( ndxTag->npNodeChain );
+ if( ndxTag->cpKeyBuf )
+ free( ndxTag->cpKeyBuf );
+ if( ndxTag->cpKeyBuf2 )
+ free( ndxTag->cpKeyBuf2 );
+ if( ndxTag->exp ){
+ delete ndxTag->exp;
+ ndxTag->exp = NULL;
+ }
+ ndxTag->sKeyExpression.Set( NULL );
+ ndxTag->sTagName.Set( NULL );
+ free( ndxTag );
+ ndxTag = NULL;
+ }
+ if( cNodeBuf )
+ free( cNodeBuf );
+}
+/***********************************************************************/
+//! @brief Add key.
+/*!
+ Add key. If this is a unique index, this logic assumes the duplicate
+ check logic was already done.
+
+ \param vpTag Tag to update.
+ \param ulRecNo Record number to add key for.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::AddKey( void * vpTag, xbUInt32 ulRecNo ){
+
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+ if( GetUniqueKeyOpt() == XB_EMULATE_DBASE && npTag->bFoundSts )
+ return XB_NO_ERROR;
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbInt16 iHeadNodeUpdateOpt = 2;
+
+
+ try{
+
+ if(( iRc = xbIxNdx::KeySetPosAdd( npTag, ulRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ xbInt32 lKeyCnt = GetKeyCount( npTag->npCurNode );
+ if( lKeyCnt < npTag->iKeysPerBlock ){
+ // Section A - add key to appropriate position if space available
+ if(( iRc = InsertNodeL( npTag, npTag->npCurNode, npTag->npCurNode->iCurKeyNo, npTag->cpKeyBuf, ulRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 200;
+ throw iRc;
+ }
+
+ } else {
+ // land here with a full leaf node
+ iHeadNodeUpdateOpt = 1;
+ // section B - split the leaf node
+ xbIxNode * npRightNode = AllocateIxNode( GetBlockSize() + (xbUInt32) npTag->iKeyItemLen, 1 );
+ if( !npRightNode ){
+ iErrorStop = 100;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+ if(( iRc = SplitNodeL( npTag, npTag->npCurNode, npRightNode, npTag->npCurNode->iCurKeyNo, npTag->cpKeyBuf, ulRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ xbUInt32 ulTempBlockNo = npRightNode->ulBlockNo;
+
+ // section C - go up the tree, splitting nodes as necessary
+ xbIxNode * npParent = npTag->npCurNode->npPrev;
+ while( npParent && GetKeyCount( npParent ) >= npTag->iKeysPerBlock ){
+ npRightNode = FreeNodeChain( npRightNode );
+ npRightNode = AllocateIxNode( GetBlockSize() + (xbUInt32) npTag->iKeyItemLen, 1 );
+ if( !npRightNode ){
+ iErrorStop = 200;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+ if(( iRc = SplitNodeI( npTag, npParent, npRightNode, npParent->iCurKeyNo, ulTempBlockNo )) != XB_NO_ERROR ){
+ iErrorStop = 210;
+ throw iRc;
+ }
+ ulTempBlockNo = npRightNode->ulBlockNo;
+ npTag->npCurNode = npParent;
+ npParent = npParent->npPrev;
+ }
+
+ // section D - if cur node is split root, create new root
+ if( npTag->npCurNode->ulBlockNo == npTag->ulRootBlock ){
+ // xbase->WriteLogMessage( "Section d" );
+ if(( iRc = AddKeyNewRoot( npTag, npTag->npCurNode, npRightNode )) != XB_NO_ERROR ){
+ iErrorStop = 300;
+ throw iRc;
+ }
+ npRightNode = FreeNodeChain( npRightNode );
+
+ } else {
+ // else section E, put key in parent
+ if(( iRc = InsertNodeI( vpTag, npParent, npParent->iCurKeyNo, npRightNode->ulBlockNo )) != XB_NO_ERROR ){
+ iErrorStop = 400;
+ throw iRc;
+ }
+ npRightNode = FreeNodeChain( npRightNode );
+ }
+ }
+
+ // update the header
+ if(( iRc = WriteHeadBlock( iHeadNodeUpdateOpt )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+
+ // ---- free whatever is left of the node chain here, this might not be right, might need to restore it to
+ // the point right after SetKeyPosAdd
+ npTag->npNodeChain = FreeNodeChain( ndxTag->npNodeChain );
+ npTag->npCurNode = NULL;
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::AddKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Add new root node.
+/*!
+ \param npTag Tag to update.
+ \param npLeft Left node.
+ \param npRight Right node.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxNdx::AddKeyNewRoot( xbNdxTag *npTag, xbIxNode *npLeft, xbIxNode *npRight ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbString sMsg;
+ char *pLastKey = NULL;
+
+ try{
+ xbIxNode *npRoot = AllocateIxNode( GetBlockSize() + (xbUInt32) npTag->iKeyItemLen, 1 );
+ if( !npRoot ){
+ iErrorStop = 100;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+ npTag->ulRootBlock = npRoot->ulBlockNo;
+ pLastKey = (char *) malloc( (size_t) ndxTag->iKeyLen );
+ if(( iRc = GetLastKeyForBlockNo( npTag, npLeft->ulBlockNo, pLastKey )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ char * pTrg = npRoot->cpBlockData;
+
+ // set no of keys to 1
+ ePutUInt32( pTrg, 1 );
+
+ // set the left node number
+ pTrg += 4;
+ ePutUInt32( pTrg, npLeft->ulBlockNo );
+
+ // set the key
+ pTrg+= 8;
+ memcpy( pTrg, pLastKey, (size_t) npTag->iKeyLen );
+
+ // set the right node number
+ pTrg+= (npTag->iKeyItemLen - 8);
+ ePutUInt32( pTrg, npRight->ulBlockNo );
+
+ // write out the block
+ if(( iRc = WriteBlock( npRoot->ulBlockNo, GetBlockSize(), npRoot->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ if( pLastKey )
+ free( pLastKey );
+ NodeFree( npRoot );
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::AddKeyNewRoot() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ if( pLastKey )
+ free( pLastKey );
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Append node to node chain.
+/*!
+ Append a node to the current node chain for a given tag.
+
+ \param vpTag Tag to update.
+ \param npNode Node to add to node chain.
+ \returns void
+*/
+void xbIxNdx::AppendNodeChain( void *vpTag, xbIxNode * npNode ){
+
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ if( npTag->npNodeChain == NULL ){
+ npTag->npNodeChain = npNode;
+ npTag->npCurNode = npNode;
+ } else {
+ npNode->npPrev = npTag->npCurNode;
+ npTag->npCurNode->npNext = npNode;
+ npTag->npCurNode = npNode;
+ }
+ // time stamp the node chain
+ GetFileMtime( npTag->tNodeChainTs );
+}
+
+/***********************************************************************/
+//! @brief Allocate a node.
+/*!
+ \param ulBufSize Buffer size.
+ \param iOpt 0 - Don't update the node block number on the node.
+ 1 - Set node block number to the next available block number.
+ \returns Pointer to new node.
+*/
+
+xbIxNode * xbIxNdx::AllocateIxNode( xbUInt32 ulBufSize, xbInt16 iOpt ){
+ xbIxNode *n = xbIx::AllocateIxNode( ulBufSize );
+ if( n && iOpt == 1 ) n->ulBlockNo = ndxTag->ulTotalBlocks++;
+ return n;
+}
+/***********************************************************************/
+//! @brief Check for duplicate key.
+/*!
+ \param vpTag Tag to check.
+ \returns XB_KEY_NOT_UNIQUE<br>XB_NO_ERROR
+*/
+xbInt16 xbIxNdx::CheckForDupKey( void *vpTag )
+{
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbNdxTag *npTag = (xbNdxTag *) vpTag;
+ npTag->bFoundSts = xbFalse;
+ try{
+ if( GetUnique()){
+ if( npTag->iKeySts == XB_ADD_KEY || npTag->iKeySts == XB_UPD_KEY )
+ if( KeyExists( vpTag )){
+ if( GetUniqueKeyOpt() == XB_EMULATE_DBASE ){
+ npTag->bFoundSts = xbTrue;
+ return 0;
+ } else {
+ return XB_KEY_NOT_UNIQUE;
+ }
+ }
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::CheckForDupKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Check tag integrity.
+/*!
+ Check a tag for accuracy.
+
+ \param vpTag Tag to create key for.
+ \param iOpt Output message destination<br>
+ 0 = stdout<br>
+ 1 = Syslog<br>
+ 2 = Both<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxNdx::CheckTagIntegrity( void *vpTag, xbInt16 iOpt ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iRc2;
+ xbInt16 iRc3;
+ xbInt16 iErrorStop = 0;
+ xbUInt32 ulIxCnt = 0;
+ xbUInt32 ulThisRecNo = 0;
+ xbUInt32 ulPrevRecNo = 0;
+ xbBool bDone = false;
+ xbString sMsg;
+ char cKeyType;
+ char *pPrevKeyBuf = NULL;
+ xbInt16 iAutoLock = xbFalse;
+
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ try{
+// xbase->WriteLogMessage( "xbIxNdx::CheckTagIntegrity()", iOpt );
+
+ #ifdef XB_LOCKING_SUPPORT
+ iAutoLock = dbf->GetAutoLock();
+ if( iAutoLock && !dbf->GetTableLocked() ){
+ if(( iRc = dbf->LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ }
+ #endif
+
+ memset( npTag->cpKeyBuf2, 0x00, (size_t) npTag->iKeyLen );
+ cKeyType = GetKeyType( vpTag );
+
+ sMsg.Sprintf( "Checking index type [%c]", cKeyType );
+ xbase->WriteLogMessage( sMsg, iOpt );
+
+ pPrevKeyBuf = (char *) calloc( 1, (size_t) ndxTag->iKeyLen );
+
+ // for each key in the index, make sure it is trending in the right direction
+ iRc = GetFirstKey( vpTag, 0 );
+ while( iRc == XB_NO_ERROR && !bDone ){
+ ulIxCnt++;
+ iRc = GetNextKey( vpTag, 0 );
+ if( iRc == XB_NO_ERROR ){
+ // compare this key to prev key
+ iRc2 = CompareKey( cKeyType, GetKeyData( npTag->npCurNode, npTag->npCurNode->iCurKeyNo, npTag->iKeyItemLen ),
+ pPrevKeyBuf, (size_t) npTag->iKeyLen );
+
+ if( iRc2 < 0 ){
+ sMsg.Sprintf( "Key sequence error at key number [%ld].", ulIxCnt );
+ xbase->WriteLogMessage( sMsg, iOpt );
+ iErrorStop = 100;
+ iRc = XB_INVALID_INDEX;
+ throw iRc;
+ }
+
+ ulThisRecNo = 0;
+ if(( iRc3 = GetDbfPtr( vpTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulThisRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc3;
+ }
+
+ if( iRc2 == 0 && (ulThisRecNo <= ulPrevRecNo )){
+ sMsg.Sprintf( "Dbf record number sequence error at key number [%ld].", iOpt );
+ xbase->WriteLogMessage( sMsg, iOpt );
+ iErrorStop = 120;
+ iRc = XB_INVALID_INDEX;
+ throw iRc;
+ }
+ // save this key info to prev key
+ memcpy( pPrevKeyBuf, GetKeyData( npTag->npCurNode, npTag->npCurNode->iCurKeyNo, npTag->iKeyItemLen ), (size_t) npTag->iKeyLen );
+ ulPrevRecNo = ulThisRecNo;
+ }
+ }
+
+ // verify the index count matches the tag count
+ xbUInt32 ulDbfCnt = 0;
+ if(( iRc = dbf->GetRecordCnt( ulDbfCnt )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+
+ if( GetUniqueKeyOpt() == XB_EMULATE_DBASE && GetUnique( vpTag )){
+ // Can't compare counts if using XB_EMULATE_DBASE and it's a unique index
+ } else {
+ if( ulDbfCnt != ulIxCnt ){
+ sMsg.Sprintf( "CheckTagIntegrity() Index entry count [%ld] does not match dbf record count [%ld]", ulIxCnt, ulDbfCnt );
+ xbase->WriteLogMessage( sMsg, iOpt );
+ iErrorStop = 140;
+ iRc = XB_INVALID_INDEX;
+ throw iRc;
+ }
+
+ // verify each record in the dbf file has a corresponding index entry
+ xbUInt32 j = 0;
+ while( j < ulDbfCnt ){
+ if(( iRc = dbf->GetRecord( ++j )) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+ if(( iRc = FindKeyForCurRec( vpTag )) != XB_NO_ERROR ){
+ ulThisRecNo = j;
+ iErrorStop = 160;
+ throw iRc;
+ }
+ }
+ sMsg.Sprintf( "CheckTagIntegrity() Index entry count [%ld] matches dbf record count [%ld]", ulIxCnt, ulDbfCnt );
+ xbase->WriteLogMessage( sMsg, iOpt );
+ }
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock && !dbf->GetTableLocked() ){
+ if(( iRc = dbf->LockTable( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 200;
+ throw iRc;
+ }
+ }
+ #endif
+
+
+ if( pPrevKeyBuf )
+ free( pPrevKeyBuf );
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::CheckTagIntegrity() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg, iOpt );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ), iOpt );
+ if( pPrevKeyBuf )
+ free( pPrevKeyBuf );
+
+ if( iErrorStop == 160 ){
+ sMsg.Sprintf( "xbIxNdx::CheckTagIntegrity() Missing index entry for record [%d]", ulThisRecNo );
+ xbase->WriteLogMessage( sMsg, iOpt );
+ }
+ }
+ return iRc;
+
+}
+/***********************************************************************/
+//! @brief Create key for tag.
+/*!
+ Append a node to the current node chain for a given tag.
+
+ \param vpTag Tag to create key for.
+ \param iOpt 0 = Build a key for FindKey usage, only rec buf 0.<br>
+ 1 = Append Mode, Create key for an append, only use rec buf 0, set updated switch.<br>
+ 2 = Update Mode, Create old version and new version keys, check if different, set update switch appropriately.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::CreateKey( void * vpTag, xbInt16 iOpt ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try{
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ if(( iRc = npTag->exp->ProcessExpression( 0 )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ if( npTag->exp->GetReturnType() == XB_EXP_CHAR ){
+ npTag->exp->GetStringResult( npTag->cpKeyBuf, (xbUInt32) npTag->iKeyLen );
+ }
+ else if( npTag->exp->GetReturnType() == XB_EXP_NUMERIC ){
+ xbDouble d;
+ npTag->exp->GetNumericResult( d );
+ memcpy( npTag->cpKeyBuf, &d, 8 );
+ }
+ else if( npTag->exp->GetReturnType() == XB_EXP_DATE ){
+ xbDouble d;
+ npTag->exp->GetNumericResult( d );
+ memcpy( npTag->cpKeyBuf, &d, 8 );
+ }
+
+ npTag->iKeySts = 0;
+ if( iOpt == 1 )
+ npTag->iKeySts = XB_ADD_KEY;
+
+ else if( iOpt == 2 ){
+ if(( iRc = npTag->exp->ProcessExpression( 1 )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ if( npTag->exp->GetReturnType() == XB_EXP_CHAR ){
+ npTag->exp->GetStringResult( npTag->cpKeyBuf2, (xbUInt32) npTag->iKeyLen );
+ } else if( npTag->exp->GetReturnType() == XB_EXP_NUMERIC || npTag->exp->GetReturnType() == XB_EXP_DATE ){
+ xbDouble d;
+ npTag->exp->GetNumericResult( d );
+ memcpy( npTag->cpKeyBuf2, &d, 8 );
+ }
+ if( memcmp( npTag->cpKeyBuf, npTag->cpKeyBuf2, (size_t) npTag->iKeyLen ))
+ npTag->iKeySts = XB_UPD_KEY;
+ }
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::CreateKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Create new tag.
+/*!
+ This routine creates a new tag. Since NDX files have only one tag,
+ this creates a new NDX file.
+
+ \param sName Tag Name, including .NDX suffix
+ \param sKey Key Expression
+ \param sFilter Filter expression. Not supported by NDX indices.
+ \param iDescending Not supported by NDX indices.
+ \param iUnique xbtrue - Unique.<br>xbFalse - Not unique.
+ \param iOverLay xbTrue - Overlay if file already exists.<br>xbFalse - Don't overlay.
+ \param vpTag Output from method Pointer to vptag pointer.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::CreateTag( const xbString &sName, const xbString &sKey,
+ const xbString &, xbInt16, xbInt16 iUnique, xbInt16 iOverLay, void **vpTag ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbNdxTag *npTag = ndxTag;
+ *vpTag = ndxTag;
+
+ try{
+ //xbString sMsg;
+ SetFileName( sName );
+
+ if( FileExists() && !iOverLay )
+ return XB_FILE_EXISTS;
+
+ if( FileIsOpen()){
+ if(( iRc = xbTruncate(0)) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ if(( iRc = xbFclose()) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ npTag->npNodeChain = FreeNodeChain( npTag->npNodeChain );
+ npTag->npCurNode = NULL;
+ npTag->sKeyExpression.Set( "" );
+
+ if( npTag->cpKeyBuf ){
+ free( npTag->cpKeyBuf );
+ npTag->cpKeyBuf = NULL;
+ }
+ if( npTag->cpKeyBuf2 ){
+ free( npTag->cpKeyBuf2 );
+ npTag->cpKeyBuf2 = NULL;
+ }
+ }
+
+ if(( iRc = xbFopen( "w+b", dbf->GetShareMode())) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+
+ //set up the key expression
+ npTag->exp = new xbExp( dbf->GetXbasePtr());
+ if(( iRc = npTag->exp->ParseExpression( dbf, sKey )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+
+ switch( npTag->exp->GetReturnType()){
+ case XB_EXP_CHAR:
+ npTag->cKeyType = 'C';
+ npTag->iKeyType = 0;
+ npTag->iKeyLen = npTag->exp->GetResultLen();
+ break;
+
+ case XB_EXP_NUMERIC:
+ npTag->cKeyType = 'F';
+ npTag->iKeyType = 1;
+ npTag->iKeyLen = 8;
+ break;
+
+ case XB_EXP_DATE:
+ npTag->cKeyType = 'D';
+ npTag->iKeyType = 1;
+ npTag->iKeyLen = 8;
+ break;
+
+ default:
+ iErrorStop = 50;
+ iRc = XB_INVALID_INDEX;
+ throw iRc;
+ }
+
+ npTag->iUnique = iUnique;
+ npTag->ulRootBlock = 1L;
+ npTag->ulTotalBlocks = 2l;
+ npTag->sKeyExpression = sKey;
+
+ GetFileNamePart( npTag->sTagName );
+
+ if( npTag->iKeyLen > 100 ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+
+ npTag->iKeyItemLen = npTag->iKeyLen + 8;
+ while(( npTag->iKeyItemLen % 4 )!= 0 ) npTag->iKeyItemLen++;
+
+ npTag->iKeysPerBlock = (xbInt16) (GetBlockSize() - 8 ) / npTag->iKeyItemLen;
+ ndxTag->cpKeyBuf = (char *) malloc( (size_t) ndxTag->iKeyLen );
+ ndxTag->cpKeyBuf2 = (char *) malloc( (size_t) ndxTag->iKeyLen );
+
+ if(( iRc = WriteHeadBlock(0)) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw iRc;
+ }
+
+ //write out block binary zeroes
+ char buf[512];
+ memset( buf, 0x00, 512 );
+ if(( iRc = xbFwrite( buf, 1, 512 )) != XB_NO_ERROR ){
+ iErrorStop = 80;
+ throw iRc;
+ }
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::CreateTag() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Delete a key.
+/*!
+ This routine deletes a key from a supplied node.
+ \param vpTag Tag to delete key on.
+ \param npNode Node to delete key on.
+ \param iSlotNo Slot number of key to delete.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::DeleteFromNode( void *vpTag, xbIxNode * npNode, xbInt16 iSlotNo )
+{
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ try{
+
+ xbInt32 lKeyCnt = GetKeyCount( npNode );
+ xbInt16 iLen = (lKeyCnt - iSlotNo - 1) * npTag->iKeyItemLen;
+ if( !IsLeaf( vpTag, npNode ))
+ iLen += 4;
+
+ if( iLen > 0 ){
+ char *pTrg = npNode->cpBlockData;
+ pTrg += (4 + (npTag->iKeyItemLen * (iSlotNo)) ); //lTrgPos;
+ char *pSrc = pTrg;
+ pSrc += npTag->iKeyItemLen;
+ memmove( pTrg, pSrc, (size_t) iLen );
+ }
+
+ // set the new number of keys
+ ePutUInt32( npNode->cpBlockData, (xbUInt32) lKeyCnt - 1 );
+
+ // write out the block
+ if(( iRc = WriteBlock( npNode->ulBlockNo, GetBlockSize(), npNode->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::DeleteFromNode() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return XB_NO_ERROR;
+}
+
+/***********************************************************************/
+//! @brief Delete a key.
+/*!
+ This routine deletes a key. It assumes the key to delete
+ is the current key in the node chain.
+
+ \param vpTag Tag to delete key on.
+
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::DeleteKey( void *vpTag ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ // save copy of node chain to reset to after delete completed
+ xbIxNode *npSaveNodeChain = npTag->npNodeChain;
+ npTag->npNodeChain = NULL;
+ xbIxNode * npSaveCurNode = npTag->npCurNode;
+
+ try{
+
+ xbString sMsg;
+
+ if(( iRc = xbIxNdx::KeySetPosDel( npTag )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ // Delete key needs to handle two scenarios
+ // 1 - if the delete is on the only key of a leaf node, then traverse up the tree, trimming as needed
+ // 2 - if the last key on a node is deleted, and the key value is not the same as the prev key value
+ // go up the tree looking for an interior node needing updated key value
+
+
+ xbInt32 lOrigKeyCnt = GetKeyCount( npTag->npCurNode );
+ if(( iRc = DeleteFromNode( npTag, npTag->npCurNode, npTag->npCurNode->iCurKeyNo )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ if( lOrigKeyCnt == 1 ){
+ // scenario 1
+ xbBool bDone = xbFalse;
+ xbBool bIsLeaf = xbFalse;
+ xbInt32 lKeyCnt;
+ npTag->npCurNode = npTag->npCurNode->npPrev;
+
+ while( npTag->npCurNode && !bDone ){
+ lKeyCnt = GetKeyCount( npTag->npCurNode );
+ bIsLeaf = IsLeaf( npTag, npTag->npCurNode );
+ if( lKeyCnt > 0 ){
+ if(( iRc = DeleteFromNode( npTag, npTag->npCurNode, npTag->npCurNode->iCurKeyNo )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ }
+ if( (bIsLeaf && lKeyCnt > 1) || (!bIsLeaf && lKeyCnt > 0) )
+ bDone = xbTrue;
+ else
+ npTag->npCurNode = npTag->npCurNode->npPrev;
+ }
+ } else if( npTag->npCurNode->iCurKeyNo == (xbUInt32) lOrigKeyCnt - 1 ){
+
+ // scenario 2
+ // if last two keys identical, then nothing to do, else go up looking for a key to change
+ if( memcmp( GetKeyData( npTag->npCurNode, npTag->npCurNode->iCurKeyNo, npTag->iKeyItemLen ),
+ GetKeyData( npTag->npCurNode, npTag->npCurNode->iCurKeyNo-1, npTag->iKeyItemLen ),
+ (size_t) npTag->iKeyLen )){
+
+ xbIxNode *pNode = npTag->npCurNode->npPrev;
+ char *pSrc = GetKeyData( npTag->npCurNode, npTag->npCurNode->iCurKeyNo-1, npTag->iKeyItemLen );
+
+ while( pNode && pNode->ulBlockNo != npTag->ulRootBlock && pNode->iCurKeyNo == (xbUInt32) GetKeyCount( pNode ) )
+ pNode = pNode->npPrev;
+ if( pNode ){
+ if( pNode->iCurKeyNo < (xbUInt32) GetKeyCount( pNode )){
+ char *pTrg = pNode->cpBlockData;
+ pTrg += 12 + (pNode->iCurKeyNo * (xbUInt32) npTag->iKeyItemLen);
+ for( xbInt16 i = 0; i < npTag->iKeyLen; i++ )
+ *pTrg++ = *pSrc++;
+
+ // write out the block
+ if(( iRc = WriteBlock( pNode->ulBlockNo, GetBlockSize(), pNode->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ }
+ }
+ }
+ }
+
+ // restore node chain to pre delete status (which should be post add status)
+ npTag->npNodeChain = FreeNodeChain( npTag->npNodeChain );
+ npTag->npNodeChain = npSaveNodeChain;
+ npTag->npCurNode = npSaveCurNode;
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::DeleteKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ if( npSaveNodeChain ){
+ npTag->npNodeChain = npSaveNodeChain;
+ npSaveNodeChain = FreeNodeChain( npSaveNodeChain );
+ npTag->npCurNode = npSaveCurNode;
+ }
+ }
+ return iRc;
+}
+
+
+/***********************************************************************/
+//! @brief Delete tag.
+/*!
+ In the case of an ndx tag, it deletes the ndx file as it contains
+ only one tag.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::DeleteTag( void * ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ //xbNdxTag * npTag;
+ //vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ try{
+
+ // if open, close it
+ if( FileIsOpen()){
+ if(( iRc = Close()) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ }
+ // delete file
+ if(( iRc = xbRemove()) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::DeleteTag() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+
+//! @brief Dump a block for a given tag.
+/*!
+ Dump blocks for given tag for debugging purposes.
+ \param iOpt Output message destination<br>
+ 0 = stdout<br>
+ 1 = Syslog<br>
+ 2 = Both<br>
+ \param vpTag - Not required for single tag NDX files.
+ \returns void
+*/
+
+//xbInt16 xbIxNdx::DumpTagBlocks( xbInt16 iOpt, void *vpTag ){
+
+xbInt16 xbIxNdx::DumpTagBlocks( xbInt16 iOpt, void * ){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbUInt32 lNoOfKeys;
+ char *p;
+ xbString s;
+ xbBool bIsLeaf = false;
+
+ try{
+ if( !FileIsOpen()){
+ iRc = XB_NOT_OPEN;
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ xbUInt32 ulStartBlock;
+ xbUInt32 ulEndBlock;
+ ulStartBlock = 1;
+ ulEndBlock = ndxTag->ulTotalBlocks;
+
+ for( xbUInt32 lBlk = ulStartBlock; lBlk < ulEndBlock; lBlk++ ){
+
+ memset( cNodeBuf, 0x00, XB_NDX_BLOCK_SIZE );
+ if(( iRc = ReadBlock( lBlk, XB_NDX_BLOCK_SIZE, cNodeBuf )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ p = cNodeBuf;
+ lNoOfKeys = eGetUInt32( p );
+
+ if( eGetUInt32( p + 4 ) > 0 ){
+ bIsLeaf = false;
+ s.Sprintf( "Node # %ld - Interior Node - Key Type [%c] Key Count [%ld]", lBlk, ndxTag->cKeyType, lNoOfKeys );
+ } else {
+ bIsLeaf = true;
+ s.Sprintf( "Node # %ld - Leaf Node - Key Type [%c] Key count [%ld]", lBlk, ndxTag->cKeyType, lNoOfKeys );
+ }
+ xbase->WriteLogMessage( s, iOpt );
+ xbase->WriteLogMessage( "Key Child Dbf Rec Key", iOpt );
+ p += 4;
+ xbUInt32 ulLeftBranch;
+ xbUInt32 ulRecNo;
+ xbString sKey;
+ xbDouble d;
+
+ xbUInt32 l;
+ for( l = 0; l < lNoOfKeys; l++ ){
+ ulLeftBranch = eGetUInt32( p );
+ p+= 4;
+ ulRecNo = eGetUInt32( p );
+ p+= 4;
+ if( ndxTag->cKeyType == 'C' ){
+ sKey.Assign( p, 1, (xbUInt32) ndxTag->iKeyLen );
+ } else if( ndxTag->cKeyType == 'D' ){
+ xbInt32 lDate = (xbInt32) eGetDouble( p );
+ xbDate dt( lDate );
+ //xbString s2;
+ //dt.JulToDate8( lDate, s2 );
+ sKey.Sprintf( "%ld - %s", lDate, dt.Str());
+ } else {
+ d = eGetDouble( p );
+ sKey.Sprintf( "%f", d );
+ }
+ p+= (ndxTag->iKeyItemLen-8);
+
+ s.Sprintf( "%3d %9d %9d %s", l+1, ulLeftBranch, ulRecNo, sKey.Str() );
+ xbase->WriteLogMessage( s, iOpt );
+ }
+ if( !bIsLeaf ){
+ ulLeftBranch = eGetUInt32( p );
+ s.Sprintf( "%3d %9d", l+1, ulLeftBranch );
+ xbase->WriteLogMessage( s, iOpt );
+ }
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::DumpTagBlocks() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Dump index file header.
+/*!
+ Dump a index file header for debugging purposes.
+ \param iOpt Output message destination<br>
+ 0 = stdout<br>
+ 1 = Syslog<br>
+ 2 = Both<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::DumpHeader( xbInt16 iOpt, xbInt16 ){
+ xbString s;
+ xbInt16 iRc;
+
+ if(( iRc = ReadHeadBlock( 1 )) != XB_NO_ERROR )
+ return iRc;
+
+ s.Sprintf( "Index Header Node for %s", GetFileName().Str());
+ xbase->WriteLogMessage( s, iOpt );
+ s.Sprintf( "--------------------------------" );
+ xbase->WriteLogMessage( s, iOpt );
+ s.Sprintf( "Root block = %ld", ndxTag->ulRootBlock );
+ xbase->WriteLogMessage( s, iOpt );
+ s.Sprintf( "Total blocks = %ld", ndxTag->ulTotalBlocks );
+ xbase->WriteLogMessage( s, iOpt );
+ s.Sprintf( "Key types = %c,%d", ndxTag->cKeyType, ndxTag->iKeyType );
+ xbase->WriteLogMessage( s, iOpt );
+ s.Sprintf( "Key Length = %d", ndxTag->iKeyLen );
+ xbase->WriteLogMessage( s, iOpt );
+ s.Sprintf( "Keys Per Block = %d", ndxTag->iKeysPerBlock );
+ xbase->WriteLogMessage( s, iOpt );
+ s.Sprintf( "Key Item Len = %ld", ndxTag->iKeyItemLen );
+ xbase->WriteLogMessage( s, iOpt);
+ s.Sprintf( "Serial No = %d", ndxTag->cSerNo );
+ xbase->WriteLogMessage( s, iOpt);
+ s.Sprintf( "Unique = %d", ndxTag->iUnique );
+ xbase->WriteLogMessage( s, iOpt );
+ s.Sprintf( "KeyExpression = %s", ndxTag->sKeyExpression.Str() );
+ xbase->WriteLogMessage( s, iOpt );
+ return XB_NO_ERROR;
+}
+/***********************************************************************/
+//! @brief Dump the index for a tag.
+/*!
+ Stub.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbIxNdx::DumpIxForTag( void *, xbInt16 )
+{
+ return XB_NO_ERROR;
+}
+/***********************************************************************/
+//! @brief Dump the index node chain.
+/*!
+ Dump the index node chain for debugging purposes.
+ \param vpTag Tag of node chain to dump.
+ \param iOpt Output message destination<br>
+ 0 = stdout<br>
+ 1 = Syslog<br>
+ 2 = Both<br>
+ \returns void
+*/
+void xbIxNdx::DumpIxNodeChain( void *vpTag, xbInt16 iOpt ) const
+{
+
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ xbString s( "Dump Node Chain" );
+ xbase->WriteLogMessage( s, iOpt );
+
+ if( npTag->npNodeChain ){
+ xbIxNode *n = npTag->npNodeChain;
+ xbInt16 iCtr = 0;
+ char cLeaf;
+ s.Sprintf( "Cnt\tThis Prev Next CurKeyNo BlockNo NoOfKeys Type" );
+ xbase->WriteLogMessage( s, iOpt );
+ while( n ){
+ IsLeaf( vpTag, n ) ? cLeaf = 'L' : cLeaf = 'I';
+ s.Sprintf( "%d\t%08x %08x %08x %08d %08d %08d %c",
+ iCtr++, n, n->npPrev, n->npNext, n->iCurKeyNo,
+ n->ulBlockNo, eGetUInt32( n->cpBlockData ), cLeaf );
+ xbase->WriteLogMessage( s, iOpt );
+ n = n->npNext;
+ }
+ } else {
+ s = "Empty Node Chain";
+ xbase->WriteLogMessage( s, iOpt );
+ }
+}
+/***********************************************************************/
+//! @brief Dump node.
+/*!
+ Dump a node for debugging purposes.
+ \param vpTag Tag of node chain to dump.
+ \param pNode Node to dump.
+ \param iOpt Output message destination<br>
+ 0 = stdout<br>
+ 1 = Syslog<br>
+ 2 = Both<br>
+ \returns XB_NVALID_OBJECT<br>XB_NO_ERROR
+*/
+
+xbInt16 xbIxNdx::DumpNode( void *vpTag, xbIxNode *pNode, xbInt16 iOpt ) const
+{
+ xbString s;
+ xbString sKey;
+ xbUInt32 lLeftBranch;
+ xbUInt32 lRecNo;
+ xbDouble d;
+
+ if( !pNode )
+ return XB_INVALID_OBJECT;
+
+ xbIx::DumpNode( vpTag, pNode, iOpt );
+
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ xbUInt32 lNoOfKeys = eGetUInt32( pNode->cpBlockData );
+ xbBool bIsLeaf = IsLeaf( vpTag, pNode );
+
+ if( bIsLeaf )
+ xbase->WriteLogMessage( "Leaf node", iOpt );
+ else
+ xbase->WriteLogMessage( "Interior node", iOpt );
+
+ s.Sprintf( "Key type = [%c] No Of Keys =[%d] Prev =[%x] Next =[%x]", npTag->cKeyType, lNoOfKeys, pNode->npPrev, pNode->npNext );
+ xbase->WriteLogMessage( s, iOpt );
+
+ char *p = pNode->cpBlockData;
+ p += 4;
+
+ xbUInt32 l;
+ for( l = 0; l < lNoOfKeys; l++ ){
+
+ lLeftBranch = eGetUInt32( p );
+ p+= 4;
+ lRecNo = eGetUInt32( p );
+ p+= 4;
+
+ if( npTag->cKeyType == 'C' ){
+ sKey.Assign( p, 1, (xbUInt32) npTag->iKeyLen );
+ } else if( npTag->cKeyType == 'D' ){
+ xbInt32 lDate = (xbInt32) eGetDouble( p );
+ xbDate dt( lDate );
+ sKey.Sprintf( "%ld - %s", lDate, dt.Str());
+ } else {
+ d = eGetDouble( p );
+ sKey.Sprintf( "%f", d );
+ }
+ p+= (npTag->iKeyItemLen-8);
+ s.Sprintf( "%3d %9d %9d %s", l+1, lLeftBranch, lRecNo, sKey.Str() );
+ xbase->WriteLogMessage( s, iOpt );
+ }
+ if( !bIsLeaf ){
+ lLeftBranch = eGetUInt32( p );
+ s.Sprintf( "%3d %9d", l+1, lLeftBranch );
+ xbase->WriteLogMessage( s.Str(), iOpt );
+ }
+ return XB_NO_ERROR;
+}
+#endif
+/***********************************************************************/
+//! @brief Find key
+/*!
+ \param vpTag Pointer to tag to search.
+ \param vpKey Void pointer to key data to search on.
+ \param lSearchKeyLen Length of key to search for.
+ \param iRetrieveSw xbTrue - Retrieve the record if key found.<br>
+ xbFalse - Don't retrieve record, check for key existence only.
+ \returns XB_NO_ERROR - Key found.<br>
+ XB_NOT_FOUND - Key not found.<br>
+ <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxNdx::FindKey( void *vpTag, const void *vpKey, xbInt32 lSearchKeyLen,
+ xbInt16 iRetrieveSw ){
+
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbString sMsg;
+ // xbInt16 iFindSts;
+ try{
+ // clean up any previous table updates before moving on
+ if( iRetrieveSw ){
+ if( dbf->GetDbfStatus() == XB_UPDATED ){
+ if( dbf->GetAutoCommit() == 1 ){
+ if(( iRc = dbf->Commit()) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ } else {
+ if(( iRc = dbf->Abort()) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+ }
+ }
+
+ xbUInt32 ulNoOfKeys;
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+ char cKeyType = npTag->cKeyType;
+
+ if( npTag->npNodeChain ){
+
+ // determine if the index has been updated since the last time it was used
+ time_t tFileTs;
+ if(( iRc = GetFileMtime( tFileTs )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ if( npTag->tNodeChainTs < tFileTs ){
+ npTag->npNodeChain = FreeNodeChain( npTag->npNodeChain );
+ npTag->npCurNode = NULL;
+ if(( iRc = ReadHeadBlock( 1 )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ if(( iRc = GetBlock( npTag, (npTag->ulRootBlock ), 1, (xbUInt32) npTag->iKeyItemLen )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ } else {
+ // pop up the chain looking for appropriate starting point
+ xbBool bDone = false;
+ xbIxNode * TempIxNode;
+ while( npTag->npCurNode && !bDone && npTag->npCurNode->ulBlockNo != npTag->ulRootBlock ){ // not root node
+ iRc = CompareKey( cKeyType, vpKey, GetKeyData( npTag->npCurNode, 0, npTag->iKeyItemLen ), (size_t) lSearchKeyLen );
+ if( iRc <= 0 ){
+ TempIxNode = npTag->npCurNode;
+ npTag->npCurNode = npTag->npCurNode->npPrev;
+ TempIxNode = FreeNodeChain( TempIxNode );
+ } else {
+ // get the number of keys on the block and compare the key to the rightmost key
+ xbUInt32 ulKeyCtr = eGetUInt32( npTag->npCurNode->cpBlockData ) - 1;
+ iRc = CompareKey( cKeyType, vpKey, GetKeyData( npTag->npCurNode, ulKeyCtr, npTag->iKeyItemLen), (size_t) lSearchKeyLen );
+
+ if( iRc > 0 ){
+ TempIxNode = npTag->npCurNode;
+ npTag->npCurNode = npTag->npCurNode->npPrev;
+ TempIxNode = FreeNodeChain( TempIxNode );
+ } else {
+ bDone = true;
+ }
+ }
+ }
+ }
+ } else {
+ if(( iRc = GetBlock( npTag, (npTag->ulRootBlock ), 1, (xbUInt32) npTag->iKeyItemLen )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ }
+
+
+ // if cur node is the base node and no keys on this node, then the index is empty
+ if( npTag->ulRootBlock == npTag->npCurNode->ulBlockNo ){
+ ulNoOfKeys = eGetUInt32( npTag->npCurNode->cpBlockData );
+ if( ulNoOfKeys == 0 && IsLeaf( npTag, npTag->npCurNode )){
+ // iRc = XB_EMPTY;
+
+ iRc = XB_NOT_FOUND;
+ return iRc;
+ }
+ }
+
+ // should be in the appropriate position in the node chain to continue the search from here
+ // run down through the interior nodes
+ xbInt16 iSearchRc = 0;
+ xbUInt32 ulKeyPtr = 0;
+
+ while( !IsLeaf( npTag, npTag->npCurNode ) ){
+
+ // get the number of keys on the block and compare the key to the rightmost key
+ ulNoOfKeys = eGetUInt32( npTag->npCurNode->cpBlockData );
+ if( ulNoOfKeys == 0 ) // interior nodes can have zero keys, just a link to the next lower node
+ npTag->npCurNode->iCurKeyNo = 0;
+ else
+ {
+ iRc = CompareKey( cKeyType, vpKey, GetKeyData( npTag->npCurNode, ulNoOfKeys - 1, npTag->iKeyItemLen), (size_t) lSearchKeyLen );
+ if( iRc > 0 ){
+ npTag->npCurNode->iCurKeyNo = ulNoOfKeys;
+ } else {
+ npTag->npCurNode->iCurKeyNo = (xbUInt32) BSearchBlock( cKeyType, npTag->npCurNode,
+ (xbInt32) npTag->iKeyItemLen, vpKey, (xbInt32) lSearchKeyLen, iSearchRc );
+ }
+ }
+
+ if(( iRc = GetKeyPtr( npTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 80;
+ throw iRc;
+ }
+
+ if(( iRc = GetBlock( npTag, ulKeyPtr, 1, (xbUInt32) npTag->iKeyItemLen )) != XB_NO_ERROR ){
+ iErrorStop = 90;
+ throw iRc;
+ }
+ }
+
+ // should be on a the correct leaf node, it may or may not contain the actual key
+ ulNoOfKeys = eGetUInt32( npTag->npCurNode->cpBlockData );
+ xbInt16 iCompRc = 0;
+
+ if( ulNoOfKeys == 0 ){
+ iRc = XB_NOT_FOUND;
+ return iRc;
+ } else {
+
+ iRc = BSearchBlock( cKeyType, npTag->npCurNode, npTag->iKeyItemLen, vpKey, lSearchKeyLen, iCompRc );
+
+ // iCompRc
+ // 0 found
+ // < 0 eof encountered, search key > last key in file
+ // > 0 not found, positioned to next key
+
+
+ // std::cout << "xbIxNdx::FindKey -Rc = " << iRc << " CompRc = " << iCompRc << " NoOfKeys = " << ulNoOfKeys << " blk no = " << npTag->npCurNode->ulBlockNo << "\n";
+
+ if( iCompRc >= 0 ){
+ npTag->npCurNode->iCurKeyNo = (xbUInt32) iRc;
+ if( iRetrieveSw ){
+ xbUInt32 ulKey = npTag->npCurNode->iCurKeyNo;
+ if( ulKey >= ulNoOfKeys ) // if position past end of keys, need to go back one and position to last key
+ ulKey--;
+
+ if(( iRc = GetDbfPtr( vpTag, ulKey, npTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ if(( iRc = dbf->GetRecord( ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ }
+ }
+ }
+
+ if( iCompRc == 0 )
+ return XB_NO_ERROR;
+ else if( iCompRc > 0 )
+ return XB_NOT_FOUND;
+ else
+ return XB_EOF;
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::FindKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Find key for current record
+/*!
+ This routine is called when updating a key.
+
+ \param vpTag Pointer to tag to search.
+ XB_NOT_FOUND Key not found.<br>
+ <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::FindKeyForCurRec( void * vpTag )
+{
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ try{
+ if(( iRc = CreateKey( vpTag, 0 )) < XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ // find key
+ iRc = FindKey( vpTag, npTag->cpKeyBuf, npTag->iKeyLen, 0 );
+ if( iRc == XB_NOT_FOUND || iRc == XB_EMPTY || iRc == XB_EOF )
+ return iRc;
+
+ if( iRc != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+
+ // if keys are unique, and the recrd number matches, then we are good
+ if( GetUnique() )
+ return XB_NO_ERROR;
+
+ // get here if key found and not unique, need to move forward looking for correct rec no
+ xbUInt32 ulDbfRecNo = dbf->GetCurRecNo();
+ xbBool bKeysMatch = true; // keys match?
+ xbBool bCurRecsMatch = false; // cur recod number matches?
+ xbUInt32 ulIxRecNo = 0;
+ char cKeyType = GetKeyType( vpTag );
+
+ if(( iRc = GetDbfPtr( vpTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulIxRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ if( ulIxRecNo == ulDbfRecNo )
+ bCurRecsMatch = true;
+
+ xbInt16 iCompRc;
+ while( !bCurRecsMatch && bKeysMatch ){
+
+ if(( iRc = GetNextKey( vpTag, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+
+ // do compare key here
+ iCompRc = CompareKey( cKeyType, npTag->cpKeyBuf, GetKeyData( npTag->npCurNode, 0, npTag->iKeyItemLen ), (size_t) npTag->iKeyLen );
+ if( iCompRc != 0 )
+ bKeysMatch = false;
+ else{
+ if(( iRc = GetDbfPtr( vpTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulIxRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ if( ulIxRecNo == ulDbfRecNo )
+ bCurRecsMatch = true;
+ }
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::FindKeyForCurRec() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return XB_NO_ERROR;
+}
+
+/***********************************************************************/
+//! @brief Get dbf record number for given key number.
+/*!
+ \param vpTag Tag to retrieve dbf rec number on.
+ \param iKeyNo Key number for retrieval
+ \param np Pointer to node
+ \param ulDbfPtr- Output dbf record number
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxNdx::GetDbfPtr( void *vpTag, xbInt16 iKeyNo, xbIxNode *np, xbUInt32 &ulDbfPtr ) const {
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ #ifdef XB_DEBUG_SUPPORT
+ // turn this off in production mode for better performance
+ xbUInt32 ulNoOfKeys = eGetUInt32 ( np->cpBlockData );
+ if( iKeyNo < 0 || iKeyNo > (xbInt16) --ulNoOfKeys ){
+ iErrorStop = 10;
+ throw XB_INVALID_KEYNO;
+ }
+ #endif
+
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+ char *p = ( np->cpBlockData);
+ p += (8 + (iKeyNo * npTag->iKeyItemLen));
+ ulDbfPtr = eGetUInt32 ( p );
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::GetDbfPtr() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Get the first key for the given tag.
+/*!
+ \param vpTag Tag to retrieve first key on.
+ \param iRetrieveSw xbTrue - Retrieve the record on success.<br>
+ xbFalse - Don't retrieve record.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::GetFirstKey( void *vpTag, xbInt16 iRetrieveSw ){
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ try{
+ // clear out any history
+ if( npTag->npNodeChain ){
+ npTag->npNodeChain = FreeNodeChain( npTag->npNodeChain );
+ npTag->npCurNode = NULL;
+ }
+ if(( iRc = ReadHeadBlock( 1 )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ // lRootBlock is now available
+ if(( iRc = GetBlock( npTag, npTag->ulRootBlock, 1, (xbUInt32) npTag->iKeyItemLen )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ // if no keys on this node, and it's a leaf node then the index is empty
+ xbUInt32 ulKeyPtr = eGetUInt32( npTag->npCurNode->cpBlockData );
+ if( ulKeyPtr == 0 && IsLeaf( npTag, npTag->npCurNode )){
+ iRc = XB_EMPTY;
+ return iRc;
+ }
+ while( !IsLeaf( npTag, npTag->npCurNode )) // go down the chain looking for a leaf node
+ {
+ if(( iRc = GetKeyPtr( npTag, 0, npTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ if(( iRc = GetBlock( npTag, ulKeyPtr, 1, (xbUInt32) npTag->iKeyItemLen )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ }
+ if( iRetrieveSw ){
+ if(( iRc = GetDbfPtr( npTag, 0, npTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ if(( iRc = dbf->GetRecord( ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ }
+ }
+ catch( xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::GetFirstKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Get the key expression for the given tag.
+/*!
+ \param vpTag Tag to retrieve expression from.
+ \returns Key expression.
+*/
+
+xbString &xbIxNdx::GetKeyExpression( const void * vpTag ) const{
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+ return npTag->sKeyExpression;
+}
+
+
+/***********************************************************************/
+//! @brief Get the key filter for the given tag.
+/*!
+ NDX index files do not support filters. This returns NULL.
+ \returns NULL.
+*/
+
+xbString &xbIxNdx::GetKeyFilter( const void * ) const{
+ return sNullString;
+}
+/***********************************************************************/
+//! @brief Get the key length for the given tag.
+/*!
+ \param vpTag Tag to retrieve key length for.
+ \returns Length of key.
+*/
+xbInt32 xbIxNdx::GetKeyLen( const void * vpTag ) const{
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+ return npTag->iKeyLen;
+}
+/***********************************************************************/
+//! @brief Get child node number for given key number.
+/*!
+ \param vpTag Tag to retrieve dbf rec number on.
+ \param iKeyNo Key number for retrieval
+ \param np Pointer to node
+ \param ulKeyPtr Output node number
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::GetKeyPtr( void *vpTag, xbInt16 iKeyNo, xbIxNode *np, xbUInt32 &ulKeyPtr ) const {
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ try{
+ #ifdef XB_DEBUG_SUPPORT
+ // turn this off in production mode for better performance
+ xbUInt32 ulNoOfKeys = eGetUInt32 ( np->cpBlockData );
+ if( iKeyNo < 0 || iKeyNo > (xbInt16) ulNoOfKeys ){
+ iErrorStop = 10;
+ throw XB_INVALID_KEYNO;
+ }
+ #endif
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+ char *p = ( np->cpBlockData);
+ p += (4 + (iKeyNo * npTag->iKeyItemLen));
+ ulKeyPtr = eGetUInt32 ( p );
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::GetKeyPtr() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Returns key update status.
+/*!
+ \param vpTag Tag to check status on.
+ \returns XB_UPD_KEY Key updated.<br>
+ XB_DEL_KEY Key deleted.<br>
+ XB_ADD_KEY Key added.<br>
+ 0 No key updates
+
+*/
+xbInt16 xbIxNdx::GetKeySts( void *vpTag ) const{
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+ return npTag->iKeySts;
+}
+/***********************************************************************/
+//! @brief Get character key type for given tag.
+/*!
+ \param vpTag Tag to retrieve key type for.
+ \returns Char key type.
+*/
+
+char xbIxNdx::GetKeyType( const void * vpTag ) const{
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+ return npTag->cKeyType;
+}
+
+/***********************************************************************/
+//! @brief Get numeric key type for given tag.
+/*!
+ \param vpTag Tag to retrieve first key for.
+ \returns Numeric key type.
+*/
+xbInt16 xbIxNdx::GetKeyTypeN( const void * vpTag ) const{
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+ return npTag->iKeyType;
+}
+/***********************************************************************/
+//! @brief Get the last key for the given tag.
+/*!
+ \param vpTag Tag to retrieve last key on.
+ \param iRetrieveSw xbTrue - Retrieve the record on success.<br>
+ xbFalse - Don't retrieve record.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxNdx::GetLastKey( void *vpTag, xbInt16 iRetrieveSw ){
+ return GetLastKey( 0, vpTag, iRetrieveSw );
+// return GetLastKey( 0, vpTag, 1 );
+
+}
+/***********************************************************************/
+//! @brief Get the last key for the given tag and starting node.
+/*!
+ \param ulNodeNo Starting node
+ \param vpTag Tag to retrieve last key on.
+ \param iRetrieveSw xbTrue - Retrieve the record if key found.<br>
+ xbFalse - Don't retrieve record.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxNdx::GetLastKey( xbUInt32 ulNodeNo, void *vpTag, xbInt16 iRetrieveSw ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbUInt32 ulKeyPtr = 0;
+ xbUInt32 ulNoOfKeys = 0;
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ try{
+ // clear out any history
+ if( npTag->npNodeChain ){
+ npTag->npNodeChain = FreeNodeChain( npTag->npNodeChain );
+ npTag->npCurNode = NULL;
+ }
+ if( ulNodeNo == 0 ){
+ if(( iRc = ReadHeadBlock( 1 )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ // lRootBlock is now available
+ if(( iRc = GetBlock( npTag, npTag->ulRootBlock, 1, (xbUInt32) npTag->iKeyItemLen )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ } else {
+ if(( iRc = GetBlock( npTag, ulNodeNo, 1, (xbUInt32) npTag->iKeyItemLen )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+ // if no keys on this node, then the index is empty
+ ulNoOfKeys = eGetUInt32( npTag->npCurNode->cpBlockData );
+ if( ulNoOfKeys == 0 && IsLeaf( npTag, npTag->npCurNode )){
+ iRc = XB_EMPTY;
+ return iRc;
+ }
+ npTag->npCurNode->iCurKeyNo = ulNoOfKeys;
+ while( !IsLeaf( npTag, npTag->npCurNode ) ){ // go down the chain looking for a leaf node
+ npTag->npCurNode->iCurKeyNo = eGetUInt32( npTag->npCurNode->cpBlockData );
+ if(( iRc = GetKeyPtr( npTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ if(( iRc = GetBlock( npTag, ulKeyPtr, 1, (xbUInt32) npTag->iKeyItemLen )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ ulNoOfKeys = eGetUInt32( npTag->npCurNode->cpBlockData );
+ npTag->npCurNode->iCurKeyNo = ulNoOfKeys;
+ }
+ // get here on a leaf node, it has one fewer iCurKeyNo
+ npTag->npCurNode->iCurKeyNo--;
+ if( iRetrieveSw ){
+ ulNoOfKeys = eGetUInt32( npTag->npCurNode->cpBlockData );
+ if(( iRc = GetDbfPtr( npTag, ulNoOfKeys - 1, npTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ if(( iRc = dbf->GetRecord( ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw iRc;
+ }
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::GetLastKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Get the last key for a block number.
+/*!
+ \param vpTag Tag to retrieve first key on.
+ \param ulBlockNo Block number for key retrieval.
+ \param cpBuf output buffer for key placement
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::GetLastKeyForBlockNo( void *vpTag, xbUInt32 ulBlockNo, char *cpBuf ){
+
+ // returns the last key for a given block number
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ try{
+ xbIxNode * npSaveNodeChain = npTag->npNodeChain;
+ xbIxNode * npSaveCurNode = npTag->npCurNode;
+ npTag->npNodeChain = NULL;
+
+ if(( iRc = GetLastKey( ulBlockNo, npTag, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ // set the key
+ memcpy( cpBuf, GetKeyData( npTag->npCurNode, GetKeyCount( npTag->npCurNode ) - 1, npTag->iKeyItemLen ), (size_t) npTag->iKeyLen );
+
+ // free memory
+ npTag->npNodeChain = FreeNodeChain( npTag->npNodeChain );
+ npTag->npNodeChain = npSaveNodeChain;
+ npTag->npCurNode = npSaveCurNode;
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::GetLastKeyForBlockNo() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ) );
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Get the next key for the given tag.
+/*!
+ \param vpTag Tag to retrieve next key on.
+ \param iRetrieveSw xbTrue - Retrieve the record on success.<br>
+ xbFalse - Don't retrieve record.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::GetNextKey( void * vpTag, xbInt16 iRetrieveSw ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ try{
+ if( !npTag->npNodeChain )
+ return GetFirstKey( vpTag, iRetrieveSw );
+
+ // more keys on this node? if yes, get the next one to the right
+ xbUInt32 ulKeyPtr;
+ if((eGetUInt32( npTag->npCurNode->cpBlockData ) -1) > npTag->npCurNode->iCurKeyNo ){
+ npTag->npCurNode->iCurKeyNo++;
+ if(( iRc = GetDbfPtr( npTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ if( iRetrieveSw ){
+ if(( iRc = dbf->GetRecord( ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ } else {
+ return iRc;
+ }
+ } else {
+ return iRc;
+ }
+ }
+ // if at end of head node, then eof
+ if( npTag->npCurNode->ulBlockNo == npTag->ulRootBlock )
+ return XB_EOF;
+
+ // This logic assumes that interior nodes have n+1 left node no's where n is he the number of keys in the node
+ xbIxNode * TempIxNode = npTag->npCurNode;
+ npTag->npCurNode = npTag->npCurNode->npPrev;
+ TempIxNode = FreeNodeChain( TempIxNode );
+
+ while( npTag->npCurNode->iCurKeyNo >= eGetUInt32( npTag->npCurNode->cpBlockData ) &&
+ (npTag->npCurNode->ulBlockNo != npTag->ulRootBlock )){
+ TempIxNode = npTag->npCurNode;
+ npTag->npCurNode = npTag->npCurNode->npPrev;
+ TempIxNode = FreeNodeChain( TempIxNode );
+ }
+
+ // head node and at end of head node, then eof
+ if( npTag->npCurNode->ulBlockNo == npTag->ulRootBlock &&
+ npTag->npCurNode->iCurKeyNo == eGetUInt32( npTag->npCurNode->cpBlockData ))
+ return XB_EOF;
+
+ // move one to the right
+ npTag->npCurNode->iCurKeyNo++;
+
+ if(( iRc = GetKeyPtr( npTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+
+ if(( iRc = GetBlock( npTag, ulKeyPtr, 1, (xbUInt32) npTag->iKeyItemLen )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ while( !IsLeaf( npTag, npTag->npCurNode )) // go down the chain looking for a leaf node
+ {
+ if(( iRc = GetKeyPtr( npTag, 0, npTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ if(( iRc = GetBlock( npTag, ulKeyPtr, 1, (xbUInt32) npTag->iKeyItemLen )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw iRc;
+ }
+ }
+ if( iRetrieveSw ){
+ if(( iRc = GetDbfPtr( npTag, 0, npTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 80;
+ throw iRc;
+ }
+ if(( iRc = dbf->GetRecord( ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 90;
+ throw iRc;
+ }
+ }
+ }
+ catch( xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::GetNextKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Get the previous key for the given tag.
+/*!
+ \param vpTag Tag to retrieve previous key on.
+ \param iRetrieveSw xbTrue - Retrieve the record on success.<br>
+ xbFalse - Don't retrieve record.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxNdx::GetPrevKey( void * vpTag, xbInt16 iRetrieveSw ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ // This method assumes last index call landed on a valid key.
+ // If last call resulted in an error, this method will returns XB_BOF
+
+ try{
+ if( !npTag->npNodeChain )
+ return GetLastKey( 0, vpTag, iRetrieveSw );
+
+ xbUInt32 ulKeyPtr;
+ if( npTag->npCurNode->iCurKeyNo > 0 ){
+ npTag->npCurNode->iCurKeyNo--;
+
+ if(( iRc = GetDbfPtr( npTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ if( iRetrieveSw ){
+ if(( iRc = dbf->GetRecord( ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ } else {
+ return iRc;
+ }
+ }
+ }
+
+ // next two lines might have been an issue
+ if( npTag->npCurNode->ulBlockNo == npTag->ulRootBlock && GetKeyCount( npTag->npCurNode ) == 0 && IsLeaf( npTag, npTag->npCurNode ))
+ return XB_EMPTY;
+
+ if( npTag->npCurNode->ulBlockNo == npTag->ulRootBlock )
+ return XB_BOF;
+
+ // This logic assumes that interior nodes have n+1 left node no's where n is he the number of keys in the node
+ xbIxNode * TempIxNode = npTag->npCurNode;
+ npTag->npCurNode = npTag->npCurNode->npPrev;
+ TempIxNode = FreeNodeChain( TempIxNode );
+
+ while( npTag->npCurNode->iCurKeyNo == 0 &&
+ (npTag->npCurNode->ulBlockNo != npTag->ulRootBlock )){
+ TempIxNode = npTag->npCurNode;
+ npTag->npCurNode = npTag->npCurNode->npPrev;
+ TempIxNode = FreeNodeChain( TempIxNode );
+ }
+
+ // head node and at end of head node, then bof
+ if( npTag->npCurNode->ulBlockNo == npTag->ulRootBlock &&
+ npTag->npCurNode->iCurKeyNo == 0 )
+ return XB_BOF;
+
+ // move one to the left
+ npTag->npCurNode->iCurKeyNo--;
+
+ if(( iRc = GetKeyPtr( npTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+
+ if(( iRc = GetBlock( npTag, ulKeyPtr, 1, (xbUInt32) npTag->iKeyItemLen )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+
+ while( !IsLeaf( npTag, npTag->npCurNode )){ // go down the chain looking for a leaf node
+ npTag->npCurNode->iCurKeyNo = eGetUInt32( npTag->npCurNode->cpBlockData );
+ if(( iRc = GetKeyPtr( npTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ if(( iRc = GetBlock( npTag, ulKeyPtr, 1, (xbUInt32) npTag->iKeyItemLen )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw iRc;
+ }
+ }
+
+ npTag->npCurNode->iCurKeyNo = eGetUInt32( npTag->npCurNode->cpBlockData ) - 1;
+ if( iRetrieveSw ){
+ if(( iRc = GetDbfPtr( npTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 80;
+ throw iRc;
+ }
+ if(( iRc = dbf->GetRecord( ulKeyPtr )) != XB_NO_ERROR ){
+ iErrorStop = 90;
+ throw iRc;
+ }
+ }
+ }
+
+ catch( xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::GetPrevKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Get the sort order for given tag.
+/*!
+ Ndx indices only support ascending keys.
+ \returns 0
+*/
+xbBool xbIxNdx::GetSortOrder( void * ) const{
+ return 0;
+}
+/***********************************************************************/
+//! @brief Get tag for tag number.
+/*!
+ \returns Pointer to ndx tag.
+*/
+void * xbIxNdx::GetTag( xbInt16 ) const{
+ return ndxTag;
+}
+/***********************************************************************/
+//! @brief Get tag for tag name.
+/*!
+ \returns Pointer to ndx tag.
+*/
+void * xbIxNdx::GetTag( xbString & ) const{
+ return ndxTag;
+}
+
+/***********************************************************************/
+//! @brief Get tag count.
+/*!
+ NDX index files contain one tag.
+ \returns 1
+*/
+
+xbInt16 xbIxNdx::GetTagCount() const{
+ return 1;
+}
+/***********************************************************************/
+//! @brief Get tag name.
+/*!
+ \returns Tag name.
+*/
+xbString &xbIxNdx::GetTagName( void * ) const {
+// char * xbIxNdx::GetTagName( void * ) const {
+
+ return ndxTag->sTagName;
+
+}
+/***********************************************************************/
+//! @brief Get tag name.
+/*!
+ \returns Tag name.
+*/
+const char * xbIxNdx::GetTagName( void *, xbInt16 ) const {
+ return ndxTag->sTagName;
+}
+
+/***********************************************************************/
+//! @brief Get the unique setting for given tag.
+/*!
+ \param vpTag Tag to unique setting on.
+ \returns xbTrue - Unique index.<br> xbFalse - Not unique index.
+*/
+xbBool xbIxNdx::GetUnique( void * vpTag ) const{
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+ return npTag->iUnique;
+}
+
+/***********************************************************************/
+//! @brief Insert key into interior node.
+/*!
+ Insert key into non-full interior node.<br>
+ Assumes valid inputs
+
+ \param vpTag Tag in play.
+ \param npNode Node for insertion.
+ \param iSlotNo Slot number to insert key.
+ \param ulPtr Pointer number to insert.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::InsertNodeI( void *vpTag, xbIxNode *npNode, xbInt16 iSlotNo, xbUInt32 ulPtr ){
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ char *pTrg;
+ xbInt16 iSrcPos;
+ char *pLastKey = NULL;
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ try{
+ // update number of keys on the node
+ xbInt32 lKeyCnt = GetKeyCount( npNode );
+ iSrcPos = 12 + (iSlotNo * npTag->iKeyItemLen);
+
+ char *pSrc = npNode->cpBlockData;
+ pSrc += iSrcPos;
+
+ // if not appending to the end of the node, make some room, move things to the right
+ if( iSlotNo < lKeyCnt ) {
+ xbInt16 iCopyLen = ((lKeyCnt - iSlotNo) * npTag->iKeyItemLen) - 4;
+ pTrg = pSrc;
+ pTrg += npTag->iKeyItemLen;
+ memmove( pTrg, pSrc, (size_t) iCopyLen );
+ }
+
+ // get the right most key for the left part of the split node
+ xbUInt32 ulKeyPtr2;
+ if(( iRc = GetKeyPtr( vpTag, npNode->iCurKeyNo, npNode, ulKeyPtr2 )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ // get the new right key value for the freshly split node
+ pLastKey = (char *) malloc((size_t) ndxTag->iKeyLen);
+ if(( iRc = GetLastKeyForBlockNo( vpTag, ulKeyPtr2, pLastKey )) != XB_NO_ERROR ){
+ iRc = 110;
+ throw iRc;
+ }
+ // write the key value
+ pTrg = pSrc;
+ char *pTrg2 = pSrc;
+ pSrc = pLastKey;
+ for( xbInt16 i = 0; i < npTag->iKeyLen; i++ )
+ *pTrg++ = *pSrc++;
+
+ pTrg2 += (npTag->iKeyItemLen - 8);
+ ePutUInt32( pTrg2, ulPtr );
+ ePutInt32( npNode->cpBlockData, ++lKeyCnt );
+
+ // write out the updated block to disk
+ if(( iRc = WriteBlock( npNode->ulBlockNo, GetBlockSize(), npNode->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ if( pLastKey )
+ free( pLastKey );
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::InsertNodeI() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ if( pLastKey )
+ free( pLastKey );
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Insert key into leaf node.
+/*!
+ Insert key into non-full leaf node.<br>
+ Assumes valid inputs
+
+ \param vpTag Tag in play.
+ \param npNode Node for insertion.
+ \param iSlotNo Slot number to insert key.
+ \param ulPtr Pointer number to insert.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxNdx::InsertNodeL( void *vpTag, xbIxNode *npNode, xbInt16 iSlotNo,
+ char * cpKeyBuf, xbUInt32 ulPtr ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ char *pSrc;
+ char *pTrg;
+ char *pKeyPos;
+ xbString sMsg;
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ try{
+ xbInt32 lKeyCnt = GetKeyCount( npNode );
+ xbInt16 iKeyPos = 4 + iSlotNo * npTag->iKeyItemLen;
+ pKeyPos = npNode->cpBlockData;
+ pKeyPos += iKeyPos;
+
+ // if not appending to end, make space, move things right
+ if( iSlotNo < lKeyCnt ) {
+ xbInt16 iCopyLen = (lKeyCnt - iSlotNo) * npTag->iKeyItemLen;
+ pTrg = pKeyPos;
+ pTrg += npTag->iKeyItemLen;
+ memmove( pTrg, pKeyPos, (size_t) iCopyLen );
+ }
+ // if leaf, write rec number
+ pTrg = pKeyPos;
+ memset( pTrg, 0x00, 4 );
+ pTrg += 4;
+ ePutUInt32( pTrg, ulPtr );
+ pTrg += 4;
+
+ // write the key value
+ pSrc = cpKeyBuf;
+ for( xbInt16 i = 0; i < npTag->iKeyLen; i++ )
+ *pTrg++ = *pSrc++;
+
+ // update number of keys on the node
+ ePutInt32( npNode->cpBlockData, ++lKeyCnt );
+
+ // write out the updated block to disk
+ if(( iRc = WriteBlock( npNode->ulBlockNo, GetBlockSize(), npNode->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::InsertNodeL() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Determine node leaf status
+/*!
+ \param npNode Node to examine.
+ \returns xbTrue - Leaf node.<br> xbFalse - Interior node.
+*/
+xbBool xbIxNdx::IsLeaf( void *, xbIxNode *npNode ) const {
+ xbUInt32 ulBlock = eGetUInt32 ( npNode->cpBlockData+4 );
+ if( ulBlock > 0 ) // if the second four bytes are a number, it's an interior node
+ return false;
+ else
+ return true;
+}
+/***********************************************************************/
+//! @brief Determine if key exists.
+/*!
+ This method assumes the key has already been built and is in either
+ cpKeyBuf or dKey.
+
+ \param vpTag - Pointer to tag.
+ \returns xbTrue - Key exists.<br> xbFalse - Key does not exist.
+*/
+xbInt16 xbIxNdx::KeyExists( void * vpTag ){
+
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ xbInt16 iRc = FindKey( vpTag, npTag->cpKeyBuf, npTag->iKeyLen, 0 );
+ if( iRc == 0 )
+ return 1;
+ else
+ return 0;
+}
+
+/***********************************************************************/
+//! @brief Set position for key add.
+/*!
+ This routine is called by the AddKey() method and is used to position
+ the node chain to the position the new key should be added to the index.
+
+ \param npTag Pointer to npTag.
+ \param ulAddRecNo Record number to add.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxNdx::KeySetPosAdd( xbNdxTag *npTag, xbUInt32 ulAddRecNo ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try{
+
+ iRc = FindKey( npTag, npTag->cpKeyBuf, npTag->iKeyLen, 0 );
+ if( iRc == XB_NOT_FOUND || iRc == XB_EMPTY )
+ return XB_NO_ERROR; // good position
+
+ else if( iRc != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ // get here if key was found, get the right most instance of any non unique key for append, find correct spot for update
+ if( GetUnique() == 0 ){
+ xbUInt32 ulCurRecNo;
+ if(( iRc = GetDbfPtr( npTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulCurRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ xbBool bKeysMatch = xbTrue;
+ while( bKeysMatch && ulAddRecNo > ulCurRecNo && iRc == XB_NO_ERROR ){
+ if(( iRc = GetNextKey( npTag, 0 )) == XB_NO_ERROR ){
+ if( memcmp( GetKeyData( npTag->npCurNode, npTag->npCurNode->iCurKeyNo, npTag->iKeyItemLen ), npTag->cpKeyBuf, (size_t) npTag->iKeyLen ))
+ bKeysMatch = xbFalse;
+ else{
+ if(( iRc = GetDbfPtr( npTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulCurRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ }
+ }
+ }
+ }
+ if( iRc == XB_EOF ){ // eof condition
+ if(( iRc = GetLastKey( 0, npTag, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ npTag->npCurNode->iCurKeyNo++;
+ return XB_NO_ERROR;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::KeySetPos() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Set position for key add.
+/*!
+ This routine is called by the DeleteKey() method and is used to position
+ the node chain to the position the old key should be deleted from the index.
+
+ \param npTag Pointer to npTag.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::KeySetPosDel( xbNdxTag *npTag ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbString sMsg;
+
+ try{
+ iRc = FindKey( NULL, npTag->cpKeyBuf2, npTag->iKeyLen, 0 );
+ if( iRc == XB_NOT_FOUND || iRc == XB_EMPTY )
+ return XB_NO_ERROR; // good position
+ else if( iRc != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ xbUInt32 ulIxRecNo;
+ if(( iRc = GetDbfPtr( npTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulIxRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ if( ulIxRecNo == dbf->GetCurRecNo())
+ return XB_NO_ERROR;
+ if( GetUnique() == 1 ){
+ iErrorStop = 40;
+ iRc = XB_NOT_FOUND;
+ throw iRc;
+ }
+ xbBool bFound = xbFalse;
+ xbBool bKeysMatch = xbTrue;
+ while( bKeysMatch && !bFound && iRc == XB_NO_ERROR ){
+ if(( iRc = GetNextKey( npTag, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ if( memcmp( GetKeyData( npTag->npCurNode, npTag->npCurNode->iCurKeyNo, npTag->iKeyItemLen ), npTag->cpKeyBuf2, (size_t) npTag->iKeyLen )){
+ bKeysMatch = xbFalse;
+ } else {
+ if(( iRc = GetDbfPtr( npTag, npTag->npCurNode->iCurKeyNo, npTag->npCurNode, ulIxRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ if( ulIxRecNo == dbf->GetCurRecNo())
+ bFound = xbTrue;
+ }
+ }
+ if( bFound )
+ return XB_NO_ERROR;
+ else
+ return XB_NOT_FOUND;
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::KeySetPosDel() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Returns key filter status.
+/*!
+ \param vpTag Tag to check status on.
+ \returns xbtrue - Key was updated.<br>xbFalse - Key not updated.
+
+ Always true for NDX style indices.
+*/
+//inline xbBool xbIxNdx::KeyFiltered( void *vpTag ) const{
+// return xbTrue;
+//}
+
+/***********************************************************************/
+//! @brief Read head block of index file.
+/*!
+ \param iOpt 0 - Read in entire block
+ 1 - Read in only dynamic section of block
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbIxNdx::ReadHeadBlock( xbInt16 iOpt = 0 ) {
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ try{
+ if( !FileIsOpen()){
+ iRc = XB_NOT_OPEN;
+ iErrorStop = 10;
+ throw iRc;
+ }
+ xbInt16 iLen;
+ iOpt == 0 ? iLen = 512 : iLen = 21;
+
+ if(( iRc = ReadBlock( (xbUInt32) 0, (size_t) iLen, cNodeBuf )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ char *p = cNodeBuf;
+ ndxTag->ulRootBlock = eGetUInt32( p ); p+=4;
+ ndxTag->ulTotalBlocks = eGetUInt32( p ); p+=5;
+ if( iOpt == 0 ){
+ ndxTag->cKeyType = *p; p+=3;
+ ndxTag->iKeyLen = eGetInt16( p ); p+=2;
+ ndxTag->iKeysPerBlock = eGetInt16( p ); p+=2;
+ ndxTag->iKeyType = eGetInt16( p ); p+=2;
+ ndxTag->iKeyItemLen = eGetInt16( p ); p+=2;
+ ndxTag->cSerNo = *p; p+=3;
+ ndxTag->iUnique = *p; p++;
+ ndxTag->sKeyExpression.Set( p );
+
+ if( ndxTag->exp )
+ delete ndxTag->exp;
+
+ ndxTag->exp = new xbExp( xbase, dbf );
+ if(( iRc = ndxTag->exp->ParseExpression( ndxTag->sKeyExpression.Str() )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+
+ if( ndxTag->cpKeyBuf )
+ free( ndxTag->cpKeyBuf );
+ if( ndxTag->cpKeyBuf2 )
+ free( ndxTag->cpKeyBuf2 );
+
+ ndxTag->cpKeyBuf = (char *) malloc( (size_t) ndxTag->iKeyLen );
+ ndxTag->cpKeyBuf2 = (char *) malloc( (size_t) ndxTag->iKeyLen );
+
+ if( ndxTag->sTagName == "" )
+ GetFileNamePart( ndxTag->sTagName );
+
+ } else {
+ p+= 11;
+ ndxTag->cSerNo = *p;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::ReadHeadBlock() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Reindex a tag.
+/*!
+ \param vpTag Pointer to tag pointer.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::Reindex( void **vpTag ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ //xbNdxTag * npTag;
+ //vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ try{
+ xbString sFileName = GetFqFileName();
+ xbString sKey; // = GetKeyExpression( vpTag );
+ sKey.Set( GetKeyExpression( *vpTag ));
+ xbInt16 iUnique = GetUnique( *vpTag );
+ xbString sFilter = "";
+
+ void *vpTag2;
+ if(( iRc = CreateTag( sFileName, sKey, sFilter, 0, iUnique, xbTrue, &vpTag2 )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ xbUInt32 ulRecCnt = 0;
+ if(( iRc = dbf->GetRecordCnt( ulRecCnt )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+
+ for( xbUInt32 l = 1; l <= ulRecCnt; l++ ){
+ if(( iRc = dbf->GetRecord( l )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+
+ if(( iRc = CreateKey( vpTag2, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+
+ if( iUnique ){
+ iRc = CheckForDupKey( vpTag2 );
+ if( iRc != 0 ){
+ if( iRc < 0 ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ return XB_KEY_NOT_UNIQUE;
+ }
+ }
+
+ if(( iRc = AddKey( vpTag2, l )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ }
+ *vpTag = vpTag2;
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::Reindex() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+
+ return iRc;
+}
+
+
+/***********************************************************************/
+//! @brief Set current tag.
+/*!
+ For ndx indices, there is only one tag.
+ \returns XB_NO_ERROR.
+*/
+xbInt16 xbIxNdx::SetCurTag( xbInt16 ) {
+ xbIx::SetCurTag( ndxTag );
+ return XB_NO_ERROR;
+}
+/***********************************************************************/
+//! @brief Set current tag.
+/*!
+ For ndx indices, there is only one tag.
+ \returns XB_NO_ERROR.
+*/
+xbInt16 xbIxNdx::SetCurTag( xbString & ) {
+ xbIx::SetCurTag( ndxTag );
+ dbf->SetCurTag( "NDX", this, GetTag(0) );
+ return XB_NO_ERROR;
+}
+
+/***********************************************************************/
+//! @brief Split an interior node
+/*!
+
+ This routine splits an interior node into two nodes, divided by dSplitFactor.<br>
+ This behaves differently than V7 Dbase. V7 does not balance the nodes.<br>
+ For V7, if adding a key to the end of a node, it will create a right node
+ with only one key, and the left node is still full.<br><br>
+
+ Possible performance improvement options.<br>
+ Two modes when splitting:<br>
+ a) Split nodes in the middle - good for random access applications<br>
+ b) Split off right node with only one key - good for applications with
+ expectation of ascending keys added moving forward.<br>
+
+ This routine first inserts the key into the left node in the appropriate location
+ then splits the node based on the split factor setting.
+
+ \param vpTag Tag in play.
+ \param npLeft Left node to split.
+ \param npRight Right node to split.
+ \param iSlotNo Slot number for split.
+ \param ulPtr Pointer number to insert.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::SplitNodeI( void *vpTag, xbIxNode * npLeft, xbIxNode *npRight, xbInt16 iSlotNo, xbUInt32 ulPtr ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbNdxTag * npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+ xbDouble dSplitFactor = .5; // split the nodes 50/50
+ xbString sMsg;
+
+ try{
+ xbInt32 lKeyCnt = GetKeyCount( npLeft );
+ xbInt32 lNewLeftKeyCnt = (xbInt32) ((lKeyCnt + 1) * dSplitFactor) + 1;
+ xbInt32 lNewRightKeyCnt = lKeyCnt - lNewLeftKeyCnt;
+ xbInt16 iSrcPos;
+ xbInt16 iCopyLen;
+ char *pSrc;
+ char *pTrg;
+
+ // insert the key into the left node
+ if(( iRc = InsertNodeI( vpTag, npLeft, iSlotNo, ulPtr )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+ // move the right half of the left node to the right node
+ iSrcPos = ((lNewLeftKeyCnt + 1) * npTag->iKeyItemLen) + 4;
+ iCopyLen = (lNewRightKeyCnt * npTag->iKeyItemLen) + 4;
+ pSrc = npLeft->cpBlockData;
+ pSrc += iSrcPos;
+ pTrg = npRight->cpBlockData;
+ pTrg += 4;
+ memmove( pTrg, pSrc, (size_t) iCopyLen );
+
+ // write the new key counts into the nodes
+ pTrg = npLeft->cpBlockData;
+ ePutInt32( pTrg, lNewLeftKeyCnt );
+ pTrg = npRight->cpBlockData;
+ ePutInt32( pTrg, lNewRightKeyCnt );
+
+ // write the new key counts into the nodes
+ pTrg = npLeft->cpBlockData;
+ ePutInt32( pTrg, lNewLeftKeyCnt );
+ pTrg = npRight->cpBlockData;
+ ePutInt32( pTrg, lNewRightKeyCnt );
+
+ // write out the block
+ if(( iRc = WriteBlock( npLeft->ulBlockNo, GetBlockSize(), npLeft->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ // write out the block
+ if(( iRc = WriteBlock( npRight->ulBlockNo, GetBlockSize(), npRight->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 200;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::SplitNodeI() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Split a leaf node.
+/*!
+ This routine splits an index leaf into two nodes, divided by dSplitFactor.<br>
+ This behaves differently than V7 Dbase. V7 does not balance the nodes.<br>
+ For V7, if adding a key to the end of a node, it will create a right node
+ with only one key, and the left node is still full.<br><br>
+
+ Possible performance improvement options.<br>
+ Two modes when splitting:<br>
+ a) Split nodes in the middle - good for random access applications<br>
+ b) Split off right node with only one key - good for applications with
+ expectation of ascending keys added moving forward.<br>
+
+ This routine first inserts the key into the left node in the appropriate location
+ then splits the node based on the split factor setting.
+
+ \param vpTag Tag in play.
+ \param npLeft Left node to split.
+ \param npRight Right node to split.
+ \param iSlotNo Slot number for split.
+ \param ulPtr Pointer number to insert.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::SplitNodeL( void *vpTag, xbIxNode * npLeft, xbIxNode *npRight,
+ xbInt16 iSlotNo, char * cpKeyBuf, xbUInt32 ulPtr ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbDouble dSplitFactor = .5;
+ xbNdxTag *npTag;
+ vpTag ? npTag = (xbNdxTag *) vpTag : npTag = ndxTag;
+
+ xbString sMsg;
+ try{
+ xbInt32 lKeyCnt = GetKeyCount( npLeft );
+ xbInt32 lNewLeftKeyCnt = (xbInt32) ((lKeyCnt + 1) * dSplitFactor) + 1;
+ xbInt32 lNewRightKeyCnt = lKeyCnt + 1 - lNewLeftKeyCnt;
+
+ // xbInt16 iSrcPos;
+ xbInt16 iLen;
+ char *pSrc = npLeft->cpBlockData;
+ char *pTrg;
+
+ if(( iRc = InsertNodeL( vpTag, npLeft, iSlotNo, cpKeyBuf, ulPtr )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+ // move right half off of left node to the right node
+ pSrc = npLeft->cpBlockData;
+ pSrc += ((lNewLeftKeyCnt * npTag->iKeyItemLen)+4);
+ pTrg = npRight->cpBlockData;
+ pTrg += 4;
+ iLen = lNewRightKeyCnt * npTag->iKeyItemLen;
+ memmove( pTrg, pSrc, (size_t) iLen );
+
+ // write the new key counts into the nodes
+ pTrg = npLeft->cpBlockData;
+ ePutInt32( pTrg, lNewLeftKeyCnt );
+ pTrg = npRight->cpBlockData;
+ ePutInt32( pTrg, lNewRightKeyCnt );
+
+ // write out the block
+ if(( iRc = WriteBlock( npLeft->ulBlockNo, GetBlockSize(), npLeft->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ // write out the block
+ if(( iRc = WriteBlock( npRight->ulBlockNo, GetBlockSize(), npRight->cpBlockData )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::SplitNodeL() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief UpdateTagKey
+/*!
+ This routine updates a key or a given tag.
+ The file header is considered to be the first 2048 bytes in the file.
+
+ \param cAction A - Add a key.<br>
+ D - Delete a key.<br>
+ R - Revise a key.<br>
+ \param vpTg - Pointer to tag.<br>
+ \param ulRecNo - Record number association with the action.<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbIxNdx::UpdateTagKey( char cAction, void *vpTag, xbUInt32 ulRecNo ){
+
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ // ..xbNdxTag *npTag = (xbMdxTag *) vpTag;
+
+ try{
+ // save off any needed fileds for updating
+ // xbUInt32 ulTagSizeSave = mpTag->ulTagSize;
+ //xbUInt32 ulLeftChildSave = mpTag->ulLeftChild;
+ //xbUInt32 ulRightChildSave = mpTag->ulRightChild;
+
+
+ if( cAction == 'D' || cAction == 'R' ){
+// std::cout << "UpdateTagKey delete\n";
+ if(( iRc = DeleteKey( vpTag )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ }
+
+ if( cAction == 'A' || cAction == 'R' ){
+// std::cout << "UpdateTagKey add\n";
+ if(( iRc = AddKey( vpTag, ulRecNo )) != XB_NO_ERROR ){
+ iErrorStop = 200;
+ throw iRc;
+ }
+ }
+
+// if( ulTagSizeSave != mpTag->ulTagSize ){
+// std::cout << "UpdateTagKey - tag size was updated need to do something here\n";
+// }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::UpdateTagKey() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Write head block.
+/*!
+ Commit the index head node to disk.
+ \param iOpt 0 - Entire header.<br>
+ 1 - Update root block, number of blocks and seq number.<br>
+ 2 - Update sequence number only<br>
+ \returns <a href="xbretcod_8h.html">
+*/
+
+xbInt16 xbIxNdx::WriteHeadBlock( xbInt16 iOpt ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ if( iOpt == 2 ){
+
+ // increment the serial number
+ if( ndxTag->cSerNo >= 0 && ndxTag->cSerNo < 127 )
+ ndxTag->cSerNo++;
+ else
+ ndxTag->cSerNo = 0;
+
+ if(( iRc = xbFseek( 20, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ if(( iRc = xbFputc( ndxTag->cSerNo )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+ } else if( iOpt == 1 ){
+ xbRewind();
+ char buf[8];
+ ePutUInt32( &buf[0], ndxTag->ulRootBlock );
+ ePutUInt32( &buf[4], ndxTag->ulTotalBlocks );
+ if(( iRc = xbFwrite( buf, 8, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 200;
+ throw iRc;
+ }
+ return WriteHeadBlock( 2 );
+
+ } else if ( iOpt == 0 ){
+
+ char buf[512];
+ memset( buf, 0x00, 512 );
+ ePutUInt32( &buf[0], ndxTag->ulRootBlock );
+ ePutUInt32( &buf[4], ndxTag->ulTotalBlocks );
+ buf[9] = ndxTag->cKeyType;
+ buf[11] = 0x1B;
+ ePutInt16( &buf[12], ndxTag->iKeyLen );
+ ePutInt16( &buf[14], ndxTag->iKeysPerBlock );
+ ePutInt16( &buf[16], ndxTag->iKeyType );
+ ePutInt16( &buf[18], ndxTag->iKeyItemLen );
+ if( ndxTag-> iUnique ) buf[23] = 0x01;
+
+ for( xbUInt32 i = 0; i < ndxTag->sKeyExpression.Len(); i++ )
+ buf[i+24] = ndxTag->sKeyExpression.GetCharacter(i+1);
+
+ xbRewind();
+ if(( iRc = xbFwrite( buf, 512, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 300;
+ throw iRc;
+ }
+ } else {
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbIxNdx::WriteHeadBlock() Exception Caught. Error Stop = [%d] iRc = [%d] option = [%d] ser=[%d]", iErrorStop, iRc, iOpt, ndxTag->cSerNo );
+ xbase->WriteLogMessage( sMsg );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+} /* namespace */
+#endif /* XB_NDX_SUPPORT */
+
+
+
diff --git a/src/core/xblog.cpp b/src/core/xblog.cpp
new file mode 100755
index 0000000..ea7c9d6
--- /dev/null
+++ b/src/core/xblog.cpp
@@ -0,0 +1,208 @@
+/* xblog.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"
+//#include <time.h>
+
+#ifdef XB_LOGGING_SUPPORT
+
+namespace xb{
+
+/******************************************************************************/
+//! @brief Constructor.
+xbLog::xbLog() : xbFile( NULL ){
+
+ SetDirectory( GetDefaultLogDirectory());
+ SetFileName ( GetDefaultLogFileName());
+
+ bLoggingStatus = xbFalse;
+ lLogSize = 50000;
+
+ #ifdef XB_LOCKING_SUPPORT
+ iShareMode = XB_MULTI_USER;
+ #else
+ iShareMode = XB_SINGLE_USER;
+ #endif
+}
+/******************************************************************************/
+//! @brief Constructor.
+/*!
+ \param sLogFileName - Log file name.
+*/
+xbLog::xbLog( const xbString & sLogFileName ) : xbFile( NULL ){
+ if( sLogFileName.GetPathSeparator())
+ SetFqFileName( sLogFileName ); // file name includes a path
+ else
+ SetFileName( sLogFileName ); // no file path
+
+ bLoggingStatus = xbFalse;
+ lLogSize = 50000;
+
+ #ifdef XB_LOCKING_SUPPORT
+ iShareMode = XB_MULTI_USER;
+ #else
+ iShareMode = XB_SINGLE_USER;
+ #endif
+
+}
+/******************************************************************************/
+//! @brief Deconstructor.
+xbLog::~xbLog(){
+ xbFclose();
+}
+/******************************************************************************/
+//! @brief Get the current log status
+/*!
+ \returns xbTrue - Logging turned on.<br>xbFalse - Logging turned off.
+*/
+xbBool xbLog::LogGetStatus(){
+ return bLoggingStatus;
+}
+/******************************************************************************/
+//! @brief Close the logfile.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbLog::LogClose(){
+ return xbFclose();
+}
+/******************************************************************************/
+//! @brief Set maximum log file size.
+/*!
+ \param lSize - New maximum log file size.
+ \returns void
+*/
+void xbLog::LogSetLogSize( size_t lSize ){
+ lLogSize = lSize;
+}
+/******************************************************************************/
+//! @brief Set log status.
+/*!
+ \param bStatus xbTrue - Turn logging on.<br>xbFalse - Turn logging off.
+ \returns void
+*/
+void xbLog::LogSetStatus( xbBool bStatus ){
+ bLoggingStatus = bStatus;
+}
+/******************************************************************************/
+//! @brief Open the logfile.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbLog::LogOpen(){
+ xbInt16 rc;
+ if(( rc = xbFopen( "a", iShareMode )) != XB_NO_ERROR )
+ return rc;
+ xbFTurnOffFileBuffering();
+ return XB_NO_ERROR;
+}
+/******************************************************************************/
+//! @brief Write a logfile message.
+/*!
+ \param sLogEntryData - Message to write to the logfile.
+ \param iOutputOption 0 - Write to logfile.<br>
+ 1 - Write to stdout.<br>
+ 2 - Write to both logfile and stdout.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbLog::LogWrite( const xbString &sLogEntryData, xbInt16 iOutputOption ){
+
+ if( bLoggingStatus == xbFalse ){ // logging turned off
+ return XB_NO_ERROR;
+ }
+ xbInt16 rc = 0;
+ if( iOutputOption != 1 && !FileIsOpen() ){
+ if(( rc = LogOpen()) != XB_NO_ERROR ){
+ fprintf( stderr, "Error - cant write to logfile\n" );
+ return rc;
+ }
+ }
+ if( iOutputOption != 1 && lLogSize < xbFtell()){
+ xbFputs( "Swapping to next log file" );
+ xbFclose();
+ xbString sBackupName;
+ sBackupName.Sprintf( "%s.bak", GetFqFileName().Str());
+ if( FileExists( sBackupName ))
+ xbRemove( sBackupName );
+
+ xbRename( GetFqFileName(), sBackupName );
+ xbFopen( "a", iShareMode );
+ }
+ xbString sTimeStamp;
+ xbString sFled; // formatted log entry data
+
+ if( iOutputOption != 1 ){
+ #ifdef HAVE__LOCALTIME64_S_F
+ __time64_t timer;
+ struct tm tb;
+ _time64( &timer );
+ _localtime64_s( &tb, &timer );
+ tb.tm_year += 1900;
+ tb.tm_mon++;
+ sTimeStamp.Sprintf( "%4d-%02d-%02d %02d:%02d:%02d", tb.tm_year, tb.tm_mon, tb.tm_mday, tb.tm_hour, tb.tm_min, tb.tm_sec );
+ #else
+ time_t timer;
+ struct tm *tb;
+ timer = time( NULL );
+ tb = localtime( &timer );
+ tb->tm_year += 1900;
+ tb->tm_mon++;
+ sTimeStamp.Sprintf( "%4d-%02d-%02d %02d:%02d:%02d", tb->tm_year, tb->tm_mon, tb->tm_mday, tb->tm_hour, tb->tm_min, tb->tm_sec );
+ #endif
+ sFled.Sprintf( "%s - %s\n", sTimeStamp.Str(), sLogEntryData.Str() );
+ }
+
+ switch( iOutputOption ){
+ case 0:
+ xbFputs( sFled );
+ break;
+ case 1:
+ std::cout << sLogEntryData << std::endl;
+ break;
+ case 2:
+ xbFputs( sFled );
+ std::cout << sLogEntryData << std::endl;
+ break;
+ }
+ return XB_NO_ERROR;
+}
+/******************************************************************************/
+//! @brief Write bytes to logfile.
+/*!
+ \param ulByteCnt - Number of bytes to write to logfile.
+ \param p - Pointer to data to write to logfile.
+ \returns XB_NO_ERROR
+*/
+
+xbInt16 xbLog::LogWriteBytes( xbUInt32 ulByteCnt, const char *p ){
+
+ if( bLoggingStatus == xbFalse ) // logging turned off
+ return XB_NO_ERROR;
+ const char *p2 = p;
+ xbFputc( '[' );
+ for( xbUInt32 l = 0; l < ulByteCnt; l++ )
+ xbFputc( *p2++ );
+ xbFputc( ']' );
+ return XB_NO_ERROR;
+}
+/******************************************************************************/
+} // namespace
+#endif // XB_LOGGING_ON
+
+
+
+
diff --git a/src/core/xbmemo.cpp b/src/core/xbmemo.cpp
new file mode 100755
index 0000000..02bdbbf
--- /dev/null
+++ b/src/core/xbmemo.cpp
@@ -0,0 +1,219 @@
+/* xbmemo.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
+
+ Base memo class
+*/
+
+#include "xbase.h"
+
+#ifdef XB_MEMO_SUPPORT
+
+namespace xb{
+
+/***********************************************************************/
+//! @brief Class Constructor.
+/*!
+ \param dbf Pointer to dbf construct.
+ \param sFileName Memo file name.
+*/
+
+xbMemo::xbMemo( xbDbf * dbf, xbString const &sFileName ) : xbFile( dbf->GetXbasePtr() ) {
+ this->dbf = dbf; /* pointer to the associated dbf class instance */
+ // xbase = dbf->GetXbasePtr(); /* pointer to the engine */
+ SetDirectory( dbf->GetDirectory());
+ SetFileName( sFileName );
+ mbb = NULL;
+ #ifdef XB_LOCKING_SUPPORT
+ bFileLocked = xbFalse;
+ #endif
+}
+/***********************************************************************/
+//! @brief Class Destructor.
+xbMemo::~xbMemo(){
+ if( mbb )
+ free( mbb );
+}
+/***********************************************************************/
+//! @brief Calculate the last data block number.
+/*!
+ \param ulLastDataBlock Output - Last used block number in the file.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbMemo::CalcLastDataBlock( xbUInt32 & ulLastDataBlock ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ if(( iRc = xbFseek( 0, SEEK_END )) != XB_NO_ERROR )
+ return iRc;
+
+ ulLastDataBlock = (xbUInt32) xbFtell() / (xbUInt32) GetBlockSize();
+ return XB_NO_ERROR;
+}
+/***********************************************************************/
+//! @brief Close the memo file.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbMemo::CloseMemoFile(){
+
+ if( mbb ){
+ free( mbb );
+ mbb = NULL;
+ }
+ return xbFclose();
+}
+
+
+/***********************************************************************/
+//! @brief Get memo file type.
+/*!
+ \returns 3 - Version 3 memo file.<br>
+ 4 - Version 4 memo file.
+*/
+xbInt16 xbMemo::GetMemoFileType(){
+ return iMemoFileType;
+}
+
+/***********************************************************************/
+//! @brief Get next block available from file header.
+/*!
+ \param ulBlockNo Output - Next block number for appending data to memo file.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbMemo::GetHdrNextBlock( xbUInt32 & ulBlockNo ){
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try{
+ if(( iRc = ReadDbtHeader( 0 )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ ulBlockNo = ulHdrNextBlock;
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbmemo::GetNextAvailableBlock() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+#ifdef XB_LOCKING_SUPPORT
+//! @brief Lock memo file
+/*!
+
+ \param iLockFunction XB_LOCK<br>XB_UNLOCK
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbMemo::LockMemo( xbInt16 iLockFunction ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ if( iLockFunction == XB_LOCK ){
+
+ if( bFileLocked ) // already locked
+ return XB_NO_ERROR;
+
+ if( dbf->GetLockFlavor() == LK_DBASE ){
+ iRc = xbLock( XB_LOCK, LK4026531838, 1 );
+ if( iRc != XB_NO_ERROR ){
+ if( iRc == XB_LOCK_FAILED )
+ return iRc;
+ else {
+ iErrorStop = 120;
+ throw iRc;
+ }
+ } else {
+ bFileLocked = xbTrue;
+ }
+ }
+ } else if( iLockFunction == XB_UNLOCK ){
+
+ if( !bFileLocked ) // already unlocked
+ return XB_NO_ERROR;
+
+ if( dbf->GetLockFlavor() == LK_DBASE ){
+ iRc = xbLock( XB_UNLOCK, LK4026531838, 1 );
+ if( iRc != XB_NO_ERROR ){
+ if( iRc == XB_LOCK_FAILED )
+ return iRc;
+ else {
+ iErrorStop = 140;
+ throw iRc;
+ }
+ } else {
+ bFileLocked = xbFalse;
+ }
+ }
+ } else {
+ iErrorStop = 300;
+ iRc = XB_INVALID_OPTION;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbmemo::LockMemoFile() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Get memo file lock status.
+/*!
+ \returns xbTrue - Memo file is locked.<br>
+ xbFalse - Memo file is not locked.
+*/
+xbBool xbMemo::GetMemoLocked() const {
+ return bFileLocked;
+}
+#endif
+
+/***********************************************************************/
+//! @brief Update Next Node number in file header
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbMemo::UpdateHeadNextNode(){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ try{
+ char buf[4];
+ ePutUInt32( buf, ulHdrNextBlock );
+ if(( iRc = xbFseek( 0, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ if(( iRc = xbFwrite( &buf, 4, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbmemo::UpdateHeadeNextNode() Exception Caught. Error Stop = [%d] iRc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+} /* namespace */
+#endif /* XB_MEMO_SUPPORT */
+
diff --git a/src/core/xbmemo3.cpp b/src/core/xbmemo3.cpp
new file mode 100755
index 0000000..b5494fb
--- /dev/null
+++ b/src/core/xbmemo3.cpp
@@ -0,0 +1,590 @@
+/* xbmemo3.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
+
+ This class is used for support dBASE V3 memo files
+
+*/
+
+#include "xbase.h"
+
+#ifdef XB_MEMO_SUPPORT
+#ifdef XB_DBF3_SUPPORT
+
+namespace xb{
+
+/***********************************************************************/
+//! @brief Class Constructor.
+/*!
+ \param dbf Pointer to dbf instance.
+ \param sFileName Memo file name.
+*/
+xbMemoDbt3::xbMemoDbt3( xbDbf * dbf, xbString const & sFileName ) : xbMemo( dbf, sFileName ){
+ iMemoFileType = 3;
+ SetBlockSize( 512 );
+}
+
+/***********************************************************************/
+//! @brief Class Deconstructor.
+xbMemoDbt3::~xbMemoDbt3(){}
+
+/***********************************************************************/
+//! @brief Abort.
+/*!
+ Abort any pending updates to the memo file.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbMemoDbt3::Abort(){
+ return XB_NO_ERROR;
+}/***********************************************************************/
+//! @brief Commit changes to memo file.
+/*!
+ \returns XB_NO_ERROR.
+*/
+xbInt16 xbMemoDbt3::Commit(){
+ return XB_NO_ERROR;
+}
+/***********************************************************************/
+//! @brief Create memo file.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbMemoDbt3::CreateMemoFile(){
+
+ xbInt16 rc = XB_NO_ERROR;
+ char cBuf[4];
+ if(( rc = xbFopen( "w+b", dbf->GetShareMode())) != XB_NO_ERROR )
+ return rc;
+ ulHdrNextBlock = 1L;
+ ePutUInt32( cBuf, ulHdrNextBlock );
+ if(( rc = xbFwrite( cBuf, 4, 1 ))!= XB_NO_ERROR ){
+ xbFclose();
+ return rc;
+ }
+ for(int i = 0; i < 12; i++ )
+ xbFputc( 0x00 );
+ xbFputc( 0x03 );
+ for(int i = 0; i < 495; i++ )
+ xbFputc( 0x00 );
+ if(( mbb = (void *) malloc( 512 )) == NULL ){
+ xbFclose();
+ return XB_NO_MEMORY;
+ }
+ return XB_NO_ERROR;
+}
+/***********************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+//! @brief Dump memo file header.
+/*!
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbMemoDbt3::DumpMemoFreeChain() {
+ std::cout << "Xbase version 3 file - no free block chain" << std::endl;
+ return XB_NO_ERROR;
+}
+
+//! @brief Dump memo file header.
+/*!
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbMemoDbt3::DumpMemoHeader(){
+ xbInt16 rc = XB_NO_ERROR;
+ xbUInt64 stFileSize;
+ if(( rc = ReadDbtHeader( 1 )) != XB_NO_ERROR )
+ return rc;
+ GetFileSize( stFileSize );
+ std::cout << "Version 3 Memo Header Info" << std::endl;
+ std::cout << "Memo File Name = " << GetFqFileName() << std::endl;
+ std::cout << "Next Available Block = " << ulHdrNextBlock << std::endl;
+ std::cout << "Memo File Version = " << (xbInt16) cVersion << " (";
+ BitDump( cVersion );
+ std::cout << ")" << std::endl;
+ std::cout << "Block Size = " << GetBlockSize() << std::endl;
+ std::cout << "File Size = " << stFileSize << std::endl;
+ std::cout << "Block Count = " << stFileSize / GetBlockSize() << std::endl;
+ return XB_NO_ERROR;
+}
+#endif // XB_DEBUG_SUPPORT
+/***********************************************************************/
+//! @brief Get a memo field for a given field number.
+/*!
+ \param iFieldNo Field number to retrieve data for.
+ \param sMemoData Output - string containing memo field data.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbMemoDbt3::GetMemoField( xbInt16 iFieldNo, xbString & sMemoData ){
+
+ xbInt16 iErrorStop = 0;
+ xbInt16 rc = XB_NO_ERROR;
+ xbUInt32 ulScnt;
+ char *sp, *spp;
+ xbUInt32 ulBlockNo;
+ xbBool bDone = xbFalse;
+ sMemoData = "";
+ try{
+ if(( rc = dbf->GetULongField( iFieldNo, ulBlockNo )) < XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw rc;
+ }
+ if( ulBlockNo == 0L ){
+ sMemoData = "";
+ return XB_NO_ERROR;
+ }
+ spp = NULL;
+ while( !bDone ){
+ if(( rc = ReadBlock( ulBlockNo++, GetBlockSize(), mbb )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw rc;
+ }
+ ulScnt = 0;
+ sp = (char *) mbb;
+ while( ulScnt < 512 && !bDone ){
+ if( *sp == 0x1a && *spp == 0x1a )
+ bDone = xbTrue;
+ else{
+ ulScnt++; spp = sp; sp++;
+ }
+ }
+ sMemoData.Append( (char *) mbb, ulScnt );
+ }
+ sMemoData.ZapTrailingChar( 0x1a );
+ }
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt3::GetMemoField() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+ return rc;
+}
+/***********************************************************************/
+//! @brief Get a memo field length for a given field number.
+/*!
+ \param iFieldNo Field number to retrieve data for.
+ \param ulFieldLen Output - length of memo field data.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbMemoDbt3::GetMemoFieldLen( xbInt16 iFieldNo, xbUInt32 & ulFieldLen ){
+
+ xbInt16 iErrorStop = 0;
+ xbInt16 rc = XB_NO_ERROR;
+ xbInt16 iScnt;
+ char *sp, *spp;
+ xbUInt32 ulBlockNo;
+ xbInt16 iNotDone;
+ try{
+ if(( rc = dbf->GetULongField( iFieldNo, ulBlockNo )) < XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw rc;
+ }
+ if( ulBlockNo == 0 ){
+ ulFieldLen = 0;
+ return XB_NO_ERROR;
+ }
+ ulFieldLen = 0L;
+ spp = NULL;
+ iNotDone = 1;
+ while( iNotDone ){
+ if(( rc = ReadBlock( ulBlockNo++, GetBlockSize(), mbb )) != XB_NO_ERROR ){
+ iErrorStop = 1;
+ throw rc;
+ }
+ iScnt = 0;
+ sp = (char *) mbb;
+ while( iScnt < 512 && iNotDone ){
+ if( *sp == 0x1a && *spp == 0x1a )
+ iNotDone = 0;
+ else{
+ ulFieldLen++; iScnt++; spp = sp; sp++;
+ }
+ }
+ }
+ if( ulFieldLen > 0 ) ulFieldLen--;
+ }
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt3::GetMemoFieldLen() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+ return rc;
+}
+/***********************************************************************/
+//! @brief Open memo file.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbMemoDbt3::OpenMemoFile() {
+ xbInt16 rc = XB_NO_ERROR;
+ if(( rc = xbFopen( dbf->GetOpenMode(), dbf->GetShareMode())) != XB_NO_ERROR )
+ return rc;
+ if(( mbb = (void *) malloc( 512 )) == NULL ){
+ xbFclose();
+ return XB_NO_MEMORY;
+ }
+ return XB_NO_ERROR;
+}
+/***********************************************************************/
+//! @brief Pack memo file.
+/*!
+ This routine frees up any unused blocks in the file resulting from field updates.
+ Version 3 memo files do not reclaim unused space (Version 4 files do).
+ This routine cleans up the unused space.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbMemoDbt3::PackMemo( void (*memoStatusFunc ) ( xbUInt32 ulItemNum, xbUInt32 ulNumItems ))
+{
+ xbInt16 iRc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ char * cBlock = NULL;
+
+ #ifdef XB_LOCKING_SUPPORT
+ xbInt16 iAutoLock = dbf->GetAutoLock();
+ xbBool bTableLocked = xbFalse;
+ xbBool bMemoLocked = xbFalse;
+ #endif
+
+ try{
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock && !dbf->GetTableLocked() ){
+ if(( iRc = dbf->LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ } else {
+ bTableLocked = xbTrue;
+ }
+ if(( iRc = LockMemo( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ } else {
+ bMemoLocked = xbTrue;
+ }
+ }
+ #endif
+
+ // create temp file
+ xbString sTempMemoName;
+ if(( iRc = CreateUniqueFileName( GetDirectory(), "dbt", sTempMemoName )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ xbMemoDbt3 *pMemo = new xbMemoDbt3( dbf, sTempMemoName );
+ if(( iRc = pMemo->CreateMemoFile()) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ // for dbase III, block size is always 512, don't need to reset it
+ // for each record in dbf
+ xbUInt32 ulRecCnt;
+ if(( iRc = dbf->GetRecordCnt( ulRecCnt )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ xbInt32 lFldCnt = dbf->GetFieldCnt();
+ char cFldType;
+ xbString sMemoFldData;
+
+ for( xbUInt32 ulI = 1; ulI <= ulRecCnt; ulI++ ){
+ if(( iRc = dbf->GetRecord( ulI )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ if( (void *) memoStatusFunc )
+ (*memoStatusFunc) ( ulI, ulRecCnt );
+
+ // for each memo field
+ for( xbInt32 lFc = 0; lFc < lFldCnt; lFc++ ){
+ if(( iRc = dbf->GetFieldType( lFc, cFldType )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ if( cFldType == 'M' ){
+ // copy it to work field
+ if(( iRc = dbf->GetMemoField( lFc, sMemoFldData )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ // write it to new field
+ if(( iRc = pMemo->UpdateMemoField( lFc, sMemoFldData )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw iRc;
+ }
+ }
+ }
+ }
+
+ //copy target back to source
+ xbUInt32 ulBlkSize = GetBlockSize();
+ xbUInt64 ullFileSize;
+ if(( iRc = pMemo->GetFileSize( ullFileSize )) != XB_NO_ERROR ){
+ iErrorStop = 80;
+ throw iRc;
+ }
+ // file size should be evenly divisible by block size
+ xbUInt32 ulBlkCnt;
+
+ if( ullFileSize % ulBlkSize ){
+ iErrorStop = 90;
+ throw iRc;
+ } else {
+ ulBlkCnt = (xbUInt32) (ullFileSize / ulBlkSize);
+ }
+ if(( iRc = xbTruncate( 0 )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+ if(( cBlock = (char *) malloc( (size_t) ulBlkSize )) == NULL ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ // can't rename files in a multiuser, cross platform environment, causes issues
+ // copy work table back to source table
+ for( xbUInt32 ulBc = 0; ulBc < ulBlkCnt; ulBc++ ){
+ if(( iRc = pMemo->ReadBlock( ulBc, ulBlkSize, cBlock )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ if(( iRc = WriteBlock( ulBc, ulBlkSize, cBlock )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ }
+ //close and delete target
+ if(( iRc = pMemo->xbFclose()) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+ if(( iRc = pMemo->xbRemove()) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+ free( cBlock );
+ delete pMemo;
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock && !dbf->GetTableLocked() ){
+ if(( iRc = dbf->LockTable( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 200;
+ throw iRc;
+ }
+ if(( iRc = LockMemo( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 210;
+ throw iRc;
+ }
+ }
+ #endif
+ }
+ catch (xbInt16 iRc ){
+ free( cBlock );
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( bTableLocked )
+ dbf->LockTable( XB_UNLOCK );
+ if( bMemoLocked )
+ LockMemo( XB_UNLOCK );
+ #endif
+
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt3::PackMemo() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+//! @brief Read dbt header file.
+/*!
+ \param iOption 0 --> read only first four bytes<br>
+ 1 --> read the entire thing
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbMemoDbt3::ReadDbtHeader( xbInt16 iOption ){
+ char *p;
+ char MemoBlock[20];
+ xbInt16 rc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbUInt32 ulReadSize;
+
+ try{
+ if( !FileIsOpen() ){
+ iErrorStop = 10;
+ rc = XB_NOT_OPEN;
+ throw rc;
+ }
+ if( iOption == 0 )
+ ulReadSize = 4;
+ else{
+ xbUInt64 stFileSize = 0;
+ if(( rc = GetFileSize( stFileSize )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw rc;
+ }
+ if( stFileSize < 4 ){
+ iErrorStop = 30;
+ rc = XB_INVALID_BLOCK_NO;
+ throw rc;
+ }
+ else if( stFileSize > 20 )
+ ulReadSize = 40;
+ else
+ ulReadSize = 4;
+ }
+ if( xbFseek( 0, SEEK_SET )){
+ iErrorStop = 50;
+ rc = XB_SEEK_ERROR;
+ throw rc;
+ }
+ if(( xbFread( &MemoBlock, ulReadSize, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ rc = XB_READ_ERROR;
+ throw rc;
+ }
+ p = MemoBlock;
+ ulHdrNextBlock = eGetUInt32( p );
+
+ if( iOption == 0)
+ return XB_NO_ERROR;
+
+ if( ulReadSize >= 20 ){
+ p+=16;
+ cVersion = *p;
+ }
+ }
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt3::ReadDbtHeader() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+ return rc;
+}
+/***********************************************************************/
+//! @brief Update header name.
+/*!
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbMemoDbt3::UpdateHeaderName(){
+ return XB_NO_ERROR;
+}
+/***********************************************************************/
+//! @brief Update a memo field for a given field number.
+/*!
+ \param iFieldNo Field number to update data for.
+ \param sMemoData Data to update memo field data with.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbMemoDbt3::UpdateMemoField( xbInt16 iFieldNo, const xbString & sMemoData ) {
+
+ xbInt16 iErrorStop = 0;
+ xbInt16 rc = XB_NO_ERROR;
+ try{
+ if( sMemoData == "" ){
+ if(( rc = dbf->PutField( iFieldNo, "" )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw rc;
+ }
+ } else {
+ xbUInt32 ulDataLen = sMemoData.Len() + 2;
+ xbUInt32 ulBlocksNeeded = (ulDataLen / 512) + 1;
+ xbUInt32 ulLastDataBlock;
+ if(( rc = CalcLastDataBlock( ulLastDataBlock )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw rc;
+ }
+ if(( rc = xbFseek( ((xbInt64) ulLastDataBlock * 512), SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw rc;
+ }
+ if(( rc = xbFwrite( sMemoData.Str(), sMemoData.Len(), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw rc;
+ }
+ if(( rc = xbFputc( 0x1a, 2 )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw rc;
+ }
+ if(( rc = xbFputc( 0x00, (xbInt32) ( ulBlocksNeeded * 512 ) - (xbInt32) ulDataLen )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw rc;
+ }
+ if(( rc = dbf->PutULongField( iFieldNo, ulLastDataBlock )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw rc;
+ }
+ ulHdrNextBlock = ulLastDataBlock + ulBlocksNeeded;
+ if(( rc = UpdateHeadNextNode()) != XB_NO_ERROR ){
+ iErrorStop = 80;
+ throw rc;
+ }
+ }
+ }
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt3::UpdateMemoField() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+ return rc;
+}
+
+/***********************************************************************/
+//! @brief Empty the memo file.
+/*!
+ This routine clears everything out of the file. It does not address the
+ block pointers on the dbf file.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbMemoDbt3::Zap(){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ char cBuf[4];
+
+ try{
+ ulHdrNextBlock = 1L;
+ ePutUInt32( cBuf, ulHdrNextBlock );
+
+ if(( iRc != xbFseek( 0, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ if(( iRc != xbFwrite( cBuf, 4, 1 ))!= XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ if(( iRc != xbTruncate( 512 )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt3::Zap() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+
+/***********************************************************************/
+} /* namespace */
+#endif /* XB_DBF3_SUPPORT */
+#endif /* XB_MEMO_SUPPORT */
diff --git a/src/core/xbmemo4.cpp b/src/core/xbmemo4.cpp
new file mode 100755
index 0000000..4f92d2b
--- /dev/null
+++ b/src/core/xbmemo4.cpp
@@ -0,0 +1,1372 @@
+/* xbmemo4.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
+
+ This class is used for support dBASE V4 memo files
+
+*/
+
+#include "xbase.h"
+
+#ifdef XB_MEMO_SUPPORT
+#ifdef XB_DBF4_SUPPORT
+
+namespace xb{
+
+/***********************************************************************/
+//! @brief Class Constructor.
+/*!
+ \param dbf Pointer to dbf instance.
+ \param sFileName Memo file name.
+*/
+xbMemoDbt4::xbMemoDbt4( xbDbf * dbf, xbString const & sFileName ) : xbMemo( dbf, sFileName ){
+ iMemoFileType = 4;
+ SetBlockSize( dbf->GetCreateMemoBlockSize() );
+}
+
+/***********************************************************************/
+//! @brief Class Deconstructor.
+xbMemoDbt4::~xbMemoDbt4(){}
+
+/***********************************************************************/
+//! @brief Abort.
+/*!
+ Abort any pending updates to the memo file.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbMemoDbt4::Abort(){
+
+ xbInt16 rc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbUInt32 ulBlockNo;
+
+ try{
+ xbUInt32 ulNodeCnt = llNewBlocks.GetNodeCnt();
+ for( xbUInt32 l = 0; l < ulNodeCnt; l++ ){
+ if(( rc = llNewBlocks.RemoveFromFront( ulBlockNo )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw rc;
+ }
+ if(( rc = FreeMemoBlockChain( ulBlockNo )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw rc;
+ }
+ }
+ llOldBlocks.Clear();
+ }
+
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::Abort() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+ return rc;
+}
+
+/***********************************************************************/
+//! @brief Commit changes to memo file.
+/*!
+ Commit any pending updates to the memo file.
+ \returns XB_NO_ERROR.
+*/
+xbInt16 xbMemoDbt4::Commit(){
+
+ xbInt16 rc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbUInt32 ulBlockNo;
+
+ try{
+ xbUInt32 ulNodeCnt = llOldBlocks.GetNodeCnt();
+ for( xbUInt32 l = 0; l < ulNodeCnt; l++ ){
+ if(( rc = llOldBlocks.RemoveFromFront( ulBlockNo )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw rc;
+ }
+ if(( rc = FreeMemoBlockChain( ulBlockNo )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw rc;
+ }
+ }
+ llNewBlocks.Clear();
+ }
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::Commit() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+ return rc;
+}
+/***********************************************************************/
+//! @brief Create memo file.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbMemoDbt4::CreateMemoFile(){
+
+ xbInt16 iErrorStop = 0;
+ xbInt16 rc = XB_NO_ERROR;
+ char cBuf[4];
+
+ try{
+ if(( rc = xbFopen( "w+b", dbf->GetShareMode() )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw rc;
+ }
+
+ ulHdrNextBlock = 1L;
+ ePutUInt32( cBuf, ulHdrNextBlock );
+ if(( rc = xbFwrite( cBuf, 4, 1 ))!= XB_NO_ERROR ){
+ iErrorStop = 20;
+ xbFclose();
+ throw rc;
+ }
+ for(int i = 0; i < 4; i++ )
+ xbFputc( 0x00 );
+ GetFileNamePart( sDbfFileNameWoExt );
+ sDbfFileNameWoExt.PadRight( ' ', 8 ); // need at least eight bytes of name
+ sDbfFileNameWoExt = sDbfFileNameWoExt.Mid( 1, 8 ); // need no more than eight bytes of name
+ for( int i = 1; i < 9; i++ )
+ xbFputc( sDbfFileNameWoExt[i] );
+
+ for(int i = 0; i < 4; i++ )
+ xbFputc( 0x00 );
+
+ ePutInt16( cBuf, GetBlockSize());
+ if(( rc = xbFwrite( cBuf, 2, 1 ))!= XB_NO_ERROR ){
+ iErrorStop = 60;
+ xbFclose();
+ throw rc;
+ }
+ for( xbUInt32 i = 0; i < (GetBlockSize() - 22); i++ )
+ xbFputc( 0x00 );
+ if(( mbb = (void *) malloc( GetBlockSize())) == NULL ){
+ rc = XB_NO_MEMORY;
+ iErrorStop = 80;
+ return XB_NO_MEMORY;
+ }
+ }
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::CreateMemoFile() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ xbFclose();
+ }
+ return rc;
+}
+/***********************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+//! @brief Dump memo file header.
+/*!
+ \returns XB_NO_ERROR
+*/
+
+xbInt16 xbMemoDbt4::DumpMemoFreeChain()
+{
+ xbInt16 rc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbUInt32 ulCurBlock, ulLastDataBlock;
+
+ try{
+ if(( rc = ReadDbtHeader(1)) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw rc;
+ }
+ if(( rc = CalcLastDataBlock( ulLastDataBlock )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw rc;
+ }
+
+ ulCurBlock = ulHdrNextBlock;
+ std::cout << "**********************************" << std::endl;
+ std::cout << "Head Node Next Block = " << ulCurBlock << std::endl;;
+ std::cout << "Total blocks in file = " << ulLastDataBlock << std::endl;
+
+ while( ulCurBlock < ulLastDataBlock ){
+ if(( rc = ReadBlockHeader( ulCurBlock, 2 )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw rc;
+ }
+ std::cout << "**********************************" << std::endl;
+ std::cout << "This Free Block = [" << ulCurBlock << "] contains [" << ulFreeBlockCnt << "] block(s)" << std::endl;
+ std::cout << "Next Free Block = [" << ulNextFreeBlock << "]" << std::endl;
+ ulCurBlock = ulNextFreeBlock;
+ }
+ }
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::UpdateMemoField() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+ return XB_NO_ERROR;
+}
+
+//! @brief Dump memo internals.
+/*!
+ \returns XB_NO_ERROR
+*/
+
+xbInt16 xbMemoDbt4::DumpMemoInternals() {
+
+ xbLinkListNode<xbUInt32> *llPtr;
+ xbInt16 iNodeCnt;
+
+ llPtr = llOldBlocks.GetHeadNode();
+ iNodeCnt = llOldBlocks.GetNodeCnt();
+
+ std::cout << "Link List Old Blocks - " << iNodeCnt << " nodes" << std::endl;
+ for( xbInt16 i = 0; i < iNodeCnt; i++ ){
+ std::cout << llPtr->GetKey() << ",";
+ llPtr = llPtr->GetNextNode();
+ }
+ std::cout << std::endl;
+
+ llPtr = llNewBlocks.GetHeadNode();
+ iNodeCnt = llNewBlocks.GetNodeCnt();
+ std::cout << "Link List New Blocks - " << iNodeCnt << " nodes" << std::endl;
+ for( xbInt16 i = 0; i < iNodeCnt; i++ ){
+ std::cout << llPtr->GetKey() << ",";
+ llPtr = llPtr->GetNextNode();
+ }
+ std::cout << std::endl;
+
+ return XB_NO_ERROR;
+}
+/***********************************************************************/
+//! @brief Dump memo file header.
+/*!
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbMemoDbt4::DumpMemoHeader(){
+
+ xbInt16 rc = XB_NO_ERROR;
+ xbUInt32 ulLastDataBlock;
+ CalcLastDataBlock( ulLastDataBlock );
+
+ if(( rc = ReadDbtHeader( 1 )) != XB_NO_ERROR )
+ return rc;
+ std::cout << "Version 4 Memo Header Info" << std::endl;
+ std::cout << "Memo File Name = " << GetFqFileName() << std::endl;
+ std::cout << "Hdr Next Avail Block = " << ulHdrNextBlock << std::endl;
+ std::cout << "Block Size = " << GetBlockSize() << std::endl;
+ std::cout << "Dbf File Name wo Ext = " << sDbfFileNameWoExt.Str() << std::endl;
+ std::cout << "Last Data Block = " << ulLastDataBlock << std::endl;
+ return rc;
+}
+#endif // XB_DEBUG_SUPPORT
+
+/************************************************************************/
+//! @brief Find an empty set of blocks in the free block chain
+/*!
+ This routine searches thruugh the free node chain in a dbase IV type
+ memo file searching for a place to grab some free blocks for reuse
+
+ \param ulBlocksNeeded The size to look in the chain for.
+ \param ulLastDataBlock is the last data block in the file, enter 0
+ for the routine to calculate it.
+ \param ulLocation The location it finds.
+ \param ulPreviousNode Block number of the node immediately previous to this node in the chain.<br>
+ 0 if header node
+ \param bFound Output xbFalse - Spot not found in chain.<br>
+ xbTrue - Spot found in chain.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbMemoDbt4::FindBlockSetInChain( xbUInt32 ulBlocksNeeded,
+ xbUInt32 &ulLastDataBlock, xbUInt32 &ulLocation, xbUInt32 &ulPrevNode, xbBool &bFound ){
+ xbInt16 rc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbUInt32 ulCurNode;
+
+ try{
+ ulPrevNode = 0L;
+ if( ulLastDataBlock == 0 ){
+ /* Determine last good data block */
+ if(( rc = CalcLastDataBlock( ulLastDataBlock )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw rc;
+ }
+ }
+ if( ulHdrNextBlock < ulLastDataBlock ){
+ ulCurNode = ulHdrNextBlock;
+
+ if(( rc = ReadBlockHeader( ulHdrNextBlock, 2 )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw rc;
+ }
+ while( ulBlocksNeeded > ulFreeBlockCnt && ulNextFreeBlock < ulLastDataBlock ){
+ ulPrevNode = ulCurNode;
+ ulCurNode = ulNextFreeBlock;
+ if(( rc = ReadBlockHeader( ulNextFreeBlock, 2 )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw rc;
+ }
+ }
+ if( ulBlocksNeeded <= ulFreeBlockCnt ){
+ ulLocation = ulCurNode;
+ // PreviousNode = lPrevNode;
+ bFound = xbTrue;
+ } else { // no data found and at end of chain
+ ulPrevNode = ulCurNode;
+ bFound = xbFalse;
+ }
+ } else {
+ bFound = xbFalse;
+ }
+ }
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::FindBlockSetInChain() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+ return rc;
+}
+/***********************************************************************/
+//! @brief Free a block.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbMemoDbt4::FreeMemoBlockChain( xbUInt32 ulBlockNo ){
+ xbUInt32 ulLastDataBlock;
+ return FreeMemoBlockChain( ulBlockNo, ulLastDataBlock );
+}
+
+/***********************************************************************/
+//! @brief Free a block.
+/*!
+ \param ulBlockNo The block number being deleted.
+ \param ulLastDataBlock Output - Last free block number,prior to this block.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbMemoDbt4::FreeMemoBlockChain( xbUInt32 ulBlockNo, xbUInt32 &ulLastDataBlock )
+{
+ xbInt16 rc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbUInt32 ulNoOfFreedBlocks;
+ xbUInt32 ulLastFreeBlock = 0;
+ xbUInt32 ulLastFreeBlockCnt = 0;
+ xbUInt32 ulSaveNextFreeBlock;
+
+ // iFieldNo - The field no m\bing deleted
+ // iBlockNo - The block number being deleted
+ // iNoOfFreeBlocks - The number of blocks being freed with this delete
+ // iLastDataBlock - The next block number to allocate if more blocks needed
+ // iHdrNextBlock - The head pointer in the main header block
+ // iNextFreeBlock - The block that is immediately following the current free block to be added
+ // iLastFreeBlock - Last free block number,prior to this block
+ // iLastFreeBlockCnt - Last free block number of blocks
+
+ try{
+
+ if( ulBlockNo <= 0 ){
+ iErrorStop = 10;
+ rc =XB_INVALID_BLOCK_NO;
+ throw rc;
+ }
+
+ /* Load the first block */
+ if(( rc = ReadBlockHeader( ulBlockNo, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw rc;
+ }
+
+ if( (ulFieldLen) % GetBlockSize() )
+ ulNoOfFreedBlocks = ((ulFieldLen) / GetBlockSize()) + 1L;
+ else
+ ulNoOfFreedBlocks = (ulFieldLen) / GetBlockSize();
+
+ /* Determine last good data block */
+ if(( rc = CalcLastDataBlock( ulLastDataBlock )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw rc;
+ }
+
+ if(( rc = ReadDbtHeader( 0 )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw rc;
+ }
+
+ // Not an empty node chain, position to correct location in chain
+ ulNextFreeBlock = ulHdrNextBlock;
+ while( ulBlockNo > ulNextFreeBlock && ulBlockNo < ulLastDataBlock ){
+ ulLastFreeBlock = ulNextFreeBlock;
+
+ if(( rc = ReadBlockHeader( ulNextFreeBlock, 2 )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ return rc;
+ }
+ ulLastFreeBlockCnt = ulFreeBlockCnt;
+ }
+
+ // One of two outcomes at this point
+ // A) This block is combined with the next free block chain, and points to the free chain after the next free block
+ // B) This block is not combined with the next free block chain, and points to the next block
+ // (which could be the last block
+
+ // should next block should be concatonated onto the end of this set?
+ ulSaveNextFreeBlock = ulNextFreeBlock;
+ if(( ulBlockNo + ulNoOfFreedBlocks ) == ulNextFreeBlock && ulNextFreeBlock < ulLastDataBlock ){
+ if(( rc = ReadBlockHeader( ulNextFreeBlock, 2 )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw rc;
+ }
+ ulNoOfFreedBlocks += ulFreeBlockCnt;
+ ulSaveNextFreeBlock = ulNextFreeBlock;
+ }
+
+ // if this is the first set of free blocks
+ if( ulLastFreeBlock == 0 ){
+ // 1 - write out the current block
+ // 2 - update header block
+ // 3 - write header block
+ // 4 - update data field
+
+ ePutUInt32( (char *) mbb, ulSaveNextFreeBlock );
+ ePutUInt32( (char *) mbb+4, ulNoOfFreedBlocks );
+ if(( rc = WriteBlock( ulBlockNo, 8, mbb )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw rc;
+ }
+
+ ulHdrNextBlock = ulBlockNo;
+ if(( rc = UpdateHeadNextNode()) != XB_NO_ERROR ){
+ iErrorStop = 80;
+ throw rc;
+ }
+ return XB_NO_ERROR;
+ }
+
+ /* determine if this block set should be added to the previous set */
+ if(( ulLastFreeBlockCnt + ulLastFreeBlock ) == ulBlockNo ){
+
+ if(( rc = ReadBlockHeader( ulLastFreeBlock, 2 )) != XB_NO_ERROR ){
+ iErrorStop = 90;
+ throw rc;
+ }
+ ulFreeBlockCnt += ulNoOfFreedBlocks;
+
+ ePutUInt32( (char *) mbb, ulSaveNextFreeBlock );
+ ePutUInt32( (char *) mbb+4, ulFreeBlockCnt );
+ if(( rc = WriteBlock( ulLastFreeBlock, 8, mbb )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw rc;
+ }
+ return XB_NO_ERROR;
+ }
+
+ /* insert into the chain */
+ /* 1 - set the next bucket on the current node */
+ /* 2 - write this node */
+ /* 3 - go to the previous node */
+ /* 4 - insert this nodes id into the previous node set */
+ /* 5 - write previous node */
+
+ ePutUInt32( (char *) mbb, ulSaveNextFreeBlock );
+ ePutUInt32( (char *) mbb+4, ulNoOfFreedBlocks );
+ if(( rc = WriteBlock( ulBlockNo, 8, mbb )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw rc;
+ }
+
+ if(( rc = ReadBlockHeader( ulLastFreeBlock, 2 )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw rc;
+ }
+
+ ePutUInt32( (char *) mbb, ulBlockNo );
+ if(( rc = WriteBlock( ulLastFreeBlock, 8, mbb )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw rc;
+ }
+
+ }
+
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::DeleteMemoField() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+
+ return rc;
+}
+
+
+/************************************************************************/
+//! @brief Get a set of blocks from the free block chain.
+/*!
+ This routine grabs a set of blocks out of the free block chain.
+
+ \param ulBlocksNeeded The number of blocks requested.
+ \param ulLocation
+ \param ulPrevNode
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+
+xbInt16 xbMemoDbt4::GetBlockSetFromChain( xbUInt32 ulBlocksNeeded,
+ xbUInt32 ulLocation, xbUInt32 ulPrevNode )
+
+{
+
+ xbInt16 rc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ xbUInt32 ulNextFreeBlock2;
+ xbUInt32 ulNewFreeBlocks;
+ xbUInt32 ulSaveNextFreeBlock;
+
+ try{
+ if(( rc = ReadBlockHeader( ulLocation, 2 )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw rc;
+ }
+
+ if( ulBlocksNeeded == ulFreeBlockCnt ){ // grab this whole set of blocks
+ if( ulPrevNode == 0 ){ // first in the chain
+ ulHdrNextBlock = ulNextFreeBlock;
+ if(( rc = UpdateHeadNextNode()) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw rc;
+ }
+ }
+ else // remove out of the middle or end
+ {
+ ulNextFreeBlock2 = ulNextFreeBlock;
+ if(( rc = ReadBlockHeader( ulPrevNode, 2 )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw rc;
+ }
+ ulNextFreeBlock = ulNextFreeBlock2;
+ if(( rc = WriteBlockHeader( ulPrevNode, 2 )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw rc;
+ }
+ }
+ } else { // only take a portion of this set
+ if( ulPrevNode == 0 ){ // first in the set
+ ulHdrNextBlock = ulLocation + ulBlocksNeeded;
+ if(( rc = UpdateHeadNextNode()) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw rc;
+ }
+ ulFreeBlockCnt -= ulBlocksNeeded;
+ if(( rc = WriteBlockHeader( ulHdrNextBlock, 2 )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw rc;
+ }
+
+ }
+ else { // remove out of the middle or end
+
+ ulNewFreeBlocks = ulFreeBlockCnt - ulBlocksNeeded;
+ ulSaveNextFreeBlock = ulNextFreeBlock;
+ ulNextFreeBlock2 = ulLocation + ulBlocksNeeded;
+
+ if(( rc = ReadBlockHeader( ulPrevNode, 2 )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw rc;
+ }
+
+ ulNextFreeBlock = ulNextFreeBlock2;
+ if(( rc = WriteBlockHeader( ulPrevNode, 2 )) != XB_NO_ERROR ){
+ iErrorStop = 80;
+ throw rc;
+ }
+ ulFreeBlockCnt = ulNewFreeBlocks;
+ ulNextFreeBlock = ulSaveNextFreeBlock;
+ if(( rc = WriteBlockHeader( ulNextFreeBlock2, 2 )) != XB_NO_ERROR ){
+ iErrorStop = 90;
+ throw rc;
+ }
+ }
+ }
+ }
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::GetBlockSetFromChain() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+ return rc;
+}
+
+/***********************************************************************/
+//! @brief Get a memo field for a given field number.
+/*!
+ \param iFieldNo Field number to retrieve data for.
+ \param sMemoData Output - string containing memo field data.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbMemoDbt4::GetMemoField( xbInt16 iFieldNo, xbString & sMemoData ){
+
+ xbUInt32 ulBlockNo;
+ xbUInt32 ulMemoFieldLen;
+ xbUInt32 ulMemoFieldDataLen;
+ xbInt16 rc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ char *p = NULL;
+
+ try{
+
+ if(( rc = GetMemoFieldLen( iFieldNo, ulMemoFieldLen, ulBlockNo )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw rc;
+ }
+
+ if( ulBlockNo == 0L || ulMemoFieldLen == 0L )
+ sMemoData = "";
+ else{
+ ulMemoFieldDataLen = ulMemoFieldLen - 8;
+
+ if(( p = (char *)calloc(1, ulMemoFieldDataLen+1)) == NULL ){
+ iErrorStop = 20;
+ rc = XB_NO_MEMORY;
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::GetMemoField() lBlockNo = %ld Data Len = [%ld]", ulBlockNo, ulMemoFieldDataLen + 1 );
+ xbase->WriteLogMessage( sMsg.Str() );
+ throw rc;
+ }
+
+ // go to the first block of the memo field, skip past the first 8 bytes
+ if(( xbFseek( ( ulBlockNo * GetBlockSize() + 8 ), SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ rc = XB_SEEK_ERROR;
+ throw rc;
+ }
+
+ // read the memo file data into buffer pointed to by "p"
+ if(( rc = xbFread( p, ulMemoFieldDataLen, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ rc = XB_READ_ERROR;
+ throw rc;
+ }
+
+ // null terminate the string
+ char *p2;
+ p2 = p + ulMemoFieldDataLen;
+ *p2 = 0x00;
+
+ // save it to the string
+ sMemoData.Set( p, ulMemoFieldDataLen + 1 );
+ free( p );
+ }
+
+ }
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::GetMemoField() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ if( p )
+ free( p );
+ }
+ return rc;
+}
+
+/***********************************************************************/
+//! @brief Get a memo field length for a given field number.
+/*!
+ \param iFieldNo Field number to retrieve data for.
+ \param ulMemoFieldLen Output - length of memo field data.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbMemoDbt4::GetMemoFieldLen( xbInt16 iFieldNo, xbUInt32 &ulMemoFieldLen ){
+ xbUInt32 ulBlockNo;
+ return GetMemoFieldLen( iFieldNo, ulMemoFieldLen, ulBlockNo );
+}
+
+/***********************************************************************/
+//! @brief Get a memo field length for a given field number.
+/*!
+ \param iFieldNo Field number to retrieve data for.
+ \param ulMemoFieldLen Output - length of memo field data.
+ \param ulBlockNo Output - Starting block number.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbMemoDbt4::GetMemoFieldLen( xbInt16 iFieldNo, xbUInt32 &ulMemoFieldLen, xbUInt32 &ulBlockNo ){
+
+ xbInt16 rc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+ char cFieldType;
+
+ try{
+
+ if(( rc = dbf->GetFieldType( iFieldNo, cFieldType )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw rc;
+ }
+ if( cFieldType != 'M' ){
+ iErrorStop = 20;
+ rc = XB_INVALID_MEMO_FIELD;
+ throw rc;
+ }
+ if(( rc = dbf->GetULongField( iFieldNo, ulBlockNo )) < XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw rc;
+ }
+
+ if( ulBlockNo < 1 ){
+ ulMemoFieldLen = 0;
+ return XB_NO_ERROR;
+ }
+
+ if(( rc = ReadBlockHeader( ulBlockNo, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw rc;
+ }
+ ulMemoFieldLen = ulFieldLen;
+
+ }
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::GetMemoFieldLen() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+ return rc;
+}
+
+/***********************************************************************/
+//! @brief Open memo file.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbMemoDbt4::OpenMemoFile() {
+
+ xbInt16 iErrorStop = 0;
+ xbInt16 rc = XB_NO_ERROR;
+
+ try{
+ if(( rc = xbFopen( dbf->GetOpenMode(), dbf->GetShareMode())) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw rc;
+ }
+ if(( rc = ReadDbtHeader( 1 )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw rc;
+ }
+ if(( mbb = (void *) malloc( GetBlockSize())) == NULL ){
+ xbFclose();
+ iErrorStop = 30;
+ rc = XB_NO_MEMORY;
+ throw rc;
+ }
+ }
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::OpenMemoFile() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+ return rc;
+}
+/***********************************************************************/
+//! @brief Pack memo file.
+/*!
+ This routine frees up any unused blocks in the file resulting from field updates.
+ Version 3 memo files do not reclaim unused space (Version 4 files do).
+ This routine cleans up the unused space.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbMemoDbt4::PackMemo( void (*memoStatusFunc ) ( xbUInt32 ulItemNum, xbUInt32 ulNumItems )){
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ char * cBlock = NULL;
+
+ #ifdef XB_LOCKING_SUPPORT
+ xbInt16 iAutoLock = dbf->GetAutoLock();
+ xbBool bTableLocked = xbFalse;
+ xbBool bMemoLocked = xbFalse;
+ #endif
+
+ try{
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock && !dbf->GetTableLocked() ){
+ if(( iRc = dbf->LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ } else {
+ bTableLocked = xbTrue;
+ }
+ if(( iRc = LockMemo( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ } else {
+ bMemoLocked = xbTrue;
+ }
+ }
+ #endif
+
+ // create temp file
+ xbString sTempMemoName;
+ if(( iRc = CreateUniqueFileName( GetDirectory(), "dbt", sTempMemoName )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ xbMemoDbt4 *pMemo = new xbMemoDbt4( dbf, sTempMemoName );
+ if(( iRc = pMemo->CreateMemoFile()) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ // for dbase III, block size is always 512, don't need to reset it
+ // for each record in dbf
+ xbUInt32 ulRecCnt;
+ if(( iRc = dbf->GetRecordCnt( ulRecCnt)) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ xbInt32 lFldCnt = dbf->GetFieldCnt();
+ char cFldType;
+ xbString sMemoFldData;
+
+ for( xbUInt32 ulI = 1; ulI <= ulRecCnt; ulI++ ){
+ if(( iRc = dbf->GetRecord( ulI )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+
+ if( (void *) memoStatusFunc)
+ (*memoStatusFunc)(ulI, ulRecCnt );
+
+ // for each memo field
+ for( xbInt32 lFc = 0; lFc < lFldCnt; lFc++ ){
+ if(( iRc = dbf->GetFieldType( lFc, cFldType )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ if( cFldType == 'M' ){
+ // copy it to work field
+ if(( iRc = dbf->GetMemoField( lFc, sMemoFldData )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ // write it to new field
+ if(( iRc = pMemo->UpdateMemoField( lFc, sMemoFldData )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw iRc;
+ }
+ }
+ }
+ }
+
+ //copy target back to source
+ xbUInt32 ulBlkSize = GetBlockSize();
+ xbUInt64 ullFileSize;
+ if(( iRc = pMemo->GetFileSize( ullFileSize )) != XB_NO_ERROR ){
+ iErrorStop = 80;
+ throw iRc;
+ }
+ // file size should be evenly divisible by block size
+ xbUInt32 ulBlkCnt;
+
+ if( ullFileSize % ulBlkSize ){
+ iErrorStop = 90;
+ throw iRc;
+ } else {
+ ulBlkCnt = (xbUInt32) (ullFileSize / ulBlkSize);
+ }
+ if(( iRc = xbTruncate( 0 )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+
+ if(( cBlock = (char *) malloc( ulBlkSize )) == NULL ){
+ iErrorStop = 110;
+ throw iRc;
+ }
+
+ // can't rename files in a multiuser, cross platform environment, causes issues
+ // copy work table back to source table
+
+ for( xbUInt32 ulBc = 0; ulBc < ulBlkCnt; ulBc++ ){
+ if(( iRc = pMemo->ReadBlock( ulBc, ulBlkSize, cBlock )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ if(( iRc = WriteBlock( ulBc, ulBlkSize, cBlock )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw iRc;
+ }
+ }
+
+ if(( xbFseek( 8, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ iRc = XB_SEEK_ERROR;
+ throw iRc;
+ }
+
+ for( int i = 1; i < 9; i++ )
+ xbFputc( sDbfFileNameWoExt[i] );
+
+ //close and delete target
+ if(( iRc = pMemo->xbFclose()) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw iRc;
+ }
+ if(( iRc = pMemo->xbRemove()) != XB_NO_ERROR ){
+ iErrorStop = 160;
+ throw iRc;
+ }
+ free( cBlock );
+ delete pMemo;
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( iAutoLock && !dbf->GetTableLocked() ){
+ if(( iRc = dbf->LockTable( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 200;
+ throw iRc;
+ }
+ if(( iRc = LockMemo( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 210;
+ throw iRc;
+ }
+ }
+ #endif
+ }
+ catch (xbInt16 iRc ){
+ free( cBlock );
+
+ #ifdef XB_LOCKING_SUPPORT
+ if( bTableLocked )
+ dbf->LockTable( XB_UNLOCK );
+ if( bMemoLocked )
+ LockMemo( XB_UNLOCK );
+ #endif
+
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::PackMemo() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/***********************************************************************/
+//! @brief Read block header.
+/*!
+ \param ulBlockNo Block to read
+ \param iOption 1 - Read fields option 1
+ 2 - Read fields option 2
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbMemoDbt4::ReadBlockHeader( xbUInt32 ulBlockNo, xbInt16 iOption ) {
+
+ xbInt16 rc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+
+ if(( rc = ReadBlock( ulBlockNo, 8, mbb )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ rc = XB_READ_ERROR;
+ }
+ if( iOption == 1 ){
+ iField1 = eGetInt16((char *) mbb );
+ iStartPos = eGetInt16((char *) mbb+2);
+ ulFieldLen = eGetUInt32((char *) mbb+4);
+ }
+ else if( iOption == 2 ){
+ ulNextFreeBlock = eGetUInt32((char *) mbb );
+ ulFreeBlockCnt = eGetUInt32((char *) mbb+4 );
+ }
+ else{
+ iErrorStop = 20;
+ rc = XB_INVALID_OPTION;
+ throw rc;
+ }
+ }
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::ReadBlockHeader() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+ return rc;
+}
+/***********************************************************************/
+//! @brief Read dbt header file.
+/*!
+ \param iOption 0 --> read only first four bytes<br>
+ 1 --> read the entire thing
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbMemoDbt4::ReadDbtHeader( xbInt16 iOption ) {
+
+ xbInt16 iErrorStop = 0;
+ xbInt16 rc = XB_NO_ERROR;
+ xbInt16 iReadLen = 0;
+ char *p;
+ char MemoBlock[22];
+
+ try{
+ if( !FileIsOpen() ){
+ iErrorStop = 10;
+ rc = XB_NOT_OPEN;
+ throw rc;
+ }
+ if( xbFseek( 0, SEEK_SET )){
+ iErrorStop = 20;
+ rc = XB_SEEK_ERROR;
+ throw rc;
+ }
+ if( iOption )
+ iReadLen = 22;
+ else
+ iReadLen = 4;
+
+ if(( xbFread( &MemoBlock, (size_t) iReadLen, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ rc = XB_READ_ERROR;
+ throw rc;
+ }
+
+ p = MemoBlock;
+ ulHdrNextBlock = eGetUInt32( p );
+ if( iOption == 0)
+ return XB_NO_ERROR;
+
+ p += 8;
+ sDbfFileNameWoExt = "";
+ for( int i = 0; i < 8; i++ )
+ sDbfFileNameWoExt += *p++;
+
+ p += 4;
+ SetBlockSize( (xbUInt32) eGetInt16( p ));
+
+ cVersion = MemoBlock[16];
+
+ }
+ catch (xbInt16 rc ){
+
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::ReadDbtHeader() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+ return rc;
+}
+
+/***********************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+//! @brief Read free block information from header.
+/*!
+ This routing pulls any reusable block information for file header.
+ Not used with version 3 memo files - stub.
+
+ \param ulBlockNo
+ \param ulNextBlock
+ \param ulFreeBlockCnt
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbMemoDbt4::ReadFreeBlockHeader( xbUInt32 ulBlockNo, xbUInt32 &ulNextBlock, xbUInt32 &ulFreeBlockCount ){
+
+ xbInt16 rc = XB_NO_ERROR;
+ rc = ReadBlockHeader( ulBlockNo, 2 );
+ ulNextBlock = ulNextFreeBlock;
+ ulFreeBlockCount = ulFreeBlockCnt;
+ return rc;
+}
+#endif
+/***********************************************************************/
+//! @brief Update header name.
+/*!
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbMemoDbt4::UpdateHeaderName() {
+
+ xbInt16 rc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ GetFileNamePart( sDbfFileNameWoExt );
+ sDbfFileNameWoExt.PadRight( ' ', 8 ); // need at least eight bytes of name
+ sDbfFileNameWoExt = sDbfFileNameWoExt.Mid( 1, 8 ); // need no more than eight bytes of name
+
+ try{
+ if(( rc = xbFseek( 8, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw rc;
+ }
+
+ for( int i = 1; i < 9; i++ ){
+ if(( rc = xbFputc( sDbfFileNameWoExt[i] )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw rc;
+ }
+ }
+ }
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::UpdateHeaderName() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+ return rc;
+}
+/***********************************************************************/
+//! @brief Update a memo field length for a given field number.
+/*!
+ \param iFieldNo Field number to update data for.
+ \param sMemoData Data to update memo field data with.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbMemoDbt4::UpdateMemoField( xbInt16 iFieldNo, const xbString & sMemoData ) {
+
+ xbInt16 iErrorStop = 0;
+ xbInt16 rc = XB_NO_ERROR;
+ xbUInt32 ulBlockNo;
+
+ try{
+
+ if(( rc = dbf->GetULongField( iFieldNo, ulBlockNo )) < XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw rc;
+ }
+
+ if( sMemoData == "" ){
+ if( ulBlockNo == 0 ){
+ /* if nothing to do, return */
+ return XB_NO_ERROR;
+ } else {
+
+ // if this is in the new blocks link list already, then this is not the first update for this memo field
+ // this would be second or third update on the field since the original change and not commited
+ // Since it won't be needed in either a Commmit() or Abort(), can be freed immediately
+ if( llNewBlocks.SearchFor( ulBlockNo ) > 0 ){
+ if(( rc = FreeMemoBlockChain( ulBlockNo )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw rc;
+ }
+ if(( llNewBlocks.RemoveByVal( ulBlockNo )) < XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw rc;
+ }
+ } else {
+ // first revision, save what it was in case of Abort() command
+ if(( llOldBlocks.InsertAtFront( ulBlockNo )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw rc;
+ }
+ }
+
+ if(( rc = dbf->PutField( iFieldNo, "" )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw rc;
+ }
+
+ }
+ } else {
+ // free up the old space
+ xbUInt32 ulLastDataBlock = 0L;
+
+ if( ulBlockNo > 0 ){
+ if( llNewBlocks.SearchFor( ulBlockNo ) > 0 ){
+
+ if(( rc = FreeMemoBlockChain( ulBlockNo, ulLastDataBlock )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw rc;
+ }
+ } else {
+ // first revision, save what it was in case of Abort() command
+ if(( rc = llOldBlocks.InsertAtFront( ulBlockNo )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw rc;
+ }
+ }
+ }
+ // should next line be unsigned 32 bit int?
+ xbUInt32 ulTotalLen = 8 + sMemoData.Len();
+ xbUInt32 ulBlocksNeeded;
+ if( ulTotalLen % GetBlockSize())
+ ulBlocksNeeded = ulTotalLen / GetBlockSize() + 1;
+ else
+ ulBlocksNeeded = ulTotalLen / GetBlockSize();
+
+ xbBool bUsedBlockFound;
+ xbUInt32 ulHeadBlock;
+ xbUInt32 ulPrevNode;
+ if(( rc = FindBlockSetInChain( ulBlocksNeeded, ulLastDataBlock, ulHeadBlock, ulPrevNode, bUsedBlockFound )) != XB_NO_ERROR ){
+ iErrorStop = 80;
+ throw rc;
+ }
+ iField1 = -1;
+ iStartPos = 8;
+ ulFieldLen = sMemoData.Len() + 8;
+
+ if( bUsedBlockFound ){
+
+ if(( rc = GetBlockSetFromChain( ulBlocksNeeded, ulHeadBlock, ulPrevNode )) != XB_NO_ERROR ){
+ iErrorStop = 90;
+ throw rc;
+ }
+
+ if(( rc = WriteBlockHeader( ulHeadBlock, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw rc;
+ }
+
+ if(( rc = xbFwrite( sMemoData.Str(), sMemoData.Len(), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw rc;
+ }
+
+ } else { // append to the end
+
+ if(( rc = WriteBlockHeader( ulLastDataBlock, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw rc;
+ }
+
+ if(( rc = xbFwrite( sMemoData.Str(), sMemoData.Len(), 1 )) != XB_NO_ERROR ){
+ iErrorStop = 130;
+ throw rc;
+ }
+
+ if(( rc = xbFputc( 0x00, (xbInt32)((ulBlocksNeeded * GetBlockSize()) - (sMemoData.Len() + 8)))) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw rc;
+ }
+
+ if( ulLastDataBlock == ulHdrNextBlock ){ // this is first node to be added to the node chain
+ ulHdrNextBlock += ulBlocksNeeded;
+ ulHeadBlock = ulLastDataBlock;
+ if(( rc = UpdateHeadNextNode()) != XB_NO_ERROR ){
+ iErrorStop = 150;
+ throw rc;
+ }
+
+ } else { // adding memo data to the end of the file, but chain exists
+
+ ulNextFreeBlock = ulLastDataBlock + ulBlocksNeeded;
+ ulHeadBlock = ulLastDataBlock;
+ if(( rc = WriteBlockHeader( ulPrevNode, 2 )) != XB_NO_ERROR ){
+ iErrorStop = 160;
+ throw rc;
+ }
+ }
+ }
+
+ if(( rc = llNewBlocks.InsertAtFront( ulHeadBlock )) != XB_NO_ERROR ){ // In case of Abort(), this block needs to be freed
+ iErrorStop = 170;
+ throw rc;
+ }
+ if(( rc = dbf->PutLongField( iFieldNo, (xbInt32) ulHeadBlock )) != XB_NO_ERROR ){
+ iErrorStop = 180;
+ throw rc;
+ }
+ }
+ }
+
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::UpdateMemoField() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+
+ return rc;
+}
+/***********************************************************************/
+//! @brief Write block header.
+/*!
+ \param ulBlockNo Block to read
+ \param iOption 1 - Read fields option 1
+ 2 - Read fields option 2
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbMemoDbt4::WriteBlockHeader( xbUInt32 ulBlockNo, xbInt16 iOption ) {
+
+ xbInt16 rc = XB_NO_ERROR;
+ xbInt16 iErrorStop = 0;
+
+ try{
+ if( iOption == 1 ){
+ ePutInt16 ((char *) mbb, iField1 );
+ ePutInt16 ((char *) mbb+2, iStartPos );
+ ePutUInt32((char *) mbb+4, ulFieldLen );
+ }
+ else if( iOption == 2 ){
+ ePutUInt32((char *) mbb, ulNextFreeBlock );
+ ePutUInt32((char *) mbb+4, ulFreeBlockCnt );
+ }
+ else{
+ iErrorStop = 10;
+ rc = XB_INVALID_OPTION;
+ throw rc;
+ }
+
+ if(( rc = WriteBlock( ulBlockNo, 8, mbb )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ rc = XB_READ_ERROR;
+ }
+ }
+ catch (xbInt16 rc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::WriteHeader() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, rc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( rc ));
+ }
+ return rc;
+}
+/***********************************************************************/
+//! @brief Empty the memo file.
+/*!
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbMemoDbt4::Zap(){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ char cBuf[4];
+ try{
+ ulHdrNextBlock = 1L;
+ ePutUInt32( cBuf, ulHdrNextBlock );
+
+ if(( iRc != xbFseek( 0, SEEK_SET )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ if(( iRc != xbFwrite( cBuf, 4, 1 ))!= XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ if(( iRc != xbTruncate( GetBlockSize())) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ }
+
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbMemoDbt4::Zap() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}/***********************************************************************/
+} /* namespace */
+#endif /* XB_DBF4_SUPPORT */
+#endif /* XB_MEMO_SUPPORT */
+
diff --git a/src/core/xbssv.cpp b/src/core/xbssv.cpp
new file mode 100755
index 0000000..c595f6b
--- /dev/null
+++ b/src/core/xbssv.cpp
@@ -0,0 +1,550 @@
+/* xbssv.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"
+
+
+
+namespace xb{
+
+const xbErrorMessage xbErrorMessages[] = {
+ { XB_NO_ERROR, "No Error" },
+ { XB_NO_MEMORY, "No Memory" },
+ { XB_INVALID_OPTION, "Invalid Option" },
+ { XB_DUP_TABLE_OR_ALIAS, "Duplicate Alias/Table Name" },
+ { XB_INVALID_NODELINK, "Invalid Node Link" },
+ { XB_KEY_NOT_UNIQUE, "Key Not Unique" },
+ { XB_FILE_EXISTS, "File Already Exists" },
+ { XB_ALREADY_OPEN, "Database already open" },
+ { XB_DBF_FILE_NOT_OPEN, "DBF File Not Open" },
+ { XB_FILE_NOT_FOUND, "File not found" },
+ { XB_FILE_TYPE_NOT_SUPPORTED, "Not an Xbase type database" },
+ { XB_RENAME_ERROR, "Unable to rename file" },
+ { XB_INVALID_OBJECT, "Invalid Object" },
+ { XB_NOT_OPEN, "Database not open" },
+ { XB_NOT_FOUND, "Not Found" },
+ { XB_OPEN_ERROR, "Open Error" },
+ { XB_CLOSE_ERROR, "Close Error" },
+ { XB_SEEK_ERROR, "Seek Error" },
+ { XB_READ_ERROR, "Read Error" },
+ { XB_WRITE_ERROR, "Error writing to disk drive" },
+ { XB_EOF, "End Of File" },
+ { XB_BOF, "Beginning Of File" },
+ { XB_INVALID_BLOCK_SIZE, "Invalid Block Size" },
+ { XB_INVALID_BLOCK_NO, "Invalid Block Number" },
+ { XB_INVALID_RECORD, "Invalid Record Number" },
+ { XB_DELETE_FAILED, "Delete Failed" },
+ { XB_INVALID_TABLE_NAME, "Invalid Table Name" },
+ { XB_EMPTY, "Empty Table or Index" },
+ { XB_LIMIT_REACHED, "Limit Reached" },
+ { XB_INVALID_FIELD_TYPE, "Unknown Field Type" },
+ { XB_INVALID_FIELD_NO, "Invalid Field Number" },
+ { XB_INVALID_DATA, "Invalid Data" },
+ { XB_INVALID_FIELD_NAME, "Invalid Field Name" },
+ { XB_INVALID_MEMO_FIELD, "Not a Memo field" },
+ { XB_INVALID_FIELD, "Invalid Field" },
+ { XB_INVALID_FIELD_LEN, "Invalid Field Length" },
+ { XB_INVALID_DATE, "Invalid Date" },
+ { XB_INVALID_LOCK_OPTION, "Invalid Lock Option" },
+ { XB_LOCK_FAILED, "Lock Failed" },
+ { XB_TABLE_NOT_LOCKED, "Table Not Locked" },
+ { XB_PARSE_ERROR, "Parse Error" },
+ { XB_INVALID_FUNCTION, "Invalid or Undefined Function" },
+ { XB_INVALID_PARM, "Invalid Parm" },
+ { XB_INCONSISTENT_PARM_LENS, "Inconsistent parm lengths" },
+ { XB_INCOMPATIBLE_OPERANDS, "Incompatible operands" },
+ { XB_UNBALANCED_PARENS, "Unbalanced Parens" },
+ { XB_UNBALANCED_QUOTES, "Unbalanced Quotes" },
+ { XB_INVALID_EXPRESSION, "Invalid expression" },
+ { XB_INVALID_KEYNO, "Invalid Key Number" },
+ { XB_INVALID_INDEX, "Index File Error" },
+ { XB_INVALID_TAG, "Invalid index tag" },
+ { XB_SYNTAX_ERROR, "Invalid SQL Syntax" },
+ { XB_MAX_ERROR_NO, "End of Error List" }
+};
+// see also xbretcod.h
+
+
+xbInt16 xbSsv::iEndianType = 0;
+xbString xbSsv::sDefaultDateFormat = "MM/DD/YY";
+
+xbInt16 xbSsv::iDefaultFileVersion = 4;
+xbString xbSsv::sNullString = "";
+xbBool xbSsv::bDefaultAutoCommit = xbTrue;
+
+
+#ifdef WIN32
+xbString xbSsv::sDataDirectory = PROJECT_DATA_DIR;
+#else
+xbString xbSsv::sDataDirectory = PROJECT_DATA_DIR;
+#endif
+
+#ifdef XB_LOGGING_SUPPORT
+xbString xbSsv::sDefaultLogDirectory = PROJECT_LOG_DIR;
+xbString xbSsv::sDefaultLogFileName = PROJECT_DFLT_LOGFILE;
+#endif
+
+#ifdef XB_LOCKING_SUPPORT
+xbInt32 xbSsv::lDefaultLockWait = 100;
+xbInt16 xbSsv::iDefaultLockRetries = 3;
+xbBool xbSsv::bDefaultAutoLock = xbTrue;
+xbInt16 xbSsv::iDefaultLockFlavor = 1;
+xbBool xbSsv::bMultiUser = xbTrue;
+#else
+xbBool xbSsv::bMultiUser = xbFalse;
+#endif
+
+#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
+
+
+#ifdef XB_MDX_SUPPORT
+xbInt16 xbSsv::iCreateMdxBlockSize = 1024; // 1024 is DBase 7 default size for MDX index blocks
+#endif
+
+
+/*************************************************************************/
+//! @brief Class Constructor.
+xbSsv::xbSsv(){}
+/*************************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+void xbSsv::BitDump( unsigned char c ) const {
+ for( int i = 7; i >= 0; i-- )
+ std::cout << (BitSet( c, i ) ? 1 : 0);
+}
+void xbSsv::BitDump( char c ) const {
+ BitDump( (unsigned char) c );
+}
+#endif
+/*************************************************************************/
+//! @brief Check a bit in a one byte field and see if it is set.
+/*!
+ \param c One byte char field to examine.
+ \param iBitNo which bit to examine.
+ \returns xbTrue Bit is set<br>
+ xbFalse Bit is not set
+*/
+xbBool xbSsv::BitSet( unsigned char c, xbInt16 iBitNo ) const {
+ return c & 1 << iBitNo;
+}
+
+/*************************************************************************/
+//! @brief Display error message on console for a given error number.
+/*!
+ \param iErrorCode Error number to reference
+*/
+void xbSsv::DisplayError( xbInt16 iErrorCode ) const {
+ std::cout << (const char *) GetErrorMessage( iErrorCode ) << std::endl;
+}
+/*************************************************************************/
+//! @brief Get the default auto commit setting.
+/*!
+
+ When auto commit is enabled, the library will automatically post any updates
+ when moving off an updated record or closing files.
+ If auto commit is disabled, the application program will need to explicitly
+ update the tables using using dbf->Put() and dbf->AppendRecord().
+
+ \returns xbTrue if auto commit is turned on<br>
+ xbFalse is auto commit is turned off
+*/
+
+xbBool xbSsv::GetDefaultAutoCommit() const {
+ return bDefaultAutoCommit;
+}
+
+/*************************************************************************/
+//! @brief Get the current data directory.
+/*!
+ \returns xbString containing the current data directory
+ where the database files are stored.
+*/
+
+xbString &xbSsv::GetDataDirectory() const {
+ return sDataDirectory;
+}
+/*************************************************************************/
+//! @brief Get the default date format.
+/*!
+ \returns xbString containing the default date format.
+*/
+
+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.
+/*!
+ \returns B - Big endian<br>
+ L - Little endian<br>
+*/
+xbInt16 xbSsv::GetEndianType() const {
+ return iEndianType;
+}
+
+/*************************************************************************/
+//! @brief Get an error message.
+/*!
+ \param iErrorCode ErrorCode is the error number of description to be returned.
+ \returns Returns a pointer to a string containing a text description for the error code.
+*/
+
+const char * xbSsv::GetErrorMessage( xbInt16 iErrorCode ) const{
+
+ if( iErrorCode > 0 || iErrorCode <= XB_MAX_ERROR_NO )
+ return "";
+
+ xbBool bFound = xbFalse;
+ xbInt16 iCtr = 0;
+ while( !bFound ){
+ if( xbErrorMessages[iCtr].iErrorNo == XB_MAX_ERROR_NO )
+ return "Unknown Error";
+ if( xbErrorMessages[iCtr].iErrorNo == iErrorCode )
+ return xbErrorMessages[iCtr].sErrorText;
+ iCtr++;
+ }
+ return "";
+}
+
+/*************************************************************************/
+//! @brief Set the data directory.
+/*!
+ \param sDataDirectory Set the data direcroty.
+*/
+
+void xbSsv::SetDataDirectory( const xbString &sDataDirectory ){
+ this->sDataDirectory = sDataDirectory;
+
+
+ #ifdef WIN32
+ this->sDataDirectory.SwapChars( '/', '\\' );
+ #else
+ this->sDataDirectory.SwapChars( '\\', '/' );
+ #endif
+
+}
+
+/*************************************************************************/
+//! @brief Set the default date format.
+/*!
+ \param sDefaultDateFormat Set the default date format.
+*/
+
+void xbSsv::SetDefaultDateFormat( const xbString &sDefaultDateFormat ) {
+ this->sDefaultDateFormat = sDefaultDateFormat;
+}
+
+/*************************************************************************/
+//! @brief Set the default auto commit.
+/*!
+
+ Disabling auto commit requires the application execute explicit updates
+ using dbf->Put() and dbf->AppendRecord(). With auto commit on, the library
+ posts updates automatically when moving off the current record or closing
+ a file.
+
+ \param bDefaultAutoCommit xbTrue - Enable default auto commit.<br>
+ xbFalse - Disable default auto commit.<br>
+*/
+
+void xbSsv::SetDefaultAutoCommit( xbBool bDefaultAutoCommit ) {
+ this->bDefaultAutoCommit = bDefaultAutoCommit;
+}
+/*************************************************************************/
+//! @brief Set the endian type
+/*!
+ This routine determines the Endian-ness at run time instead of
+ compile time as some processers (ie; Sparc,ARM) can be switched either way.
+ This routine is called automatically by the library at startup and does not
+ need to be called in an application program.
+
+*/
+
+void xbSsv::SetEndianType() {
+ xbInt16 e = 1;
+ iEndianType = *(char *) &e;
+ if( iEndianType )
+ iEndianType = 'L';
+ else
+ iEndianType = 'B';
+ return;
+}
+
+/*************************************************************************/
+#ifdef XB_LOGGING_SUPPORT
+
+//! @brief Get the default log file name.
+/*!
+ \returns Returns the log file name.
+*/
+xbString & xbSsv::GetDefaultLogFileName() const {
+ return sDefaultLogFileName;
+}
+
+
+/*************************************************************************/
+//! @brief Get the default log directory.
+/*!
+ \returns Returns the log directory.
+*/
+xbString & xbSsv::GetDefaultLogDirectory() const {
+ return sDefaultLogDirectory;
+}
+
+
+/*************************************************************************/
+//! @brief Set the default log directory name.
+/*!
+ \param sDefaultLogDirectory Name of desired log directory.
+
+*/
+void xbSsv::SetDefaultLogDirectory( const xbString &sDefaultLogDirectory ){
+
+ this->sDefaultLogDirectory = sDefaultLogDirectory;
+
+ #ifdef WIN32
+ this->sDefaultLogDirectory.SwapChars( '/', '\\' );
+ #else
+ this->sDefaultLogDirectory.SwapChars( '\\', '/' );
+ #endif
+
+
+}
+
+#else
+
+xbString & xbSsv::GetDefaultLogFileName() const {
+ return sNullString;
+}
+
+xbString & xbSsv::GetDefaultLogDirectory() const {
+ return sNullString;
+}
+
+void xbSsv::SetDefaultLogDirectory( const xbString &sDefaultLogDirectory ){
+ return;
+}
+
+#endif
+
+
+/*************************************************************************/
+
+#ifdef XB_LOCKING_SUPPORT
+
+//! @brief Get the default lock retries.
+/*!
+ This is the number of lock attempts the libary will make before returning
+ failure if the file can not be locked.
+ \returns Default lock retry count.
+*/
+xbInt16 xbSsv::GetDefaultLockRetries() const {
+ return iDefaultLockRetries;
+}
+
+//! @brief Set the default lock retries.
+/*!
+ \param iDefaultLockRetries - Number of lock attempts before returning failure.
+*/
+void xbSsv::SetDefaultLockRetries( xbInt16 iDefaultLockRetries ) {
+ this->iDefaultLockRetries = iDefaultLockRetries;
+}
+
+//! @brief Get the default auto lock setting.
+/*!
+ When auto locking is turned on, the library automatically locks and unlocks
+ files and indices as needed in a multi user environment.
+ \returns Number of lock attempt settings.
+*/
+xbBool xbSsv::GetDefaultAutoLock() const {
+ return bDefaultAutoLock;
+}
+
+
+//! @brief Set the default auto lock setting.
+/*!
+ When auto locking is turned on, the library automatically locks and unlocks
+ files and indices as needed in a multi user environment. Locking is not required
+ in single a single user environment.
+
+ \param bDefaultAutoLock xbTrue - Turn autolocking on<br>
+ xbFalse - Turn autolocking off<br>
+*/
+void xbSsv::SetDefaultAutoLock( xbBool bDefaultAutoLock ) {
+ this->bDefaultAutoLock = bDefaultAutoLock;
+}
+
+//! @brief Enable default auto locking.
+/*!
+ When auto locking is turned on, the library automatically locks and unlocks
+ files and indices as needed in a multi user environment.
+*/
+void xbSsv::EnableDefaultAutoLock() {
+ this->bDefaultAutoLock = xbTrue;
+}
+
+//! @brief Disable defalt auto locking.
+/*!
+ When auto locking is turned off, the library does not automatically lock
+ and unlock files and indices as needed in a multi user environment.
+ Locking is not needed in a single user environment.
+
+*/
+void xbSsv::DisableDefaultAutoLock() {
+ this->bDefaultAutoLock = xbFalse;
+}
+/***************************************************************************/
+//! @brief Get default lock flavor
+/*!
+ Currently one flavor. This routine is part of the structure to support
+ future additional locking scenarios for Clipper and Foxpro.
+ \returns 1
+*/
+xbInt16 xbSsv::GetDefaultLockFlavor() const {
+ return iDefaultLockFlavor;
+}
+
+/***************************************************************************/
+//! @brief Set default lock flavor
+/*!
+ Currently one flavor. This routine is part of the structure to support
+ future additional locking scenarios for Clipper and Foxpro.
+*/
+void xbSsv::SetDefaultLockFlavor( xbInt16 iDefaultLockFlavor ) {
+ this->iDefaultLockFlavor = iDefaultLockFlavor;
+}
+
+/***************************************************************************/
+//! @brief Set default lock wait
+/*!
+ \param lLockWait Set default lock wait in milliseconds.
+*/
+void xbSsv::SetDefaultLockWait( xbInt32 lLockWait ) {
+ this->lDefaultLockWait = lLockWait;
+}
+
+/***************************************************************************/
+//! @brief Get default lock wait
+/*!
+ \returns Lock wait time in milliseconds.
+
+*/
+xbInt32 xbSsv::GetDefaultLockWait() const {
+ return lDefaultLockWait;
+}
+#endif
+
+/***************************************************************************/
+//! @brief Get the multi user setting.
+/*!
+ \returns xbTrue - Multi user mode turned on.<br>
+ xbFalse - Multi user mode turned off.<br>
+*/
+xbBool xbSsv::GetMultiUser() const {
+ return bMultiUser;
+}
+
+//! @brief Get the multi user setting.
+/*!
+ \param bMultiUser xbTrue - Turn on Multi user mode.<br>
+ xbFalse - Turn off Multi user mode.<br>
+*/
+void xbSsv::SetMultiUser( xbBool bMultiUser ) {
+ this->bMultiUser = bMultiUser;
+}
+
+
+
+/************************************************************************/
+#ifdef XB_MDX_SUPPORT
+//! @brief Get the mdx file block size used when creating a memo file.
+/*!
+ \returns system default setting for MDX block size.
+*/
+xbInt16 xbSsv::GetCreateMdxBlockSize() const {
+ return iCreateMdxBlockSize;
+}
+
+/************************************************************************/
+//! @brief Create mdx block size.
+/*!
+ This routine sets the mdx file block size at the system level. This value is
+ used when the mdx index file is initially created so if you want to change it,
+ this must be called before creating the table.
+
+ \param iBlockSize - Block size, must be evenly divisible by 512 and <= 16384
+ \returns XB_INVALID_BLOCK_SIZE<br>XB_NO_ERROR
+*/
+
+xbInt16 xbSsv::SetCreateMdxBlockSize( xbInt16 iBlockSize ){
+
+ if( iBlockSize < 512 || iBlockSize > 16384 || iBlockSize % 512 )
+ return XB_INVALID_BLOCK_SIZE;
+ else
+ iCreateMdxBlockSize = iBlockSize;
+
+ return XB_NO_ERROR;
+}
+#endif
+
+/************************************************************************/
+#if defined (XB_NDX_SUPPORT) || defined (XB_MDX_SUPPORT)
+//! @brief Get Unique Key Opt
+/*!
+ This routine returns the Unique Key Processing Option which is one of:
+ XB_HALT_ON_DUPKEY
+ XB_EMULATE_DBASE
+*/
+
+xbInt16 xbSsv::GetUniqueKeyOpt() const {
+ return iUniqueKeyOpt;
+}
+
+//! @brief Set Unique Key Opt
+/*! @brief Set Unique Key Opt
+ This routine Sets the Unique Key Processing Option which is one of:
+ XB_HALT_ON_DUPKEY
+ XB_EMULATE_DBASE
+*/
+xbInt16 xbSsv::SetUniqueKeyOpt( xbInt16 iOpt ){
+ if( iOpt == XB_HALT_ON_DUPKEY || iOpt == XB_EMULATE_DBASE ){
+ iUniqueKeyOpt = iOpt;
+ return XB_NO_ERROR;
+ } else {
+ return XB_INVALID_OPTION;
+ }
+}
+#endif
+/************************************************************************/
+
+
+
+
+} /* namespace */ \ No newline at end of file
diff --git a/src/core/xbstring.cpp b/src/core/xbstring.cpp
new file mode 100755
index 0000000..872062f
--- /dev/null
+++ b/src/core/xbstring.cpp
@@ -0,0 +1,1839 @@
+/* xbstring.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2021,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
+
+*/
+
+//#ifdef __GNU LesserG__
+// #pragma implementation "xbstring.h"
+//#endif
+
+#include "xbase.h"
+
+
+namespace xb{
+
+XBDLLEXPORT const char * xbString::NullString = "";
+XBDLLEXPORT char xbString::cJunkBuf;
+
+/************************************************************************/
+//! @brief Destructor
+
+xbString::~xbString(){
+ if (data != NULL)
+ free(data);
+
+}
+
+/************************************************************************/
+//! @brief Constructor
+/*!
+ \param ulSize - Allocation size. The allocation size is normally handled internally
+ by the class, but it can be set in this constructor.
+*/
+xbString::xbString(xbUInt32 ulSize) {
+ data = (char *)calloc(1, ulSize);
+ this->size = ulSize;
+// memset( data, 0x00, ulSize ); - redundant, initialized by calloc
+}
+/************************************************************************/
+//! @brief Constructor
+/*!
+ \param c - Initialize string to c.
+*/
+xbString::xbString(char c) {
+ data = (char *)calloc(1, 2);
+ data[0] = c;
+ data[1] = 0;
+ size = 2;
+}
+/************************************************************************/
+//! @brief Constructor
+/*!
+ \param s - Initialize string to s.
+*/
+xbString::xbString( const char *s ) {
+
+ if( s == NULL ){
+ size = 0;
+ data = NULL;
+ } else {
+ size = (xbUInt32) (strlen(s) + 1 );
+ data = (char *) calloc( 1, size );
+ xb_strcpy( data, s );
+ }
+ // ctor(s);
+}
+/************************************************************************/
+//! @brief Constructor
+/*!
+ \param d - Initiailize string to d.
+*/
+xbString::xbString( xbDouble d ) {
+ data = NULL;
+ size = 0;
+ Sprintf("%f", d);
+}
+/************************************************************************/
+//! @brief Constructor
+/*!
+ \param s Initialize string to s.
+ \param ulMaxLen Maximum length of string. Truncate any characters greater than ulMaxLen.
+*/
+xbString::xbString( const char *s, xbUInt32 ulMaxLen ) {
+ xbUInt32 sSize = (xbUInt32) strlen( s );
+ if( sSize < ulMaxLen )
+ size = sSize;
+ else
+ size = ulMaxLen;
+ data = (char *)calloc(1, size+1);
+ for( xbUInt32 i = 0; i < size; i++ )
+ data[i] = s[i];
+ data[size] = '\0';
+ size++; // account for null trailing byte
+ return;
+}
+/************************************************************************/
+//! @brief Constructor
+/*!
+ \param s Initialize string to s.
+*/
+xbString::xbString( const xbString &s ) {
+ ctor(s.Str());
+}
+
+/************************************************************************/
+//! @brief Operator const char *
+/*!
+ \returns Pointer to string data.
+*/
+xbString::operator const char *() const {
+ return data ? data : NullString;
+}
+
+/************************************************************************/
+//! @brief Set operator =
+/*!
+ \param s - Set the string to the string on the right of the equal sign.
+*/
+xbString &xbString::operator=( const xbString &s ) {
+ return Set(s);
+}
+/************************************************************************/
+//! @brief Set operator =
+/*!
+ \param s - Set the string to the string on the right of the equal sign.
+*/
+xbString &xbString::operator=( const char *s ) {
+ return Set(s);
+}
+
+/************************************************************************/
+//! @brief Stream insertion operator <<
+/*!
+ std::cout << MyString << std::endl;
+
+ \param os Output stream
+ \param s String to send to output stream
+*/
+std::ostream& operator<< ( std::ostream& os, const xbString & s ) {
+ return os << s.Str();
+}
+/************************************************************************/
+//! @brief Append operator +=
+/*!
+ \param s - Append s to the string.
+*/
+xbString &xbString::operator+=( const xbString &s ) {
+
+ if (s.IsNull())
+ return (*this);
+
+ xbUInt32 Len = s.Len();
+ xbUInt32 oldLen = this->Len();
+ xbUInt32 newLen = Len + oldLen;
+
+ data = (char *)realloc(data, newLen+1);
+ if( !data )
+ return (*this);
+
+ if(oldLen == 0)
+ data[0] = 0;
+
+ char *t = data;
+ t+= oldLen;
+ for( xbUInt32 i = 0; i < Len; i++ )
+ *t++ = s.GetCharacter(i+1);
+
+ data[newLen] = '\0';
+ size += Len;
+
+ return (*this);
+}
+/************************************************************************/
+//! @brief Append operator +=
+/*!
+ \param s - Append s to the string.
+*/
+xbString &xbString::operator+=( const char *s ) {
+
+ if (s == NULL)
+ return (*this);
+ xbUInt32 Len = (xbUInt32) strlen(s);
+ xbUInt32 oldLen = this->Len();
+ xbUInt32 newLen = Len + oldLen;
+ data = (char *)realloc(data, newLen+1);
+ if(oldLen == 0)
+ data[0] = 0;
+ for( xbUInt32 i = 0; i < Len; i++ )
+ data[i+oldLen] = s[i];
+ data[newLen] = '\0';
+ size += Len;
+ return (*this);
+}
+/************************************************************************/
+//! @brief Append operator +=
+/*!
+ \param c - Append c to the string.
+*/
+xbString &xbString::operator+=( char c ) {
+ xbUInt32 Len = 1;
+ xbUInt32 oldLen = this->Len();
+ data = (char *)realloc(data, oldLen+Len+1);
+ data[oldLen] = c;
+ data[oldLen+1] = 0;
+ size++;
+ return (*this);
+}
+/************************************************************************/
+//! @brief Append operator -=
+/*!
+ Append s to the right of this string, right trimming both strings.
+ \param s - Append s to the right of the string value.
+*/
+xbString &xbString::operator-=( const xbString &s ) {
+
+ Rtrim();
+ if (s.IsNull())
+ return (*this);
+ xbUInt32 Len = s.Len();
+ xbUInt32 oldLen = this->Len();
+ xbUInt32 newLen = Len + oldLen;
+
+ data = (char *)realloc(data, newLen+1);
+ if(oldLen == 0)
+ data[0] = 0;
+
+ for( xbUInt32 i = 0; i < Len; i++ )
+ data[i+oldLen] = s.GetCharacter(i+1);
+
+ data[newLen] = '\0';
+ size += Len;
+ Rtrim();
+ return (*this);
+}
+/************************************************************************/
+//! @brief Append operator -=
+/*!
+ Append s to the right of this string, right trimming both strings.
+ \param s - Append s to the right of the string value.
+*/
+xbString &xbString::operator-=(const char *s) {
+
+ Rtrim();
+ if (s == NULL)
+ return (*this);
+ xbUInt32 Len = (xbUInt32) strlen(s);
+ xbUInt32 oldLen = this->Len();
+ xbUInt32 newLen = Len + oldLen;
+
+ data = (char *)realloc(data, newLen+1);
+
+ if(oldLen == 0)
+ data[0] = 0;
+
+ for( xbUInt32 i = 0; i < Len; i++ )
+ data[i+oldLen] = s[i];
+ data[newLen] = '\0';
+
+ size += Len;
+ Rtrim();
+ return (*this);
+}
+/************************************************************************/
+//! @brief Append operator -=
+/*!
+ Append c to the right of this string, trimming right space on this string first.
+ \param c - Append s to the right of the string value.
+*/
+xbString &xbString::operator-=(const char c) {
+ Rtrim();
+ xbUInt32 oldSize = size;
+ size += 1;
+ data = (char *)realloc( data, size );
+ if( oldSize == 0 ) data[0] = 0;
+ data[size-2] = c;
+ data[size-1] = 0;
+ Trim();
+ return (*this);
+}
+/************************************************************************/
+//! @brief Concatonate operator -
+/*!
+ Concatonate left string with right string returning reference to new string.
+ Both strings are trimmed.
+
+ \param s1 Right string operator.
+*/
+xbString xbString::operator-(const xbString &s1) {
+ xbString tmp( data );
+ tmp -= s1;
+ return tmp;
+}
+/************************************************************************/
+//! @brief Concatonate operator +
+/*!
+ Concatonate left string with right string returning reference to new string.
+
+ \param s1 Right string operator.
+*/
+xbString xbString::operator+( const char *s1) {
+ xbString tmp( data );
+ tmp += s1;
+ return tmp;
+}
+/************************************************************************/
+//! @brief Concatonate operator +
+/*!
+ Concatonate left string with right string returning reference to new string.
+
+ \param s1 Right string operator.
+*/
+xbString xbString::operator+( const xbString &s1) {
+ xbString tmp( data );
+ tmp += s1;
+ return tmp;
+}
+/************************************************************************/
+//! @brief Concatonate operator +
+/*!
+ Concatonate left string with right string returning reference to new string.
+
+ \param c Right string operator.
+*/
+
+xbString xbString::operator+( const char c) {
+ xbString tmp( data );
+ tmp += c;
+ return tmp;
+}
+/************************************************************************/
+//! @brief operator []
+/*!
+ \param n - Offset into the string of the byte to retrieve.
+ \returns c - The character to return from the offset within the [] brackets.
+*/
+char &xbString::operator[]( xbUInt32 n ) const {
+ if( n > 0 && n <= size )
+ return data[n-1];
+ else
+ return cJunkBuf;
+}
+/************************************************************************/
+//! @brief operator []
+/*!
+ \param n - Offset into the string of the byte to retrieve.
+ \returns c - The character to return from the offset within the [] brackets.
+*/
+char &xbString::operator[]( xbInt32 n ) const {
+ if( n > 0 && n <= (xbInt32) size )
+ return data[n-1];
+ else
+ return cJunkBuf;
+}
+/************************************************************************/
+//! @brief operator ==
+/*!
+ \param s String to compare
+ \returns xbTrue - Strings match.<br>
+ zbFalse - Strings don't match.<br>
+
+*/
+xbBool xbString::operator==( const xbString &s ) const {
+
+ if( data == NULL || data[0] == 0 ) {
+ if( s.data == NULL || s.data[0] == 0 )
+ return true;
+ return false;
+ } else {
+ if( s.data == NULL || s.data[0] == 0 )
+ return false;
+ return( strcmp(data,s.data) == 0 ? xbTrue : xbFalse );
+ }
+}
+/************************************************************************/
+//! @brief operator ==
+/*!
+ \param s String to compare
+ \returns xbTrue - Strings match.<br>
+ zbFalse - Strings don't match.<br>
+*/
+xbBool xbString::operator==( const char *s ) const {
+
+ if (s == NULL) {
+ if ( data == NULL)
+ return true;
+ return false;
+ }
+ if ((s[0] == 0) && data == NULL)
+ return true;
+ if ( data == NULL)
+ return false;
+ return( strcmp( data, s) == 0 ? xbTrue : xbFalse );
+}
+/************************************************************************/
+//! @brief operator !=
+/*!
+ \param s String to compare
+ \returns xbTrue - Strings don't match.<br>
+ xbFalse - Strings match.<br>
+*/
+xbBool xbString::operator!=( const xbString &s ) const {
+ if( data == NULL || data[0] == 0 ) {
+ if( s.data == NULL || s.data[0] == 0 )
+ return xbFalse; // NULL != NULL
+ return xbTrue; // NULL != !NULL
+ } else {
+ if( s.data == NULL || s.data[0] == 0 )
+ return xbTrue; // !NULL != NULL
+ return( strcmp( data, s.data ) != 0 ? xbTrue : xbFalse ); // !NULL != !NULL
+ }
+}
+/************************************************************************/
+//! @brief operator !=
+/*!
+ \param s String to compare
+ \returns xbTrue - Strings don't match.<br>
+ zbFalse - Strings match.<br>
+*/
+xbBool xbString::operator!=( const char *s ) const {
+ if( s == NULL || s[0] == 0 ) {
+ if( data == NULL || data[0] == 0 )
+ return xbFalse; // NULL != NULL
+ return xbTrue; // NULL != !NULL
+ } else {
+ if( s == NULL || s[0] == 0 )
+ return xbTrue; // !NULL != NULL
+ return( strcmp( data, s ) != 0 ? xbTrue : xbFalse ); // !NULL != !NULL
+ }
+}
+/************************************************************************/
+//! @brief operator <
+/*!
+ \param s String to compare
+ \returns xbTrue - Left string is less than the right string.<br>
+ zbFalse - Left string is not less than the right string.<br>
+*/
+xbBool xbString::operator< ( const xbString &s ) const {
+
+ if( data == NULL || data[0] == 0 ) {
+ if( s.data == NULL || s.data[0] == 0 )
+ return false;
+ return true;
+ } else {
+ if( s.data == NULL || s.data[0] == 0 )
+ return false;
+ return ( strcmp(data, s.data) < 0 ? xbTrue : xbFalse );
+ }
+}
+/************************************************************************/
+//! @brief operator >
+/*!
+ \param s String to compare
+ \returns xbTrue - Left string is greater than the right string.<br>
+ zbFalse - Left string is not greater than the right string.<br>
+*/
+xbBool xbString::operator> ( const xbString &s ) const {
+ if( data == NULL || data[0] == 0 ) {
+ if( s.data == NULL || s.data[0] == 0 )
+ return false;
+ return false;
+ } else {
+ if( s.data == NULL || s.data[0] == 0 )
+ return true;
+ return( strcmp(data,s.data) > 0 ? xbTrue : xbFalse );
+ }
+}
+/************************************************************************/
+//! @brief operator <=
+/*!
+ \param s String to compare
+ \returns xbTrue - Left string is less than or equal to the right string.<br>
+ zbFalse - Left string is not less than or equal to the right string.<br>
+*/
+xbBool xbString::operator<=( const xbString &s ) const {
+ if( data == NULL || data[0] == 0 ) {
+ if( s.data == NULL || s.data[0] == 0 )
+ return true;
+ return true;
+ } else {
+ if( s.data == NULL || s.data[0] == 0 )
+ return false;
+ return( strcmp(data,s.data) <= 0 ? xbTrue : xbFalse );
+ }
+}
+/************************************************************************/
+//! @brief operator >=
+/*!
+ \param s String to compare
+ \returns xbTrue - Left string is greater than or equal to the right string.<br>
+ zbFalse - Left string is not greater than or equal to the right string.<br>
+*/
+xbBool xbString::operator>=( const xbString &s ) const {
+ if( data == NULL || data[0] == 0 ) {
+ if( s.data == NULL || s.data[0] == 0 )
+ return true;
+ return false;
+ } else {
+ if( s.data == NULL || s.data[0] == 0 )
+ return true;
+ return( strcmp(data, s.data) >= 0 ? xbTrue : xbFalse );
+ }
+}
+
+/************************************************************************/
+//! @brief Add a prefixing back slash to specified characters in the string.
+/*!
+ \param c Character to prefix with a backslash.
+ \returns Reference to this string.
+*/
+xbString &xbString::AddBackSlash( char c ) {
+
+ xbUInt32 lCnt = CountChar( c );
+ if( lCnt == 0 )
+ return *this;
+ char *p;
+ if(( p = (char *)calloc( 1, size + lCnt )) == NULL )
+ return *this;
+
+ char *p2 = p;
+ for( xbUInt32 lS = 0; lS < size; lS++ ){
+ if( data[lS] == c )
+ *p2++ = '\\';
+ *p2++ = data[lS];
+ }
+ if( data )
+ free( data );
+ data = p;
+ size += lCnt;
+ return *this;
+}
+/************************************************************************/
+//! @brief Append data to string.
+/*!
+ \param s String data to append.
+ \returns Reference to this string.
+*/
+xbString &xbString::Append( const xbString &s ) {
+ *this += s;
+ return *this;
+}
+
+/************************************************************************/
+//! @brief Append data to string.
+/*!
+ \param s String data to append.
+ \returns Reference to this string.
+*/
+xbString &xbString::Append( const char *s ) {
+ *this += s;
+ return *this;
+}
+/************************************************************************/
+//! @brief Append data to string.
+/*!
+ \param c String data to append.
+ \returns Reference to this string.
+*/
+xbString &xbString::Append( char c ) {
+ *this += c;
+ return *this;
+}
+/************************************************************************/
+//! @brief Append data to string.
+/*!
+ \param s String data to append.
+ \param ulByteCount Maximum number of bytes to append.
+ \returns Reference to this string.
+*/
+xbString &xbString::Append( const char *s, xbUInt32 ulByteCount ) {
+
+ if (s == NULL) return (*this);
+ xbUInt32 oldLen = this->Len();
+ xbUInt32 newLen = ulByteCount + oldLen;
+
+ data = (char *)realloc(data, newLen+1);
+
+ if(oldLen == 0)
+ data[0] = 0;
+
+ for( xbUInt32 i = 0; i < ulByteCount; i++ )
+ data[i+oldLen] = s[i];
+
+ data[newLen] = '\0';
+ size += ulByteCount;
+ return (*this);
+}
+
+/************************************************************************/
+//! @brief Assign portion of string.
+/*!
+ \param sStr - Source string for copy operation. sStr needs to be a Null terminated string.
+ \param ulStartPos - Starting position within source string.
+ \param ulCopyLen - Length of data to copy.
+ \returns Reference to this string.
+*/
+xbString &xbString::Assign(const char * sStr, xbUInt32 ulStartPos, xbUInt32 ulCopyLen){
+ if(data){
+ free(data);
+ data = 0;
+ size = 0;
+ }
+ xbUInt32 lLen = (xbUInt32) strlen( sStr );
+ if( ulStartPos > lLen ){
+ size = 0;
+ return( *this );
+ }
+ if((( ulCopyLen - 1) + ulStartPos ) > lLen )
+ ulCopyLen = lLen - ulStartPos + 1;
+ data = (char *)calloc(1, ulCopyLen + 1);
+ size = ulCopyLen;
+ for( xbUInt32 i = 0; i < ulCopyLen; i++ )
+ data[i] = sStr[i + ulStartPos - ((xbUInt32) 1)];
+ data[ulCopyLen] = '\0';
+ return (*this);
+}
+/************************************************************************/
+//! @brief Assign portion of string.
+/*!
+ \param sStr - Source string for copy operation. sStr needs to be a Null terminated string.
+ \param ulStartPos - Starting position within source string.
+ \returns Reference to this string.
+*/
+xbString &xbString::Assign(const char * sStr, xbUInt32 ulStartPos){
+ if(data){
+ free(data);
+ data = 0;
+ size = 0;
+ }
+ xbUInt32 ulSrcLen = (xbUInt32) strlen( sStr );
+ if( ulStartPos > ulSrcLen ){
+ size = 0;
+ return( *this );
+ }
+ xbUInt32 ulCopyLen;
+ ulCopyLen = ulSrcLen - ulStartPos + 1;
+ data = (char *)calloc(1, ulCopyLen + 1);
+ size = ulCopyLen;
+ for( xbUInt32 i = 0; i < ulCopyLen; i++ )
+ data[i] = sStr[i + ulStartPos - ((xbUInt32) 1)];
+ data[ulCopyLen] = '\0';
+ return (*this);
+}
+
+/************************************************************************/
+//! @brief Assign portion of string.
+/*!
+ \param sStr - Source string for copy operation. sStr needs to be a Null terminated string.
+ \param ulStartPos - Starting position within source string.
+ \param ulCopyLen - Length of data to copy.
+ \returns Reference to this string.
+*/
+xbString &xbString::Assign(const xbString& sStr, xbUInt32 ulStartPos, xbUInt32 ulCopyLen){
+ if(data){
+ free(data);
+ data = 0;
+ size = 0;
+ }
+ xbUInt32 ulSrcLen = sStr.Len();
+ if( ulStartPos > ulSrcLen ){
+ size = 0;
+ return( *this );
+ }
+ if((( ulCopyLen - 1) + ulStartPos ) > ulSrcLen )
+ ulCopyLen = ulSrcLen - ulStartPos + 1;
+ data = (char *)calloc(1, ulCopyLen + 1);
+ size = ulCopyLen;
+ for( xbUInt32 i = 0; i < ulCopyLen; i++ )
+ data[i] = sStr[i + ulStartPos];
+ data[ulCopyLen] = '\0';
+ return (*this);
+}
+/************************************************************************/
+//! @brief Assign portion of string.
+/*!
+ \param sStr - Source string for copy operation. sStr needs to be a Null terminated string.
+ \param ulStartPos - Starting position within source string.
+ \returns Reference to this string.
+*/
+xbString &xbString::Assign(const xbString& sStr, xbUInt32 ulStartPos){
+ if(data){
+ free(data);
+ data = 0;
+ size = 0;
+ }
+ xbUInt32 ulSrcLen = sStr.Len();
+ if( ulStartPos > ulSrcLen ){
+ size = 0;
+ return( *this );
+ }
+ xbUInt32 ulCopyLen;
+ ulCopyLen = ulSrcLen - ulStartPos + 1;
+ data = (char *)calloc(1, ulCopyLen + 1);
+ size = ulCopyLen;
+ for( xbUInt32 i = 0; i < ulCopyLen; i++ )
+ data[i] = sStr[i + ulStartPos];
+ data[ulCopyLen] = '\0';
+ return (*this);
+}
+/************************************************************************/
+//! @brief Copy a string
+/*!
+ \returns xbString.
+*/
+xbString xbString::Copy() const {
+ return( *this );
+}
+/************************************************************************/
+//! @brief Count the number of characters in the string.
+/*!
+ \param c Character to count.
+ \param iOpt 0 - Count the number of characters.<br>
+ 1 - Count the number of characters not between single or double quotes.
+ \returns The number of characters.
+*/
+xbUInt32 xbString::CountChar( char c, xbInt16 iOpt ) const {
+ if( iOpt == 0 )
+ return CountChar( c );
+ else{
+ xbBool bSingleQuote = xbFalse;
+ xbBool bDoubleQuote = xbFalse;
+ char cPrevChar = 0x00;
+ xbUInt32 i,j;
+ for( i = 0, j = 0; i < size; i++ ){
+ if( bSingleQuote && data[i] == '\'' && cPrevChar != '\\' ){
+ bSingleQuote = xbFalse;
+ }
+ else if( bDoubleQuote && data[i] == '"' && cPrevChar != '\\' ){
+ bDoubleQuote = xbFalse;
+ }
+ else if( data[i] == '\'' && cPrevChar != '\\' && !bDoubleQuote ){
+ bSingleQuote = xbTrue;
+ }
+ else if( data[i] == '"' && cPrevChar != '\\' && !bSingleQuote ){
+ bDoubleQuote = xbTrue;
+ }
+ else if( !bDoubleQuote && !bSingleQuote && data[i] == c ){
+ j++;
+ }
+ cPrevChar = data[i];
+ }
+ return j;
+ }
+}
+/************************************************************************/
+//! @brief Count the number of characters in the string.
+/*!
+ \param c Character to count.
+ \returns The number of characters.
+*/
+xbUInt32 xbString::CountChar( char c ) const {
+ xbUInt32 i,j;
+ for( i = 0,j = 0; i < size; i++ )
+ if( data[i] == c )
+ j++;
+ return j;
+}
+/************************************************************************/
+void xbString::ctor( const char *s ) {
+
+ // this routine assumes it was called by one of the constructors.
+
+ if (s == NULL) {
+ data = NULL;
+ size = 0;
+ return;
+ }
+
+ size = (xbUInt32) (strlen(s) + 1);
+ data = (char *) calloc( 1, size);
+
+ xb_strcpy(data, s);
+}
+/************************************************************************/
+//! @brief Convert hex character to string.
+/*!
+ This routine converts a four byte string in the format of 0x00 to a one byte char value.
+ The first four bytes of the string must be in the format 0x00.
+ Anything past the first four bytes is disregarded.
+
+ \param cOut Output character.
+ \returns XB_INVALID_PARM on error<br>
+ XB_NO_ERROR on success.
+*/
+xbInt16 xbString::CvtHexChar( char &cOut ){
+
+ int j, k;
+ char c;
+
+ if( Len() < 4 || data[0] != '0' || (data[1]!='X' && data[1]!='x' ))
+ return XB_INVALID_PARM;
+
+ c = (char) toupper( data[2] );
+ j = ( c > '9' ? c - 'A' + 10 : c - '0' );
+ c = (char)toupper( data[3] );
+ k = ( c > '9' ? c - 'A' + 10 : c - '0' );
+ j = ( j << 4 ) + k;
+
+ cOut = ( char ) j;
+ return XB_NO_ERROR;
+}
+/************************************************************************/
+//! @brief Convert string of hex characters to string.
+/*!
+
+ This routine converts a string of four byte format of 0x00 to a string of one byte chars.
+
+ \param sOut Output string of converted characters.
+ \returns XB_INVALID_PARM on error<br>
+ XB_NO_ERROR on success.
+*/
+xbInt16 xbString::CvtHexString( xbString &sOut ){
+ char c;
+ xbString ws;
+ ws = data;
+ sOut = "";
+ xbInt16 iRc;
+ while( ws.Len()){
+ if(( iRc= ws.CvtHexChar( c )) != XB_NO_ERROR )
+ return iRc;
+ sOut += c;
+ ws.Ltrunc( 4 );
+ }
+ return XB_NO_ERROR;
+}
+/************************************************************************/
+//! @brief Convert string to xbUInt64 number
+/*!
+ \param ullOut - output unsigned long long.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbString::CvtULongLong( xbUInt64 &ullOut ){
+
+ // version 1 - fast, but no data checking
+ ullOut = 0;
+ char *s = data;
+ int i = 0;
+ while( *s ){
+ ullOut *= 10;
+ ullOut += (xbUInt64) *s - '0';
+ s++;
+ i++;
+ }
+ return XB_NO_ERROR;
+}
+/************************************************************************/
+//! @brief Convert string to xbInt64 number
+/*!
+ \param llOut - output long long.
+ \returns XB_NO_ERROR
+*/
+xbInt16 xbString::CvtLongLong( xbInt64 &llOut ){
+
+ // version 1 - fast, but no data checking
+ llOut = 0;
+ char *s = data;
+ int i = 0;
+ while( *s ){
+ llOut *= 10;
+ llOut += (xbInt64) *s - '0';
+ s++;
+ i++;
+ }
+ return XB_NO_ERROR;
+}
+
+/************************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+void xbString::Dump( const char * title, xbInt16 iHexOption ) const {
+ fprintf(stdout, "%s StringSize[%d] DataLen=[%d] data=[%s]\n", title, size, Len(), data );
+ if( iHexOption ){
+ std::cout << "Hex values" << std::endl;
+ for( xbUInt32 i = 0; i < strlen( data ); i++ )
+ printf( " %x", data[i] );
+ std::cout << std::endl;
+ }
+}
+void xbString::Dump( const char * title ) const {
+ Dump( title, 0 );
+}
+
+void xbString::DumpHex( const char * title ) const {
+ Dump( title, 1 );
+}
+#endif
+
+/************************************************************************/
+//! @brief Extract an element out of a delimited string.
+/*!
+ \param pSrc Source string.
+ \param cDelim Delimiter.
+ \param lSkipCnt Number of delimiters to skip.
+ \param iOpt 0 - ignore single and double quotes.<br>
+ 1 - ignore delimiters between single or double quotes.
+ \returns Reference to string extracted from element.
+*/
+xbString &xbString::ExtractElement( const char *pSrc, char cDelim, xbUInt32 lSkipCnt, xbInt16 iOpt )
+{
+ /* opt values
+ 0 - ignore single and double quotes
+ 1 - ignore delimiters between single or double quotes
+ */
+
+ xbUInt32 lLen;
+ xbUInt32 lCurCnt = 0;
+ xbBool bInSingleQuotes = xbFalse;
+ xbBool bInDoubleQuotes = xbFalse;
+ char cPrevChar = 0x00;
+ const char *s = pSrc;
+ const char *pAnchor;
+
+ /* skip past skipcnt delimiters */
+ while( *s && lCurCnt < (lSkipCnt-1) ){
+ if( iOpt == 0 ){
+ if( *s == cDelim )
+ lCurCnt++;
+ } else {
+ if( *s == cDelim && !bInSingleQuotes && !bInDoubleQuotes ){
+ lCurCnt++;
+ } else if( *s == '\'' && !bInDoubleQuotes && cPrevChar != '\\' ){
+ if( bInSingleQuotes == xbTrue )
+ bInSingleQuotes = xbFalse;
+ else
+ bInSingleQuotes = xbTrue;
+ } else if( *s == '"' && !bInSingleQuotes && cPrevChar != '\\' ){
+ if( bInDoubleQuotes == xbTrue )
+ bInDoubleQuotes = xbFalse;
+ else
+ bInDoubleQuotes = xbTrue;
+ }
+ }
+ cPrevChar = *s;
+ s++;
+ }
+
+ /* at the beginning of the field */
+ pAnchor = s;
+ xbBool bDone = xbFalse;
+ while( *s && !bDone ){
+ if( iOpt == 0 ){
+ if( *s == cDelim )
+ bDone = xbTrue;
+ } else {
+ if( *s == cDelim && !bInSingleQuotes && !bInDoubleQuotes ){
+ bDone = xbTrue;
+ } else if( *s == '\'' && !bInDoubleQuotes && cPrevChar != '\\' ){
+ if( bInSingleQuotes == xbTrue )
+ bInSingleQuotes = xbFalse;
+ else
+ bInSingleQuotes = xbTrue;
+ } else if( *s == '"' && !bInSingleQuotes && cPrevChar != '\\' ){
+ if( bInDoubleQuotes == xbTrue )
+ bInDoubleQuotes = xbFalse;
+ else
+ bInDoubleQuotes = xbTrue;
+ }
+ }
+ cPrevChar = *s;
+ s++;
+ }
+
+ // if at end of string, go back one and drop the delimiter
+ if( *s ) s--;
+
+ lLen = (xbUInt32)(s - pAnchor);
+
+ /* copy data */
+ data = (char *) realloc( data, lLen+1 );
+ memcpy( data, pAnchor, lLen );
+ data[lLen] = 0;
+ this->size = lLen+1;
+ return *this;
+}
+
+/************************************************************************/
+//! @brief Get a character by position
+/*!
+ \param n - Position in string to extract. First position is 1 (not 0).
+ \returns Character from position n, or null.
+*/
+char xbString::GetCharacter( xbUInt32 n ) const {
+ if( n > 0 && n <= size )
+ return data[n-1];
+ else
+ return 0x00;
+}
+/************************************************************************/
+//! @brief Get the position of the last occurrence of a given character.
+/*!
+ \param c - Character to search for.
+ \returns Last position of character in the string.
+*/
+xbUInt32 xbString::GetLastPos(char c) const {
+
+ if (data == NULL)
+ return 0;
+
+ char *p = data;
+ xbUInt32 iPos = 0;
+ xbUInt32 hPos = 0;
+ while( *p && iPos++ < ( size - 1 )){
+ if( *p == c )
+ hPos = iPos;
+ p++;
+ }
+ if( hPos )
+ return hPos;
+ else
+ return 0;
+}
+/************************************************************************/
+//! @brief Get the position of the last occurrence of a given string.
+/*!
+ \param s - String to search for.
+ \returns Last position of character in the string.
+*/
+xbUInt32 xbString::GetLastPos(const char* s) const{
+
+ if (data == NULL)
+ return 0;
+
+ char *p = data;
+ char *saveP = NULL;
+ while( p ){
+ p = strstr( p, s);
+ if( p ){
+ saveP = p;
+ p++;
+ }
+ }
+ if (saveP == NULL)
+ return 0;
+ return (xbUInt32)(saveP - data) + 1;
+}
+/************************************************************************/
+//! @brief Get the path separator out of the string.
+/*!
+ \returns Char value containing either / or \ depending on OS.
+*/
+char xbString::GetPathSeparator() const {
+
+ if (data == NULL)
+ return 0x00;
+ char *p = data;
+ while( *p ){
+ if( *p == '\\' || *p == '/' )
+ return *p;
+ else
+ p++;
+ }
+ return 0x00;
+}
+
+/************************************************************************/
+//! @brief Retrieve the size of the string buffer.
+/*!
+ \returns Size of string buffer including the null terminating byte.
+*/
+xbUInt32 xbString::GetSize() const {
+ return size;
+}
+
+/************************************************************************/
+//! @brief Determine if the string has any alpha characters
+/*!
+ \returns xbTrue - String contains one or more aloha characters.<br>
+ xbFalse - String contains no alpha characters.
+*/
+xbBool xbString::HasAlphaChars() const {
+ for( xbUInt32 i = 0; i < size; i++ )
+ if( isalpha( data[i] ))
+ return xbTrue;
+ return xbFalse;
+}
+
+
+/************************************************************************/
+//! @brief Determine if string is empty
+/*!
+ \returns xbTrue if string is empty.<br>
+ xbFalse if string is not empty.
+*/
+xbBool xbString::IsEmpty() const {
+ if( data == NULL )
+ return true;
+ if( data[0] == 0 )
+ return xbTrue;
+ return xbFalse;
+}
+
+/************************************************************************/
+//! @brief Determine if string is NULL
+/*!
+ \returns xbTrue if string is NULL.<br>
+ xbFalse if string is not NULL.
+*/
+xbBool xbString::IsNull() const {
+ return( data == NULL );
+}
+
+
+/************************************************************************/
+//! @brief Retain left part of string, drop rightmost characters.
+/*!
+ \param ulLen New string length, truncate rightmost excess.
+ \returns Reference to string.
+*/
+xbString &xbString::Left( xbUInt32 ulLen ) {
+ return Mid( 1, ulLen );
+}
+
+/************************************************************************/
+//! @brief Retrieve length of current string.
+/*!
+ \returns String length, excluding the terminating null byte.
+*/
+// return length of string
+xbUInt32 xbString::Len() const {
+ return( data ? (xbUInt32) strlen(data) : 0 );
+}
+
+/************************************************************************/
+//! @brief Left trim white space from string.
+/*!
+ \returns Reference to this string.
+*/
+xbString &xbString::Ltrim(){
+
+ if( !data )
+ return *this;
+
+ char *p = data;
+ if( !*p || (*p && *p != ' ') )
+ return *this; /* nothing to do */
+
+ xbUInt32 s = 0;
+ while( *p && *p == ' ' ){
+ p++;
+ s++;
+ size--;
+ }
+ xbUInt32 i;
+ for( i = 0; i < size; i++ )
+ data[i] = data[i+s];
+ data[i] = 0x00;
+ data = (char *) realloc( data, size );
+ return *this;
+}
+
+/************************************************************************/
+//! @brief Left truncate string
+/*!
+ \param ulCnt Number of bytes to remove from the left.
+ \returns Reference to this string.
+*/
+xbString &xbString::Ltrunc( xbUInt32 ulCnt ){
+ // left truncate cnt bytes
+
+ char * ndata;
+ char * p;
+ if( ulCnt >= size ){
+ if( size > 0 ){
+ free( data );
+ data = NULL;
+ size = 0;
+ }
+ return *this;
+ }
+ ndata = (char *) calloc( 1, size - ulCnt );
+ p = data;
+ p += ulCnt;
+ xb_strcpy( ndata, p );
+ free( data );
+ data = ndata;
+ size = size - ulCnt;
+ return *this;
+}
+
+/************************************************************************/
+//! @brief Extract portion of data from string
+/*!
+ \param ulStartPos Starting position
+ \param ulTargLen Length
+ \returns Reference to string
+*/
+xbString &xbString::Mid( xbUInt32 ulStartPos, xbUInt32 ulTargLen ){
+
+ // this is a 1 based routine
+ if( ulStartPos == 0 )
+ return *this;
+
+ if( data == NULL )
+ return( *this );
+ if( data[0] == 0 )
+ return( *this );
+ if( ulStartPos > Len() )
+ return( *this );
+ char *pTarg = data;
+ char *pSrc = data + ulStartPos - 1;
+ for( xbUInt32 l = 0; l < ulTargLen; l++ )
+ *pTarg++ = *pSrc++;
+ *pTarg = 0x00;
+ Resize( ulTargLen + 1 );
+ return *this;
+}
+
+/************************************************************************/
+//! @brief Left pad string
+/*!
+ \param c Padding character.
+ \param ulNewLen New string length.
+ \returns Reference to this string.
+*/
+xbString &xbString::PadLeft( char c, xbUInt32 ulNewLen ){
+
+ xbUInt32 srcLen;
+ if( data )
+ srcLen = (xbUInt32) strlen( data );
+ else
+ srcLen = 0;
+
+ if( srcLen >= ulNewLen )
+ return *this;
+
+ char * newData = (char *) calloc( 1, ulNewLen + 1 );
+ xbUInt32 i;
+ for( i = 0; i < ulNewLen - srcLen; i++ )
+ newData[i] = c;
+
+ char *targ = &newData[i];
+ xb_strcpy( targ, data );
+ free( data );
+ data = newData;
+ size = ulNewLen + 1;
+ return *this;
+}
+
+/************************************************************************/
+//! @brief Right pad string
+/*!
+ \param c Padding character.
+ \param ulNewLen New string length.
+ \returns Reference to this string.
+*/
+xbString &xbString::PadRight( char c, xbUInt32 ulNewLen ){
+ xbUInt32 srcLen = (xbUInt32) strlen( data );
+ if( srcLen >= ulNewLen )
+ return *this;
+ data = (char *) realloc( data, ulNewLen + 1 );
+ xbUInt32 i;
+ for( i = srcLen; i < ulNewLen; i++ )
+ data[i] = c;
+ data[i] = 0x00;
+ size = ulNewLen + 1;
+ return *this;
+}
+
+/************************************************************************/
+//! @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 {
+
+ if (data == NULL)
+ return 0;
+ char *p = data;
+ xbUInt32 iPos = 0;
+ int iFound = 0;
+ while( *p && !iFound && iPos < ( size - 1 )){
+ if( *p == c )
+ iFound = 1;
+ else {
+ iPos++;
+ p++;
+ }
+ }
+
+ if( iFound )
+ return iPos + 1;
+ else
+ return 0;
+}
+
+/************************************************************************/
+//! @brief Determine position of a given substring
+/*!
+ \param s Substring
+ \returns Position within string. Returns 0 if not found.
+*/
+xbUInt32 xbString::Pos(const char* s) const{
+
+ if (data == NULL)
+ return 0;
+
+ char *p = strstr(data, s);
+ if ( p == NULL)
+ return 0;
+
+ return (xbUInt32)(p - data + 1);
+}
+
+/************************************************************************/
+//! @brief Insert character into string
+/*!
+ \param ulPos Insertion position.
+ \param c Character to insert.
+ \returns Reference to this string.
+*/
+xbString &xbString::PutAt(xbUInt32 ulPos, char c){
+ if((ulPos-1) > Len() )
+ return *this;
+ data[ulPos-1] = c;
+ return *this;
+}
+
+/************************************************************************/
+//! @brief Remove portion of string.
+/*!
+ \param ulStartPos Starting position for removal operation.
+ \param ulDelSize Size of deletion.
+ \returns Reference to string.
+*/
+xbString &xbString::Remove(xbUInt32 ulStartPos, xbUInt32 ulDelSize ) {
+ if( data == NULL )
+ return( *this );
+ if( data[0] == 0 )
+ return( *this );
+ xbUInt32 srcLen = Len();
+
+ if( ulStartPos > srcLen || ulStartPos < 1 || ulDelSize < 1 )
+ return( *this );
+
+ if(( ulStartPos + ulDelSize - 1) >= size ){
+ data[ulStartPos-1] = 0x00;
+ size = ulStartPos;
+ return( *this );
+ }
+
+ char *t;
+ char *s;
+ t = data + (ulStartPos - 1);
+ s = t + ulDelSize;
+ size -= ulDelSize;
+ while( *s )
+ *t++ = *s++;
+ *t = 0x00;
+ return( *this );
+}
+
+
+/************************************************************************/
+//! @brief Resize a string
+/*!
+ \param ulSize - New string size, including null termination byte.
+ \returns Reference to this string.
+*/
+//the new size includes the null termination byte
+xbString &xbString::Resize(xbUInt32 ulSize) {
+
+// data = (char *) realloc((void *) data, ulSize );
+
+
+// original
+ data = (char *)realloc(data, ulSize);
+
+
+ if( ulSize > 0 )
+ data[ulSize-1] = 0;
+ this->size = ulSize;
+ return *this;
+}
+/************************************************************************/
+//! @brief Right trim the string.
+/*!
+ This routine removes any trailing white space on the string.
+
+ \returns Reference to string.
+*/
+xbString &xbString::Rtrim(){
+
+ xbUInt32 l = Len();
+ if( l == 0 )
+ return *this;
+ l--;
+
+ for(;;) {
+ if( data[l] != ' ' )
+ break;
+ data[l] = 0;
+ size--;
+ if( l == 0 )
+ break;
+ l--;
+ }
+ return *this;
+}
+
+/************************************************************************/
+//! @brief Set the value of the string.
+/*!
+
+ Note: This routine fails if you try to set the string to itself or some part of itself.
+
+ \param s Value to set the string.
+ \returns Reference to string.
+
+*/
+xbString &xbString::Set( const char *s ) {
+
+ if(data != NULL){
+ free(data);
+ data = NULL;
+ }
+ if(s == NULL ) {
+ if( data )
+ free( data );
+ data = NULL;
+ size = 0;
+ } else {
+ //data = (char *)calloc(1, strlen(s) + 1 );
+ data = (char *) realloc( data, strlen(s) + 1 );
+ xb_strcpy(data, s);
+ size = (xbUInt32) (strlen(data) + 1);
+ }
+ return (*this);
+}
+/************************************************************************/
+//! @brief Set the value of the string.
+/*!
+ \param s Value to set the string.
+ \returns Reference to string.
+*/
+xbString &xbString::Set( const xbString &s ) {
+
+ if( s.Str() == NULL ){
+ if( data ) free( data );
+ data = NULL;
+ size = 0;
+ } else {
+ char *p = (char *) calloc( 1, s.Len() + 1 );
+ xb_strcpy( p, s.Str());
+ size = s.Len() + 1;
+ if( data ) free( data );
+ data = p;
+ }
+ return (*this );
+}
+
+/************************************************************************/
+//! @brief Set the value of the string.
+/*!
+
+ Note: This routine fails if you try to set the string to itself or some part of itself.
+
+ \param s Value to set the string.
+ \param ulSize Maximum size of resultant string.
+ \returns Reference to string.
+*/
+
+xbString &xbString::Set(const char *s, xbUInt32 ulSize) {
+
+ if( data != NULL )
+ free( data );
+
+ if(s == NULL) {
+ data = NULL;
+ size = 0;
+ return (*this);
+ }
+
+ data = (char *) calloc( 1, ulSize+1 );
+ char *pTarget = data;
+ for( xbUInt32 i = 0; i < ulSize; i++ ){
+ *pTarget = *s;
+ pTarget++;
+ s++;
+ }
+ this->size = ulSize + 1;
+ return *this;
+}
+
+
+/************************************************************************/
+//! @brief Set the string to long integer numeric value.
+/*!
+ \param lNum Value to set the string
+ \returns Reference to this string.
+*/
+xbString &xbString::SetNum(xbInt32 lNum) {
+ Sprintf("%ld", lNum);
+ return *this;
+}
+
+/************************************************************************/
+//! @brief Printf routine for formatting a string.
+/*!
+ See documentation on the standard C printf function for how to use this.
+
+ MyString.Sprintf( "a number %d some text %s", 100, "test text data" );
+
+ \param sFormat A format specifier
+ \returns Reference to a formatted string
+*/
+xbString &xbString::Sprintf( const char *sFormat, ...) {
+
+ xbInt32 iRc;
+ va_list ap;
+
+ char *t;
+
+// if( data )
+// free( data );
+
+#ifdef HAVE__VSNPRINTF_S_F
+
+ va_start( ap, sFormat );
+ size = (xbUInt32) _vsnprintf_s( NULL, 0, sFormat, ap ) + 1;
+ va_end( ap );
+
+ t = (char *) malloc( size );
+ if( !t ){
+ size = 0;
+ return( *this );
+ }
+
+ va_start( ap, sFormat );
+ iRc = _vsnprintf_s( t, size, sFormat, ap );
+ va_end( ap );
+
+#else
+#ifdef HAVE_VSPRINTF_S_F
+
+ va_start( ap, sFormat );
+ // size = (xbUInt32) vsprintf_s( NULL, 0, sFormat, ap ) + 1;
+ size = _vscprintf( sFormat, ap ) + 1;
+ va_end( ap );
+
+ t = (char *) malloc( size );
+ if( !t ){
+ size = 0;
+ return( *this );
+ }
+
+ va_start( ap, sFormat );
+ iRc = vsprintf_s( t, size, sFormat, ap );
+ va_end( ap );
+
+#else
+#ifdef HAVE_VSNPRINTF_F
+
+ va_start( ap, sFormat );
+ size = (xbUInt32) vsnprintf( NULL, 0, sFormat, ap) + 1;
+ va_end( ap );
+
+ t = (char *) calloc( 1, size );
+ if( !t ){
+ size = 0;
+ return( *this );
+ }
+ va_start( ap, sFormat );
+ iRc = vsnprintf( t, size, sFormat, ap );
+ va_end( ap );
+
+# else
+# error "Fatal error building [xbstring.cpp] - You have neither _vsnprintf_s nor vsnprintf_s."
+# endif
+#endif
+#endif
+
+ if( iRc < 0 ){
+ if( data )
+ free( data );
+ data = NULL;
+ size = 0;
+ } else {
+ if( data )
+ free( data );
+ data = t;
+ }
+ return( *this );
+}
+
+/************************************************************************/
+//! @brief Return string data
+/*!
+ \returns char * to string data or NULL if string is empty
+*/
+const char *xbString::Str() const {
+ return data ? data : NullString;
+}
+
+/************************************************************************/
+//! @brief Copy all or part of string to character array
+/*!
+ \param cDest pointer to destination buffer.
+ \param n Number of bytest to copy. It is the responsibility of the application
+ to verify the buffer is large enough to hold the string contents.
+ \returns char * to result
+
+*/
+char *xbString::strncpy( char * cDest, xbUInt32 n ) const {
+ xbUInt32 i;
+ xbUInt32 ulLen;
+ n > (size-1) ? ulLen = size-1 : ulLen = n;
+ memset( cDest, 0x00, ulLen );
+ for( i = 0; i < ulLen; i++ )
+ cDest[i] = data[i];
+// cDest[i] = 0x00;
+ return cDest;
+}
+/************************************************************************/
+//! @brief Swap characters
+/*!
+ \param cFrom character to replace.
+ \param cTo character to replace with.
+ \returns Reference to this string.
+*/
+xbString &xbString::SwapChars( char cFrom, char cTo ){
+ xbUInt32 i;
+ for( i = 0; i < size; i++ )
+ if( data[i] == cFrom )
+ data[i] = cTo;
+ return *this;
+}
+
+
+/************************************************************************/
+//! @brief Replace all upper case charaters with lower case characters
+/*!
+ \returns Reference to this string.
+*/
+xbString &xbString::ToLowerCase(){
+ xbUInt32 Len = this->Len();
+ for (xbUInt32 i=0; i<Len; i++)
+ data[i] = (char)tolower(data[i]);
+ return *this;
+}
+
+/************************************************************************/
+//! @brief Replace all lower case charaters with lower case characters
+/*!
+ \returns Reference to this string.
+*/
+xbString &xbString::ToUpperCase(){
+ xbUInt32 Len = this->Len();
+ for (xbUInt32 i=0;i<Len;i++)
+ data[i] = (char)toupper(data[i]);
+ return *this;
+}
+/************************************************************************/
+//! @brief Trim all leading and trailing white space from string.
+/*!
+ \returns Reference to string.
+*/
+xbString &xbString::Trim(){
+ Rtrim();
+ Ltrim();
+ return *this;
+}
+
+
+/************************************************************************/
+//! @brief Private function used for reallocateing memory
+/*!
+ This function is designed to be a drop in replacement for the realloc
+ function call.
+*/
+/*
+char * xbString::xb_realloc( char * pIn, xbUInt32 iLen ){
+
+ if( iLen == 0 ){
+ if( pIn ){
+ free( pIn );
+ return NULL;
+ }
+ }
+
+ char *pNew = (char *) calloc( 1, (size_t) iLen );
+ if( !pNew ) return NULL;
+ char *s = pIn;
+ char *t = pNew;
+ xbUInt32 iCnt = 0;
+ while( *s && iCnt++ < iLen )
+ *t++ = *s++;
+ return pNew;
+}
+*/
+/************************************************************************/
+//! @brief Private function used for copying a string
+/*!
+ For performance reasons, this is an internal function that does no
+ memory checking and assumes a valid buffer area is available to be copied.
+
+ This function is marked as private because of the above reason and
+ is used by "stronger" calling functions.
+
+ \param sTarget Target destination of copied string
+ \param sSource Source string to copy
+ \returns Reference to string.
+*/
+
+char * xbString::xb_strcpy( char *sTarget, const char *sSource ){
+
+ char *temp = sTarget;
+ while( *sSource != '\0'){
+ *sTarget++ = *sSource++;
+// sTarget++;
+// sSource++;
+ }
+ *sTarget= '\0';
+ return temp;
+}
+
+/************************************************************************/
+//! @brief Check for valid logical field data
+/*!
+ Valid logical data is one 'T', 'F', 'N' or 'Y'.<br>
+
+ \returns xbTrue if the data is valid logical data.<br>
+ xbFalse if not valid logical data.
+*/
+
+xbBool xbString::ValidLogicalValue() const {
+ if( Len() == 1 )
+ if( data[0] == 'T' || data[0] == 'F' || data[0] == 'Y' || data[0] == 'N' || data[0] == '?' )
+ return xbTrue;
+ return xbFalse;
+}
+/************************************************************************/
+//! @brief This function returns true if the data is valid numeric data
+/*!
+ \returns xbTrue if valid numeric data.<br>
+ xbFalse if not valid numeric daata.
+*/
+
+xbBool xbString::ValidNumericValue() const {
+ const char *p;
+ p = data;
+ while( *p ){
+ if( *p != '+' && *p != '-' && *p != '.' && *p != '0' && *p != '1' &&
+ *p != '2' && *p != '3' && *p != '4' && *p != '5' && *p != '6' &&
+ *p != '7' && *p != '8' && *p != '9' )
+ return xbFalse;
+ else
+ p++;
+ }
+ return xbTrue;
+}
+
+
+/************************************************************************/
+//! @brief Remove every instance of a character from a string.
+/*!
+ \param c character to remove from string.
+ \returns Reference to this stirng.void
+*/
+
+xbString &xbString::ZapChar( char c ){
+
+ if( data == NULL )
+ return *this;
+ if( data[0] == 0 )
+ return *this;
+
+ char *s;
+ char *t;
+
+ s = data;
+ t = data;
+ while( *s ){
+ if( *s == c ){
+ s++;
+ size--;
+ } else {
+ *t++ = *s++;
+ }
+ }
+ *t = 0x00;
+ Resize( size );
+ return *this;
+}
+
+/************************************************************************/
+//! @brief Remove leading character from a string.
+/*!
+ \param c character to remove from beginning of string.
+ \returns Reference to this string.
+*/
+xbString &xbString::ZapLeadingChar( char c ){
+ /* left truncate all of character c */
+ xbUInt32 iLen = 0;
+ char *p;
+ p = data;
+ while( *p && *p == c ){
+ iLen++;
+ p++;
+ }
+ if( iLen )
+ Ltrunc( iLen );
+ return *this;
+}
+
+
+/************************************************************************/
+//! @brief Remove trailing character from a string.
+/*!
+ \param c character to remove from ending of string.
+ \returns Reference to this string.
+*/
+xbString &xbString::ZapTrailingChar( char c ){
+
+ xbUInt32 l = Len();
+ if( l == 0 )
+ return *this;
+
+ l--;
+ for(;;) {
+ if( data[l] != c )
+ break;
+ data[l] = 0;
+ size--;
+ if( l == 0 )
+ break;
+ l--;
+ }
+ return *this;
+}
+
+} /* namespace */ \ No newline at end of file
diff --git a/src/core/xbtag.cpp b/src/core/xbtag.cpp
new file mode 100755
index 0000000..a71880b
--- /dev/null
+++ b/src/core/xbtag.cpp
@@ -0,0 +1,121 @@
+/* xbtag.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_INDEX_SUPPORT
+
+
+namespace xb{
+
+/************************************************************************/
+//! @brief Constructor
+/*!
+ \param pIx Pointer to index file instance.
+ \param vpTag Pointer to tag structure within file instance.
+ \param sType NDX or MDX
+ \param sTagName Name of tag.
+ \param sExpression Tag key definition.
+ \param sFilter MDX only - tag qualification expression.
+ \param bUnique xbTrue - Index is unique.<br>xbFalse - Index is not unique.
+ \param bSort MDX only<br>xbTrue - Descending.<br>xbFalse - Ascending.
+*/
+
+xbTag::xbTag( xbIx *pIx, void *vpTag, xbString &sType, xbString &sTagName, xbString &sExpression, xbString &sFilter,
+xbBool bUnique, xbBool bSort )
+{
+ this->pIx = pIx;
+ this->vpTag = vpTag;
+ this->sType = sType;
+ this->sTagName = sTagName;
+ this->sExpression = sExpression;
+ this->sFilter = sFilter;
+ this->bUnique = bUnique;
+ this->bSort = bSort;
+}
+
+
+/************************************************************************/
+//! @brief Get tag key expression.
+/*!
+ \returns Tag key expression.
+*/
+const xbString &xbTag::GetExpression() const {
+ return sExpression;
+}
+/************************************************************************/
+//! @brief Get tag filter expression.
+/*!
+ \returns Tag filter expression (mdx only).
+*/
+
+const xbString &xbTag::GetFilter() const {
+ return sFilter;
+}
+/************************************************************************/
+//! @brief Get index file pointer.
+/*!
+ \returns Pointer to index file instance.
+*/
+xbIx *xbTag::GetIx() const {
+ return pIx;
+}
+/************************************************************************/
+//! @brief Get tag ascending setting.
+/*!
+ \returns Tag sort setting - MDX only.<br>xbTrue - Descending.<br>xbFalse - Ascending.
+*/
+xbBool xbTag::GetSort() const {
+ return bSort;
+}
+/************************************************************************/
+//! @brief Get tag name.
+/*!
+ \returns Tag name.
+*/
+
+const xbString &xbTag::GetTagName() const {
+ return sTagName;
+}
+/************************************************************************/
+//! @brief Get tag type.
+/*!
+ \returns Tag type.
+*/
+const xbString &xbTag::GetType() const {
+ return sType;
+}
+
+/************************************************************************/
+//! @brief Get tag unique setting.
+/*!
+ \returns Tag unique setting.<br>xbTrue - Unique.<br>xbFalse - Not unique.
+*/
+
+xbBool xbTag::GetUnique() const {
+ return bUnique;
+}
+/************************************************************************/
+//! @brief Get tag pointer for tag within index file.
+/*!
+ \returns Pointer to tag within index file instance.
+*/
+void *xbTag::GetVpTag() const {
+ return vpTag;
+}
+/************************************************************************/
+} /* namespace */
+#endif /* XB_INDEX_SUPPORT */ \ No newline at end of file
diff --git a/src/core/xbtblmgr.cpp b/src/core/xbtblmgr.cpp
new file mode 100755
index 0000000..e1bf496
--- /dev/null
+++ b/src/core/xbtblmgr.cpp
@@ -0,0 +1,257 @@
+/* xbtblmgr.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 HAVE_STRING_H
+//#include <string.h>
+//#endif
+
+namespace xb{
+
+/*************************************************************************/
+
+xbTblMgr::xbTblMgr(){
+ TblList = NULL;
+ iOpenTableCount = 0;
+}
+
+/*************************************************************************/
+
+xbTblMgr::~xbTblMgr(){
+ xbTblList *l;
+ if( TblList ){
+ while( TblList ){
+ l = TblList;
+ TblList = TblList->pNext;
+ delete l->psTblName;
+ delete l->psTblAlias;
+ free( l );
+ }
+ }
+}
+
+/*************************************************************************/
+
+xbInt16 xbTblMgr::AddTblToTblList( xbDbf *d, const xbString & sTblName ){
+ return AddTblToTblList( d, sTblName, "" );
+}
+
+/*************************************************************************/
+
+xbInt16 xbTblMgr::AddTblToTblList( xbDbf *d, const xbString & sTblName, const xbString & sTblAlias ) {
+
+ xbTblList *i, *s, *t;
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbString sAlias;
+
+ try{
+
+ if( sTblName.Len() == 0 ){
+ iErrorStop = 10;
+ iRc = XB_INVALID_TABLE_NAME;
+ throw iRc;
+ }
+
+ 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 {
+ sAlias = sTblAlias;
+ }
+
+ if((i = (xbTblList *) calloc(1, sizeof(xbTblList))) == NULL){
+ iErrorStop = 20;
+ iRc = XB_NO_MEMORY;
+ throw iRc;
+ }
+ 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;
+ t = TblList;
+
+ while(t && (strcmp( t->psTblAlias->Str(), sAlias.Str()) < 0 )){
+ s = t;
+ t = t->pNext;
+ }
+
+ if( t && (strcmp( t->psTblAlias->Str(), sAlias.Str()) == 0 )){
+ iErrorStop = 30;
+ delete i->psTblName;
+ delete i->psTblAlias;
+ free( i );
+ iRc = XB_DUP_TABLE_OR_ALIAS;
+ throw iRc;
+ }
+ i->pNext = t;
+ if (s == NULL)
+ TblList = i;
+ else
+ s->pNext = i;
+ }
+ catch (xbInt16 iRc ){
+ if( iErrorStop != 30 ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbTblMgr::AddTblToTblList() Exception Caught. Error Stop = [%d] iRc = [%d] Tbl Name = [%s] Alias = [%s]", iErrorStop, iRc, sTblName.Str(), sTblAlias.Str() );
+ std::cout << sMsg << std::endl;
+ }
+ }
+ if( iRc == XB_NO_ERROR )
+ iOpenTableCount++;
+ return iRc;
+}
+
+/*************************************************************************/
+xbInt16 xbTblMgr::DisplayTableList() const {
+ xbInt16 iTblCnt = 0;
+ xbTblList * l = TblList;
+ std::cout << "-- Open Table List --" << std::endl;
+ if( l == NULL )
+ std::cout << "Table list is empty" << std::endl;
+ else{
+ while( l ){
+ iTblCnt++;
+ std::cout << iTblCnt << " Table=[" << l->psTblName->Str() << "] Alias=[" << l->psTblAlias->Str() << "]" << std::endl;
+ l = l->pNext;
+ }
+ }
+ return iTblCnt;
+}
+
+/*************************************************************************/
+/* Get pointer to named dbf.
+ Looks up an open DBF file by Name.
+
+ returns A pointer to the xbDbf class instance if found or NULL if not found.
+
+ // looks for a match as an alias first, if not found as an alias, looks at the name
+
+*/
+
+xbDbf *xbTblMgr::GetDbfPtr(const xbString& sTblAlias) const {
+
+ xbTblList *t;
+ t = TblList;
+ while( t ){
+ if( sTblAlias == t->psTblAlias->Str())
+ return t->pDbf;
+ t = t->pNext;
+ }
+
+ t = TblList;
+ while( t ){
+ if( sTblAlias == t->psTblName->Str())
+ return t->pDbf;
+ t = t->pNext;
+ }
+ return NULL;
+}
+
+/*************************************************************************/
+/* Get pointer to named dbf.
+ Looks up an open DBF file by Name.
+
+ returns pointer to the xbDbf class instance if found or NULL if not found.
+*/
+
+xbDbf *xbTblMgr::GetDbfPtr(xbInt16 iItemNo ) const {
+
+ xbTblList *t;
+ t = TblList;
+ xbInt16 iCnt = 1;
+
+ if( iItemNo < 1 || iItemNo > iOpenTableCount )
+ return NULL;
+
+ while( t && iCnt < iItemNo ){
+ t = t->pNext;
+ iCnt++;
+ }
+ if( t )
+ return t->pDbf;
+ else
+ return NULL;
+}
+
+/*************************************************************************/
+xbInt16 xbTblMgr::GetOpenTableCount() const {
+ return iOpenTableCount;
+}
+
+/*************************************************************************/
+xbInt16 xbTblMgr::RemoveTblFromTblList( const xbString & sTblAlias ) {
+ xbTblList *i, *s;
+
+ i = TblList;
+ s = NULL;
+
+ while( i ){
+
+ if( strcmp( i->psTblAlias->Str(), sTblAlias.Str()) == 0 ) {
+ if(s)
+ s->pNext = i->pNext;
+ else
+ TblList = i->pNext;
+
+ delete i->psTblName;
+ delete i->psTblAlias;
+ free( i );
+ iOpenTableCount--;
+ return XB_NO_ERROR;
+ } else {
+ s = i;
+ i = i->pNext;
+ }
+ }
+ return XB_NOT_FOUND;
+}
+/*************************************************************************/
+xbInt16 xbTblMgr::RemoveTblFromTblList( xbDbf *pTbl ) {
+ xbTblList *i, *s;
+
+ i = TblList;
+ s = NULL;
+
+ while( i ){
+
+ if( i->pDbf == pTbl ) {
+ if(s)
+ s->pNext = i->pNext;
+ else
+ TblList = i->pNext;
+
+ delete i->psTblName;
+ delete i->psTblAlias;
+ free( i );
+ iOpenTableCount--;
+ return XB_NO_ERROR;
+ } else {
+ s = i;
+ i = i->pNext;
+ }
+ }
+ return XB_NOT_FOUND;
+}
+
+/*************************************************************************/
+} /* namespace */
diff --git a/src/core/xbuda.cpp b/src/core/xbuda.cpp
new file mode 100755
index 0000000..0a9c2e7
--- /dev/null
+++ b/src/core/xbuda.cpp
@@ -0,0 +1,78 @@
+/* xbuda.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
+
+This module handles uda (user data area) methods
+
+*/
+
+#include "xbase.h"
+
+
+// might need to change thisto XB_EXPRESSION_SUPPORT
+#ifdef XB_EXPRESSION_SUPPORT
+
+
+namespace xb{
+
+/************************************************************************/
+xbUda::xbUda() {
+ llOrd. SetDupKeys( xbFalse );
+}
+/************************************************************************/
+xbUda::~xbUda() {}
+/************************************************************************/
+void xbUda::Clear() {
+ llOrd.Clear();
+}
+/************************************************************************/
+xbInt16 xbUda::GetTokenCnt() const {
+ return llOrd.GetNodeCnt();
+}
+/************************************************************************/
+
+xbInt16 xbUda::GetTokenForKey( const xbString &sKey, xbString &sToken ) {
+ return llOrd.GetDataForKey( sKey, sToken );
+}
+
+/************************************************************************/
+xbInt16 xbUda::AddTokenForKey( const xbString &sKey, const xbString &sToken ) {
+ return llOrd.InsertKey( sKey, sToken );
+}
+/************************************************************************/
+
+xbInt16 xbUda::UpdTokenForKey( const xbString &sKey, const xbString &sData ) {
+ return llOrd.UpdateForKey( sKey, sData );
+}
+
+/************************************************************************/
+xbInt16 xbUda::DelTokenForKey( const xbString &sKey ) {
+ return llOrd.RemoveKey( sKey ); //, sToken );
+}
+
+
+/************************************************************************/
+
+void xbUda::DumpUda() const{
+
+ xbLinkListNode<xbString> *lln = llOrd.GetHeadNode();
+
+ xbInt32 l = 0;
+ while( lln ){
+ std::cout << ++l << " Key=[" << lln->GetKey() << "] Data=[" << lln->GetData() << "]" << std::endl;
+ lln = lln->GetNextNode();
+ }
+}
+
+/************************************************************************/
+} /* namespace */
+#endif /* XB_EXPRESSION_SUPPORT */ \ No newline at end of file
diff --git a/src/core/xbxbase.cpp b/src/core/xbxbase.cpp
new file mode 100755
index 0000000..7dd3ac7
--- /dev/null
+++ b/src/core/xbxbase.cpp
@@ -0,0 +1,712 @@
+/* xbxbase.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"
+
+namespace xb{
+
+/*************************************************************************/
+//! @brief Class Constructor.
+xbXBase::xbXBase() {
+ SetEndianType();
+ #ifdef XB_LOGGING_SUPPORT
+ xLog = new xbLog();
+ #endif
+}
+/*************************************************************************/
+//! @brief Class Deconstructor.
+xbXBase::~xbXBase(){
+ CloseAllTables();
+ #ifdef XB_LOGGING_SUPPORT
+ delete xLog;
+ #endif
+}
+
+/*************************************************************************/
+//! @brief Close all tables / files.
+/*!
+ This closes everything.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbXBase::CloseAllTables(){
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbInt16 iOpenTableCnt = GetOpenTableCount();
+ try{
+ xbDbf *d;
+ for( xbInt16 i = 0; i < iOpenTableCnt; i++ ){
+ d = (xbDbf *) GetDbfPtr( 1 );
+ if( d ){
+ if(( iRc = d->Close()) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ } else {
+ iRc = XB_INVALID_OBJECT;
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbxbase::CloseAllTables() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, iRc );
+ WriteLogMessage( sMsg.Str() );
+ WriteLogMessage( GetErrorMessage( iRc ));
+ }
+ return iRc;
+}
+/*************************************************************************/
+#ifdef XB_LOGGING_SUPPORT
+//! @brief Get fully qualified log file name.
+/*!
+ \returns Returns the fully qualified log file name.
+*/
+const xbString & xbXBase::GetLogFqFileName() const {
+ return xLog->GetFqFileName();
+}
+
+//! @brief Get the log file name.
+/*!
+ \returns Returns the log file name.
+*/
+const xbString & xbXBase::GetLogFileName() const {
+ return xLog->GetFileName();
+}
+
+//! @brief Get the log directory.
+/*!
+ \returns Returns the log directory.
+*/
+const xbString & xbXBase::GetLogDirectory() const {
+ return xLog->GetDirectory();
+}
+
+//! @brief Get the log directory.
+/*!
+ \returns xbTrue - Logging enabled.<br>xbFalse - Logging disables.
+*/
+xbBool xbXBase::GetLogStatus() const {
+ return xLog->LogGetStatus();
+}
+
+//! @brief Set the log file name.
+/*!
+ \param sLogFileName - Log File Name.
+ \return void
+*/
+void xbXBase::SetLogFileName( const xbString & sLogFileName ){
+ xLog->SetFileName( sLogFileName );
+}
+
+//! @brief Set the log directory.
+/*!
+ \param sLogDirectory - Log File Directory.
+ \return void
+*/
+void xbXBase::SetLogDirectory( const xbString & sLogDirectory ){
+ xLog->SetDirectory( sLogDirectory );
+}
+
+//! @brief Set the logfile size.
+/*!
+ \param lSize - Log File Size.
+ \return void
+*/
+void xbXBase::SetLogSize( size_t lSize ) {
+ xLog->LogSetLogSize( lSize );
+}
+
+
+//! @brief Write message to logfile.
+/*!
+ \param sLogMessage - Message to write.
+ \param iOpt 0 = stdout<br>
+ 1 = Syslog<br>
+ 2 = Both<br>
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbXBase::WriteLogMessage( const xbString & sLogMessage, xbInt16 iOpt ){
+ return xLog->LogWrite( sLogMessage, iOpt );
+}
+
+//! @brief Write message to logfile.
+/*!
+ \param lCnt - Number of bytes to write.
+ \param p - Pointer to bytes to write to log file.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+xbInt16 xbXBase::WriteLogBytes( xbUInt32 lCnt, const char *p ){
+ return xLog->LogWriteBytes( lCnt, p );
+}
+
+//! @brief Enable message logging.
+void xbXBase::EnableMsgLogging() {
+ xLog->LogSetStatus( xbTrue );
+}
+
+//! @brief Disable message logging.
+void xbXBase::DisableMsgLogging() {
+ xLog->LogSetStatus( xbFalse );
+}
+
+//! @brief Flush log file updates to disk.
+xbInt16 xbXBase::FlushLog() {
+ return xLog->xbFflush();
+}
+#else
+
+// if logging not compiled in, these stubs are called with no effect
+const xbString & xbXBase::GetLogFqFileName() const {
+ return sNullString;
+}
+const xbString & xbXBase::GetLogFileName() const {
+ return sNullString;
+}
+const xbString & xbXBase::GetLogDirectory() const {
+ return sNullString;
+}
+void xbXBase::SetLogFileName( const xbString & sLogFileName ){
+ return;
+}
+void xbXBase::SetLogDirectory( const xbString & sLogDirectory ){
+ return;
+}
+xbBool xbXBase::GetLogStatus() const {
+ return xbFalse;
+}
+xbInt16 xbXBase::WriteLogMessage( const xbString & sLogMessage ){
+ return XB_NO_ERROR;
+}
+xbInt16 xbXBase::WriteLogBytes( xbUInt32 lCnt, const char *p ){
+ return XB_NO_ERROR;
+}
+void xbXBase::EnableMsgLogging() {
+ return;
+}
+void xbXBase::DisableMsgLogging() {
+ return;
+}
+xbInt16 xbXBase::FlushLog() {
+ return;
+}
+void xbXBase::SetLogSize( size_t lSize ) {
+ return;
+}
+#endif // XB_LOGGING_SUPPORT
+
+/*************************************************************************/
+#ifdef XB_FUNCTION_SUPPORT
+
+//! @brief Get information regarding expression functions.
+/*!
+ \param sExpLine An expression beginning with function name.
+ \param cReturnType Output - return type of function.
+ \param iCalc Used to calculate the function return value is<br>
+ 1 = use value specified in lReturnLenVal<br>
+ 2 = use length of operand specified in col 4<br>
+ 3 = use valued of numeric operand specified in col 4<br>
+ 4 = length of parm 1 * numeric value parm<br>
+ 5 = larger length of parm 2 or length of parm 3<br>
+ 6 = if two or more parms, use numeric value from second parm, otherwise use col4 value
+ \param lReturnLenVal Used in combination with iReturnLenCalc.
+ \returns <a href="xbretcod_8h.html">Return Codes</a>
+*/
+
+xbInt16 xbXBase::GetFunctionInfo( const xbString &sExpLine, char &cReturnType, xbInt16 &iCalc, xbInt32 &lReturnLenVal ) const{
+
+ xbUInt32 iLen;
+ const char *s;
+ if( sExpLine.Len() == 0 )
+ return XB_INVALID_FUNCTION;
+
+ s = sExpLine;
+ iLen = 0;
+ while( *s && *s != '(' && *s != ' ' ) { s++; iLen++; }
+ xbString sFunction( sExpLine, iLen );
+ cReturnType = 0x00;
+ char cFunc1 = sFunction[1];
+
+ if( cFunc1 < 'L' ){
+ // std::cout << "less than L\n";
+ if( cFunc1 < 'D' ){
+ // std::cout << "less than D\n";
+ if( sFunction == "ABS" ){
+ // { "ABS", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 4;
+ } else if( sFunction == "ALLTRIM" ){
+ // { "ALLTRIM", 'C', 2, 1 },
+ cReturnType = 'C';
+ iCalc = 2;
+ lReturnLenVal = 1;
+ } else if( sFunction == "ASC" ){
+ // { "ASC", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 4;
+ } else if( sFunction == "AT" ){
+ // { "AT", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 4;
+ } else if( sFunction == "CDOW" ){
+ // { "CDOW", 'C', 1, 9 },
+ cReturnType = 'C';
+ iCalc = 1;
+ lReturnLenVal = 9;
+ } else if( sFunction == "CHR" ){
+ // { "CHR", 'C', 1, 1 },
+ cReturnType = 'C';
+ iCalc = 1;
+ lReturnLenVal = 1;
+ } else if( sFunction == "CMONTH" ){
+ // { "CMONTH", 'C', 1, 9 },
+ cReturnType = 'C';
+ iCalc = 1;
+ lReturnLenVal = 9;
+ } else if( sFunction == "CTOD" ){
+ // { "CTOD", 'D', 1, 8 },
+ cReturnType = 'D';
+ iCalc = 1;
+ lReturnLenVal = 8;
+ }
+ } else {
+ // std::cout << ">= D\n";
+ if( sFunction == "DATE" ){
+ // { "DATE", 'D', 1, 8 },
+ cReturnType = 'D';
+ iCalc = 1;
+ lReturnLenVal = 8;
+ } else if( sFunction == "DAY" ){
+ // { "DAY", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 4;
+ } else if( sFunction == "DEL" ){
+ // { "DEL", 'C', 1, 1 },
+ cReturnType = 'C';
+ iCalc = 1;
+ lReturnLenVal = 1;
+ } else if( sFunction == "DELETED" ){
+ // { "DELETED", 'L', 1, 1 },
+ cReturnType = 'L';
+ iCalc = 1;
+ lReturnLenVal = 1;
+ } else if( sFunction == "DESCEND" ){
+ // { "DESCEND", '1', 2, 1 },
+ cReturnType = '1';
+ iCalc = 2;
+ lReturnLenVal = 1;
+ } else if( sFunction == "DOW" ){
+ // { "DOW", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 4;
+ } else if( sFunction == "DTOC" ){
+ // { "DTOC", 'C', 1, 8 },
+ cReturnType = 'C';
+ iCalc = 1;
+ lReturnLenVal = 8;
+ } else if( sFunction == "DTOS" ){
+ // { "DTOS", 'C', 1, 8 },
+ cReturnType = 'C';
+ iCalc = 1;
+ lReturnLenVal = 8;
+ } else if( sFunction == "EXP" ){
+ // { "EXP", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 4;
+ } else if( sFunction == "IIF" ){
+ // { "IIF", 'C', 5, 0 },
+ cReturnType = 'C';
+ iCalc = 5;
+ lReturnLenVal = 0;
+ } else if( sFunction == "INT" ){
+ // { "INT", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 4;
+ } else if( sFunction == "ISALPHA" ){
+ // { "ISALPHA", 'L', 1, 1 },
+ cReturnType = 'L';
+ iCalc = 1;
+ lReturnLenVal = 1;
+ } else if( sFunction == "ISLOWER" ){
+ // { "ISLOWER", 'L', 1, 1 },
+ cReturnType = 'L';
+ iCalc = 1;
+ lReturnLenVal = 1;
+ } else if( sFunction == "ISUPPER" ){
+ // { "ISUPPER", 'L', 1, 1 },
+ cReturnType = 'L';
+ iCalc = 1;
+ lReturnLenVal = 1;
+ }
+ }
+ } else {
+ // std::cout << ">= L\n";
+ if( cFunc1 < 'R' ) {
+ // std::cout << " < R\n";
+ if( sFunction == "LEFT" ){
+ // { "LEFT", 'C', 3, 2 },
+ cReturnType = 'C';
+ iCalc = 3;
+ lReturnLenVal = 2;
+ } else if( sFunction == "LEN" ){
+ // { "LEN", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 3;
+ } else if( sFunction == "LOG" ){
+ // { "LOG", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 4;
+ } else if( sFunction == "LOWER" ){
+ // { "LOWER", 'C', 2, 1 },
+ cReturnType = 'C';
+ iCalc = 2;
+ lReturnLenVal = 1;
+ } else if( sFunction == "LTRIM" ){
+ // { "LTRIM", 'C', 2, 1 },
+ cReturnType = 'C';
+ iCalc = 2;
+ lReturnLenVal = 1;
+ } else if( sFunction == "MAX" ){
+ // { "MAX", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 4;
+ } else if( sFunction == "MIN" ){
+ // { "MIN", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 4;
+ } else if( sFunction == "MONTH" ){
+ // { "MONTH", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 4;
+ }
+ } else if( cFunc1 == 'R' ){
+ // std::cout << "==R\n";
+ if( sFunction == "RECNO" ){
+ // { "RECNO", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 4;
+ } else if( sFunction == "RECCOUNT" ){
+ // { "RECCOUNT", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 4;
+ } else if( sFunction == "REPLICATE" ){
+ // { "REPLICATE", 'C', 4, 0 },
+ cReturnType = 'C';
+ iCalc = 4;
+ lReturnLenVal = 0;
+ } else if( sFunction == "RIGHT" ){
+ // { "RIGHT", 'C', 3, 2 },
+ cReturnType = 'C';
+ iCalc = 3;
+ lReturnLenVal = 2;
+ } else if( sFunction == "RTRIM" ){
+ // { "RTRIM", 'C', 2, 1 },
+ cReturnType = 'C';
+ iCalc = 2;
+ lReturnLenVal = 1;
+ }
+ } else if( cFunc1 == 'S' ){
+ // std::cout << "==S\n";
+ if( sFunction == "SPACE" ){
+ // { "SPACE", 'C', 3, 1 },
+ cReturnType = 'C';
+ iCalc = 3;
+ lReturnLenVal = 1;
+ } else if( sFunction == "SQRT" ){
+ // { "SQRT", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 4;
+ } else if( sFunction == "STOD" ){
+ // { "STOD", 'D', 1, 8 },
+ cReturnType = 'D';
+ iCalc = 1;
+ lReturnLenVal = 8;
+ } else if( sFunction == "STR" ){
+ // { "STR", 'C', 6, 10 },
+ cReturnType = 'C';
+ iCalc = 6;
+ lReturnLenVal = 10;
+ } else if( sFunction == "STRZERO" ){
+ // { "STRZERO", 'C', 3, 2 },
+ cReturnType = 'C';
+ iCalc = 3;
+ lReturnLenVal = 2;
+ } else if( sFunction == "SUBSTR" ){
+ // { "SUBSTR", 'C', 3, 3 },
+ cReturnType = 'C';
+ iCalc = 3;
+ lReturnLenVal = 3;
+ }
+ } else {
+ // std::cout << ">S\n";
+ if( sFunction == "TRIM" ){
+ // { "TRIM", 'C', 2, 1 },
+ cReturnType = 'C';
+ iCalc = 2;
+ lReturnLenVal = 1;
+ } else if( sFunction == "UPPER" ){
+ // { "UPPER", 'C', 2, 1 },
+ cReturnType = 'C';
+ iCalc = 2;
+ lReturnLenVal = 1;
+ } else if( sFunction == "VAL" ){
+ // { "VAL", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 3;
+ } else if( sFunction == "YEAR" ){
+ // { "YEAR", 'N', 1, 4 },
+ cReturnType = 'N';
+ iCalc = 1;
+ lReturnLenVal = 4;
+ }
+ }
+ }
+ if( cReturnType == 0x00 )
+ return XB_INVALID_FUNCTION;
+ else
+ return XB_NO_ERROR;
+}
+#endif
+/*************************************************************************/
+//! @brief Cross platform sleep function.
+/*!
+ \param lMillisecs Milliseconds to sleep.
+*/
+void xbXBase::xbSleep( xbInt32 lMillisecs ){
+ #ifdef WIN32
+ Sleep( lMillisecs );
+ #else
+ usleep( (xbInt64) lMillisecs * 1000 );
+ #endif
+
+}
+/***********************************************************************/
+//! @brief Cross memcmp function.
+/*!
+ \param s1 Left operand to compare.
+ \param s2 Right operand to compare.
+ \param n Number of bytes to compare.
+ \returns 1 s1 > s2<br>
+ 0 s1 == s2<br>
+ -1 s1 < s2
+*/
+xbInt16 xbXBase::xbMemcmp( const unsigned char *s1, const unsigned char *s2, size_t n ){
+ // The standard memcmp function was found not to behave the same across all platforms
+ for( size_t i = 0; i < n; i++ ){
+ if( s1[i] > s2[i] )
+ return 1;
+ else if( s1[i] < s2[i] )
+ return -1;
+ }
+ return 0;
+}
+
+/***********************************************************************/
+//! @brief Open highest qualified class available for dbf file.
+/*!
+ This routine opens the highest available version of the dbf file.
+ Defaults to XB_READ_WRITE and XB_MULTI_USER mode.
+ \returns param dbf - Output pointer to dbf file opened or null if error
+*/
+xbDbf* xbXBase::Open( const xbString &sTableName, xbInt16 &iRc ){
+ return Open( sTableName, "", XB_READ_WRITE, XB_MULTI_USER, 0, iRc );
+}
+/***********************************************************************/
+//! @brief Open highest qualified class available for dbf file.
+/*!
+ This routine can open various versions of the dbf file dependent on the iVersion field
+
+ \param sTableName - Table name to open.
+ \param sAlias - Optional alias name.
+ \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
+ 3 - Version three dbf
+ \param iRc - Return code from open request
+ \returns param dbf - Output pointer to dbf file opened or null if error
+*/
+
+
+xbDbf* xbXBase::Open( const xbString &sTableName, const xbString &sAlias, xbInt16 iOpenMode,
+ xbInt16 iShareMode, xbInt16 iRequestVersion, xbInt16 &iRc ){
+
+ xbInt16 iErrorStop = 0;
+ xbDbf * pDbf = 0;
+ iRc = 0;
+ xbString sFqFileName;
+
+ try{
+
+ if( sTableName.Len() == 0 ){
+ iErrorStop = 10;
+ iRc = XB_FILE_NOT_FOUND;
+ throw iRc;
+ }
+ xbFile *f = new xbFile(this);
+ f->SetFileName( sTableName );
+ if(( iRc = f->FileExists( f->GetFqFileName())) != xbTrue ){
+ iErrorStop = 20;
+ iRc = XB_FILE_NOT_FOUND;
+ throw iRc;
+ }
+ unsigned char cFileTypeByte;
+ if(( iRc = f->GetXbaseFileTypeByte( f->GetFqFileName(), cFileTypeByte )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+
+ xbInt16 iTblVsn = f->DetermineXbaseTableVersion( cFileTypeByte );
+ f->xbFclose();
+ sFqFileName.Set( f->GetFqFileName() );
+ delete f;
+
+ if( iTblVsn == 4 && ( iRequestVersion == 0 || iRequestVersion == 4 )){
+ #ifdef XB_DBF4_SUPPORT
+ pDbf = new xbDbf4( this );
+ iRc = pDbf->Open( sFqFileName, sAlias, iOpenMode, iShareMode );
+ #else
+ // std::cout << "Dbase IV file support not build into library. See XB_DBF4_SUPPORT" << std::endl;
+ iErrorStop = 40;
+ iRc = XB_FILE_TYPE_NOT_SUPPORTED;
+ throw iRc;
+ #endif
+ }
+ else if( iTblVsn == 3 && ( iRequestVersion == 0 || iRequestVersion == 3 )){
+
+ #ifdef XB_DBF3_SUPPORT
+ pDbf = new xbDbf3( this );
+ iRc = pDbf->Open( sFqFileName, sAlias, iOpenMode, iShareMode );
+ #else
+ //std::cout << "Dbase III file support not build into library. See XB_DBF3_SUPPORT" << std::endl;
+ iErrorStop = 50;
+ iRc = XB_FILE_TYPE_NOT_SUPPORTED;
+ throw iRc;
+ #endif
+
+ } else {
+ iErrorStop = 60;
+ iRc = XB_FILE_TYPE_NOT_SUPPORTED;
+ throw iRc;
+ }
+
+ if( iRc != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+
+ std::cout << "Openerror\n";
+
+ xbString sMsg;
+ sMsg.Sprintf( "xbxbase::Open() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, iRc );
+ WriteLogMessage( sMsg.Str() );
+ WriteLogMessage( GetErrorMessage( iRc ));
+
+ }
+ return pDbf;
+
+}
+
+xbInt16 xbXBase::OpenHighestVersion( const xbString &sTableName, const xbString &sAlias,
+ xbDbf **dbf )
+{
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ xbDbf * pwDbf;
+
+ try{
+ xbFile f(this);
+ if( sTableName.Len() == 0 ){
+ iErrorStop = 10;
+ iRc = XB_FILE_NOT_FOUND;
+ throw iRc;
+ }
+ f.SetFileName( sTableName );
+ if(( iRc = f.FileExists( f.GetFqFileName() )) != xbTrue ){
+ iErrorStop = 20;
+ iRc = XB_FILE_NOT_FOUND;
+ throw iRc;
+ }
+ unsigned char cFileTypeByte;
+ if(( iRc = f.GetXbaseFileTypeByte( f.GetFqFileName(), cFileTypeByte )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ return iRc;
+ }
+ if( f.DetermineXbaseTableVersion( cFileTypeByte ) == 4 ){
+ #ifdef XB_DBF4_SUPPORT
+ pwDbf = new xbDbf4( this );
+ pwDbf->Open( f.GetFqFileName(), sAlias );
+ *dbf = pwDbf;
+ pwDbf = 0;
+ #else
+ // std::cout << "Dbase IV file support not build into library. See XB_DBF4_SUPPORT" << std::endl;
+ iErrorStop = 40;
+ iRc = XB_FILE_TYPE_NOT_SUPPORTED;
+ throw iRc;
+ #endif
+
+ } else if( f.DetermineXbaseTableVersion( cFileTypeByte ) == 3 ){
+ #ifdef XB_DBF3_SUPPORT
+ *dbf = new xbDbf3( this );
+ #else
+ //std::cout << "Dbase III file support not build into library. See XB_DBF3_SUPPORT" << std::endl;
+ iErrorStop = 50;
+ iRc = XB_FILE_TYPE_NOT_SUPPORTED;
+ throw iRc;
+ #endif
+
+ } else {
+ iErrorStop = 60;
+ iRc = XB_FILE_TYPE_NOT_SUPPORTED;
+ throw iRc;
+ }
+
+ }
+ catch (xbInt16 iRc ){
+
+ std::cout << "OpenHighestVersion error\n";
+
+ xbString sMsg;
+ sMsg.Sprintf( "xbxbase::OpenHighestVersion() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, iRc );
+ WriteLogMessage( sMsg.Str() );
+ WriteLogMessage( GetErrorMessage( iRc ));
+
+ }
+ return iRc;
+}
+/***********************************************************************/
+} /* namespace */
diff --git a/src/examples/xb_ex_date.cpp b/src/examples/xb_ex_date.cpp
new file mode 100755
index 0000000..fc038b5
--- /dev/null
+++ b/src/examples/xb_ex_date.cpp
@@ -0,0 +1,210 @@
+/* xb_ex_date.cpp
+
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2021,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
+
+This program demonstrates using the xbDate class
+
+*/
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+int main()
+{
+
+ xbString StringDate( "19601007" ); /* oct 7 1960 */
+ char CharDate[9] = "19611109"; /* nov 9 1961 */
+
+ xbDate d1; /* today is default */
+ xbDate d2( StringDate ); /* from string data */
+ xbDate d3( CharDate ); /* from char data */
+ xbDate d4; /* another date class */
+ xbString s;
+
+ std::cout << "This program demonstrates usage of the xbDate class" << std::endl;
+ std::cout << "Date 1 (Sysdate) is " << d1.Str() << std::endl;
+ std::cout << "Date 2 (StringDate) is " << d2.Str() << std::endl;
+ std::cout << "Date 3 (CharDate) is " << d3.Str() << std::endl;
+
+ std::cout << "This year is " << d1.YearOf() << std::endl;
+ std::cout << "Year of xbString Date is " << d2.YearOf()
+ << std::endl;
+ std::cout << "Year of char Date is " << d3.YearOf()
+ << std::endl;
+
+ std::cout << "This Month is " << d1.MonthOf() << std::endl;
+ std::cout << "Month of xbString Date is " << d2.MonthOf()
+ << std::endl;
+ std::cout << "Month of char Date is " << d3.MonthOf()
+ << std::endl;
+
+ std::cout << "Today is day " << d1.DayOf( XB_FMT_WEEK ) << " of the week" << std::endl;
+ std::cout << "StringDate is day " << d2.DayOf( XB_FMT_MONTH ) << " of the month" << std::endl;
+ std::cout << "CharDate is day " << d3.DayOf( XB_FMT_YEAR ) << " of the year" << std::endl;
+
+ if( d1.IsLeapYear())
+ std::cout << "This is a leap year" << std::endl;
+ else
+ std::cout << "This is not a leap year." << std::endl;
+
+ if( d2.IsLeapYear())
+ std::cout << "StringDate is a leap year" << std::endl;
+ else
+ std::cout << "StringDate is not a leap year." << std::endl;
+
+ if( d3.IsLeapYear())
+ std::cout << "CharDate is a leap year" << std::endl;
+ else
+ std::cout << "CharDate is not a leap year." << std::endl;
+
+ std::cout << "Today is " << d1.Sysdate() << std::endl;
+
+ if( d1.DateIsValid( "19951301" ))
+ std::cout << "19951301 is a valid date" << std::endl;
+ else
+ std::cout << "19951301 is not a valid date" << std::endl;
+
+ if( d1.DateIsValid( "19920229" ))
+ std::cout << "19920229 is a valid date" << std::endl;
+ else
+ std::cout << "19920229 is not a valid date" << std::endl;
+
+ if( d2.DateIsValid( StringDate ))
+ std::cout << StringDate.Str() << " is a valid date" << std::endl;
+ else
+ std::cout << StringDate.Str() << " is not a valid date" << std::endl;
+
+ std::cout << "Today's Julian date " << d1.JulianDays() << std::endl;
+ std::cout << "Julian date of Jan 01, 1970 " << d2.JulianDays() << std::endl;
+ std::cout << "StringDate Julian date " << d2.JulianDays() << std::endl;
+
+ std::cout << "There are " << (d1.JulianDays() - d2.JulianDays()) << " days between " << d1.Str() << " and " << d2.Str() << std::endl;
+
+ std::cout << "Todays Julian date (Number of days since Jan 1 0100):" << d1.JulianDays() << std::endl;
+
+ d4 = d1; // set d4 class = to sysdate
+ std::cout << "Object d4 initialized to " << d4.Str() << std::endl;
+ std::cout << "This should be todays date: "
+ << d4.JulToDate8(d4.JulianDays()) << std::endl;
+ std::cout << "In 7 days it will be "
+ << d4.JulToDate8(d4.JulianDays() + 7L ) << std::endl;
+
+ d1.CharDayOf( s );
+ std::cout << "Today is " << s.Str() << std::endl;
+
+ d2.CharDayOf( s );
+ std::cout << "StringDate day is " << s.Str() << std::endl;
+ d1.CharMonthOf( s );
+ std::cout << "This month is " << s.Str() << std::endl;
+ d2.CharMonthOf( s );
+ std::cout << "StringDate month is " << s.Str() << std::endl;
+
+
+ /* various format routines using different formats, strings and chars */
+ xbString sOutDate;
+
+ d1.FormatDate( "YYDDD", sOutDate );
+ std::cout << "Format (YYDDD) = " << sOutDate.Str() << std::endl;
+
+ d1.FormatDate( "MM/DD/YY", sOutDate );
+ std::cout << "Format (MM/DD/YY) = " << sOutDate.Str() << std::endl;
+
+ d1.FormatDate( "YY-MM-DD", sOutDate );
+ std::cout << "Format (YY-MM-DD) = " << sOutDate.Str() << std::endl;
+
+ d1.FormatDate( "DDDDDDDDD, MMMMMMMMMM DD YYYY", sOutDate );
+ std::cout << "Format (DDDDDDDDD, MMMMMMMMMM DD YYYY) = " << sOutDate.Str() << std::endl;
+
+ std::cout << "Last day this month " << d1.LastDayOfMonth() << std::endl;
+ std::cout << "Last day of month for StringDate is " << d2.LastDayOfMonth() << std::endl;
+
+ std::cout << "Overloaded operators test..." << std::endl;
+
+ if( d1 == d2 )
+ std::cout << d1.Str() << " is equal to " << d2.Str()
+ << std::endl;
+ else
+ std::cout << d1.Str() << " is not equal to " << d2.Str()
+ << std::endl;
+
+ if( d1 != d3 )
+ std::cout << d1.Str() << " is not equal to " << d3.Str()
+ << std::endl;
+ else
+ std::cout << d1.Str() << " is equal to " << d3.Str()
+ << std::endl;
+
+ if( d1 < d2 )
+ std::cout << d1.Str() << " is less than " << d2.Str()
+ << std::endl;
+ else
+ std::cout << d1.Str() << " is not less than " << d2.Str()
+ << std::endl;
+
+ if( d1 > d2 )
+ std::cout << d1.Str() << " is greater than " << d2.Str()
+ << std::endl;
+ else
+ std::cout << d1.Str() << " is not greater than " << d2.Str()
+ << std::endl;
+
+ if( d1 <= d2 )
+ std::cout << d1.Str() << " is less than or equal to " << d2.Str()
+ << std::endl;
+ else
+ std::cout << d1.Str() << " is not less than or equal to "
+ << d2.Str() << std::endl;
+
+ if( d1 >= d2 )
+ std::cout << d1.Str() << " is greater than or equal to "
+ << d2.Str() << std::endl;
+ else
+ std::cout << d1.Str() << " is not greater than or equal to "
+ << d2.Str() << std::endl;
+
+ d1.Sysdate();
+ d1++;
+ std::cout << "Tomorrow is " << d1.Str() << std::endl;
+ d1-=2;
+ std::cout << "Yesterday was " << d1.Str() << std::endl;
+ std::cout << "There are " << d1 - d2 << " days between " << d1.Str()
+ << " and " << d2.Str() << std::endl;
+
+ d1="20140701";
+ std::cout << "Operator = example " << d1.Str() << std::endl;
+
+ d1+=5;
+ std::cout << "Operator += 5 example " << d1.Str() << std::endl;
+
+ d1--;
+ std::cout << "Operator -- example " << d1.Str() << std::endl;
+
+ d1-4;
+ std::cout << "Operator -4 example " << d1.Str() << std::endl;
+
+ d1+10;
+ std::cout << "Operator +10 example " << d1.Str() << std::endl;
+ std::cout << "CenturyOf() " << d1.CenturyOf() << std::endl;
+
+ xbString sWorkDate;
+ d1.CTOD( "10/07/60" );
+ std::cout << "CTOD( '10/07/60' ) " << d1.Str() << std::endl;
+
+ d1.Set( "19590118" );
+ std::cout << "Set( '19590118' ) " << d1.Str() << std::endl;
+
+ std::cout << "CalcRollingCenturyForYear( 95 ) = " << d1.CalcRollingCenturyForYear( 95 ) << std::endl;
+ return 0;
+}
diff --git a/src/examples/xb_ex_sql.cpp b/src/examples/xb_ex_sql.cpp
new file mode 100755
index 0000000..695baa2
--- /dev/null
+++ b/src/examples/xb_ex_sql.cpp
@@ -0,0 +1,111 @@
+/* xb_ex_sql.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
+
+ This example demonstrates the implementation of initial sql functions into the library
+
+*/
+
+#include <xbase.h>
+using namespace xb;
+
+int main( int argCnt, char **av )
+{
+ xbInt16 iRc;
+ xbXBase x; /* initialize xbase */
+
+#ifdef XB_LOGGING_SUPPORT
+ x.EnableMsgLogging();
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ xbSql sql( &x );
+ xbString sSql;
+
+
+ sSql.Sprintf( "USE %s", PROJECT_DATA_DIR);
+ iRc = sql.ExecuteNonQuery( sSql );
+ if( iRc != XB_NO_ERROR ){
+ std::cout << "USE PROJECT_DATA_DIR error" << std::endl;
+ x.DisplayError( iRc );
+ return 1;
+ } else {
+ std::cout << sSql << " successful" << std::endl;
+ }
+
+ sSql = "DROP TABLE IF EXISTS TESTTBL.DBF";
+ iRc = sql.ExecuteNonQuery( sSql );
+ if( iRc != XB_NO_ERROR ){
+ std::cout << "DROP TABLE error" << std::endl;
+ x.DisplayError( iRc );
+ return 1;
+ } else {
+ std::cout << "DROP TABLE successful" << std::endl;
+ }
+
+ std::cout << "Drop table completed\n";
+
+ sSql = "CREATE TABLE TESTTBL.DBF( CHRFLD CHAR(60), DTFLD DATE, INTFLD INTEGER, SMINTFLD SMALLINT, NUMFLD NUMERIC(9,4), DECFLD DECIMAL(9,4), FLTFLD FLOAT(9,4) VCHARFLD VARCHAR, LGFLD LOGICAL)";
+ iRc = sql.ExecuteNonQuery( sSql );
+ if( iRc != XB_NO_ERROR ){
+ std::cout << "CREATE TABLE error" << std::endl;
+ x.DisplayError( iRc );
+ return 1;
+ } else {
+ std::cout << "CREATE TABLE successful" << std::endl;
+ }
+
+ sSql = "CREATE INDEX TAG1 ON TESTTBL.DBF( CHRFLD )";
+ iRc = sql.ExecuteNonQuery( sSql );
+ if( iRc != XB_NO_ERROR ){
+ std::cout << "CREATE INDEX error" << std::endl;
+ x.DisplayError( iRc );
+ return 1;
+ } else {
+ std::cout << "CREATE INDEX successful" << std::endl;
+ }
+
+
+ sSql = "INSERT INTO TESTTBL.DBF ( CHRFLD ) VALUES ( 'z' )";
+ iRc = sql.ExecuteNonQuery( sSql );
+ if( iRc != XB_NO_ERROR ){
+ std::cout << "INSERT error" << std::endl;
+ x.DisplayError( iRc );
+ return 1;
+ } else {
+ std::cout << "INSERT successful" << std::endl;
+ }
+
+ char c;
+ xbString s;
+ for( xbUInt16 i = 0; i < 3 && iRc == XB_NO_ERROR; i++ ){
+ for( xbUInt16 j = 0; j < 5 && iRc == XB_NO_ERROR; j++ ){
+ c = j + 65;
+ s = c;
+ s.PadRight( c, (xbUInt32) i + 1 );
+ sSql.Sprintf( "INSERT INTO TESTTBL.DBF ( CHRFLD ) VALUES ( '%s' )", s.Str());
+ std::cout << sSql.Str() << std::endl;
+ iRc = sql.ExecuteNonQuery( sSql );
+ if( iRc != XB_NO_ERROR ){
+ std::cout << "INSERT error" << std::endl;
+ x.DisplayError( iRc );
+ return 1;
+ }
+ }
+ }
+
+ x.CloseAllTables();
+ return 0;
+}
diff --git a/src/examples/xb_ex_string.cpp b/src/examples/xb_ex_string.cpp
new file mode 100755
index 0000000..3d582a1
--- /dev/null
+++ b/src/examples/xb_ex_string.cpp
@@ -0,0 +1,385 @@
+/* xb_ex_string.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2021,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
+
+*/
+
+// This demonstrates the string class
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+int main()
+{
+
+ // create a string, assign a value, print it
+ xbString s1;
+ s1 = "Test String 1";
+ fprintf( stdout, "s1 = [%s]\n", s1.Str());
+
+ // create another string, copy the value from s1 into it, print it
+ xbString s2;
+ s2 = s1;
+ std::cout << "s2 = [" << s2.Str() << "]" << std::endl;
+
+ // create another string with and print it
+ xbString s3( 'X' );
+ std::cout << "s3 = [" << s3.Str() << "]" << std::endl;
+
+ // create another string with and print it and print it out yet another way
+ xbString s4( "Class constructor test 4" );
+ printf( "s4 = [%s]\n", s4.Str() );
+
+ // create another string with a size limit and print it out
+ xbString s5( "Class constructor test 4", 7 );
+ printf( "s5 = [%s]\n", s5.Str() );
+
+ // create another string from a string
+ xbString s6( s5 );
+ printf( "s6 = [%s]\n", s6.Str() );
+
+ // create 100 byte string with nothing in it
+ xbString s7( (xbUInt32) 100 );
+ printf( "s7 = [%s]\n", s7.Str() );
+
+ // Extract character from a particular position in the string
+ printf( "[] test -- Position 7 (starts from 1) from String 1 = [%c]\n", s1[7] );
+ // or use the getCharacter method
+ printf( "getCharacter() test -- Position 7 (starts from 1) from String 1 = [%c]\n", s1.GetCharacter(7) );
+
+ // set string 7 to a character
+ s7 = 'Z';
+ printf( "updated s7 = [%s]\n", s7.Str() );
+
+ // trim methods
+ s3 = " abc ";
+ s3.Ltrim();
+ s3.Dump( "LTrim test" );
+
+
+ s3 = " abc ";
+ s3.Rtrim();
+ s3.Dump( "RTrim test" );
+
+ s3.Trim();
+ s3.Dump( "Trim test" );
+ printf( "s3 Len = [%d]\n", s3.Len() );
+
+ // Concatenation tests - I
+ s1 = "Concatenation test1 part 1 ";
+ s1 += "Concatenation test1 part 2 ";
+ s2 = " s2 data ";
+ s1 += s2;
+ s1 += 'z';
+
+ // Concatenation tests - II
+ s1 = "Concatenation test1 part 1 ";
+ s1 -= "Concatenation test1 part 2 ";
+ s1 -= 'X';
+ s1 -= s2;
+ s1.Dump( "Concatenation test 2 " );
+
+
+ // Concatenation tests - III
+ s1 = "s1data ";
+ s2 = "s2data ";
+
+ s3 = s1 - s2;
+ s3.Dump( "Concatenation test 3a" );
+
+ s3 = s1 + s2;
+ s3.Dump( "Concatenation test 3b" );
+
+ s3 = s1 + " char * data ";
+ s3.Dump( "Concatenation test 3c" );
+
+ // s3 = " char * data " + s2;
+ // s3.Dump( "Concatenation test 3d" );
+
+ s3 = s1 + 'Z';
+ s3.Dump( "Concatenation test 3e" );
+
+// s3 = 'A' + s1;
+ s3 = 'A';
+
+ std::cout << s3.Str() << std::endl;
+ s3 += s1;
+
+ std::cout << s3.Str() << std::endl;
+
+
+ s3 = 'A' + s1;
+
+
+ return 0;
+
+ // s3.Dump( "Concatenation test 3f" );
+
+ std::cout << std::endl << "== operator tests" << std::endl;
+ if( s1 == s2 )
+ std::cout << s1.Str() << " == " << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " != " << s2.Str() << std::endl;
+
+ s1 = s2;
+ if( s1 == s2 )
+ std::cout << s1.Str() << " == " << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " != " << s2.Str() << std::endl;
+
+ if( s1 == "sometestdata" )
+ std::cout << s1.Str() << " == sometestdata" << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " != sometestdata" << s2.Str() << std::endl;
+
+ std::cout << std::endl << "!= operator tests" << std::endl;
+ s2 = "abc123";
+ s1.Dump( "s1" );
+ s2.Dump( "s2" );
+ if( s1 != s2 )
+ std::cout << s1.Str() << " != " << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " == " << s2.Str() << std::endl;
+
+ s1 = s2;
+ if( s1 != s2 )
+ std::cout << s1.Str() << " != " << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " == " << s2.Str() << std::endl;
+
+ if( s1 != "sometestdata" )
+ std::cout << s1.Str() << " != [sometestdata]" << std::endl;
+ else
+ std::cout << s1.Str() << " == [sometestdata]" << std::endl;
+
+ std::cout << std::endl << "< operator tests" << std::endl;
+ s1 = "AAA";
+ s2 = "BBB";
+
+ if( s1 < s2 )
+ std::cout << s1.Str() << " < " << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " >= " << s2.Str() << std::endl;
+
+ s1 = "BBB";
+ if( s1 < s2 )
+ std::cout << s1.Str() << " < " << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " >= " << s2.Str() << std::endl;
+
+ s1 = "CCC";
+ if( s1 < s2 )
+ std::cout << s1.Str() << " < " << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " >= " << s2.Str() << std::endl;
+
+ std::cout << std::endl << "> operator tests" << std::endl;
+ s1 = "AAA";
+ s2 = "BBB";
+
+ if( s1 > s2 )
+ std::cout << s1.Str() << " > " << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " <= " << s2.Str() << std::endl;
+
+ s1 = "BBB";
+ if( s1 > s2 )
+ std::cout << s1.Str() << " > " << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " <= " << s2.Str() << std::endl;
+
+ s1 = "CCC";
+ if( s1 > s2 )
+ std::cout << s1.Str() << " > " << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " <= " << s2.Str() << std::endl;
+
+ std::cout << std::endl << "<= operator tests" << std::endl;
+ s1 = "AAA";
+ s2 = "BBB";
+
+ if( s1 <= s2 )
+ std::cout << s1.Str() << " <= " << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " > " << s2.Str() << std::endl;
+
+ s1 = "BBB";
+ if( s1 <= s2 )
+ std::cout << s1.Str() << " <= " << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " > " << s2.Str() << std::endl;
+
+ s1 = "CCC";
+ if( s1 <= s2 )
+ std::cout << s1.Str() << " <= " << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " > " << s2.Str() << std::endl;
+
+ std::cout << std::endl << ">= operator tests" << std::endl;
+ s1 = "AAA";
+ s2 = "BBB";
+
+ if( s1 >= s2 )
+ std::cout << s1.Str() << " >= " << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " < " << s2.Str() << std::endl;
+
+ s1 = "BBB";
+ if( s1 >= s2 )
+ std::cout << s1.Str() << " >= " << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " < " << s2.Str() << std::endl;
+
+ s1 = "CCC";
+ if( s1 >= s2 )
+ std::cout << s1.Str() << " >= " << s2.Str() << std::endl;
+ else
+ std::cout << s1.Str() << " < " << s2.Str() << std::endl;
+
+ std::cout << "(const char *) " << (const char *) s2.Str() << std::endl;
+
+ std::cout << std::endl << "CountChar() test" << std::endl;
+ s1 = "ABADFDSGA";
+ xbUInt32 i = s1.CountChar( 'A' );
+ std::cout << "There are " << i << " 'A's in " << s1.Str() << std::endl;
+
+ s1.Ltrunc( 4 );
+ std::cout << "lTunc(4) test s1 = [" << s1.Str() << "]" << std::endl;
+
+ std::cout << std::endl << "PutAt() test" << std::endl;
+ s1.PutAt( 3, 'Z' );
+ std::cout << "Third char should be a 'Z' = " << s1.Str() << std::endl;
+
+ std::cout << std::endl << "AddBackSlash() test" << std::endl;
+ s1.AddBackSlash( 'Z' );
+ std::cout << "Should be a backslash before the 'Z' = " << s1.Str() << std::endl;
+
+ std::cout << std::endl << "Assign() test" << std::endl;
+ s2 = "1234567890";
+ std::cout << "s2 = " << s2.Str() << std::endl;
+ s1.Assign( s2, 4, 5 );
+ std::cout << "assign( s2, 4, 5 ) results = " << s1.Str() << std::endl;
+ s1.Assign( s2, 4, 15 );
+ std::cout << "assign( s2, 4, 15 ) results = " << s1.Str() << std::endl;
+
+ s1.Assign( s2, 5 );
+ std::cout << "Assign( s2, 5 ) results = " << s1.Str() << std::endl;
+ s1.Assign( s2, 15 );
+ std::cout << "Assign( s2, 15 ) results = " << s1.Str() << std::endl;
+
+ std::cout << std::endl << "s1.copy() test" << std::endl;
+ s1 = "ABC";
+ std::cout << "s1 = " << s1.Str() << std::endl;
+ std::cout << "s2 = " << s2.Str() << std::endl;
+
+ s1 = s2.Copy();
+ s1.Dump( "s1.Copy() results" );
+
+ s1 = "0x35";
+ char hexChar;
+ s1.CvtHexChar( hexChar );
+ std::cout << "CvtHexChar test [" << s1.Str() << "] converts to [" << hexChar << "]" << std::endl;
+ s1 = "0x65";
+ s1.CvtHexChar( hexChar );
+ std::cout << "cvHexChar test [" << s1.Str() << "] converts to [" << hexChar << "]" << std::endl;
+
+ s1 = "0x610x620x630x640x65";
+ s1.CvtHexString( s2 );
+ std::cout << "CvtHexString [" << s1.Str() << "] converts to [" << s2.Str() << "]" << std::endl;
+
+ s1.ExtractElement( "aaaa|bbbb|cccc|dddd", '|', 2, 0 );
+ s1.Dump( "ExtractElement() " );
+
+ s1 = "123";
+ s2 = "ABC";
+ std::cout << "HasAlphaChars( " << s1.Str() << " ) = " << s1.HasAlphaChars() << std::endl;
+ std::cout << "HasAlphaChars( " << s2.Str() << " ) = " << s2.HasAlphaChars() << std::endl;
+
+ s2 = "";
+ std::cout << "IsEmpty( " << s1.Str() << " ) = " << s1.IsEmpty() << std::endl;
+ std::cout << "IsEmpty( " << s2.Str() << " ) = " << s2.IsEmpty() << std::endl;
+
+ s1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ std::cout << s1.Str() << " s1.Mid( 3,5 ) = [" << s1.Mid( 3, 5 ).Str() << "]" << std::endl;
+ std::cout << s1.Str() << " s1.Mid( 25, 10 ) = [" << s1.Mid( 25, 10 ).Str() << "]" << std::endl;
+
+ std::cout << s1.Str() << " s1.Pos('G') = " << s1.Pos( 'G' ) << std::endl;
+ std::cout << s1.Str() << " s1.Pos(\"JKL\") = " << s1.Pos( "JKL" ) << std::endl;
+
+ s1.Dump( "Remove( 3, 5 ) before " );
+ std::cout << s1.Str() << " s1.Remove( 3, 5 ) = [" << s1.Remove( 3, 5 ).Str() << "]" << std::endl;
+ s1.Dump( "Remove( 3, 5 ) after " );
+ s1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+
+ std::cout << "s1.Remove( 20, 10 ) = [" << s1.Remove( 20, 10 ).Str() << "]" << std::endl;
+ s1.Dump( "Remove( 20, 10 ) " );
+
+ s1.Sprintf( "%d", 12345 );
+ s1.Dump( "Sprintf( %d, 12345 ) " );
+
+ s1.SetNum( (long) 123456 );
+ std::cout << "s1.SetNum( 123456 ) = " << s1.Str() << std::endl;
+
+ s1.Set( "Yet another way to set a string value" );
+ s1.Dump( "Set" );
+
+ s1 = "ABCABCABZ";
+ s1.Dump( "SwapChars( 'A', '9' ) before" );
+ s1.SwapChars( 'A', '9' );
+ s1.Dump( "SwapChars( 'A', '9' ) after");
+
+ s1.ToLowerCase();
+ s1.Dump( "ToLowerCase" );
+
+ s1.ToUpperCase();
+ s1.Dump( "ToUpperCase" );
+
+ s1.ZapChar( '9' );
+ s1.Dump( "ZapChar( '9' )" );
+
+ s1.ZapLeadingChar( 'B' );
+ s1.Dump( "ZapLeadingChar( 'B' )" );
+
+ s1.ZapTrailingChar( 'Z' );
+ s1.Dump( "ZapLeadingChar( 'Z' )" );
+
+ s1 = "123";
+ s1.PadLeft( '0', 9 );
+ s1.Dump( "s1.PadLeft('0', 9 ) ");
+
+ s1 = "abc";
+ s1.PadRight( 'Z', 9 );
+ s1.Dump( "s1.PadRight('Z', 9 ) ");
+
+ xbString sNullString;
+ if( sNullString.IsNull())
+ std::cout << "sNullString is null" << std::endl;
+ else
+ std::cout << "sNullString is not null" << std::endl;
+
+ xbString tstS( "ZZZZZZZZZ" );
+ tstS = s1.Left( 5 );
+
+ std::cout << "tstS = " << tstS.Str() << "\n";
+ std::cout << "s1 = " << s1.Str() << "\n";
+
+ tstS = "1234567890";
+ std::cout << "mid result = " << tstS.Mid( 3, 3 ).Str() << std::endl;
+
+ tstS = "1234567890";
+ std::cout << "left result = " << tstS.Left( 3 ).Str() << std::endl;
+
+
+ return 0;
+}
diff --git a/src/examples/xb_ex_v3_create_dbf.cpp b/src/examples/xb_ex_v3_create_dbf.cpp
new file mode 100755
index 0000000..ecfcd72
--- /dev/null
+++ b/src/examples/xb_ex_v3_create_dbf.cpp
@@ -0,0 +1,102 @@
+/* xb_ex_v3_create_dbf.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
+
+ This example demonstrates the creation of a Version III file and and indices
+
+*/
+
+#include <xbase.h>
+
+using namespace xb;
+
+int main()
+{
+
+#ifdef XB_DBF3_SUPPORT
+
+ xbSchema MyRecord[] =
+ {
+ { "FIRSTNAME", XB_CHAR_FLD, 15, 0 },
+ { "LASTNAME", XB_CHAR_FLD, 20, 0 },
+ { "BIRTHDATE", XB_DATE_FLD, 8, 0 },
+ { "AMOUNT", XB_NUMERIC_FLD, 9, 2 },
+ { "RETIRED?", XB_LOGICAL_FLD, 1, 0 },
+ { "ZIPCODE", XB_NUMERIC_FLD, 5, 0 },
+#ifdef XB_MEMO_SUPPORT
+ { "MEMO1", XB_MEMO_FLD, 10, 0 },
+#endif
+ { "",0,0,0 }
+ };
+
+ /* define the classes */
+ xbXBase x; /* initialize xbase */
+ x.SetDataDirectory( PROJECT_DATA_DIR ); /* where all the tables live */
+
+ xbDbf *MyDbfFile; /* Pointer to dbf class */
+ MyDbfFile = new xbDbf3(&x); /* Create Version 3 instance */
+
+
+// Create Dbase3 NDX style indices if support compiled in
+#ifdef XB_NDX_SUPPORT
+ xbIxNdx MyIndex1( MyDbfFile ); /* class for index 1 */
+ xbIxNdx MyIndex2( MyDbfFile ); /* class for index 2 */
+ xbIxNdx MyIndex3( MyDbfFile ); /* class for index 3 */
+#endif
+
+
+// fixme
+// Create Clipper NTX style indices if support compiled in - bring this back to life in a future release
+#ifdef XB_INDEX_NTX
+ xbNtx MyIndex4( &MyDbfFile ); /* class for index 4 */
+ xbNtx MyIndex5( &MyDbfFile ); /* class for index 5 */
+#endif
+
+ xbInt16 rc;
+
+ if(( rc = MyDbfFile->CreateTable( "MyV3Table1", "MyV3ExampleTableAlias", MyRecord, XB_OVERLAY, XB_MULTI_USER )) != XB_NO_ERROR )
+ x.DisplayError( rc );
+ else
+ {
+
+#ifdef XB_NDX_SUPPORT
+
+ xbIx *pIx;
+ void *pTag;
+
+ /*
+ Create a few index tags
+ CreateTag( const xbString &sIxType, const xbString &sName, const xbString &sKey, const xbString &sFilter,
+ xbInt16 iDescending, xbInt16 iUnique, xbInt16 iOverLay, xbIx **xbIxOut, void **vpTagOut );
+ */
+
+ /* define a simple index */
+ if(( rc = MyDbfFile->CreateTag ( "NDX", "MYINDEX1.NDX", "LASTNAME", "", 0, 1, XB_OVERLAY, &pIx, &pTag )) != XB_NO_ERROR )
+ x.DisplayError( rc );
+
+ /* define a multi-field index "LASTNAME FIRSTNAME" */
+ if(( rc = MyDbfFile->CreateTag( "NDX", "MYINDEX2.NDX", "LASTNAME+FIRSTNAME", "", 0, 1, XB_OVERLAY, &pIx, &pTag )) != XB_NO_ERROR )
+ x.DisplayError( rc );
+
+ /* define a numeric index "ZIPCODE" */
+ if(( rc = MyDbfFile->CreateTag( "NDX", "MYINDEX3.NDX", "ZIPCODE", "", 0, 0, XB_OVERLAY, &pIx, &pTag )) != XB_NO_ERROR )
+ x.DisplayError( rc );
+
+#endif
+
+ }
+
+ MyDbfFile->Close(); /* Close database and associated indexes */
+
+#endif // XB_DBF3_SUPPORT
+ return 0;
+}
diff --git a/src/examples/xb_ex_v3_upd_dbf.cpp b/src/examples/xb_ex_v3_upd_dbf.cpp
new file mode 100755
index 0000000..aa6ec49
--- /dev/null
+++ b/src/examples/xb_ex_v3_upd_dbf.cpp
@@ -0,0 +1,282 @@
+/* xb_ex_v3_upd_dbf.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2021,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
+
+ This example demonstrates how to open the DBase III table created by xb_ex_v3_create_dbf
+ and apply various updates to the table.
+
+*/
+
+#include <xbase.h>
+
+using namespace xb;
+
+int main()
+{
+
+#ifdef XB_DBF3_SUPPORT
+
+ xbInt16 fld_FIRSTNAME;
+ xbInt16 fld_LASTNAME;
+ xbInt16 fld_BIRTHDATE;
+ xbInt16 fld_AMOUNT;
+ xbInt16 fld_RETIRED;
+ xbInt16 fld_ZIPCODE;
+
+ #ifdef XB_MEMO_SUPPORT
+ xbInt16 fld_MEMO1;
+ xbString sMemoData;
+ #endif
+
+
+ /* define the classes */
+ xbXBase x; /* initialize xbase */
+ x.SetDataDirectory( PROJECT_DATA_DIR ); /* where all the tables live */
+ x.EnableMsgLogging();
+ x.WriteLogMessage( "Program [xb_ex_v3_upd_dbf] initializing..." );
+
+
+ xbDbf * MyTable = new xbDbf3( &x ); /* class for V3 table */
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ try{
+
+ if(( iRc = MyTable->Open( "MyV3Table1.DBF" )) != XB_NO_ERROR ){
+ iErrorStop = 1;
+ throw iRc;
+ }
+
+ #ifdef XB_NDX_SUPPORT
+ // V3 NDX style indices can be opened manually (vs production MDX index files opened automatically)
+ if(( iRc = MyTable->OpenIndex( "NDX", "MYINDEX1.NDX")) != XB_NO_ERROR ){
+ iErrorStop = 2;
+ throw iRc;
+ }
+ if(( iRc = MyTable->OpenIndex( "NDX", "MYINDEX2.NDX" )) != XB_NO_ERROR ){
+ iErrorStop = 3;
+ throw iRc;
+ }
+ if(( iRc = MyTable->OpenIndex( "NDX", "MYINDEX3.NDX" )) != XB_NO_ERROR ){
+ iErrorStop = 4;
+ throw iRc;
+ }
+ std::cout << "Current tag = [" << MyTable->GetCurTagName().Str() << "]\n";
+ #endif
+
+
+
+ // get the field numbers for all the fields in the table
+ fld_FIRSTNAME = MyTable->GetFieldNo( "FIRSTNAME" );
+ fld_LASTNAME = MyTable->GetFieldNo( "LASTNAME" );
+ fld_BIRTHDATE = MyTable->GetFieldNo( "BIRTHDATE" );
+ fld_AMOUNT = MyTable->GetFieldNo( "AMOUNT" );
+ fld_RETIRED = MyTable->GetFieldNo( "RETIRED?" );
+ fld_ZIPCODE = MyTable->GetFieldNo( "ZIPCODE" );
+
+ #ifdef XB_MEMO_SUPPORT
+ fld_MEMO1 = MyTable->GetFieldNo( "MEMO1" );
+ #endif
+
+
+ // Blank the record buffer
+ if(( iRc = MyTable->BlankRecord()) != XB_NO_ERROR ){
+ iErrorStop = 7;
+ throw iRc;
+ }
+
+ // put field examples - using field numbers
+ if(( iRc = MyTable->PutField( fld_LASTNAME, "JONES" )) != XB_NO_ERROR ){
+ iErrorStop = 8;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutField( fld_FIRSTNAME, "JERRY" )) != XB_NO_ERROR ){
+ iErrorStop = 9;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutField( fld_AMOUNT, "12.35" )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutField( fld_BIRTHDATE, "19880208" )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutLogicalField( fld_RETIRED, "Y" )) != XB_NO_ERROR ){
+ iErrorStop = 11;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutLongField( fld_ZIPCODE, 12345 )) != XB_NO_ERROR ){
+ iErrorStop = 12;
+ throw iRc;
+ }
+
+ #ifdef XB_MEMO_SUPPORT
+ sMemoData = "Memo data record 1";
+ if(( iRc = MyTable->UpdateMemoField( fld_MEMO1, sMemoData )) != XB_NO_ERROR ){
+ iErrorStop = 13;
+ throw iRc;
+ }
+ #endif
+
+ // Append the first record
+ if(( iRc = MyTable->AppendRecord()) != XB_NO_ERROR ){
+ iErrorStop = 15;
+ throw iRc;
+ }
+
+ // put field to the record buffer using field name (slightly less efficient than using field numbers)
+
+ // Blank the record buffer
+ if(( iRc = MyTable->BlankRecord()) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutField( "LASTNAME", "EINSTIEN" )) != XB_NO_ERROR ){
+ iErrorStop = 21;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutField( "FIRSTNAME", "ALBERT" )) != XB_NO_ERROR ){
+ iErrorStop = 22;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutField( "AMOUNT", "987.55" )) != XB_NO_ERROR ){
+ iErrorStop = 23;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutField( fld_BIRTHDATE, "19890209" )) != XB_NO_ERROR ){
+ iErrorStop = 24;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutLogicalField( "RETIRED?", "N" )) != XB_NO_ERROR ){
+ iErrorStop = 25;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutLongField( "ZIPCODE", 44256 )) != XB_NO_ERROR ){
+ iErrorStop = 26;
+ throw iRc;
+ }
+
+ #ifdef XB_MEMO_SUPPORT
+ sMemoData = "Memo data record 2";
+ if(( iRc = MyTable->UpdateMemoField( fld_MEMO1, sMemoData )) != XB_NO_ERROR ){
+ iErrorStop = 27;
+ throw iRc;
+ }
+ #endif
+
+ // Append the second record
+ if(( iRc = MyTable->AppendRecord()) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+
+ // get a field with a field number
+ xbString FirstName;
+ if(( iRc = MyTable->GetField( fld_FIRSTNAME, FirstName )) < 0 ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ std::cout << "First Name is [" << FirstName.Str() << "]" << std::endl;
+
+ xbString LastName;
+ if(( iRc = MyTable->GetField( "LASTNAME", LastName )) < 0 ){
+ iErrorStop = 41;
+ throw iRc;
+ }
+ std::cout << "Last Name is [" << LastName.Str() << "]" << std::endl;
+
+ xbInt16 iNoOfDecimals;
+ if(( iRc = MyTable->GetFieldDecimal( "AMOUNT", iNoOfDecimals )) != XB_NO_ERROR ){
+ iErrorStop = 42;
+ throw iRc;
+ }
+ std::cout << "There are " << iNoOfDecimals << " decimals in the AMOUNT field" << std::endl;
+
+ xbString FieldName;
+ if(( iRc = MyTable->GetFieldName( 4, FieldName )) != XB_NO_ERROR ){
+ iErrorStop = 43;
+ throw iRc;
+ }
+ std::cout << "Field #4 name is " << FieldName.Str() << std::endl;
+
+ xbString sRetired;
+ if(( iRc = MyTable->GetLogicalField( "RETIRED?", sRetired )) < 0 ){
+ iErrorStop = 45;
+ throw iRc;
+ }
+ std::cout << "Switch value = [" << sRetired.Str() << "]" << std::endl;
+
+ xbInt32 lZip;
+ if(( iRc = MyTable->GetLongField( "ZIPCODE", lZip )) < 0 ){
+ iErrorStop = 46;
+ throw iRc;
+ }
+ std::cout << "Long value = [" << lZip << "]" << std::endl;
+
+ // Initialize the record buffer in preparation for another record
+ if(( iRc = MyTable->BlankRecord()) != XB_NO_ERROR ){
+ iErrorStop = 48;
+ throw iRc;
+ }
+
+ // Append another record (it will be blank)
+ if(( iRc = MyTable->AppendRecord()) != XB_NO_ERROR ){
+ iErrorStop = 49;
+ throw iRc;
+ };
+
+ // mark current record for deletion
+ if(( iRc = MyTable->DeleteRecord()) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ };
+
+ // save current record
+ if(( iRc = MyTable->PutRecord()) != XB_NO_ERROR ){
+ iErrorStop = 51;
+ throw iRc;
+ }
+ // pack the table with no options
+ if(( iRc = MyTable->Pack()) != XB_NO_ERROR ){
+ iErrorStop = 52;
+ throw iRc;
+ }
+
+ /* Close database and associated indexes */
+ if(( iRc = MyTable->Close()) != XB_NO_ERROR ){
+ iErrorStop = 53;
+ throw iRc;
+ }
+
+ }
+ catch( xbInt16 rc ){
+ std::cout << "xb_ex_v3_upd_dbf error. Error stop point = [" << iErrorStop << "] iRc = [" << rc << "]" << std::endl;
+ std::cout << x.GetErrorMessage( rc ) << std::endl;
+ }
+
+#endif // XB_DBF3_SUPPORT
+
+ return 0;
+}
diff --git a/src/examples/xb_ex_v4_create_dbf.cpp b/src/examples/xb_ex_v4_create_dbf.cpp
new file mode 100755
index 0000000..a2aff74
--- /dev/null
+++ b/src/examples/xb_ex_v4_create_dbf.cpp
@@ -0,0 +1,81 @@
+/* xb_ex_v4_create_dbf.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
+
+ This example demonstrates the creation of a Version IV file and and indices
+
+*/
+
+#include <xbase.h>
+
+using namespace xb;
+
+int main()
+{
+
+#ifdef XB_DBF4_SUPPORT
+
+ xbSchema MyRecord[] =
+ {
+ { "FIRSTNAME", XB_CHAR_FLD, 15, 0 },
+ { "LASTNAME", XB_CHAR_FLD, 20, 0 },
+ { "BIRTHDATE", XB_DATE_FLD, 8, 0 },
+ { "AMOUNT", XB_NUMERIC_FLD, 9, 2 },
+ { "RETIRED?", XB_LOGICAL_FLD, 1, 0 },
+ { "ZIPCODE", XB_NUMERIC_FLD, 5, 0 },
+ { "NUMFLD1", XB_FLOAT_FLD, 12, 2 },
+ { "NUMFLD2", XB_FLOAT_FLD, 14, 2 },
+ #ifdef XB_MEMO_SUPPORT
+ { "MEMO1", XB_MEMO_FLD, 10, 0 },
+ #endif
+ { "",0,0,0 }
+ };
+
+ /* define the classes */
+ xbXBase x; /* initialize xbase */
+ x.SetDataDirectory( PROJECT_DATA_DIR ); /* where all the tables/files live */
+
+ xbInt16 iRc;
+ xbDbf * MyDbfFile;
+ xbIx *pIx;
+ void *pTag;
+ MyDbfFile = new xbDbf4( &x );
+
+ if(( iRc = MyDbfFile->CreateTable( "MyV4Table1", "MyV4TableAlias", MyRecord, XB_OVERLAY, XB_MULTI_USER )) != XB_NO_ERROR )
+ x.DisplayError( iRc );
+ else
+ {
+
+ #ifdef XB_MDX_SUPPORT
+
+ /*
+ Create a few index tags
+ CreateTag( const xbString &sIxType, const xbString &sName, const xbString &sKey, const xbString &sFilter,
+ xbInt16 iDescending, xbInt16 iUnique, xbInt16 iOverLay, xbIx **xbIxOut, void **vpTagOut );
+ */
+
+ // std::cout << "Creating three index tags\n";
+ if(( iRc = MyDbfFile->CreateTag( "MDX", "NAME_TAG", "LASTNAME+FIRSTNAME", ".NOT. DELETED()", 0, 0, XB_OVERLAY, &pIx, &pTag )) != XB_NO_ERROR )
+ x.DisplayError( iRc );
+ if(( iRc = MyDbfFile->CreateTag( "MDX", "BDDATE_TAG", "BIRTHDATE", "", 0, 0, XB_OVERLAY, &pIx, &pTag )) != XB_NO_ERROR )
+ x.DisplayError( iRc );
+ if(( iRc = MyDbfFile->CreateTag( "MDX", "ZIP_TAG", "ZIPCODE", "", 0, 0, XB_OVERLAY, &pIx, &pTag )) != XB_NO_ERROR )
+ x.DisplayError( iRc );
+
+ #endif // XB_MDX_SUPPORT
+ }
+
+ MyDbfFile->Close(); /* Close database and associated indexes */
+
+#endif // XB_DBF4_SUPPORT
+ return 0;
+}
diff --git a/src/examples/xb_ex_v4_upd_dbf.cpp b/src/examples/xb_ex_v4_upd_dbf.cpp
new file mode 100755
index 0000000..6f68c73
--- /dev/null
+++ b/src/examples/xb_ex_v4_upd_dbf.cpp
@@ -0,0 +1,283 @@
+/* xb_ex_v4_upd_dbf.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
+
+ This example demonstrates how to open the DBase III table created by xb_ex_v4_create_dbf
+ and apply various updates to the table.
+
+*/
+
+#include <xbase.h>
+
+using namespace xb;
+
+#undef XB_MEMO_FIELDS
+
+int main()
+{
+
+#ifdef XB_DBF4_SUPPORT
+
+ xbInt16 fld_FIRSTNAME;
+ xbInt16 fld_LASTNAME;
+ xbInt16 fld_BIRTHDATE;
+ xbInt16 fld_AMOUNT;
+ xbInt16 fld_RETIRED;
+ xbInt16 fld_ZIPCODE;
+ xbInt16 fld_NUMFLD1;
+ xbInt16 fld_NUMFLD2;
+
+
+ #ifdef XB_MEMO_FIELDS
+ xbInt16 fld_MEMO1;
+ #endif
+
+
+ /* define the classes */
+ xbXBase x; /* initialize xbase */
+ x.SetDataDirectory( PROJECT_DATA_DIR ); /* where all the tables live */
+ x.EnableMsgLogging();
+ x.WriteLogMessage( "Program [xb_ex_v4_upd_dbf] initializing..." );
+
+
+ xbDbf *MyTable = new xbDbf4( &x ); /* class for table */
+
+#ifdef XB_INDEX_NDX
+ xbNdx MyIndex1( &MyTable ); /* class for index 1 */
+#endif
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+
+ try{
+
+ if(( iRc = MyTable->Open( "MyV4Table1.DBF" )) != XB_NO_ERROR ){
+ iErrorStop = 1;
+ throw iRc;
+ }
+
+ /* get the field numbers for all the fields in the table */
+
+
+ fld_FIRSTNAME = MyTable->GetFieldNo( "FIRSTNAME" );
+ fld_LASTNAME = MyTable->GetFieldNo( "LASTNAME" );
+ fld_BIRTHDATE = MyTable->GetFieldNo( "BIRTHDATE" );
+ fld_AMOUNT = MyTable->GetFieldNo( "AMOUNT" );
+ fld_RETIRED = MyTable->GetFieldNo( "RETIRED?" );
+ fld_ZIPCODE = MyTable->GetFieldNo( "ZIPCODE" );
+ fld_NUMFLD1 = MyTable->GetFieldNo( "NUMFLD1" );
+ fld_NUMFLD2 = MyTable->GetFieldNo( "NUMFLD2" );
+
+ #ifdef XB_MEMO_FIELDS
+ fld_MEMO1 = MyTable->GetFieldNo( "MEMO1" );
+ #endif
+
+
+ #ifdef XB_MDX_SUPPPORT
+ std::cout << "Current tag = [" << MyTable->GetCurTagName() << "]\n";
+ #endif
+
+ // Blank the record buffer
+ if(( iRc = MyTable->BlankRecord()) != XB_NO_ERROR ){
+ iErrorStop = 7;
+ throw iRc;
+ }
+
+ // put field examples - using field numbers
+ if(( iRc = MyTable->PutField( fld_LASTNAME, "JONES" )) != XB_NO_ERROR ){
+ iErrorStop = 8;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutField( fld_FIRSTNAME, "JERRY" )) != XB_NO_ERROR ){
+ iErrorStop = 9;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutField( fld_AMOUNT, "12.35" )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutLogicalField( fld_RETIRED, "Y" )) != XB_NO_ERROR ){
+ iErrorStop = 11;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutField( fld_BIRTHDATE, "19880209" )) != XB_NO_ERROR ){
+ iErrorStop = 12;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutLongField( fld_ZIPCODE, 12345 )) != XB_NO_ERROR ){
+ iErrorStop = 13;
+ throw iRc;
+ }
+
+ // Append the first record
+ if(( iRc = MyTable->AppendRecord()) != XB_NO_ERROR ){
+ iErrorStop = 15;
+ throw iRc;
+ }
+
+ // Blank the record buffer
+ if(( iRc = MyTable->BlankRecord()) != XB_NO_ERROR ){
+ iErrorStop = 16;
+ throw iRc;
+ }
+
+ // put field to the record buffer using field name (slightly less efficient than using field numbers)
+ if(( iRc = MyTable->PutField( "LASTNAME", "FUCKPUTIN" )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutField( "FIRSTNAME", "ALBERT" )) != XB_NO_ERROR ){
+ iErrorStop = 21;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutField( "AMOUNT", "987.55" )) != XB_NO_ERROR ){
+ iErrorStop = 22;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutLogicalField( "RETIRED?", "N" )) != XB_NO_ERROR ){
+ iErrorStop = 23;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->PutLongField( "ZIPCODE", 44256 )) != XB_NO_ERROR ){
+ iErrorStop = 24;
+ throw iRc;
+ }
+
+ xbFloat f = (xbFloat) 12345.67;
+ std::cout << f << std::endl;
+
+ if(( iRc = MyTable->PutFloatField( fld_NUMFLD1, f )) != XB_NO_ERROR ){
+ iErrorStop = 13;
+ throw iRc;
+ }
+ xbDouble d = 76543.21;
+ if(( iRc = MyTable->PutDoubleField( fld_NUMFLD2, d )) != XB_NO_ERROR ){
+ iErrorStop = 14;
+ throw iRc;
+ }
+
+ // Append the second record
+ if(( iRc = MyTable->AppendRecord()) != XB_NO_ERROR ){
+ iErrorStop = 25;
+ throw iRc;
+ }
+
+ // get a field with a field number
+ xbString FirstName;
+ if(( iRc = MyTable->GetField( fld_FIRSTNAME, FirstName )) < 0 ){
+ iErrorStop = 30;
+ throw iRc;
+ }
+ std::cout << "First Name is [" << FirstName.Str() << "]" << std::endl;
+
+ xbString LastName;
+ if(( iRc = MyTable->GetField( "LASTNAME", LastName )) < 0 ){
+ iErrorStop = 31;
+ throw iRc;
+ }
+ std::cout << "Last Name is [" << LastName.Str() << "]" << std::endl;
+
+ xbInt16 iNoOfDecimals;
+ if(( iRc = MyTable->GetFieldDecimal( "AMOUNT", iNoOfDecimals )) != XB_NO_ERROR ){
+ iErrorStop = 32;
+ throw iRc;
+ }
+ std::cout << "There are " << iNoOfDecimals << " decimals in the AMOUNT field" << std::endl;
+
+ xbString FieldName;
+ if(( iRc = MyTable->GetFieldName( 4, FieldName )) != XB_NO_ERROR ){
+ iErrorStop = 36;
+ throw iRc;
+ }
+ std::cout << "Field #4 name is " << FieldName.Str() << std::endl;
+
+ xbString sRetired;
+ if(( iRc = MyTable->GetLogicalField( "RETIRED?", sRetired )) < 0 ){
+ iErrorStop = 38;
+ throw iRc;
+ }
+ std::cout << "Switch value = [" << sRetired.Str() << "]" << std::endl;
+
+ xbInt32 lZip;
+ if(( iRc = MyTable->GetLongField( "ZIPCODE", lZip )) < 0 ){
+ iErrorStop = 39;
+ throw iRc;
+ }
+ std::cout << "Long value = [" << lZip << "]" << std::endl;
+
+ if(( iRc = MyTable->GetFloatField( fld_NUMFLD1, f )) < 0 ){
+ iErrorStop = 41;
+ throw iRc;
+ }
+ printf( "Field NUMFLD1 %8.2f\n", f );
+
+
+ if(( iRc = MyTable->GetDoubleField( fld_NUMFLD2, d )) < 0 ){
+ iErrorStop = 42;
+ throw iRc;
+ }
+ printf( "Field NUMFLD2 %8.2f\n", d );
+
+
+ // Initialize the record buffer in preparation for another record
+ if(( iRc = MyTable->BlankRecord()) != XB_NO_ERROR ){
+ iErrorStop = 44;
+ throw iRc;
+ }
+
+ // Append another record (it will be blank)
+ if(( iRc = MyTable->AppendRecord()) != XB_NO_ERROR ){
+ iErrorStop = 45;
+ throw iRc;
+ };
+
+ // mark current record for deletion
+ if(( iRc = MyTable->DeleteRecord()) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ };
+
+ // save current record
+ if(( iRc = MyTable->PutRecord()) != XB_NO_ERROR ){
+ iErrorStop = 51;
+ throw iRc;
+ }
+
+ if(( iRc = MyTable->Commit()) != XB_NO_ERROR ){
+ iErrorStop = 52;
+ throw iRc;
+ }
+
+ /* Close database and associated indexes */
+ if(( iRc = MyTable->Close()) != XB_NO_ERROR ){
+ iErrorStop = 53;
+ throw iRc;
+ }
+
+ }
+ catch( xbInt16 iRc ){
+ std::cout << "xb_ex_v4_upd_dbf error. Error stop point = [" << iErrorStop << "] iRc = [" << iRc << "]" << std::endl;
+ std::cout << x.GetErrorMessage( iRc ) << std::endl;
+ }
+
+#endif // XB_DBF4_SUPPORT
+ return 0;
+}
diff --git a/src/include/xbase.h b/src/include/xbase.h
new file mode 100755
index 0000000..33d2dc9
--- /dev/null
+++ b/src/include/xbase.h
@@ -0,0 +1,93 @@
+/* xbase.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
+
+*/
+
+#include <xbconfig.h>
+#include <stdio.h>
+#include <errno.h>
+#include <time.h>
+#include <math.h>
+
+#ifdef HAVE_INTTYPES_H
+#include <inttypes.h>
+#endif
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+
+// #ifdef STDC_HEADERS
+#ifdef HAVE_STDARGS_H
+#include <stdargs.h>
+#endif
+
+#ifdef HAVE_CTYPE_H
+#include <ctype.h>
+#endif
+
+#ifdef HAVE_STDARG_H
+#include <stdarg.h>
+#endif
+
+#ifdef HAVE_STAT_H
+#include <sys/stat.h>
+#endif
+
+#ifdef HAVE_FCNTL_H
+#include <fcntl.h>
+#endif
+
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+
+#ifdef HAVE_VARARGS_H
+#include <varargs.h>
+#endif
+
+#ifdef HAVE_WINDOWS_H
+#include <windows.h>
+#include <io.h>
+#endif
+
+#include <iomanip>
+
+#include <xbretcod.h>
+#include <xbtypes.h>
+#include <xbstring.h>
+#include <xbssv.h>
+#include <xbdate.h>
+#include <xbtblmgr.h>
+#include <xbxbase.h>
+#include <xblnknod.h>
+#include <xblnklst.h>
+#include <xblnklstord.h>
+#include <xbfile.h>
+#include <xblog.h>
+#include <xbmemo.h>
+#include <xbbcd.h>
+#include <xbuda.h>
+#include <xbexpnode.h>
+#include <xbexp.h>
+
+#include <xbtag.h>
+#include <xbdbf.h> /* dbf base class */
+#include <xbindex.h> /* index base class */
+#include <xbfilter.h>
+#include <xbsql.h>
diff --git a/src/include/xbbcd.h b/src/include/xbbcd.h
new file mode 100755
index 0000000..f94ed01
--- /dev/null
+++ b/src/include/xbbcd.h
@@ -0,0 +1,95 @@
+/* xbbcd.h
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014, 2018, 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
+
+*/
+
+#ifndef __XB_BCD_H__
+#define __XB_BCD_H__
+#ifdef XB_INDEX_SUPPORT
+
+///@cond DOXYOFF
+
+namespace xb{
+
+// structure for bcd value
+// next structure superceeded. Different compilers allocate different
+// sizes to structures with bit fields, can't count on the size
+
+/*
+struct XBDLLEXPORT xbBcdStrucOld {
+ unsigned SigDigits : 8; // significant digit count
+ unsigned Filler : 2; // always set to 1
+ unsigned EncDigits : 5; // encoded digit count
+ unsigned Sign : 1; // +/- sign
+ unsigned char Data[10];
+};
+*/
+
+struct XBDLLEXPORT xbBcdStruct {
+ unsigned char cSigDigits; // significant digit count
+ unsigned char cEncDigits; // encoded digit count
+ unsigned char cData[10]; // data
+};
+
+struct XBDLLEXPORT xbByteSplit {
+ unsigned c1 : 4;
+ unsigned c2 : 4;
+};
+
+class XBDLLEXPORT xbBcd {
+ public:
+
+ xbBcd( const xbString &sIn );
+ xbBcd( xbDouble dIn );
+ xbBcd( const void *vBcd12In );
+ void Set( xbDouble dIn );
+ void Set( const void *cBcd12In );
+ void Set( const xbString &sIn );
+
+
+ void ToString( xbString &sOut );
+ void ToDouble( xbDouble &dOut );
+ void ToBcd( xbBcdStruct &bcdOut );
+ void ToChar( char *cOut );
+
+ // const unsigned char * GetBcd() const;
+ void StringToBcd( const xbString &sStringIn );
+
+// void StringToBcdOld( const xbString &sStringIn );
+
+ xbInt16 Compare( const xbBcd &bcdIn );
+ xbInt16 Compare( xbDouble d );
+
+ const unsigned char *GetData() const;
+ const void * GetBcd() const;
+
+
+ private:
+ void ctor();
+ unsigned char GetEncDigitsNoSign() const;
+ unsigned GetSign() const;
+ unsigned GetSigDigits() const;
+ unsigned GetActualSigDigits() const;
+
+
+// xbBcdStruc bcdOld;
+ xbBcdStruct bcd;
+};
+
+} /* namespace xb */
+
+
+///@endcond DOXYOFF
+
+#endif /* XB_INDEX_SUPPORT */
+#endif /* __XB_BCD_H__ */
diff --git a/src/include/xbconfig.h.in b/src/include/xbconfig.h.in
new file mode 100755
index 0000000..b749ff2
--- /dev/null
+++ b/src/include/xbconfig.h.in
@@ -0,0 +1,122 @@
+// the configured options and settings for xbase
+
+#define xbase_VERSION_MAJOR @xbase_VERSION_MAJOR@
+#define xbase_VERSION_MINOR @xbase_VERSION_MINOR@
+#define xbase_VERSION_PATCH @xbase_VERSION_PATCH@
+
+#define PROJECT_PARENT_DIR "@PROJECT_PARENT_DIR@"
+#define PROJECT_BINARY_DIR "@PROJECT_BINARY_DIR@"
+
+#define PROJECT_SOURCE_DIR "@PROJECT_SOURCE_DIR@"
+#define PROJECT_RUNTIME_DIR "@PROJECT_RUNTIME_DIR@"
+#define PROJECT_DATA_DIR "@PROJECT_DATA_DIR@"
+#define PROJECT_LOG_DIR "@PROJECT_LOG_DIR@"
+#define PROJECT_DFLT_LOGFILE "@CMAKE_SYSTEM_NAME@_@XB_PLATFORM@.xbLog.txt"
+#define EXTRA_LIBS "@EXTRA_LIBS@"
+#define CMAKE_RUNTIME_OUTPUT_DIRECTORY "@CMAKE_RUNTIME_OUTPUT_DIRECTORY@"
+
+
+#define CMAKE_HOME_DIRECTORY "@CMAKE_HOME_DIRECTORY@"
+#define CMAKE_PROJECT_NAME "@CMAKE_PROJECT_NAME@"
+#define BUILD_SHARED_LIBS "@BUILD_SHARED_LIBS@"
+#define CMAKE_SYSTEM_NAME "@CMAKE_SYSTEM_NAME@"
+#define CMAKE_SYSTEM_PROCESSOR "@CMAKE_SYSTEM_PROCESSOR@"
+#define CMAKE_SYSTEM_VERSION "@CMAKE_SYSTEM_VERSION@"
+#define CMAKE_BUILD_TYPE "@CMAKE_BUILD_TYPE@"
+#define CMAKE_C_FLAGS "@CMAKE_C_FLAGS@"
+#define CMAKE_C_FLAGS_DEBUG "@CMAKE_C_FLAGS_DEBUG@"
+#define CMAKE_C_FLAGS_RELEASE "@CMAKE_C_FLAGS_RELEASE@"
+
+
+#define XB_PLATFORM "@XB_PLATFORM@"
+#define Mylibrary_Exports "@Mylibrary_Exports@"
+#define MYLIB_EXPORT "@MYLIB_EXPORT@"
+#define CMAKE_SIZEOF_VOID_P "@CMAKE_SIZEOF_VOID_P@"
+
+#define CMAKE_COMPILER "@CMAKE_CXX_COMPILER_ID@"
+
+// integer definitions
+#define xbInt16 @xbInt16@
+#define xbUInt16 @xbUInt16@
+#define xbInt32 @xbInt32@
+#define xbUInt32 @xbUInt32@
+#define xbInt64 @xbInt64@
+#define xbUInt64 @xbUInt64@
+
+#cmakedefine UNIX
+
+#cmakedefine CMAKE_COMPILER_IS_GNUCC
+#cmakedefine HAVE_CTYPE_H
+#cmakedefine HAVE_DIRENT_H
+#cmakedefine HAVE_DOS_H
+#cmakedefine HAVE_FCNTL_H
+#cmakedefine HAVE_INTTYPES_H
+#cmakedefine HAVE_STDARG_H
+#cmakedefine HAVE_STDARGS_H
+#cmakedefine HAVE_STRING_H
+#cmakedefine HAVE_STRINGS_H
+#cmakedefine HAVE_STAT_H
+#cmakedefine HAVE_UNISTD_H
+#cmakedefine HAVE_VARARGS_H
+#cmakedefine HAVE_WINDOWS_H
+
+#cmakedefine HAVE__CLOSE_F
+#cmakedefine HAVE_CREATEPROCESSW_F
+#cmakedefine HAVE_CREATEPROCESSW_F2
+#cmakedefine HAVE_FCNTL_F
+#cmakedefine HAVE__FDOPEN_F
+#cmakedefine HAVE__FILENO_F
+#cmakedefine HAVE_FOPEN_S_F
+#cmakedefine HAVE__FSOPEN_F
+
+#cmakedefine HAVE_FORK_F
+#cmakedefine HAVE__FSEEKI64_F
+#cmakedefine HAVE_FSEEKO_F
+#cmakedefine HAVE_FTRUNCATE_F
+#cmakedefine HAVE__LOCALTIME64_S_F
+#cmakedefine HAVE_LOCKFILE_F
+#cmakedefine HAVE_LOCKING_F
+#cmakedefine HAVE__LOCKING_F
+#cmakedefine HAVE__OPEN_F
+#cmakedefine HAVE_SETENDOFFILE_F
+#cmakedefine HAVE_VSNPRINTF_F
+#cmakedefine HAVE__VSNPRINTF_S_F
+#cmakedefine HAVE_VSPRINTF_S_F
+
+#cmakedefine XB_PLATFORM_32
+#cmakedefine XB_PLATFORM_64
+#cmakedefine XB_DEBUG_SUPPORT
+#cmakedefine XB_LINKLIST_SUPPORT
+#cmakedefine XB_MEMO_SUPPORT
+#cmakedefine XB_LOGGING_SUPPORT
+#cmakedefine XB_DBF3_SUPPORT
+#cmakedefine XB_DBF4_SUPPORT
+#cmakedefine XB_LOCKING_SUPPORT
+#cmakedefine XB_FUNCTION_SUPPORT
+#cmakedefine XB_EXPRESSION_SUPPORT
+#cmakedefine XB_INDEX_SUPPORT
+#cmakedefine XB_NDX_SUPPORT
+#cmakedefine XB_MDX_SUPPORT
+#cmakedefine XB_SQL_SUPPORT
+#cmakedefine XB_NDXINF_SUPPORT
+#cmakedefine XB_FILTER_SUPPORT
+
+#cmakedefine XB_UTILS_SUPPORT
+#cmakedefine XB_EXAMPLES_SUPPORT
+
+#cmakedefine HAVE_LONG_LONG
+
+#if defined (WIN32)
+ #if defined ( Mylibrary_Exports )
+ #define XBDLLEXPORT __declspec(dllexport)
+ #else
+ #define XBDLLEXPORT __declspec(dllimport)
+ #endif
+#else
+ #define XBDLLEXPORT
+#endif
+
+#if defined (UNIX) && defined (XB_PLATFORM_32)
+ #define _FILE_OFFSET_BITS 64
+#endif
+
diff --git a/src/include/xbdate.h b/src/include/xbdate.h
new file mode 100755
index 0000000..5406cbb
--- /dev/null
+++ b/src/include/xbdate.h
@@ -0,0 +1,123 @@
+/* xbdate.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_XBDATE_H__
+#define __XB_XBDATE_H__
+
+#ifdef CMAKE_COMPILER_IS_GNUCC
+#pragma interface
+#endif
+
+
+namespace xb{
+
+#define XB_FMT_WEEK 1
+#define XB_FMT_MONTH 2
+#define XB_FMT_YEAR 3
+
+// next value is added to the date calculation to match dbase calculation
+// first valid dbase date is 01/01/0001
+#define JUL_OFFSET 1721425L
+
+
+//! @brief xbDate class.
+/*!
+This xbDate class handles two type of date values:<br>
+
+1) Gregorian dates with a format of CCYYMMDD. This is how dates are stored in dbf files.<br>
+2) Julian dates calculated as the number of days since 1901-01-01 + 1721425.<br>
+
+Leap Years: The routines in the class support both leap years (one every four
+years) and leap centuries (one every four hundred years.)
+
+A leap year is a year having 366 days, which can be evenly
+divisible by 4 and not by 100.<br>
+Leap centuries are years which are evenly divisible by 400.<br>
+
+From a programming perspective, Julian dates are useful for date
+arithmetic, determining the difference between two dates or calculating
+a future or past date.<br>
+
+To determine the difference between two dates, convert both dates to a
+Julian date and subtract one from the other.<br>
+
+To calculate a future or past date, convert the base date to a Julian date,
+add (or subtract) the number of days necessary to (from) it and convert the
+julian date back to a Gregorian date.
+*/
+
+class XBDLLEXPORT xbDate : public xbSsv {
+ public:
+
+ xbDate();
+ xbDate( const char * Date8 );
+ xbDate( const xbString &Date8 );
+ xbDate( xbInt32 lJulDate );
+ ~xbDate();
+
+ void operator=( const xbDate &d );
+ void operator+=( xbInt32 i );
+ void operator-=( xbInt32 i );
+ void operator++( xbInt32 i );
+ void operator--( xbInt32 i );
+
+ xbInt32 operator-( const xbDate & ) const;
+ const char * operator-( xbInt32 i );
+ const char * operator+( xbInt32 i );
+
+ xbBool operator==( const xbDate & ) const;
+ xbBool operator!=( const xbDate & ) const;
+ xbBool operator< ( const xbDate & ) const;
+ xbBool operator> ( const xbDate & ) const;
+ xbBool operator<=( const xbDate & ) const;
+ xbBool operator>=( const xbDate & ) const;
+
+ xbInt16 CalcRollingCenturyForYear( xbInt16 year ) const;
+ xbInt16 CenturyOf() const;
+ xbInt16 CharDayOf( xbString &sOutCharDay );
+ xbInt16 CharMonthOf( xbString &sOutCharMonth );
+ 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;
+ xbBool IsLeapYear() const;
+ xbInt32 JulianDays() const;
+ xbInt16 JulToDate8( xbInt32 lJulDate );
+ xbInt16 LastDayOfMonth();
+ xbInt16 MonthOf() const;
+ xbInt16 Set( const xbString &Date8 );
+ xbInt16 Sysdate();
+ xbInt16 YearOf() const;
+
+#ifdef XB_DEBUG_SUPPORT
+ void Dump( const char * title );
+ void DumpDateTables();
+#endif
+
+ private:
+ void SetDateTables();
+ xbString sDate8; /* CCYYMMDD date format ie; 20140718 */
+
+ static int iAggregatedDaysInMonths[2][13];
+ static int iDaysInMonths[2][13];
+};
+
+} /* namespace */
+#endif /*__XB_XBDATE_H__ */
+
diff --git a/src/include/xbdbf.h b/src/include/xbdbf.h
new file mode 100755
index 0000000..710dd14
--- /dev/null
+++ b/src/include/xbdbf.h
@@ -0,0 +1,538 @@
+/* xbdbf.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_XBDBF_H__
+#define __XB_XBDBF_H__
+
+//#ifdef CMAKE_COMPILER_IS_GNUCC
+//#pragma interface
+//#endif
+
+namespace xb{
+
+/*****************************/
+/* Field Types */
+
+#define XB_CHAR_FLD 'C'
+#define XB_LOGICAL_FLD 'L'
+#define XB_NUMERIC_FLD 'N'
+#define XB_DATE_FLD 'D'
+#define XB_MEMO_FLD 'M'
+#define XB_FLOAT_FLD 'F'
+
+/*****************************/
+/* File Status Codes */
+
+#define XB_CLOSED 0
+#define XB_OPEN 1
+#define XB_UPDATED 2
+
+
+/*****************************/
+/* File Access Modes */
+// #define XB_SINGLE_USER 0 // file buffering on
+// #define XB_MULTI_USER 1 // file buffering off
+
+/*****************************/
+/* File Lock Functions */
+#define XB_LOCK 0
+#define XB_UNLOCK 1
+
+#define LK_DBASE 1
+#define LK_CLIPPER 2 // future
+#define LK_FOX 3 // future
+#define LK_XBASE64 9 // future
+
+/*****************************/
+/* Record retrieve options */
+#define XB_ALL_RECS 0
+#define XB_ACTIVE_RECS 1
+#define XB_DELETED_RECS 2
+
+
+/*****************************/
+/* Other defines */
+
+#define XB_OVERLAY 1
+#define XB_DONTOVERLAY 0
+#define XB_CHAREOF '\x1A' /* end of DBF */
+#define XB_CHARHDR '\x0D' /* header terminator */
+
+
+//! @brief Schema used for defining tables with CreateTable methods.
+/*!
+ See program xb_ex_v3_create_dbf.cpp or xb_ex_v4_create_dbf.cpp
+ as examples on how to use.
+
+\code
+xbSchema MyRecord[] = {
+// FieldName, Type, Len, Dec
+ { "FIRSTNAME", XB_CHAR_FLD, 15, 0 },
+ { "LASTNAME", XB_CHAR_FLD, 20, 0 },
+ { "BIRTHDATE", XB_DATE_FLD, 8, 0 },
+ { "AMOUNT", XB_NUMERIC_FLD, 9, 2 },
+ { "RETIRED?", XB_LOGICAL_FLD, 1, 0 },
+ { "ZIPCODE", XB_NUMERIC_FLD, 5, 0 },
+ { "NUMFLD1", XB_FLOAT_FLD, 12, 2 },
+ { "NUMFLD2", XB_FLOAT_FLD, 14, 2 },
+ { "MEMO1", XB_MEMO_FLD, 10, 0 },
+ { "",0,0,0 }};
+\endcode
+*/
+struct XBDLLEXPORT xbSchema {
+ char cFieldName[11];
+ char cType;
+ xbInt16 iFieldLen; /* fields are stored as one byte on record*/
+ xbInt16 iNoOfDecs;
+};
+
+///@cond DOXYOFF
+struct XBDLLEXPORT xbSchemaRec {
+ char cFieldName[11]; /* ASCIIZ field name */
+ char cType; /* field type */
+ char *pAddress; /* pointer to field in record buffer 1 */
+ unsigned char cFieldLen; /* fields are stored as one byte on record */
+ unsigned char cNoOfDecs;
+ char *pAddress2; /* pointer to field in record buffer 2 */
+ xbInt16 iLongFieldLen; /* to handle long field lengths */
+ unsigned char cIxFlag; /* DBase IV Index field flag */
+};
+///@endcond DOXYOFF
+
+
+
+///@cond DOXYOFF
+#ifdef XB_INDEX_SUPPORT
+class XBDLLEXPORT xbIx;
+// structure for file list, each open DBF file can have one or more index files
+struct XBDLLEXPORT xbIxList {
+ xbIxList *next;
+ xbIx *ix;
+ xbString *sFmt;
+};
+#endif // XB_INDEX_SUPPORT
+///@endcond DOXYOFF
+
+
+//! @brief Base class for handling dbf files/tables.
+/*!
+The xbDbf class is used as a base class for accessing dbf files.
+In line with relational theory, a each dbf file can be considered as a table.
+The documentation uses the terms dbf and table interchangeably.<br>
+
+This module handles methods for accessing and updating dbf files.
+
+<br>
+The class is designed to support additional file layouts with a minimal amount of effort.
+If you are wanting to update the library to support a new dbf file type not currently supported
+by the library, create a derived class using xbDbf as a base class and modify methods needed
+to support the new dbf file version.<br>
+See the following for examples on how to start on this:<br>
+xbDbf3 is a derived class from xbDbf and supports the original Dbase III+ file version.<br>
+xbDbf4 is a derived class from xbDbf and supports the original Dbase IV file version.<br>
+
+*/
+
+
+class XBDLLEXPORT xbDbf : public xbFile {
+
+ public:
+ xbDbf( xbXBase *x );
+ virtual ~xbDbf();
+
+ virtual xbInt16 Abort();
+ virtual xbInt16 AppendRecord();
+ virtual xbInt16 BlankRecord();
+ virtual xbInt16 Commit();
+ virtual xbInt16 Close();
+ virtual xbInt16 CopyDbfStructure( xbDbf *dNewTable, const xbString &sTableName, const xbString &sTableAlias, xbInt16 iOverlay, xbInt16 iShareMode );
+ virtual xbInt16 CreateTable ( const xbString &sTableName, const xbString &sAlias, xbSchema *pSchema, xbInt16 iOverlay, xbInt16 iShareMode ) = 0;
+ virtual xbInt16 DeleteTable ();
+ virtual xbInt16 DeleteAll ( xbInt16 iOption );
+ virtual xbInt16 DeleteAllRecords ();
+ virtual xbInt16 DeleteRecord ();
+ virtual xbInt16 DumpHeader ( xbInt16 iOption ) const;
+ virtual xbInt16 DumpRecord ( xbUInt32 ulRecNo, xbInt16 iOutputDest = 0, xbInt16 iOutputFmt = 0 );
+ virtual xbInt16 GetAutoCommit () const;
+ virtual xbInt16 GetAutoCommit ( xbInt16 iOption ) const;
+ virtual xbUInt32 GetCurRecNo () const;
+ virtual xbInt16 GetDbfStatus () const;
+ virtual xbInt32 GetFieldCnt () const;
+ virtual xbInt16 GetFirstRecord ();
+ virtual xbInt16 GetFirstRecord ( xbInt16 iOption );
+ virtual xbInt16 GetLastRecord ();
+ virtual xbInt16 GetLastRecord ( xbInt16 iOption );
+
+ virtual xbInt16 GetNextRecord ();
+ virtual xbInt16 GetNextRecord ( xbInt16 iOption );
+ virtual xbInt16 GetNextRecord ( xbInt16 iOption, xbUInt32 ulStartRec );
+ virtual xbInt32 GetPhysicalIxCnt () const;
+ virtual xbInt16 GetPrevRecord ();
+ virtual xbInt16 GetPrevRecord ( xbInt16 iOption );
+ virtual xbInt16 GetRecord ( xbUInt32 ulRecNo );
+ virtual xbInt16 GetRecordCnt ( xbUInt32 & ulRecCnt );
+ virtual char * GetRecordBuf ( xbInt16 iOpt = 0 ) const;
+ virtual xbUInt16 GetRecordLen () const;
+ virtual const xbString &GetTblAlias() const;
+ virtual xbInt16 GetVersion () const = 0;
+ virtual xbXBase *GetXbasePtr () const; // return xbase pointer
+
+ virtual xbBool MemoFieldsExist () const;
+
+ virtual xbInt16 Open ( const xbString &sTableName );
+ virtual xbInt16 Open ( const xbString &sTableName, const xbString &sAlias );
+ virtual xbInt16 Open ( const xbString &sTableName, const xbString &sAlias, xbInt16 iOpenMode, xbInt16 iShareMode ) = 0;
+ virtual xbInt16 Pack ();
+ virtual xbInt16 Pack ( xbUInt32 &ulDeletedRecCnt );
+
+
+ virtual xbInt16 PutRecord (); // Put record to current location
+ virtual xbInt16 PutRecord ( xbUInt32 ulRecNo );
+ virtual xbInt16 ReadHeader ( xbInt16 iFilePositionOption, xbInt16 iReadOption );
+ virtual xbInt16 RecordDeleted ( xbInt16 iOpt = 0 ) const;
+
+ virtual xbInt16 SetAutoCommit ( xbInt16 iAutoCommit );
+
+ virtual xbInt16 UndeleteAllRecords();
+ virtual xbInt16 UndeleteRecord ();
+ virtual xbInt16 Zap ();
+
+
+ /* field methods */
+ //virtual xbInt16 GetRawField( xbInt16 iFieldNo, char *Buf, xbUInt32 BufSize, xbInt16 iRecBufSw ) const;
+ virtual xbInt16 GetField(xbInt16 iFieldNo, xbString &sFieldValue, xbInt16 iRecBufSw ) const;
+ virtual xbInt16 GetField(xbInt16 iFieldNo, xbString &sFieldValue) const;
+ virtual xbInt16 GetField(const xbString &sFieldName, xbString &sFieldValue) const;
+ virtual xbInt16 GetFieldDecimal( xbInt16 iFieldNo, xbInt16 &iFieldDecimal ) const;
+ virtual xbInt16 GetFieldDecimal( const xbString &sFieldName, xbInt16 &iFieldDecimal ) const;
+ virtual xbInt16 GetFieldLen( xbInt16 iFieldNo, xbInt16 &iFieldLen ) const;
+ virtual xbInt16 GetFieldLen( const xbString &sFieldName, xbInt16 &iFieldLen ) const;
+ virtual xbInt16 GetFieldName( xbInt16 iFieldNo, xbString &sFieldName ) const;
+
+ virtual xbInt16 GetFieldNo( const xbString &sFieldName, xbInt16 &iFieldNo ) const;
+ virtual xbInt16 GetFieldNo( const xbString &sFieldName ) const;
+
+ virtual xbInt16 GetFieldType( xbInt16 iFieldNo, char &cFieldType ) const;
+ virtual xbInt16 GetFieldType( const xbString &sFieldName, char &cFieldType ) const;
+ virtual xbInt16 PutField( const xbString &sFieldName, const xbString &sFieldData );
+ virtual xbInt16 PutField( xbInt16 iFieldNo, const xbString &sFieldData );
+
+ virtual xbInt16 PutLogicalField( xbInt16 iFieldNo, const xbString &sFieldData );
+ virtual xbInt16 PutLogicalField( const xbString &sFieldName, const xbString &sFieldData );
+ virtual xbInt16 GetLogicalField( xbInt16 iFieldNo, xbString &sFieldData ) const;
+ virtual xbInt16 GetLogicalField( const xbString &sFieldName, xbString &sFieldData) const;
+
+ virtual xbInt16 PutLogicalField( xbInt16 iFieldNo, xbBool bFieldData );
+ virtual xbInt16 PutLogicalField( const xbString &sFieldName, xbBool bFieldData );
+ virtual xbInt16 GetLogicalField( xbInt16 iFieldNo, xbBool &bFieldData ) const;
+ virtual xbInt16 GetLogicalField( xbInt16 iFieldNo, xbBool &bFieldData, xbInt16 iRecBufSw ) const;
+ virtual xbInt16 GetLogicalField( const xbString &sFieldName, xbBool &bFieldData) const;
+
+ virtual xbInt16 GetLongField( xbInt16 iFieldNo, xbInt32 &lFieldValue ) const;
+ virtual xbInt16 GetLongField( const xbString &sFieldName, xbInt32 &lFieldValue ) const;
+ virtual xbInt16 PutLongField( xbInt16 iFieldNo, xbInt32 lFieldValue );
+ virtual xbInt16 PutLongField( const xbString &sFieldNo, xbInt32 lFieldValue );
+
+ virtual xbInt16 GetULongField( xbInt16 iFieldNo, xbUInt32 &lFieldValue ) const;
+ virtual xbInt16 GetULongField( const xbString &sFieldName, xbUInt32 &lFieldValue ) const;
+ virtual xbInt16 PutULongField( xbInt16 iFieldNo, xbUInt32 lFieldValue );
+ virtual xbInt16 PutULongField( const xbString &sFieldNo, xbUInt32 lFieldValue );
+
+ virtual xbInt16 GetDoubleField( xbInt16 FieldNo, xbDouble &dFieldValue ) const;
+ virtual xbInt16 GetDoubleField( xbInt16 FieldNo, xbDouble &dFieldValue, xbInt16 iRecBufSw ) const;
+ virtual xbInt16 GetDoubleField( const xbString &sFieldName, xbDouble &dFieldValue ) const;
+ virtual xbInt16 PutDoubleField( xbInt16 FieldNo, xbDouble dFieldValue );
+ virtual xbInt16 PutDoubleField( const xbString &FieldName, xbDouble dFieldValue );
+
+ virtual xbInt16 GetFloatField( xbInt16 iFieldNo, xbFloat &fFieldValue ) const;
+ virtual xbInt16 GetFloatField( const xbString &sFieldName, xbFloat &fFieldValue ) const;
+ virtual xbInt16 PutFloatField( xbInt16 iFieldNo, xbFloat fFieldValue );
+ virtual xbInt16 PutFloatField( const xbString &sFieldName, xbFloat fFieldValue );
+
+ virtual xbInt16 GetDateField( xbInt16 iFieldNo, xbDate &dt ) const;
+ virtual xbInt16 GetDateField( const xbString &sFieldName, xbDate &dt ) const;
+ virtual xbInt16 PutDateField( xbInt16 iFieldNo, const xbDate &dt );
+ virtual xbInt16 PutDateField( const xbString &sFieldName, const xbDate &dt );
+
+
+
+ #ifdef XB_MEMO_SUPPORT
+ virtual xbInt16 GetMemoFieldCnt () const;
+ virtual xbMemo *GetMemoPtr ();
+ virtual xbUInt32 GetCreateMemoBlockSize() const;
+ virtual xbInt16 GetMemoField ( xbInt16 iFldNo, xbString &sMemoData );
+ virtual xbInt16 GetMemoField ( const xbString & sFldName, xbString &sMemoData );
+ virtual xbInt16 GetMemoFieldLen ( xbInt16 iFldNo, xbUInt32 &ullMemoFieldLen );
+ virtual xbInt16 GetMemoFieldLen ( const xbString & sFldName, xbUInt32 &ulMemoFieldLen );
+ virtual xbBool MemoFieldExists ( xbInt16 iFieldNo ) const;
+ virtual xbBool MemoFieldExists ( const xbString &sFieldName ) const;
+ virtual xbInt16 SetCreateMemoBlockSize( xbUInt32 ulBlockSize ) = 0;
+ virtual xbInt16 UpdateMemoField ( xbInt16 iFldNo, const xbString &sMemoData );
+ virtual xbInt16 UpdateMemoField ( const xbString & sFldName, const xbString &sMemoData );
+ #endif // XB_MEMO_SUPPORT
+
+
+ #ifdef XB_LOCKING_SUPPORT
+ virtual xbInt16 LockTable ( xbInt16 iLockFunction );
+ virtual xbInt16 LockRecord ( xbInt16 iLockFunction, xbUInt32 ulRecNo );
+ virtual xbInt16 LockAppend ( xbInt16 iLockFunction );
+ virtual xbInt16 LockHeader ( xbInt16 iLockFunction );
+
+ #ifdef XB_MEMO_SUPPORT
+ virtual xbInt16 LockMemo ( xbInt16 iLockFunction );
+ virtual xbBool GetMemoLocked () const;
+ #endif // XB_MEMO_LOCK
+
+ #ifdef XB_INDEX_SUPPORT
+ virtual xbInt16 LockIndices ( xbInt16 iLockFunction );
+ #endif // XB_INDEX_SUPPORT
+
+ xbInt16 GetAutoLock () const;
+ void SetAutoLock ( xbInt16 iAutoLock );
+ xbInt16 GetLockFlavor () const;
+ void SetLockFlavor ( xbInt16 iLockFlavor );
+ xbBool GetTableLocked () const;
+ xbBool GetHeaderLocked () const;
+ xbUInt32 GetAppendLocked () const;
+ xbLinkListNode<xbUInt32> * GetFirstRecLock () const;
+
+ #ifdef XB_DEBUG_SUPPORT
+ void DumpTableLockStatus() const;
+ #endif // XB_DEBUG_SUPPORT
+ #endif // XB_LOCKING_SUPPORT
+
+
+ #ifdef XB_INDEX_SUPPORT
+ virtual xbInt16 CloseIndexFile( xbIx *pIx );
+ virtual xbInt16 CreateTag( const xbString &sIxType, const xbString &sName, const xbString &sKey, const xbString &sFilter,
+ xbInt16 iDescending, xbInt16 iUnique, xbInt16 iOverLay, xbIx **xbIxOut, void **vpTagOut );
+ virtual xbInt16 DeleteTag( const xbString &sIxType, const xbString &sName );
+ virtual xbInt16 DeleteAllIndexFiles();
+ virtual xbInt16 Find( xbString &sKey );
+ virtual xbInt16 Find( xbDate &dtKey );
+ virtual xbInt16 Find( xbDouble &dKey );
+ virtual xbIx *GetCurIx() const;
+ virtual void *GetCurTag() const;
+
+ virtual xbInt16 GetFirstKey();
+ virtual xbInt16 GetNextKey();
+ virtual xbInt16 GetPrevKey();
+ virtual xbInt16 GetLastKey();
+
+ virtual const xbString &GetCurIxType() const;
+ virtual const xbString &GetCurTagName() const;
+ virtual xbIxList *GetIxList() const;
+ xbLinkListNode<xbTag *> *GetTagList () const;
+ virtual xbInt16 OpenIndex( const xbString &sIxType, const xbString &sIndexName );
+ virtual xbInt16 SetCurTag( const xbString &sTagName );
+ virtual void SetCurTag( const xbString &sIxType, xbIx *pIx, void *vpTag );
+
+ #ifdef XB_DEBUG_SUPPORT
+ virtual xbInt16 CheckTagIntegrity( xbInt16 iTagOpt, xbInt16 iOutputOpt );
+ virtual xbInt16 Reindex( xbInt16 iTagOpt );
+ #endif // XB_DEBUG_SUPPORT
+ #endif // XB_INDEX_SUPPORT
+
+ #ifdef XB_NDXINF_SUPPORT
+ virtual xbInt16 AssociateIndex( const xbString &sType, const xbString &sName, xbInt16 iOption );
+ xbLinkListNode<xbString> *GetNdxInfList() const;
+ #endif // XB_NDXINF_SUPPORT
+
+ //#ifdef XB_MDX_SUPPORT
+ //virtual xbInt16 GetCreateMdxBlockSize() const;
+ //virtual xbInt16 SetCreateMdxBlockSize( xbInt16 ulBlockSize );
+ //#endif
+
+
+
+ protected:
+ #ifdef XB_INDEX_SUPPORT
+ friend class xbIx;
+ friend class xbIxMdx;
+
+ xbInt16 AddIndex( xbIx *ix, const xbString &sFmt );
+ void ClearTagList();
+ virtual xbInt16 GetNdxInfFileName( xbString &sNdxIdxFileName );
+ xbInt16 RemoveIndex( xbIx * ix );
+ void UpdateSchemaIxFlag( xbInt16 iFldNo, unsigned char cVal );
+ virtual xbInt16 UpdateTagList ();
+ #endif
+
+
+
+ #ifdef XB_LOCKING_SUPPORT
+ void SetHeaderLocked ( xbBool bTableLocked );
+ void SetTableLocked ( xbBool bTableLocked );
+ #endif // XB_LOCKING_SUPORT
+
+ #ifdef XB_MEMO_SUPPORT
+ xbInt16 iMemoFieldCnt; // Memo field cnt in the table
+ xbMemo *Memo; // Pointer to memo class
+ xbUInt32 ulCreateMemoBlockSize; // blocksize to use when creating dbt file
+ #endif
+
+ #ifdef XB_NDXINF_SUPPORT
+ virtual xbInt16 DeleteNdxInfData();
+ virtual xbInt16 LoadNdxInfData();
+ virtual xbInt16 SaveNdxInfData();
+ #endif // XB_NDXINF_SUPPORT
+
+/*
+ #ifdef XB_MDX_SUPPORT
+ xbInt16 iCreateMdxBlockSize;
+ #endif // XB_MDX_SUPPORT
+*/
+
+ virtual xbInt16 GetRawField( xbInt16 iFieldNo, char *Buf, xbUInt32 BufSize, xbInt16 iRecBufSw ) const;
+ virtual void InitVars();
+ virtual xbInt16 SetVersion() = 0;
+ virtual xbInt16 ValidateSchema( xbSchema * s ) = 0;
+ xbInt16 WriteHeader( xbInt16 iPositionOption, xbInt16 iWriteOption );
+
+
+ xbUInt32 ulCurRec; // Current record or zero
+ xbInt16 iAutoCommit; // Auto commit updates if not explicitly performed before moving off record?
+ // -1 --> Use DBMS default
+ // 0 --> No auto update on this table, regardless of DBMS setting
+ // 1 --> Auto update on this table, regardless of DBMS setting
+
+ xbInt16 iFileVersion; // xBase file version - which class is in play
+
+
+ xbString sAlias; // table alias
+ xbInt16 iNoOfFields;
+ xbInt16 iDbfStatus; // 0 = closed
+ // 1 = open
+ // 2 = updates pending
+
+ xbSchemaRec *SchemaPtr; // Pointer to field data
+ char *RecBuf; // Pointer to record buffer
+ char *RecBuf2; // Pointer to original rec buf
+
+
+/* Next several variables are database header fields, up through dbase V */
+ unsigned char cVersion;
+ char cUpdateYY;
+ char cUpdateMM;
+ char cUpdateDD;
+ xbUInt32 ulNoOfRecs;
+ xbUInt16 uiHeaderLen;
+ xbUInt16 uiRecordLen;
+ char cTransactionFlag;
+ char cEncryptionFlag;
+ char cIndexFlag;
+ char cLangDriver; // dbase 7 sets to 1B
+
+
+
+ private:
+ void ResetNoOfRecords();
+
+
+#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
+
+
+#ifdef XB_INDEX_SUPPORT
+ xbIxList *ixList; // pointer to a list of indices associated with the table
+// #ifdef XB_MDX_SUPPORT
+// xbIx *ixMdx; // pointer to production multi-tag index file
+// #endif
+ 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
+
+#ifdef XB_NDXINF_SUPPORT
+ xbLinkList<xbString> llNdxInfData; // linked list of strings containing ndx file entries
+#endif // XB_NDXINF_SUPPORT
+
+
+};
+
+
+#ifdef XB_DBF3_SUPPORT
+//! @brief Derived class for handling dbf version III files/tables.
+/*!
+The xbDbf class is used as a base class for accessing dbf files.
+The xbDbf3 class is derived from the xbDbf class and is designed to handle the
+orginal version 3 type files.
+*/
+
+class XBDLLEXPORT xbDbf3 : public xbDbf {
+ public:
+ xbDbf3(xbXBase *x);
+ ~xbDbf3();
+ virtual xbInt16 CreateTable ( const xbString &sTableName, const xbString &sAlias, xbSchema *, xbInt16 iOverlay, xbInt16 iShareMode );
+ virtual xbInt16 GetVersion () const;
+ virtual xbInt16 Open ( const xbString &sTableName, const xbString &sAlias, xbInt16 iOpenMode, xbInt16 iShareMode );
+
+ #ifdef XB_MEMO_SUPPORT
+ virtual xbInt16 SetCreateMemoBlockSize( xbUInt32 iBlockSize );
+ #endif
+
+ protected:
+ xbInt16 SetVersion ();
+ virtual xbInt16 ValidateSchema( xbSchema *s );
+
+ private:
+
+};
+#endif /* XB_DBF3_SUPPORT */
+
+
+#ifdef XB_DBF4_SUPPORT
+//! @brief Derived class for handling dbf version IV files/tables.
+/*!
+The xbDbf class is used as a base class for accessing dbf files.
+The xbDbf4 class is derived from the xbDbf class and is designed to handle the
+orginal version 4 type files.
+*/
+class XBDLLEXPORT xbDbf4 : public xbDbf {
+ public:
+ xbDbf4( xbXBase *x );
+
+ ~xbDbf4();
+
+ virtual xbInt16 CreateTable ( const xbString &sTableName, const xbString &sAlias, xbSchema *, xbInt16 iOverlay, xbInt16 iShareMode );
+ virtual xbInt16 GetVersion () const;
+ virtual xbInt16 Open ( const xbString &sTableName, const xbString &sAlias, xbInt16 iOpenMode, xbInt16 iShareMode );
+
+ #ifdef XB_MEMO_SUPPORT
+ virtual xbInt16 SetCreateMemoBlockSize( xbUInt32 iBlockSize );
+ #endif
+
+ protected:
+ // void InitVars ();
+ xbInt16 SetVersion();
+ virtual xbInt16 ValidateSchema ( xbSchema *s );
+
+ private:
+
+};
+
+#endif /* XB_DBF4_SUPPORT */
+
+} /* namespace xb */
+#endif /* __XB_DBF_H__ */
diff --git a/src/include/xbexp.h b/src/include/xbexp.h
new file mode 100755
index 0000000..96413ac
--- /dev/null
+++ b/src/include/xbexp.h
@@ -0,0 +1,215 @@
+/* xbexp.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_EXP_H__
+#define __XB_EXP_H__
+
+
+// #ifdef CMAKE_COMPILER_IS_GNUCC
+// #pragma interface
+// #endif
+
+
+
+#ifdef XB_FUNCTION_SUPPORT
+#define XB_EXP_CHAR 'C'
+#define XB_EXP_DATE 'D'
+#define XB_EXP_LOGICAL 'L'
+#define XB_EXP_NUMERIC 'N'
+#define XB_EXP_UNKNOWN 'U'
+#endif
+
+#ifdef XB_EXPRESSION_SUPPORT
+
+#define XB_EXP_CONSTANT 'C'
+#define XB_EXP_FUNCTION 'F'
+#define XB_EXP_FIELD 'D'
+#define XB_EXP_OPERATOR 'O'
+#define XB_EXP_NOTROOT 'N' // not root node, needs further parsing
+#define XB_EXP_PRE_OPERATOR 'B' // (B)efore) pre increment, pre decrement
+#define XB_EXP_POST_OPERATOR 'A' // (A)fter) post increment, pre decrement
+
+#define XB_END_OF_EXPRESSION -100
+
+// #define XB_UNBALANCED_PARENS -101
+// #define XB_UNBALANCED_QUOTES -102
+
+
+namespace xb{
+
+///@cond DOXYOFF
+struct XBDLLEXPORT xbExpToken {
+ xbString sExpression; // in - expression to pull next token from
+ // out - remainder of the expression after token removed
+ xbString sToken; // next token pulled from the expression
+ char cNodeType; // one of XB_EXP_CONSTANT, XB_EXP_FUNCTION, XB_EXP_FIELD, XB_EXP_OPERATOR, XB_EXP_NOTROOT
+ char cReturnType; // one of XB_EXP_CHAR, XB_EXP_DATE, XB_EXP_LOGICAL, XB_EXP_NUMERIC, XB_EXP_UNKNOWN
+ xbInt16 iSts; // return status after retrieving or attempting next token from expression
+ // 0 = no error
+ // XB_END_OF_EXPRESSION
+ // XB_UNBALANCED_PARENS
+ // XB_UNBALANCED_QUOTES
+ char cPrevNodeType; // previous node type
+ char cPrevReturnType; // previous return type
+
+ // constructor
+ xbExpToken() { cNodeType = 0; cReturnType = 0; iSts = 0; cPrevNodeType = 0; cPrevReturnType = 0; }
+};
+///@endcond DOXYOFF
+
+
+/************************************************************************/
+
+//! @brief Class for handling expressions.
+/*!
+The xbExp class is used for parsing and evaluating expression.
+
+The Xbase64 library includes an expression parsing module which assists
+application programmers by providing a high level data manipulation tool and
+also allows for building complex index keys.
+
+The functions included were derived from dBASE III Plus, Dbase IV and Clipper.<br><br>
+
+<h3>Internal fuctioning</h3>
+The expression module works in two phases. Firstly, method
+<em>ParseExpression</em> is called and builds an expression tree from
+all the components of the expression. The tree is made up of individual
+nodes. The expression is checked for valid field names, literals,
+operands and functions. Any field references are resolved. If fields
+are used in an expression and the database name for the field is not
+included in the name with the -> operand, the routines assume the
+associated database has been successfully opened.
+<br>
+Secondly, method <em>ProcessExpression</em> is called to process the
+expression tree created by ParseExpression(). The routine parses each
+node in the expression tree, executing functions, processing operands
+and manipulating data to produce the desired result.<br>
+
+If an expression will be processed repeatedly, it is best to pre-parse the
+tree using <em>ParseExpression</em>, then for each new call to the expression,
+execute method <em>ProcessExpression</em> which processes the tree.<br><br>
+
+<h3>Expression Return Types</h3>
+Expressions will return a type of CHAR, NUMERIC, DATE or LOGICAL.<br>
+
+An expression return type can be determined with method <em>
+GetExpressionResultType</em> after parsing it.<br>
+
+Expressions returning a return type of CHAR are limited to a 200 byte internal
+buffer. There is also a 100 byte limit for NDX index key support. If
+the 200 byte limit is not large enough for your application, adjust field
+<em>enum { WorkBufMaxLen = 200 };</em> in file <em>exp.h</em>.<br><br>
+
+<h3>Expression Functions</h3>
+Each expression function also has a corresponding C++ function. It is
+slightly more efficient to call the C++ functions directly, rather than
+execute the expression parsing routines.<br><br>
+
+<h3>Expression Components</h3>
+Expressions are made up of one or more tokens. A token is one of literal,
+database field, operand or function. Literals are either numeric or character.
+Character literals are enclosed in 'single' or "double" quotes. numeric
+literals are a series of one or more contiguous numerals, ".", "+" or "-'".
+<br><br>
+A field is simply a field name in the default database, or is in the form
+of database->fieldname.
+
+*/
+
+class XBDLLEXPORT xbExp{
+
+ public:
+ xbExp( xbXBase * );
+ xbExp( xbXBase *, xbDbf * );
+ virtual ~xbExp();
+ void ClearTreeHandle();
+
+
+ #ifdef XB_DEBUG_SUPPORT
+ void DumpTree( xbInt16 iOption );
+ void DumpToken( xbExpToken &t, xbInt16 iOption = 0 );
+ #endif
+
+ xbInt16 GetResultLen() const;
+ char GetReturnType() const;
+ xbInt16 GetBoolResult( xbBool &bResult );
+ xbInt16 GetDateResult( xbDate &dtResult );
+ xbInt16 GetNumericResult( xbDouble &dResult );
+ xbInt16 GetStringResult( xbString &sResult );
+ xbInt16 GetStringResult( char * vpResult, xbUInt32 ulLen );
+ xbExpNode *GetTreeHandle();
+ xbInt16 ParseExpression( const xbString &sExpression );
+ xbInt16 ParseExpression( xbDbf *dbf, const xbString &sExpression );
+ xbInt16 ProcessExpression();
+ xbInt16 ProcessExpression( xbInt16 iRecBufSw );
+
+
+ protected:
+ xbInt16 GetNextToken( xbExpToken &t );
+ xbInt16 OperatorWeight( const xbString &sOperator );
+ xbExpNode *GetNextNode( xbExpNode * n ) const; // traverses the tree from bottom left node, right, then up
+
+ private: // methods
+
+ // xbInt16 CalcExpressionResultLen();
+ xbInt16 CalcFunctionResultLen( xbExpNode *n ) const;
+ xbInt16 CalcCharNodeLen( xbExpNode *n );
+ xbInt16 CheckParensAndQuotes( const xbString &sExpression );
+ xbInt16 GetExpressionResultLen() const;
+
+ xbInt16 GetTokenCharConstant ( xbExpToken &t );
+ xbInt16 GetTokenDatabaseField ( xbExpToken &t );
+ xbInt16 GetTokenDateConstant ( xbExpToken &t );
+ xbInt16 GetTokenFunction ( xbExpToken &t );
+ xbInt16 GetTokenLogicalConstant( xbExpToken &t );
+ xbInt16 GetTokenNumericConstant( xbExpToken &t );
+ xbInt16 GetTokenOperator ( xbExpToken &t );
+ xbInt16 GetTokenParen ( xbExpToken &t );
+
+ xbBool IsFunction ( const xbString &sExp, char &cReturnType );
+ xbBool IsLogicalConstant ( const xbString &sExp );
+ xbBool IsNumericConstant ( const xbString &sExp, char cPrevNodeType );
+ xbBool IsOperator ( const xbString &sExp );
+ char IsTokenSeparator ( char c );
+ xbBool IsWhiteSpace ( char c );
+
+ xbInt16 ParseExpression ( const xbString &sExpression, xbInt16 iWeight );
+ xbInt16 ParseExpressionConstant( xbExpToken &t, xbExpNode *n );
+ xbInt16 ParseExpressionFunction( xbExpToken &t, xbExpNode *n, xbInt16 iWeight );
+ xbInt16 ParseExpressionFunctionParms( const xbString &sParms, xbLinkList<xbString> &llParms );
+ xbInt16 ParseExpressionField ( xbExpToken &t, xbExpNode *n );
+ xbInt16 ParseExpressionOperator( xbExpToken &t, xbExpNode *n, xbInt16 iWeight );
+
+ xbInt16 ProcessExpressionFunction( xbExpNode *n, xbInt16 iRecBufSw = 0 );
+ xbInt16 ProcessExpressionOperator( xbExpNode *n );
+
+ private: // fields
+ xbXBase *xbase;
+ xbDbf *dbf;
+ xbExpNode *nTree; // pointer to tree of expNodes
+ // xbInt16 iExpLen; // size of expression result
+
+
+};
+
+/* Expression handler */
+
+
+};
+#endif // XB_EXPRESSION_SUPPORT
+#endif // __XB_EXP_H__
+
+
diff --git a/src/include/xbexpnode.h b/src/include/xbexpnode.h
new file mode 100755
index 0000000..f50d9eb
--- /dev/null
+++ b/src/include/xbexpnode.h
@@ -0,0 +1,120 @@
+/* xbexpnode.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_EXPNODE_H__
+#define __XB_EXPNODE_H__
+
+// #ifdef CMAKE_COMPILER_IS_GNUCC
+// #pragma interface
+// #endif
+
+#ifdef XB_EXPRESSION_SUPPORT
+
+
+namespace xb{
+
+//class XBDLLEXPORT xbDbf;
+
+/************************************************************************/
+//! @brief Expression node class for handling expression nodes.
+/*!
+The xbExpNode class is used by the expression logic for handling specific
+nodes within a tree of nodes.<br>
+
+Expressions are parsed into nodes and a logical tree of nodes is created
+out of all the individual components within the expression.<br>
+
+This class is used for handling a specific node within a tree.<br>
+
+An application program will typically not need to be concerned with
+this class.<br>
+
+*/
+class XBDLLEXPORT xbExpNode {
+ public:
+ xbExpNode();
+ xbExpNode( xbString &sNodeText, char cReturnType, char cNodeType );
+ xbExpNode( xbString &sNodeText, char cNodeType );
+ xbExpNode( char cNodeType );
+
+ virtual ~xbExpNode();
+ xbInt16 AddChild( xbExpNode *n );
+ xbExpNode *GetChild( xbUInt32 ulChildNo ) const;
+ xbUInt32 GetChildCnt() const;
+ xbUInt32 GetChildNo() const;
+ xbDbf *GetDbf() const;
+ xbInt16 GetFieldNo() const;
+ xbExpNode *GetFirstNode();
+ xbExpNode *GetNextNode() const;
+ void GetNodeText( xbString &sNodeText ) const;
+ char GetNodeType() const;
+ xbExpNode *GetParent() const;
+ xbString &GetStringResult();
+ xbBool GetBoolResult() const;
+ xbDouble GetNumericResult() const;
+ xbUInt32 GetResultLen() const;
+ xbExpNode *GetRightSibling() const;
+ char GetReturnType() const;
+ xbInt16 GetWeight() const;
+ xbBool HasRightSibling() const;
+ xbBool IsOperator() const;
+ xbBool IsUnaryOperator() const;
+ void RemoveLastChild();
+ void SetResultLen( xbUInt32 ulResultLen );
+ void SetDbfInfo( xbDbf *dbf );
+ void SetDbfInfo( xbDbf *dbf, xbInt16 iFieldNo );
+ void SetNodeText( xbString &sNodeText );
+ void SetNodeType( char cNodeType );
+ void SetParent( xbExpNode *n );
+ void SetResult( xbString &sResult );
+ void SetResult( xbDate &dtResult );
+ void SetResult( xbBool bResult );
+ void SetResult( xbDouble dResult );
+ void SetReturnType( char cReturnType );
+ void SetWeight( xbInt16 iWeight );
+
+ #ifdef XB_DEBUG_SUPPORT
+ void DumpNode( xbInt16 iOption ) const; // 0 = no children, 1 = and children
+ #endif
+
+ private:
+ xbString sNodeText; // expression text
+ char cReturnType; // one of: XB_EXP_CHAR, XB_EXP_DATE, XB_EXP_LOGICAL, XB_EXP_NUMERIC
+ char cNodeType; // one of: XB_EXP_CONSTANT, XB_EXP_FUNCTION, XB_EXP_FIELD, XB_EXP_OPERATOR
+ xbString sResult; // char result, and operator
+ xbDouble dResult; // numeric and bool results
+ xbExpNode * nParent; // pointer to parent
+ xbLinkList<xbExpNode *> llChildren; // linked list of descendent nodes
+ xbDbf *dbf; // pointer to dbf, used for field, RECNO() and RECCOUNT()
+ xbInt16 iFieldNo; // field no if DBF field
+ xbUInt32 ulResultLen; // for string results, accumulated length of character operations
+ // includes the sum of all nodes under this + this
+ // date = 8, numeric = 4, logical = 1
+ xbInt16 iWeight; // used for buildign the tree of nodes, assigned to operators
+ // the higher the number, the lower it goes on the tree
+
+};
+
+/************************************************************************/
+
+/* Expression handler */
+
+
+};
+#endif // XB_EXPRESSION_SUPPORT
+#endif // __XB_EXP_H__
+
+
diff --git a/src/include/xbfile.h b/src/include/xbfile.h
new file mode 100755
index 0000000..a636632
--- /dev/null
+++ b/src/include/xbfile.h
@@ -0,0 +1,194 @@
+/* xbfile.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_FILE_H__
+#define __XB_FILE_H__
+
+#ifdef CMAKE_COMPILER_IS_GNUCC
+#pragma interface
+#endif
+
+/*****************************/
+/* File Open Modes */
+#define XB_READ 0
+#define XB_READ_WRITE 1
+#define XB_WRITE 2
+
+/*****************************/
+/* File Access Modes */
+#define XB_SINGLE_USER 0 // file buffering on
+#define XB_MULTI_USER 1 // file buffering off
+
+namespace xb{
+
+/*! @brief Class for handling low level file I/O.
+*/
+
+/*!
+The xbFile class is used as an abstraction layer to isolate the library from the nuances
+of different operating systems and machine architectures.
+
+This module handles low level file I/O and is a base class
+for the (dbf) table, (dbt) memo and (ndx,mdx) index classes.
+Files are opened and manipulated via methods in the xbFile class.<br>
+This class handles:<br>
+1) Big and little endian reads/writes<br>
+2) 32 or 64 bit system calls, depending on OS<br>
+3) Various different c/c++ calls to open/close/read/write based on OS and compiler version<br>
+<br>
+If you are wanting to port this library to a new platform, start with this class.
+This class could be used if you want to write a platform independent program that needs R/W file access.
+*/
+
+
+class XBDLLEXPORT xbFile : public xbSsv {
+
+ public:
+ // xbFile();
+ xbFile( xbXBase * x );
+
+ ~xbFile();
+ xbInt16 CreateUniqueFileName( const xbString &sDirIn, const xbString &sExtIn, xbString &sFqnOut );
+ xbInt16 CreateUniqueFileName( const xbString &sDirIn, const xbString &sExtIn, xbString &sFqnOut, xbInt16 iOption );
+
+ const xbString& GetDirectory() const;
+ const xbString& GetFileName() const;
+ const xbString& GetFqFileName() const;
+
+ void SetDirectory ( const xbString &sDirectory);
+ void SetFileName ( const xbString &sFileName );
+ void SetFqFileName( const xbString &sFqName );
+
+ xbUInt32 GetBlockSize () const;
+ xbInt16 SetBlockSize ( xbUInt32 ulBlockSize );
+
+ xbInt16 GetOpenMode () const;
+ xbInt16 GetShareMode () const;
+
+ xbInt16 GetFileDirPart ( xbString &sFileDirPartOut ) const;
+ xbInt16 GetFileDirPart ( const xbString &sCompleteFileNameIn, xbString &sFileDirPartOut ) const;
+ xbInt16 GetFileExtPart ( xbString &sFileExtPartOut ) const;
+ xbInt16 GetFileExtPart ( const xbString &sCompleteFileNameIn, xbString &sFileExtPartOut ) const;
+ xbInt16 GetFileNamePart( xbString &sFileNamePartOut ) const;
+ xbInt16 GetFileNamePart( const xbString &sCompleteFileNameIn, xbString &sFileNamePartOut ) const;
+ xbInt16 GetFileType ( xbString &sFileType ) const;
+
+ xbInt16 GetXbaseFileTypeByte( const xbString &sFileName, xbInt16 &iVersion );
+ xbInt16 GetXbaseFileTypeByte( const xbString &sFileName, unsigned char &cFileTypeByte );
+ xbInt16 GetXbaseFileTypeByte( const xbString &sFileName, unsigned char &cFileTypeByte, xbInt16 &iVersion );
+ xbInt16 DetermineXbaseTableVersion( unsigned char cFileTypeByte ) const;
+ xbInt16 DetermineXbaseMemoVersion( unsigned char cFileTypeByte ) const;
+
+ xbBool FileExists () const;
+ xbBool FileExists ( xbInt16 iOption ) const;
+ xbBool FileExists ( const xbString &sFileName ) const;
+ xbBool FileExists ( const xbString &sFileName, xbInt16 iOption ) const;
+
+ xbBool FileIsOpen () const;
+
+ xbInt16 ReadBlock ( xbUInt32 ulBlockNo, size_t readSize, void *buf );
+ xbInt16 ReadBlock ( xbUInt32 ulBlockNo, xbUInt32 ulBlockSize, size_t readSize, void *buf );
+ xbInt16 WriteBlock( xbUInt32 ulBlockNo, size_t writeSize, void *buf );
+
+ xbInt16 GetFileSize( xbUInt64 &ullFileSize );
+ xbInt16 GetFileMtime( time_t &mtime );
+
+ xbDouble eGetDouble( const char *p ) const;
+ xbInt32 eGetInt32 ( const char *p ) const;
+ xbUInt32 eGetUInt32( const char *p ) const;
+ xbInt16 eGetInt16 ( const char *p ) const;
+ xbUInt16 eGetUInt16( const char *p ) const;
+ void ePutDouble( char *p, xbDouble d );
+ void ePutInt32 ( char *p, xbInt32 l );
+ void ePutUInt32( char *p, xbUInt32 ul );
+ void ePutInt16 ( char *p, xbInt16 s );
+ void ePutUInt16( char *p, xbUInt16 s );
+
+ xbInt16 xbFclose ();
+ xbInt16 xbFeof ();
+ xbInt16 xbFflush ();
+ xbInt16 xbFgetc ( xbInt32 &c );
+ xbInt16 xbFgetc ( char &c );
+
+ #ifdef XB_LOCKING_SUPPORT
+ xbInt16 xbLock ( xbInt16 iFunction, xbInt64 llOffset, size_t stLen );
+ xbInt16 GetLockRetryCount() const;
+ void SetLockRetryCount( xbInt16 iLockRetries );
+ #endif
+
+ xbInt16 xbFopen ( xbInt16 iOpenMode );
+ xbInt16 xbFopen ( const xbString &sOpenMode, xbInt16 iShareMode );
+ xbInt16 xbFopen ( xbInt16 iOpenMode, xbInt16 iShareMode );
+ xbInt16 xbFopen ( const xbString &sMode, const xbString &sFileName, xbInt16 iShareMode );
+
+ xbInt16 xbFputc ( xbInt32 c );
+ xbInt16 xbFputc ( xbInt32 c, xbInt32 iNoTimes );
+ xbInt16 xbFputs ( const xbString &s );
+ xbInt16 xbFread ( void *ptr, size_t size, size_t nmemb );
+ xbInt16 xbFgets ( size_t lSize, xbString &sLine );
+
+ size_t xbFtell ();
+ xbInt16 xbFseek ( xbInt64 llOffset, xbInt32 whence );
+
+ void xbFTurnOffFileBuffering();
+ xbInt16 xbFwrite ( const void *ptr, size_t lSize, size_t lNmemb );
+
+ xbInt16 xbReadUntil ( const char cDelim, xbString &sOut );
+ xbInt16 xbRemove ( const xbString &sFileName, xbInt16 iOption );
+ xbInt16 xbRemove ( const xbString &sFileName );
+ xbInt16 xbRemove ();
+
+ xbInt16 xbRename ( const xbString &sOldName, const xbString &sNewName );
+ xbInt16 xbRename ( const xbString &sOldName, const xbString &sNewName, xbInt16 iOption );
+ void xbRewind ();
+
+ xbInt16 xbTruncate ( xbInt64 llSize );
+ xbInt16 NameSuffixMissing( const xbString &sFileName, xbInt16 iOption ) const;
+
+ #ifdef XB_DEBUG_SUPPORT
+ xbInt16 DumpBlockToDisk( xbUInt32 ulBlockNo, size_t lBlockSize );
+ #endif
+
+
+ protected:
+
+ xbXBase *xbase; /* pointer to the main structures */
+
+ private:
+ FILE *fp;
+ xbString sFqFileName; /* fully qualified file name */
+ xbString sFileName; /* file name */
+ xbString sDirectory; /* directory, ends with / or \ */
+ xbBool bFileOpen; /* true if file is open */
+ xbUInt32 ulBlockSize; /* used for memo and index files */
+
+ xbInt16 iOpenMode; /* XB_READ || XB_READ_WRITE || XB_WRITE */
+ xbInt16 iShareMode; /* XB_SINGLE_USER || XB_MULTI_USER - set file buffering */
+ xbInt32 iFileNo; /* Library File No */
+
+ #ifdef XB_LOCKING_SUPPORT
+ xbInt16 iLockRetries; /* file override number of lock attempts */
+ #endif
+
+ #ifdef HAVE_SETENDOFFILE_F
+ HANDLE fHandle;
+ #endif
+
+
+};
+
+} /* namespace */
+#endif /* __XBFILE_H__ */
+
diff --git a/src/include/xbfilter.h b/src/include/xbfilter.h
new file mode 100755
index 0000000..8722256
--- /dev/null
+++ b/src/include/xbfilter.h
@@ -0,0 +1,78 @@
+/* xbfilter.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
+
+This class manages the user data area (UDA)
+
+*/
+
+
+#ifndef __XB_XBFILTER_H__
+#define __XB_XBFILTER_H__
+
+#ifdef CMAKE_COMPILER_IS_GNUCC
+#pragma interface
+#endif
+
+
+#ifdef XB_FILTER_SUPPORT
+
+
+namespace xb{
+
+//#ifdef XB_INDEX_SUPPORT
+//class XBDLLEXPORT xbIx;
+//#endif // XB_INDEX_SUPPORT
+
+
+class XBDLLEXPORT xbFilter {
+
+ public:
+ xbFilter( xbXBase *xbase, xbDbf *dbf );
+ ~xbFilter();
+ xbInt16 Set( xbString &sFilterExpression );
+ xbInt16 GetFirstRecord( xbInt16 iOpt = 1 );
+ xbInt16 GetNextRecord ( xbInt16 iOpt = 1 );
+ xbInt16 GetPrevRecord ( xbInt16 iOpt = 1 );
+ xbInt16 GetLastRecord ( xbInt16 iOpt = 1 );
+ void SetLimit( xbInt32 ulLimit );
+ xbInt32 GetLimit() const;
+ void ResetQryCnt();
+ 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 );
+ xbInt16 GetLastRecordIx ( xbInt16 iOpt = 1 );
+ #endif // XB_INDEX_SUPPORT
+
+
+ private:
+ xbXBase *xbase;
+ xbDbf *dbf;
+ xbExp *exp;
+
+ xbInt32 lLimit; // max number rows returned
+ xbInt32 lCurQryCnt; // current count of rows returned, neg# is moving from bottom to top
+ // pos# is moving from top to bottom
+ #ifdef XB_INDEX_SUPPORT
+ xbIx *pIx; // if index is set, the class uses the index tag, otherwise table
+ void *vpTag;
+ #endif // XB_INDEX_SUPPORT
+
+
+};
+} /* namespace */
+#endif /* XB_FILTER_SUPPORT */
+#endif /* __XBFILTER_H__ */ \ No newline at end of file
diff --git a/src/include/xbindex.h b/src/include/xbindex.h
new file mode 100755
index 0000000..b42f76e
--- /dev/null
+++ b/src/include/xbindex.h
@@ -0,0 +1,605 @@
+/* xbindex.h
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014, 2018, 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_INDEX_H__
+#define __XB_INDEX_H__
+
+#ifdef XB_INDEX_SUPPORT
+
+
+#define XB_ADD_KEY 1
+#define XB_UPD_KEY 2
+#define XB_DEL_KEY 3
+
+namespace xb{
+
+
+
+///@cond DOXYOFF
+// structure for index nodes, each node contains information regarding one block
+struct XBDLLEXPORT xbIxNode {
+ xbIxNode *npPrev; // pointer to previous node in chain
+ xbIxNode *npNext; // pointer to next node in chain
+ xbUInt32 iCurKeyNo; // current key number in the node, 0 offset
+ xbUInt32 ulBlockNo; // this block number
+ xbUInt32 ulBufSize; // size of cpBlockData
+ char *cpBlockData; // pointer to memory version of block data stored in file
+};
+///@endcond DOXYOFF
+
+
+//! @brief Base class for handling dbf indices.
+/*!
+
+The xbIx class is used as a base class for accessing index files.
+Each index file can have one or more tags.
+
+Calls to the index routines to perform index updates are handled automatically by the dbf class.
+The application program does not need to be concerned with index updates.
+
+If there is a production MDX index, it is opened automatically when the dbf file is opened.
+If there is an ndx file, that has been associated with the dbf file with the metadata routines,
+it will be opened automatically when the dbf file is opened.
+If there are non prod ndx indices that are not associated with the dbf file, the application
+program will need to open as appropriate.
+The meta data association logic is specific to the Xbase64 library and is not applicable to
+other available tools that handle ndx indices.
+All index files are automatically closed when the dbf file is closed.
+
+
+<br>
+The class is designed to support the addition of additional indices with a minimal amount of effort
+needed to integrate into the library.
+If you are looking at adding an new index type to the library, create a derived class using xbIx as a
+base class and modify methods needed to support the new index file version.
+The xbDbf class (and derived classes) perform the needed calls to the index routines for updates.<br>
+See the following for examples on how to start on this:<br>
+xbIxNdx is a derived class and supports a single tag.<br>
+xbIxMdx is a derived class and supports multiple tags.<br>
+
+
+
+<br>
+How data fields are stored in index files:
+<table>
+<tr><th>Field Type<th>Stored in DBF as<th>Stored in NDX as<th>Stored in MDX as</tr>
+<tr><td>C<td>char<td>char<td>char
+<tr><td>F<td>text numbers<td>xbDouble<td>xbBcd
+<tr><td>N<td>text numbers<td>xbDouble<td>xbBcd
+<tr><td>D<td>text CCYYMMDD<td>xbDouble - julian<td>xbDouble - julian
+</table>
+
+
+<br>
+Pages Vs Blocks
+<br>
+For purposes of the Xbase index classes, a page is considered to be 512 bytes of data
+and a block is made up of one or more 512 byte pages.
+<br>Default block sixe of NDX indices is one 512 byte page.
+<br>Default block size of MDX indices is two 512 byte pages or 1024 bytes.
+
+<br>The WriteBlock and GetBlock functions calculate the physical position in the
+file based on a combination of Block Number and Block Size. Block size is set at
+time of index file creation, default is 1024 or two pages.
+
+<br>Page numbers are stored in the physical file, but block reads and writes
+are performed.
+
+<br>
+Duplicate Keys
+<br>
+With the original DBase unique indexing option, if a table has multiple records with the
+same key value, DBase would allow multiple records in the table, but only the first
+record would be found in the index.
+<br>
+XBase64 can be configured to support the original DBase duplicate key implementation,
+or can be configured to halt with a DUPLICATE_KEY error on the insertion of a record
+with a duplicate key.
+<br>
+<table>
+<tr><th>Option<th>Description</tr>
+<tr><td>XB_HALT_ON_DUPKEY</td><td>Return error XB_KEY_NOT_UNIQUE when attempting to append record with duplicate key</td></tr>
+<tr><td>XB_EMULATE_DBASE</td><td>Emulate DBase, allow duplicate records with the same key, only the first record is indexed</td></tr>
+</table>
+*/
+
+
+class XBDLLEXPORT xbIx : public xbFile {
+ public:
+ xbIx( xbDbf * d );
+ virtual ~xbIx();
+
+ virtual xbInt16 CheckTagIntegrity( void *vpTag, xbInt16 iOpt ) = 0;
+ virtual xbInt16 Close();
+ virtual xbInt16 CreateTag( const xbString &sName, const xbString &sKey, const xbString &sFilter, xbInt16 iDescending, xbInt16 iUnique, xbInt16 iOverlay, void **vpTag ) = 0;
+ virtual xbInt16 FindKey( void *vpTag, const xbString &sKey, xbInt16 iRetrieveSw );
+ virtual xbInt16 FindKey( void *vpTag, const char * cKey, xbInt32 lKeyLen, xbInt16 iRetrieveSw );
+ virtual xbInt16 FindKey( void *vpTag, const xbBcd &bcd, xbInt16 iRetrieveSw );
+ virtual xbInt16 FindKey( void *vpTag, const xbDate &dtKey, xbInt16 iRetrieveSw );
+ virtual xbInt16 FindKey( void *vpTag, xbDouble dKey, xbInt16 iRetrieveSw );
+ virtual xbInt16 FindKey( void *vpTag, const void *vKey, xbInt32 lKeyLen, xbInt16 iRetrieveSw ) = 0;
+ virtual void *GetCurTag() const;
+ virtual xbDbf *GetDbf() const;
+
+ virtual xbString &GetKeyExpression( const void *vpTag ) const = 0;
+ virtual xbString &GetKeyFilter( const void *vpTag ) const = 0;
+ virtual char GetKeyType( const void *vpTag ) const = 0;
+ virtual xbBool GetLocked() const;
+
+ virtual xbInt16 GetFirstKey( void *vpTag, xbInt16 iRetrieveSw ) = 0;
+ virtual xbInt16 GetFirstKey( void *vpTag );
+ virtual xbInt16 GetFirstKey();
+
+ virtual xbInt16 GetLastKey( void *vpTag, xbInt16 lRetrieveSw ) = 0;
+ virtual xbInt16 GetLastKey( void *vpTag );
+ virtual xbInt16 GetLastKey();
+
+ virtual xbInt16 GetNextKey( void *vpTag, xbInt16 iRetrieveSw ) = 0;
+ virtual xbInt16 GetNextKey( void *vpTag );
+ virtual xbInt16 GetNextKey();
+
+ virtual xbInt16 GetPrevKey( void *vpTag, xbInt16 iRetrieveSw ) = 0;
+ virtual xbInt16 GetPrevKey( void *vpTag );
+ virtual xbInt16 GetPrevKey();
+
+ virtual void *GetTag( xbInt16 iTagNo ) const = 0;
+ virtual void *GetTag( xbString &sTagName ) const = 0;
+ virtual xbInt16 GetTagCount() const = 0;
+
+ virtual xbString &GetTagName( void *vpTag ) const = 0;
+ virtual const char * GetTagName( void *vpTag, xbInt16 iOpt ) const = 0;
+ virtual void GetTagName( void *vpTag, xbString &sTagName ) {};
+
+ virtual xbBool GetUnique( void *vpTag ) const = 0;
+ virtual xbBool GetSortOrder( void *vpTag ) const = 0;
+
+ virtual xbInt16 Open( const xbString &sFileName );
+ virtual xbInt16 Reindex( void **vpTag ) = 0;
+ virtual xbInt16 SetCurTag( xbInt16 iTagNo ) = 0;
+ virtual xbInt16 SetCurTag( xbString &sTagName ) = 0;
+ virtual void SetCurTag( void * vpCurTag );
+ virtual void SetLocked( xbBool bLocked );
+
+ virtual void TestStub( char *s, void *vpTag ) {};
+
+
+ #ifdef XB_DEBUG_SUPPORT
+ virtual xbInt16 DumpFreeBlocks( xbInt16 iOpt = 0 ) { return XB_NO_ERROR; }
+ virtual xbInt16 DumpHeader( xbInt16 iDestOpt = 0, xbInt16 iFmtOpt = 0 ) = 0;
+ virtual xbInt16 DumpIxForTag( void *vpTag, xbInt16 iOutputOpt ) = 0;
+ virtual void DumpIxNodeChain( void *vpTag, xbInt16 iOutputOpt ) const = 0;
+ virtual xbInt16 DumpNode( void * vpTag, xbIxNode * pNode, xbInt16 iOption ) const;
+ virtual xbInt16 DumpTagBlocks( xbInt16 iOpt = 1, void *vpTag = NULL ) = 0;
+
+ #endif
+
+ protected:
+ friend class xbDbf;
+
+ virtual xbInt16 AddKey( void *vpTag, xbUInt32 ulRecNo ) = 0;
+ virtual xbInt16 AddKeys( xbUInt32 ulRecNo );
+ virtual xbIxNode *AllocateIxNode( xbUInt32 ulBufSize = 0, xbInt16 iOption = 0 );
+ virtual xbInt16 BSearchBlock( char cKeyType, xbIxNode *npNode, xbInt32 lKeyLen, const void *vpKey, xbInt32 lSearchKeyLen, xbInt16 &iCompRc, xbBool bDescending = xbFalse ) const;
+ virtual xbInt16 CheckForDupKeys();
+ virtual xbInt16 CheckForDupKey( void *vpTag ) = 0;
+ virtual xbInt16 CompareKey( char cKeyType, const void *v1, const void *v2, size_t lKeyLen ) const;
+ virtual xbInt16 CreateKeys( xbInt16 iOpt );
+ virtual xbInt16 CreateKey( void * vpTag, xbInt16 iOpt ) = 0;
+ virtual xbInt16 DeleteFromNode( void *vpTag, xbIxNode * npNode, xbInt16 iSlotNo ) = 0;
+// virtual xbInt16 DeleteKeys( xbUInt32 ulRecNo );
+ virtual xbInt16 DeleteKeys();
+ virtual xbInt16 DeleteKey( void *vpTag ) = 0;
+
+ virtual xbInt16 DeleteTag( void *vpTag ) = 0;
+
+
+ virtual xbInt16 FindKeyForCurRec( void *vpTag ) = 0;
+ virtual xbIxNode *FreeNodeChain( xbIxNode *np );
+ virtual xbInt16 GetBlock( void *vpTag, xbUInt32 ulBlockNo, xbInt16 iOpt, xbUInt32 ulAddlBuf = 0 );
+// virtual xbBool GetIndexUpdated() const = 0;
+ virtual xbInt32 GetKeyCount( xbIxNode *npNode ) const;
+ virtual char *GetKeyData( xbIxNode *npNode, xbInt16 iKeyNo, xbInt16 iKeyItemLen ) const;
+ virtual xbInt16 GetKeySts( void *vpTag ) const = 0;
+ virtual xbInt16 GetLastKey( xbUInt32 ulNodeNo, void *vpTag, xbInt16 lRetrieveSw ) = 0;
+ virtual xbInt16 InsertNodeL( void *vpTag, xbIxNode * npNode, xbInt16 iSlotNo, char * cpKeyBuf, xbUInt32 uiPtr ) = 0;
+ virtual xbInt16 InsertNodeI( void *vpTag, xbIxNode * npNode, xbInt16 iSlotNo, xbUInt32 uiPtr ) = 0;
+ virtual xbInt16 KeyExists( void * ) = 0;
+// virtual xbInt16 KeyUpdated( void *vpTag ) const = 0;
+ virtual void NodeFree( xbIxNode * ixNode );
+ virtual xbInt16 ReadHeadBlock( xbInt16 iOpt = 0 ) = 0;
+ virtual void SetDbf( xbDbf *dbf );
+ virtual xbInt16 SplitNodeL( void *vpTag, xbIxNode * npLeft, xbIxNode *npRight, xbInt16 iSlotNo, char *cpKeyBuf, xbUInt32 uiPtr ) = 0;
+ virtual xbInt16 SplitNodeI( void *vpTag, xbIxNode * npLeft, xbIxNode *npRight, xbInt16 iSlotNo, xbUInt32 uiPtr ) = 0;
+ virtual xbInt16 UpdateTagKey( char cAction, void *vpTag, xbUInt32 ulRecNo = 0 ) = 0;
+ virtual xbInt16 WriteHeadBlock( xbInt16 iOption ) = 0;
+
+ xbDbf *dbf;
+ char *cNodeBuf; // pointer to memory for processing in a block of index data
+ void *vpCurTag; // pointer to active tag. Single index files have only one tag
+
+ private:
+ virtual void AppendNodeChain( void *vpTag, xbIxNode *npNode ) = 0;
+ virtual xbInt16 GetKeyPtr( void *vpTag, xbInt16 iKeyNo, xbIxNode *npNode, xbUInt32 &ulKeyPtr ) const = 0;
+ virtual xbBool IsLeaf( void *vpTag, xbIxNode *npNode ) const = 0;
+ // virtual void SetCurNode( void *vpTag, xbIxNode *npNode ) = 0;
+
+ xbBool bLocked; // index file locked?
+};
+
+#ifdef XB_NDX_SUPPORT
+
+#define XB_NDX_BLOCK_SIZE 512
+
+
+///@cond DOXYOFF
+struct XBDLLEXPORT xbNdxTag {
+
+ // NDX File Header Fields
+ xbUInt32 ulRootBlock; // header node is 0
+ xbUInt32 ulTotalBlocks; // includes header node
+ char cKeyType; // C = Char, F = Numeric, D = Date
+ xbInt16 iKeyLen; // length of key data
+ xbInt16 iKeysPerBlock; // max number keys per block <=100
+ xbInt16 iKeyType; // 00 = Char, 01 = Numeric
+ xbInt16 iKeyItemLen; // KeyLen + 8 bytes
+ char cSerNo; // rolling incrementing serial number +1 on each index update
+ xbInt16 iUnique; // True if unique
+ xbString sKeyExpression; // index expression
+ // end of NDX Header field
+
+ xbExp *exp; // pointer to expression for expression keys
+ time_t tNodeChainTs; // node chain time stamp
+ xbIxNode *npNodeChain;
+ xbIxNode *npCurNode;
+ char *cpKeyBuf; // key buffer, for searches and adds
+ char *cpKeyBuf2; // key buffer, for deletes
+ xbString sTagName; // tag name - is the file name without the extension
+// xbInt16 iKeyUpdated; // key updated? set in method KeyUpdated, checked in AddKey and DeleteKey routines
+ xbBool bFoundSts; // key found? used to determine if new key should be added in XB_EMULATE_DBASE mode in AddKey
+
+
+ xbInt16 iKeySts; // key updated? set in method CreateKey, checked in AddKey and DeleteKey routines
+ // old key filtered new key filtered iKeySts
+ // Y Y XB_UPD_KEY 2 - update key if changed (delete and add)
+ // Y N XB_DEL_KEY 3 - delete key
+ // N Y XB_ADD_KEY 1 - add key
+ // N N 0 - no update
+
+};
+///@endcond DOXYOFF
+
+//! @brief Class for handling NDX single tag indices.
+/*!
+
+The xbIxNdx class is derived from the xbIx base class and is specific to handling NDX single tag index files.
+Each NDX index file can have only one tag, but the methods are set up to take an argument for a specific tag.
+This was done in order to provide a consistant interface across index types.
+
+Calls to the ndx index routines to perform index updates are handled automatically be the dbf class after
+the ndx file has been opened.
+
+Xbase64 provides a mechanism to automatically open ndx files when a dbf file is opened.
+If the ndx file has been associated with the dbf file with the metadata routines,
+it will be opened automatically when the dbf file is opened.
+If there are non prod ndx indices that are not associated with the dbf file, the application
+program will need to open as appropriate.
+The meta data association logic is specific to the Xbase64 library and is not applicable to
+other available tools that handle ndx indices.
+
+*/
+
+class XBDLLEXPORT xbIxNdx : public xbIx {
+ public:
+ xbIxNdx( xbDbf * d );
+ ~xbIxNdx();
+ xbInt16 CheckTagIntegrity( void *vpTag, xbInt16 iOpt );
+ xbInt16 CreateTag( const xbString &sName, const xbString &sKey, const xbString &sFilter, xbInt16 iDescending, xbInt16 iUnique, xbInt16 iOverlay, void **vpTag );
+// xbInt16 DeleteTag( void *vpTag );
+ xbInt16 FindKey( void *vpTag, const void *vpKey, xbInt32 lKeyLen, xbInt16 iRetrieveSw );
+ xbInt16 GetFirstKey( void *vpTag, xbInt16 iRetrieveSw );
+
+ xbInt16 GetLastKey( void *vpTag, xbInt16 iRetrieveSw = 1 );
+ xbInt16 GetNextKey( void *vpTag, xbInt16 iRetrieveSw = 1 );
+ xbInt16 GetPrevKey( void *vpTag, xbInt16 iRetrieveSw = 1 );
+ xbInt32 GetKeyLen ( const void *vpTag ) const;
+ char GetKeyType ( const void *vpTag ) const;
+ xbString &GetKeyExpression( const void *vpTag ) const;
+ xbString &GetKeyFilter( const void *vpTag ) const;
+ void *GetTag( xbInt16 iTagNo ) const;
+ void *GetTag( xbString &sTagName ) const;
+ xbString &GetTagName( void *vpTag ) const;
+ const char * GetTagName( void *vpTag, xbInt16 iOpt ) const;
+
+ xbInt16 GetTagCount() const;
+ xbBool GetUnique( void *vpTag = NULL ) const;
+ xbBool GetSortOrder( void *vpTag ) const;
+ xbInt16 Reindex( void **vpTag );
+ xbInt16 SetCurTag( xbInt16 iTagNo );
+ xbInt16 SetCurTag( xbString &sTagName );
+
+
+
+ #ifdef XB_DEBUG_SUPPORT
+ xbInt16 DumpTagBlocks( xbInt16 iOpt = 1, void *vpTag = NULL );
+ xbInt16 DumpHeader( xbInt16 iOpt = 0, xbInt16 iFmt = 0 );
+ xbInt16 DumpIxForTag( void *vpTag, xbInt16 iOutputOpt );
+ void DumpIxNodeChain( void *vpTag, xbInt16 iOutputOpt ) const;
+ xbInt16 DumpNode( void * vpTag, xbIxNode * pNode, xbInt16 iOption ) const;
+ #endif
+
+ protected:
+ friend class xbDbf;
+ xbInt16 AddKey( void *vpTag, xbUInt32 ulRecNo );
+ xbIxNode *AllocateIxNode( xbUInt32 ulBufSize = 0, xbInt16 iOption = 0 );
+ xbInt16 CheckForDupKey( void *vpTag );
+ xbIxNode *CreateIxNode( xbUInt32 ulBufSize );
+ xbInt16 CreateKey( void * vpTag, xbInt16 iOpt );
+ xbInt16 DeleteFromNode( void *vpTag, xbIxNode * npNode, xbInt16 iSlotNo );
+ xbInt16 DeleteKey( void *vpTag );
+
+ xbInt16 DeleteTag( void *vpTag );
+
+ xbInt16 FindKeyForCurRec( void *vpTag );
+// xbBool GetIndexUpdated() const;
+ xbInt16 GetKeyTypeN( const void *vpTag ) const;
+ xbInt16 GetKeySts( void *vpTag ) const;
+ xbInt16 GetLastKey( xbUInt32 ulNodeNo, void *vpTag, xbInt16 iRetrieveSw = 1 );
+ xbInt16 InsertNodeI( void *vpTag, xbIxNode * npNode, xbInt16 iSlotNo, xbUInt32 uiPtr );
+ xbInt16 InsertNodeL( void *vpTag, xbIxNode * npNode, xbInt16 iSlotNo, char * cpKeyBuf, xbUInt32 uiPtr );
+ xbInt16 KeyExists( void *vpTag = NULL );
+// xbBool KeyFiltered( void *vpTag ) const;
+// xbInt16 KeyUpdated( void *vpTag ) const;
+ xbInt16 ReadHeadBlock(xbInt16 iOpt); // read the header node of the disk NDX file
+ xbInt16 SplitNodeI( void *vpTag, xbIxNode * npLeft, xbIxNode *npRight, xbInt16 iSlotNo, xbUInt32 uiPtr );
+ xbInt16 SplitNodeL( void *vpTag, xbIxNode * npLeft, xbIxNode *npRight, xbInt16 iSlotNo, char *cpKeyBuf, xbUInt32 uiPtr );
+ xbInt16 UpdateTagKey( char cAction, void *vpTag, xbUInt32 ulRecNo = 0 );
+ xbInt16 WriteHeadBlock( xbInt16 iOption );
+
+ private:
+ xbInt16 AddKeyNewRoot( xbNdxTag *npTag, xbIxNode *npLeft, xbIxNode *npRight );
+ void AppendNodeChain( void *vpTag, xbIxNode *npNode );
+ xbInt16 GetDbfPtr( void *vpTag, xbInt16 iKeyNo, xbIxNode *npNode, xbUInt32 &ulDbfPtr ) const;
+ xbInt16 GetKeyPtr( void *vpTag, xbInt16 iKeyNo, xbIxNode *npNode, xbUInt32 &ulKeyPtr ) const;
+ xbInt16 GetLastKeyForBlockNo( void *vpTag, xbUInt32 ulBlockNo, char *cpKeyBuf );
+ xbBool IsLeaf( void *vpTag, xbIxNode *npNode ) const;
+ xbInt16 KeySetPosAdd( xbNdxTag *npTag, xbUInt32 ulAddKeyRecNo );
+ xbInt16 KeySetPosDel( xbNdxTag *npTag );
+ // void SetCurNode( void *vpTag, xbIxNode *np );
+ xbNdxTag *ndxTag;
+};
+
+#endif /* XB_NDX_SUPPORT */
+
+
+#ifdef XB_MDX_SUPPORT
+//#define XB_MDX_BLOCK_SIZE 1024
+
+struct XBDLLEXPORT xbMdxTag {
+
+ // next 7 fields comprise the tag table entry
+ xbUInt32 ulTagHdrPageNo; // 512 byte page number, NOT block number
+ char cTagName[11];
+ char cKeyFmt; // always 0x10 w/ DBase V7
+ char cLeftChild; // cFwdTagThread
+ char cRightChild; // cFwdTagThread2
+ char cParent; // cBwdTagThread
+ char c2;
+ char cKeyType; // C,D,N
+
+ xbUInt32 ulRootPage; // 512 byte page number, NOT block number
+ xbUInt32 ulTagSize; // Number of 512 byte pages allocated to the tag. Tag size of two is a single 1024 block
+
+ char cKeyFmt2; // 0x10 - base
+ // 0x08 - descending
+ // 0x40 - unique
+ char cKeyType2;
+ // one unused byte fits here
+
+ char cTag11; // dbase sets to 0x1B
+
+ xbInt16 iKeyLen;
+ xbInt16 iKeysPerBlock;
+ xbInt16 iSecKeyType;
+ xbInt16 iKeyItemLen; // iKeyLen + 4
+
+ char cSerialNo; // Increments +1 for each tag update
+ char cUnique;
+ xbString *sKeyExp; // Key expression
+
+ char cHasFilter; // 0x00 or 0x01
+ char cHasKeys; // 0x00 or 0x01
+
+ xbUInt32 ulLeftChild; // dbase 7 sets this to the root page on tag creation
+ xbUInt32 ulRightChild; // dbase 7 sets this to the root page on tag creation
+
+ char cTagYY;
+ char cTagMM;
+ char cTagDD;
+
+ char cKeyFmt3; // dbase 7 sets this 0x01 if discreet field or 0x00 if calculated or combination field key expression on tag creation
+
+ xbString *sFiltExp; // Filter expression
+
+ time_t tNodeChainTs;
+ xbIxNode *npNodeChain;
+ xbIxNode *npCurNode;
+ xbExp *exp; // pointer to expression for expression based tags
+ xbExp *filter; // pointer to expression for index filter
+
+ char *cpKeyBuf; // key buffer
+ char *cpKeyBuf2; // key buffer
+// xbBool iKeyUpdated; // key updated? set in method CreateKey, checked in AddKey and DeleteKey routines
+ // 0 - no update
+ // 1 - Add
+ // 2 - Update
+ // 3 - Delete
+// xbBool bKeyFiltered; // key filtered? True if included key, False if excluded key. Set in method CreateKey, checked in AddKey and DeleteKey routines
+ xbString *sTagName; // string tag name
+
+
+ xbMdxTag *next;
+ xbBool bFoundSts; // key found? used to determine if new key should be added in XB_EMULATE_DBASE mode in AddKey
+
+
+ xbInt16 iKeySts; // key updated? set in method CreateKey, checked in AddKey and DeleteKey routines
+ // old key filtered new key filtered iKeySts
+ // Y Y XB_UPD_KEY 2 - update key if changed (delete and add)
+ // Y N XB_DEL_KEY 3 - delete key
+ // N Y XB_ADD_KEY 1 - add key
+ // N N 0 - no update
+
+
+};
+
+
+class XBDLLEXPORT xbIxMdx : public xbIx {
+ public:
+ xbIxMdx( xbDbf * d );
+ ~xbIxMdx();
+ xbInt16 CheckTagIntegrity( void *vpTag, xbInt16 iOpt );
+ xbInt16 CreateTag( const xbString &sName, const xbString &sKey, const xbString &sFilter, xbInt16 iDescending, xbInt16 iUnique, xbInt16 iOverlay, void **vpTag );
+// xbInt16 DeleteTag( void *vpTag );
+ xbInt16 FindKey( void *vpTag, const void *vKey, xbInt32 lKeyLen, xbInt16 iRetrieveSw );
+ xbInt16 FindKey( void *vpTag, xbDouble dKey, xbInt16 iRetrieveSw );
+ xbInt16 GetFirstKey( void *vpTag, xbInt16 lRetrieveSw );
+ xbString &GetKeyExpression( const void *vpTag ) const;
+ xbString &GetKeyFilter( const void *vpTag ) const;
+ char GetKeyType( const void *vpTag ) const;
+ xbInt16 GetLastKey( void *vpTag, xbInt16 lRetrieveSw );
+ xbInt16 GetNextKey( void *vpTag, xbInt16 lRetrieveSw );
+ xbInt16 GetPrevKey( void *vpTag, xbInt16 lRetrieveSw );
+ xbBool GetReuseEmptyNodesSw() const;
+ xbBool GetSortOrder( void *vpTag ) const;
+ void *GetTag( xbInt16 iTagNo ) const;
+ void *GetTag( xbString &sTagName ) const;
+ xbInt16 GetTagCount() const;
+
+ xbString &GetTagName( void *vpTag ) const;
+ const char * GetTagName( void *vpTag, xbInt16 iOpt ) const;
+ void GetTagName( void *vpTag, xbString &sTagName );
+
+ xbInt16 GetUnique( void *vpTag ) const;
+ xbInt16 Reindex( void **vpTag );
+ xbInt16 SetCurTag( xbInt16 iTagNo );
+ xbInt16 SetCurTag( xbString &sTagName );
+ void SetReuseEmptyNodesSw( xbBool bReuse );
+
+ void TestStub( char *s, void *vpTag );
+
+ protected:
+ friend class xbDbf;
+
+ xbInt16 AddKey( void *vpTag, xbUInt32 ulRecNo );
+ xbIxNode *AllocateIxNode( xbMdxTag * mpTag, xbUInt32 ulBufSize, xbUInt32 ulBlock2 );
+ xbInt16 CheckForDupKey( void *vpTag );
+ xbInt16 Close();
+ xbInt16 CreateKey( void * vpTag, xbInt16 iOpt );
+ xbInt16 DeleteFromNode( void *vpTag, xbIxNode * npNode, xbInt16 iSlotNo );
+ xbInt16 DeleteKey( void *vpTag );
+
+ xbInt16 DeleteTag( void *vpTag );
+
+ xbInt16 FindKeyForCurRec( void *vpTag );
+ xbInt16 GetKeySts( void *vpTag ) const;
+ xbInt16 GetLastKey( xbUInt32 ulBlockNo, void *vpTag, xbInt16 lRetrieveSw );
+ void *GetTagTblPtr() const;
+ void Init( xbInt16 iOpt = 0 );
+ xbInt16 InsertNodeI( void *vpTag, xbIxNode *npNode, xbInt16 iSlotNo, xbUInt32 uiPtr );
+ xbInt16 InsertNodeL( void *vpTag, xbIxNode *npNode, xbInt16 iSlotNo, char *cpKeyBuf, xbUInt32 uiPtr );
+ xbInt16 KeyExists( void * );
+ xbInt16 LoadTagTable();
+ xbInt16 ReadHeadBlock(xbInt16 iOpt); // read the header node of the disk file
+ xbInt16 SplitNodeI( void *vpTag, xbIxNode * npLeft, xbIxNode *npRight, xbInt16 iSlotNo, xbUInt32 uiPtr );
+ xbInt16 SplitNodeL( void *vpTag, xbIxNode * npLeft, xbIxNode *npRight, xbInt16 iSlotNo, char *cpKeyBuf, xbUInt32 uiPtr );
+ xbInt16 UpdateTagKey( char cAction, void *vpTag, xbUInt32 ulRecNo = 0 );
+ xbInt16 WriteHeadBlock( xbInt16 iOption );
+
+ #ifdef XB_DEBUG_SUPPORT
+ xbInt16 DumpTagBlocks( xbInt16 iOpt = 1, void *vpTag = NULL );
+ xbInt16 DumpFreeBlocks( xbInt16 iOpt = 0 );
+ xbInt16 DumpHeader( xbInt16 iOpt = 0, xbInt16 iFmtOpt = 0 );
+ xbInt16 DumpIxForTag( void *vpTag, xbInt16 iOutputOpt );
+ void DumpIxNodeChain( void *vpTag, xbInt16 iOutputOpt ) const;
+ #endif
+
+ private:
+ xbInt16 AddKeyNewRoot( xbMdxTag *npTag, xbIxNode *npLeft, xbIxNode *npRight );
+ void AppendNodeChain( void *vpTag, xbIxNode *npNode );
+ xbUInt32 BlockToPage( xbUInt32 ulBlockNo );
+ void CalcBtreePointers();
+ char CalcTagKeyFmt( xbExp &exp );
+ char CalcTagFwdThread1();
+ char CalcTagFwdThread2();
+ xbMdxTag *ClearTagTable();
+ xbInt16 DumpBlock( xbInt16 iOpt, xbUInt32 ulBlockNo, xbMdxTag * mpTag );
+ xbInt16 GetDbfPtr( void *vpTag, xbInt16 iKeyNo, xbIxNode *npNode, xbUInt32 &ulDbfPtr ) const;
+ xbInt16 GetKeyPtr( void *vpTag, xbInt16 iKeyNo, xbIxNode *npNode, xbUInt32 &ulKeyPtr ) const;
+ xbInt16 GetLastKeyForBlockNo( void *vpTag, xbUInt32 ulBlockNo, char *cpKeyBuf );
+ xbInt16 HarvestEmptyNode( xbMdxTag *mpTag, xbIxNode *npNode, xbInt16 iOpt, xbBool bHarvestRoot = xbFalse );
+ xbInt16 HarvestTagNodes( xbMdxTag *mpTag, xbBool bRecycleRoot = xbFalse );
+ xbBool IsLeaf( void *vpTag, xbIxNode *npNode ) const;
+ xbInt16 KeySetPosAdd( xbMdxTag *mpTag, xbUInt32 ulAddKeyRecNo );
+ xbInt16 KeySetPosDel( xbMdxTag *mpTag );
+ xbInt16 LoadTagDetail( xbInt16 iOption, xbMdxTag *tte );
+ xbUInt32 PageToBlock( xbUInt32 ulPageNo );
+ xbInt16 TagSerialNo( xbInt16 iOption, xbMdxTag *mpTag );
+ xbInt16 UpdateTagSize( xbMdxTag *mpTag, xbUInt32 ulTagSz );
+
+ #ifdef XB_DEBUG_SUPPORT
+ xbInt16 PrintKey( void *vpTag, xbIxNode *npNode, xbInt16 iKeyNo, xbInt16 iDepth, char cType, xbInt16 iOutputOpt );
+ #endif
+
+ // MDX File Header Fields
+ char cVersion;
+ char cCreateYY;
+ char cCreateMM;
+ char cCreateDD;
+ xbString sFileName;
+ xbInt16 iBlockFactor; // 1-32 #of 512 byte segments in a block
+
+ // use file version
+ // xbInt16 iBlockSize; // Stored at the xbFile level
+
+ char cProdIxFlag;
+ char cTagEntryCnt;
+ xbInt16 iTagLen;
+ xbInt16 iTagUseCnt;
+ char cNextTag; // byte 28 +1
+ char c1B; // always 0x1B
+ xbUInt32 ulPageCnt; // number of 512 byte pages in the mdx file
+ xbUInt32 ulFirstFreePage; // page number corresponding to the next free block
+ xbUInt32 ulNoOfBlockAvail; // might be improperly named?? not sure how it is used
+ char cUpdateYY;
+ char cUpdateMM;
+ char cUpdateDD;
+ // end of MDX Header fields
+
+
+
+ xbMdxTag *mdxTagTbl;
+
+ xbBool bReuseEmptyNodes; // Reuese empty MDX nodes when all keys deleted?
+ // DBase 7.x and MS ODBC drivers do not reuse empty nodes, leaves them stranded in the file
+ // Codebase 6.x reuses empty nodes.
+ // Setting this to True will reuse empty nodes in the same manner Codebase 6.x reuses them.
+
+};
+#endif /* XB_MDX_SUPPORT */
+
+
+} /* namespace xb */
+#endif /* XB_INDEX_SUPPORT */
+#endif /* __XB_INDEX_H__ */
diff --git a/src/include/xblnklst.h b/src/include/xblnklst.h
new file mode 100755
index 0000000..eaec587
--- /dev/null
+++ b/src/include/xblnklst.h
@@ -0,0 +1,257 @@
+/* xblnklst.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_XBLNKLST_H__
+#define __XB_XBLNKLST_H__
+
+#ifdef XB_LINKLIST_SUPPORT
+
+namespace xb{
+
+
+template<class xbNodeType>
+class XBDLLEXPORT xbLinkList {
+ public:
+ xbLinkList();
+ ~xbLinkList();
+
+ xbLinkListNode<xbNodeType> *GetHeadNode() const;
+ xbLinkListNode<xbNodeType> *GetEndNode() const;
+ xbLinkListNode<xbNodeType> *GetNodeForNo( xbUInt32 ulNodeNo ) const;
+
+ void Clear();
+ xbUInt32 GetNodeCnt () const;
+ xbInt16 InsertAtEnd ( const xbNodeType &xbLLN );
+ xbInt16 InsertAtFront ( const xbNodeType &xbLLN );
+ xbInt16 RemoveByVal ( const xbNodeType &xbLLN );
+ xbInt16 RemoveFromEnd ();
+ xbInt16 RemoveFromEnd ( xbNodeType &xbLLN );
+ xbInt16 RemoveFromFront( xbNodeType &xbLLN );
+ xbInt16 SearchFor ( const xbNodeType &xbLLN );
+
+ private:
+ xbUInt32 ulNodeCnt;
+ xbLinkListNode<xbNodeType> *llStartPtr;
+ xbLinkListNode<xbNodeType> *llEndPtr;
+};
+
+template<class xbNodeType>
+xbLinkList<xbNodeType>::xbLinkList(){
+ ulNodeCnt = 0;
+ llStartPtr = NULL;
+ llEndPtr = NULL;
+}
+
+template<class xbNodeType>
+xbLinkList<xbNodeType>::~xbLinkList(){
+ Clear();
+}
+
+template<class xbNodeType>
+void xbLinkList<xbNodeType>::Clear(){
+ xbLinkListNode<xbNodeType> *cPtr = llStartPtr, *tPtr;
+ for( xbUInt32 i = 0; i < ulNodeCnt; i++ ){
+ tPtr = cPtr;
+ cPtr = cPtr->GetNextNode();
+ delete tPtr;
+ }
+ ulNodeCnt = 0;
+ llStartPtr = NULL;
+ llEndPtr = NULL;
+}
+
+
+template<class xbNodeType>
+xbLinkListNode<xbNodeType> *xbLinkList<xbNodeType>::GetHeadNode() const{
+ return llStartPtr;
+}
+
+template<class xbNodeType>
+xbLinkListNode<xbNodeType> *xbLinkList<xbNodeType>::GetEndNode() const{
+ return llEndPtr;
+}
+
+
+template<class xbNodeType>
+xbLinkListNode<xbNodeType> *xbLinkList<xbNodeType>::GetNodeForNo( xbUInt32 ulNo ) const{
+
+ xbLinkListNode<xbNodeType> *cPtr = llStartPtr;
+ xbUInt32 i;
+ for( i = 0; i < ulNo && i < ulNodeCnt; i++ )
+ cPtr = cPtr->GetNextNode();
+
+ if( i == ulNo )
+ return cPtr;
+ else
+ return 0;
+}
+
+
+
+template<class xbNodeType>
+xbUInt32 xbLinkList<xbNodeType>::GetNodeCnt() const{
+ return ulNodeCnt;
+}
+
+template<class xbNodeType>
+xbInt16 xbLinkList<xbNodeType>::InsertAtFront( const xbNodeType & ntKey ){
+
+ xbLinkListNode<xbNodeType> *p = new xbLinkListNode<xbNodeType>( ntKey );
+ if( p == 0 )
+ return XB_NO_MEMORY;
+
+ if( ulNodeCnt > 0 ){
+ llStartPtr->SetPrevNode( p );
+ p->SetNextNode( llStartPtr );
+ } else {
+ llEndPtr = p;
+ }
+
+ llStartPtr = p;
+ ulNodeCnt++;
+ return XB_NO_ERROR;
+}
+
+template<class xbNodeType>
+xbInt16 xbLinkList<xbNodeType>::InsertAtEnd( const xbNodeType & ntKey ){
+
+ xbLinkListNode<xbNodeType> *p = new xbLinkListNode<xbNodeType>( ntKey );
+ if( p == 0 )
+ return XB_NO_MEMORY;
+
+ if( ulNodeCnt > 0 ){
+ llEndPtr->SetNextNode( p );
+ p->SetPrevNode( llEndPtr );
+ llEndPtr = p;
+ } else {
+ llStartPtr = p;
+ }
+
+ llEndPtr = p;
+ ulNodeCnt++;
+ return XB_NO_ERROR;
+}
+
+
+
+template<class xbNodeType>
+xbInt16 xbLinkList<xbNodeType>::RemoveByVal( const xbNodeType & ntKey ){
+ // Remove the first instance of ntKey from the node chain
+ xbLinkListNode<xbNodeType> *currPtr = llStartPtr;
+ xbLinkListNode<xbNodeType> *prevPtr = NULL;
+
+ for( xbUInt32 i = 0; i < ulNodeCnt; i++ ){
+ if( currPtr->GetKey() == ntKey ){
+ if( prevPtr == NULL ){ //then this is the first node
+ llStartPtr = currPtr->GetNextNode();
+ if( llStartPtr ) // if more than one link in the linked list
+ llStartPtr->SetPrevNode( NULL );
+ delete currPtr;
+ ulNodeCnt--;
+ return i + 1;
+ }
+ else {
+ prevPtr->SetNextNode( currPtr->GetNextNode());
+ if( currPtr->GetNextNode())
+ currPtr->GetNextNode()->SetPrevNode( prevPtr );
+ delete currPtr;
+ ulNodeCnt--;
+ return i + 1;
+ }
+ }
+ prevPtr = currPtr;
+ currPtr = currPtr->GetNextNode();
+ }
+ return XB_NOT_FOUND;
+}
+
+
+template<class xbNodeType>
+xbInt16 xbLinkList<xbNodeType>::RemoveFromFront( xbNodeType & ntKey ){
+
+ if( ulNodeCnt <= 0 )
+ return XB_INVALID_NODELINK;
+ xbLinkListNode<xbNodeType> *p = llStartPtr;
+ llStartPtr = p->GetNextNode();
+ if( llStartPtr )
+ llStartPtr->SetPrevNode( NULL );
+ ntKey = p->GetKey();
+ delete p;
+ ulNodeCnt--;
+ return XB_NO_ERROR;
+}
+
+
+template<class xbNodeType>
+xbInt16 xbLinkList<xbNodeType>::RemoveFromEnd( xbNodeType & ntKey ){
+
+ if( ulNodeCnt <= 0 )
+ return XB_INVALID_NODELINK;
+ xbLinkListNode<xbNodeType> *p = llEndPtr;
+ if( p->GetPrevNode()){
+ llEndPtr = p->GetPrevNode();
+ llEndPtr->SetNextNode( NULL );
+ } else {
+ // there are no more nodes
+ llStartPtr = NULL;
+ llEndPtr = NULL;
+ }
+ ntKey = p->GetKey();
+ delete p;
+ ulNodeCnt--;
+ return XB_NO_ERROR;
+}
+
+
+template<class xbNodeType>
+xbInt16 xbLinkList<xbNodeType>::RemoveFromEnd(){
+
+ if( ulNodeCnt <= 0 )
+ return XB_INVALID_NODELINK;
+ xbLinkListNode<xbNodeType> *p = llEndPtr;
+ if( p->GetPrevNode()){
+ llEndPtr = p->GetPrevNode();
+ llEndPtr->SetNextNode( NULL );
+ } else {
+ // there are no more nodes
+ llStartPtr = NULL;
+ llEndPtr = NULL;
+ }
+ delete p->GetKey();
+ delete p;
+ ulNodeCnt--;
+ return XB_NO_ERROR;
+}
+
+
+template<class xbNodeType>
+xbInt16 xbLinkList<xbNodeType>::SearchFor( const xbNodeType & ntKey ){
+
+ xbLinkListNode<xbNodeType> *cPtr = llStartPtr;
+ for( xbUInt32 i = 0; i < ulNodeCnt; i++ ){
+ if( cPtr->GetKey() == ntKey )
+ return i+1;
+ cPtr = cPtr->GetNextNode();
+ }
+ return XB_NO_ERROR;
+
+}
+} // namespace
+
+#endif // XB_LINKLIST_SUPPORT
+#endif // XB_XBLNKLST_H__
+
+
diff --git a/src/include/xblnklstord.h b/src/include/xblnklstord.h
new file mode 100755
index 0000000..d319c31
--- /dev/null
+++ b/src/include/xblnklstord.h
@@ -0,0 +1,367 @@
+/* xblnklstord.h
+
+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
+
+*/
+
+
+// Ordered link list
+
+
+
+#ifndef __XB_XBLNKLSTORD_H__
+#define __XB_XBLNKLSTORD_H__
+
+#ifdef XB_LINKLIST_SUPPORT
+
+
+namespace xb{
+
+
+template<class xbNodeType>
+class XBDLLEXPORT xbLinkListOrd {
+ public:
+ xbLinkListOrd();
+ ~xbLinkListOrd();
+
+ void Clear();
+ xbLinkListNode<xbNodeType> *GetHeadNode() const;
+ xbLinkListNode<xbNodeType> *GetEndNode() const;
+ xbLinkListNode<xbNodeType> *GetNodeForKey( const xbString &sKey ) const;
+
+ xbInt16 GetDataForKey ( const xbNodeType &ntKey, xbString &sData );
+
+ xbBool GetDupKeys ();
+
+ xbUInt32 GetNodeCnt () const;
+ xbUInt32 GetNodeCnt ( const xbString &sNodeKey ) const;
+ xbInt16 InsertKey ( const xbNodeType &ntKey );
+ xbInt16 InsertKey ( const xbNodeType &ntKey, const xbString &sData );
+ xbInt16 InsertKey ( const xbNodeType &ntKey, xbUInt32 ulData );
+
+ xbBool KeyExists ( const xbNodeType &ntKey ) const;
+ xbInt16 RemoveKey ( const xbNodeType &ntKey );
+ xbInt16 RemoveFromEnd ( xbNodeType &ntKey );
+ xbInt16 RemoveFromFront( xbNodeType &ntKey );
+ xbInt16 RemoveFromFront();
+ void SetDupKeys ( xbBool bAllowDupKeys );
+ xbInt16 UpdateForKey ( const xbNodeType &ntKey, const xbString &sData );
+
+
+ private:
+ xbUInt32 ulNodeCnt;
+ xbBool bAllowDupKeys;
+ xbLinkListNode<xbNodeType> *llStartPtr;
+ xbLinkListNode<xbNodeType> *llEndPtr;
+
+};
+
+
+template<class xbNodeType>
+xbLinkListOrd<xbNodeType>::xbLinkListOrd(){
+ bAllowDupKeys = xbTrue; // default setting - allow duplicate keys
+ ulNodeCnt = 0;
+ llStartPtr = NULL;
+ llEndPtr = NULL;
+}
+
+template<class xbNodeType>
+xbLinkListOrd<xbNodeType>::~xbLinkListOrd(){
+ Clear();
+}
+
+template<class xbNodeType>
+void xbLinkListOrd<xbNodeType>::Clear(){
+ xbLinkListNode<xbNodeType> *cPtr = llStartPtr, *tPtr;
+ for( xbUInt32 i = 0; i < ulNodeCnt; i++ ){
+ tPtr = cPtr;
+ cPtr = cPtr->GetNextNode();
+
+ // next line might cause seg faults
+ // delete tPtr->GetData();
+
+ delete tPtr;
+ }
+ ulNodeCnt = 0;
+ llStartPtr = NULL;
+ llEndPtr = NULL;
+}
+
+template<class xbNodeType>
+xbLinkListNode<xbNodeType> * xbLinkListOrd<xbNodeType>::GetHeadNode() const{
+ return llStartPtr;
+}
+
+template<class xbNodeType>
+xbLinkListNode<xbNodeType> * xbLinkListOrd<xbNodeType>::GetEndNode() const{
+ return llEndPtr;
+}
+
+template<class xbNodeType>
+xbUInt32 xbLinkListOrd<xbNodeType>::GetNodeCnt() const{
+ return ulNodeCnt;
+}
+
+template<class xbNodeType>
+xbUInt32 xbLinkListOrd<xbNodeType>::GetNodeCnt( const xbString &sNodeKey ) const{
+
+ // won't work if nodekey is not a string
+ xbLinkListNode<xbNodeType> *currPtr = llStartPtr;
+ // skip to sNodeKey
+ while( currPtr && ( sNodeKey > currPtr->GetKey())) {
+ currPtr = currPtr->GetNextNode();
+ }
+ // count entries for sNodeKey
+ xbInt16 iKeyCnt = 0;
+ while( currPtr && ( sNodeKey == currPtr->GetKey())) {
+ iKeyCnt++;
+ currPtr = currPtr->GetNextNode();
+ }
+ return iKeyCnt;
+}
+
+
+template<class xbNodeType>
+xbInt16 xbLinkListOrd<xbNodeType>::InsertKey( const xbNodeType &ntKey ){
+ xbString s;
+ return InsertKey( ntKey, s );
+}
+
+
+
+
+template<class xbNodeType>
+xbInt16 xbLinkListOrd<xbNodeType>::InsertKey( const xbNodeType &ntKey, xbUInt32 ul ){
+
+ xbString s;
+ s.Sprintf( "%ld", ul );
+ return InsertKey( ntKey, s );
+}
+
+
+template<class xbNodeType>
+xbInt16 xbLinkListOrd<xbNodeType>::InsertKey( const xbNodeType &ntKey, const xbString &sData ){
+
+ xbLinkListNode<xbNodeType> *p = new xbLinkListNode<xbNodeType>( ntKey, sData );
+ if( p == 0 )
+ return XB_NO_MEMORY;
+
+ if( ulNodeCnt > 0 ){
+ xbLinkListNode<xbNodeType> *currPtr = llStartPtr;
+ xbLinkListNode<xbNodeType> *prevPtr = NULL;
+
+ // find location in the chain
+ while( currPtr && ntKey > currPtr->GetKey() ){
+ prevPtr = currPtr;
+ currPtr = currPtr->GetNextNode();
+ }
+ if( currPtr && ntKey == currPtr->GetKey() && bAllowDupKeys == 0 ){
+ delete p;
+ return XB_KEY_NOT_UNIQUE;
+ }
+
+ if( currPtr == NULL ){
+ // std::cout << "at the end of the chain\n";
+ llEndPtr = p;
+ prevPtr->SetNextNode( p );
+ p->SetPrevNode( prevPtr );
+
+ } else if( currPtr->GetPrevNode() == NULL ){
+ // std::cout << "at the beginning of the chain\n";
+ p->SetNextNode( llStartPtr );
+ llStartPtr->SetPrevNode( p );
+ llStartPtr = p;
+
+ } else {
+ // std::cout << "in the middle of the chain\n";
+ p->SetNextNode( currPtr );
+ p->SetPrevNode( currPtr->GetPrevNode());
+ currPtr->SetPrevNode( p );
+ prevPtr->SetNextNode( p );
+ }
+ } else {
+ // std::cout << "first addition to the chain\n";
+ llStartPtr = p;
+ llEndPtr = p;
+ }
+ ulNodeCnt++;
+ return XB_NO_ERROR;
+}
+
+template<class xbNodeType>
+xbInt16 xbLinkListOrd<xbNodeType>::RemoveKey( const xbNodeType &ntKey ){
+ // Remove the first instance of ntKey from the node chain
+ xbLinkListNode<xbNodeType> *currPtr = llStartPtr;
+ xbLinkListNode<xbNodeType> *prevPtr = NULL;
+
+ while( currPtr && ntKey > currPtr->GetKey() ){
+ prevPtr = currPtr;
+ currPtr = currPtr->GetNextNode();
+ }
+
+ if( currPtr && ntKey == currPtr->GetKey()){
+// ntKey = currPtr->GetKey();
+ if( prevPtr == NULL ){ // this is the first node
+ llStartPtr = currPtr->GetNextNode();
+ // next line fails
+ if( llStartPtr ){
+ llStartPtr->SetPrevNode( NULL );
+ }
+ delete currPtr;
+ ulNodeCnt--;
+ return XB_NO_ERROR;
+ } else if( currPtr->GetNextNode() == NULL ){ // this is the last node
+ llEndPtr = prevPtr;
+ prevPtr->SetNextNode( NULL );
+ delete currPtr;
+ ulNodeCnt--;
+ return XB_NO_ERROR;
+ } else {
+
+ prevPtr->SetNextNode( currPtr->GetNextNode());
+ currPtr->GetNextNode()->SetPrevNode( prevPtr );
+ delete currPtr;
+ ulNodeCnt--;
+ return XB_NO_ERROR;
+ }
+ } else {
+ return XB_NOT_FOUND;
+ }
+}
+
+template<class xbNodeType>
+xbInt16 xbLinkListOrd<xbNodeType>::RemoveFromFront( xbNodeType &ntKey ){
+
+ if( ulNodeCnt <= 0 )
+ return XB_INVALID_NODELINK;
+ xbLinkListNode<xbNodeType> *p = llStartPtr;
+ llStartPtr = p->GetNextNode();
+ if( llStartPtr )
+ llStartPtr->SetPrevNode( NULL );
+ ntKey = p->GetKey();
+ delete p;
+ ulNodeCnt--;
+ return XB_NO_ERROR;
+}
+
+template<class xbNodeType>
+xbInt16 xbLinkListOrd<xbNodeType>::RemoveFromFront(){
+
+ if( ulNodeCnt <= 0 )
+ return XB_INVALID_NODELINK;
+ xbLinkListNode<xbNodeType> *p = llStartPtr;
+ llStartPtr = p->GetNextNode();
+ if( llStartPtr )
+ llStartPtr->SetPrevNode( NULL );
+
+ if( p->GetKey())
+ delete p->GetKey();
+
+ delete p;
+ ulNodeCnt--;
+
+ return XB_NO_ERROR;
+}
+
+
+template<class xbNodeType>
+xbInt16 xbLinkListOrd<xbNodeType>::RemoveFromEnd( xbNodeType &ntKey ){
+
+ if( ulNodeCnt <= 0 )
+ return XB_INVALID_NODELINK;
+ xbLinkListNode<xbNodeType> *p = llEndPtr;
+ llEndPtr = p->GetPrevNode();
+ llEndPtr->SetNextNode( NULL );
+ ntKey = p->GetKey();
+ delete p;
+ ulNodeCnt--;
+ return XB_NO_ERROR;
+}
+
+template<class xbNodeType>
+xbBool xbLinkListOrd<xbNodeType>::GetDupKeys(){
+ return bAllowDupKeys;
+}
+
+template<class xbNodeType>
+void xbLinkListOrd<xbNodeType>::SetDupKeys( xbBool bAllowDupKeys ){
+ this->bAllowDupKeys = bAllowDupKeys;
+}
+
+
+template<class xbNodeType>
+xbBool xbLinkListOrd<xbNodeType>::KeyExists( const xbNodeType &ntKey ) const {
+
+ xbLinkListNode<xbNodeType> *currPtr = llStartPtr;
+ while( currPtr && ntKey > currPtr->GetKey() ){
+ currPtr = currPtr->GetNextNode();
+ }
+ if( currPtr && ntKey == currPtr->GetKey()){
+ return xbTrue;
+ } else {
+ return xbFalse;
+ }
+}
+
+
+template<class xbNodeType>
+xbInt16 xbLinkListOrd<xbNodeType>::GetDataForKey( const xbNodeType &ntKey, xbString &sData ){
+
+ xbLinkListNode<xbNodeType> *currPtr = llStartPtr;
+ while( currPtr && ntKey > currPtr->GetKey() ){
+ currPtr = currPtr->GetNextNode();
+ }
+
+ if( currPtr && ntKey == currPtr->GetKey()){
+ sData = currPtr->GetData();
+ return XB_NO_ERROR;
+ } else {
+ return XB_NOT_FOUND;
+ }
+}
+
+
+template<class xbNodeType>
+xbInt16 xbLinkListOrd<xbNodeType>::UpdateForKey( const xbNodeType &ntKey, const xbString &sData ){
+
+ if( ulNodeCnt == 0 )
+ return InsertKey( ntKey, sData );
+ xbLinkListNode<xbNodeType> * currPtr = llStartPtr;
+ xbLinkListNode<xbNodeType> * prevPtr = NULL;
+ while( currPtr && ntKey > currPtr->GetKey() ) {
+ prevPtr = currPtr;
+ currPtr = currPtr->GetNextNode();
+ }
+
+ if( currPtr && ntKey == currPtr->GetKey() ) {
+ xbLinkListNode<xbNodeType> *p = new xbLinkListNode<xbNodeType>( ntKey, sData );
+ if( prevPtr )
+ prevPtr->SetNextNode( p );
+ else
+ llStartPtr = p;
+ p->SetNextNode( currPtr->GetNextNode() );
+ p->SetPrevNode( currPtr->GetPrevNode() );
+ delete currPtr;
+ return XB_NO_ERROR;
+ }
+
+ return InsertKey( ntKey, sData );
+
+// return 0;
+}
+
+} // namespace
+
+#endif // XB_LINKLIST_SUPPORT
+#endif // XB_XBLNKLSTORD_H__
+
+
diff --git a/src/include/xblnknod.h b/src/include/xblnknod.h
new file mode 100755
index 0000000..ef45be8
--- /dev/null
+++ b/src/include/xblnknod.h
@@ -0,0 +1,94 @@
+/* xblnknod.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_XBLNKNOD_H__
+#define __XB_XBLNKNOD_H__
+
+
+
+#ifdef XB_LINKLIST_SUPPORT
+
+namespace xb{
+
+template<class xbNodeType>
+class XBDLLEXPORT xbLinkListNode {
+ public:
+ xbLinkListNode( const xbNodeType & );
+ xbLinkListNode( const xbNodeType &, const xbString & );
+ xbNodeType GetKey() const;
+ xbString &GetData();
+ xbLinkListNode<xbNodeType> *GetNextNode() const;
+ xbLinkListNode<xbNodeType> *GetPrevNode() const;
+ void SetNextNode( xbLinkListNode<xbNodeType> *llNext );
+ void SetPrevNode( xbLinkListNode<xbNodeType> *llPrev );
+
+ private:
+ xbNodeType ntKey;
+ xbString sData;
+ xbLinkListNode *llNext;
+ xbLinkListNode *llPrev;
+};
+
+ template<class xbNodeType>
+ xbLinkListNode<xbNodeType>::xbLinkListNode( const xbNodeType &key ){
+ ntKey = key;
+ llNext = NULL;
+ llPrev = NULL;
+ }
+
+ template<class xbNodeType>
+ xbLinkListNode<xbNodeType>::xbLinkListNode( const xbNodeType &key, const xbString &s ){
+ ntKey = key;
+ sData = s;
+ llNext = NULL;
+ llPrev = NULL;
+ }
+
+ template<class xbNodeType>
+ xbNodeType xbLinkListNode<xbNodeType>::GetKey() const {
+ return ntKey;
+ }
+
+ template<class xbNodeType>
+ xbString &xbLinkListNode<xbNodeType>::GetData(){
+ return sData;
+ }
+
+ template<class xbNodeType>
+ xbLinkListNode<xbNodeType> *xbLinkListNode<xbNodeType>::GetNextNode() const {
+ return llNext;
+ }
+
+ template<class xbNodeType>
+ xbLinkListNode<xbNodeType> *xbLinkListNode<xbNodeType>::GetPrevNode() const {
+ return llPrev;
+ }
+
+ template<class xbNodeType>
+ void xbLinkListNode<xbNodeType>::SetNextNode( xbLinkListNode<xbNodeType> *lln ){
+ llNext = lln;
+ }
+
+ template<class xbNodeType>
+ void xbLinkListNode<xbNodeType>::SetPrevNode( xbLinkListNode<xbNodeType> *llp ){
+ llPrev = llp;
+ }
+
+} // namespace
+#endif // XB_LINKLIST_SUPPORT
+#endif // XB_XBLNKNOD_H__
+
+
diff --git a/src/include/xblog.h b/src/include/xblog.h
new file mode 100755
index 0000000..e78f476
--- /dev/null
+++ b/src/include/xblog.h
@@ -0,0 +1,66 @@
+/* xblog.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_XBLOG_H__
+#define __XB_XBLOG_H__
+
+#ifdef CMAKE_COMPILER_IS_GNUCC
+#pragma interface
+#endif
+
+namespace xb{
+
+#ifdef XB_LOGGING_SUPPORT
+
+//! @brief xbLog class.
+/*!
+The xbLog class handles message logging functions.
+
+If logging is enabled in an application, error messages are printed
+in the log file.
+
+Once a logfile reaches a predefined size, the logfile is closed, renamed
+and opened.
+
+The logging functions can be accessed through the xbXBase class.
+Each application has one of those.
+*/
+
+class XBDLLEXPORT xbLog : public xbFile {
+ public:
+ xbLog();
+ xbLog( const xbString &sLogFileName );
+ ~xbLog();
+
+ xbInt16 LogClose ();
+ xbInt16 LogGetStatus ();
+ xbInt16 LogOpen ();
+ void LogSetStatus ( xbBool bLogStatus );
+ void LogSetLogSize( size_t lSize ); // { LogSize = size; }
+ xbInt16 LogWrite ( const xbString &LogEntry, xbInt16 iOutputOption = 0 );
+ xbInt16 LogWriteBytes( xbUInt32 lByteCnt, const char *p );
+
+ private:
+ xbBool bLoggingStatus; // false = logging off
+ // true = logging on
+ size_t lLogSize;
+ xbInt16 iShareMode;
+};
+
+#endif // XB_LOGGING_SUPPORT
+} // namespace
+#endif // XB_XBLOG_H__
+
+
diff --git a/src/include/xbmemo.h b/src/include/xbmemo.h
new file mode 100755
index 0000000..e86a65c
--- /dev/null
+++ b/src/include/xbmemo.h
@@ -0,0 +1,223 @@
+/* xbmemo.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_XBMEMO_H__
+#define __XB_XBMEMO_H__
+
+
+// dont use "#pragma interface" with abstract classes
+// #ifdef CMAKE_COMPILER_IS_GNUCC
+// #pragma interface
+// #endif
+
+#ifdef XB_MEMO_SUPPORT
+
+
+
+
+namespace xb{
+
+//! @brief Base class for memo files.
+/*!
+
+The xbMemo class is used as a base class for accessing memo files.
+
+Any DBF file which has any memo fields, will also have a DBT file with the same name.
+Memo fields are stored in the DBT file in 512 or 1024 byte sized blocks.
+
+Calls to the memo routines to read and access memo fields are supported from within
+the dbf class via the GetMemoField and UpdateMemoField routines.
+From an application program point of view, the application program does not need to
+be concerned with the memo classes.<br>
+
+The main difference between the version 3 and version 4 memo files is that
+the version 4 files will reclaim and reuse blocks if available. The version 3
+memo file logic does not.<br>
+
+If you are adding a new style memo table to the logic, you can create a new class
+modeled after xbMemoDbt3 or xbDbtMemo4, using the xbMemo class as a base class.
+
+*/
+
+class XBDLLEXPORT xbMemo : public xbFile {
+ public:
+
+ xbMemo( xbDbf *dbf, xbString const &sFileName );
+
+ /* virtual methods */
+ virtual ~xbMemo();
+ virtual xbInt16 Abort () = 0;
+ virtual xbInt16 CloseMemoFile ();
+ virtual xbInt16 Commit () = 0;
+
+ #ifdef XB_LOCKING_SUPPORT
+ virtual xbInt16 LockMemo ( xbInt16 iLockFunction );
+ virtual xbBool GetMemoLocked () const;
+ #endif
+
+ /* pure virtual methods */
+ virtual xbInt16 CreateMemoFile () = 0;
+
+ virtual xbInt16 GetMemoField ( xbInt16 iFieldNo, xbString &sMemoData ) = 0;
+ virtual xbInt16 GetMemoFieldLen( xbInt16 iFieldNo, xbUInt32 &ulMemoFieldLen ) = 0;
+ virtual xbInt16 OpenMemoFile () = 0;
+ virtual xbInt16 GetMemoFileType();
+ virtual xbInt16 PackMemo ( void (*memoStatusFunc)(xbUInt32 ulItemNum, xbUInt32 ulNumItems)) = 0;
+ virtual xbInt16 UpdateMemoField( xbInt16 iFieldNo, const xbString &sMemoData ) = 0;
+
+ #ifdef XB_DEBUG_SUPPORT
+ virtual xbInt16 DumpMemoFreeChain() = 0;
+ virtual xbInt16 DumpMemoHeader () = 0;
+ #endif
+
+ // *********** FIXME *************
+ // next two methods should be protected but are called in the xb_test_xxxx programs testing routines
+ // so for now, they are kept as public
+ virtual xbInt16 CalcLastDataBlock ( xbUInt32 &lLastDataBlock );
+ virtual xbInt16 GetHdrNextBlock ( xbUInt32 &ulBlockNo );
+
+ protected:
+ friend class xbDbf;
+
+ virtual xbInt16 ReadDbtHeader ( xbInt16 iOption ) = 0;
+ virtual xbInt16 UpdateHeaderName () = 0;
+ virtual xbInt16 UpdateHeadNextNode();
+ virtual xbInt16 Zap () = 0;
+
+ xbDbf *dbf; /* pointer to related dbf instance */
+ char cVersion; /* byte 16 off the header block, 0x03 for V3, version IV - ? */
+ xbInt16 iMemoFileType; /* 3 = version III, 4 = version IV */
+ xbUInt32 ulHdrNextBlock; /* next available block , bytes 0-3 of the memo header */
+ void * mbb; /* memo block buffer */
+
+
+ private:
+
+ #ifdef XB_LOCKING_SUPPORT
+ xbBool bFileLocked; /* memo file locked */
+ #endif
+
+};
+
+
+
+#ifdef XB_DBF3_SUPPORT
+//! @brief Derived class for version 3 memo files.
+/*!
+
+The xbMemoDbt3 class is derived from the xbMome class and is used for accessing the
+older Version 3 memo files.
+
+The main difference between the version 3 and version 4 memo files is that
+the version 4 files will reclaim and reuse blocks if available. The version 3
+memo file logic does not.<br>
+
+*/
+
+
+class XBDLLEXPORT xbMemoDbt3 : public xbMemo {
+ public:
+ xbMemoDbt3( xbDbf *dbf, xbString const &sFileName );
+ ~xbMemoDbt3();
+ virtual xbInt16 Abort ();
+ virtual xbInt16 Commit ();
+ virtual xbInt16 CreateMemoFile ();
+ virtual xbInt16 GetMemoField ( xbInt16 iFieldNo, xbString &sMemoData );
+ virtual xbInt16 GetMemoFieldLen( xbInt16 iFieldNo, xbUInt32 &ulMemoFieldLen );
+ virtual xbInt16 OpenMemoFile ();
+ virtual xbInt16 PackMemo ( void (*memoStatusFunc) (xbUInt32 ulItemNum, xbUInt32 ulNumItems));
+ virtual xbInt16 UpdateMemoField( xbInt16 iFieldNo, const xbString &sMemoData );
+
+ #ifdef XB_DEBUG_SUPPORT
+ virtual xbInt16 DumpMemoFreeChain();
+ virtual xbInt16 DumpMemoHeader ();
+ #endif
+
+ protected:
+ virtual xbInt16 ReadDbtHeader( xbInt16 iOption );
+ virtual xbInt16 UpdateHeaderName();
+ virtual xbInt16 Zap();
+
+ private:
+};
+#endif
+
+
+#ifdef XB_DBF4_SUPPORT
+
+//! @brief Derived class for version 4 memo files.
+/*!
+
+The xbMemoDbt4 class is derived from the xbMeme class and is used for accessing the
+current Version 4 memo files.
+
+The main difference between the version 3 and version 4 memo files is that
+the version 4 files will reclaim and reuse blocks if available. The version 3
+memo file logic does not.<br>
+*/
+
+class XBDLLEXPORT xbMemoDbt4 : public xbMemo {
+ public:
+ xbMemoDbt4( xbDbf *dbf, xbString const &sFileName );
+ ~xbMemoDbt4();
+ virtual xbInt16 Abort ();
+ virtual xbInt16 Commit ();
+ virtual xbInt16 CreateMemoFile ();
+
+ virtual xbInt16 GetMemoField ( xbInt16 iFieldNo, xbString &sMemoData );
+ virtual xbInt16 GetMemoFieldLen ( xbInt16 iFieldNo, xbUInt32 &ulMemoFieldLen );
+ virtual xbInt16 GetMemoFieldLen ( xbInt16 iFieldNo, xbUInt32 &ulMemoFieldLen, xbUInt32 &lBlockNo );
+ virtual xbInt16 OpenMemoFile ();
+ virtual xbInt16 PackMemo ( void (*memoStatusFunc) (xbUInt32 ulItemNum, xbUInt32 ulNumItems));
+ virtual xbInt16 UpdateMemoField ( xbInt16 iFieldNo, const xbString &sMemoData );
+
+ #ifdef XB_DEBUG_SUPPORT
+ virtual xbInt16 DumpMemoFreeChain ();
+ virtual xbInt16 DumpMemoHeader ();
+ virtual xbInt16 DumpMemoInternals ();
+ virtual xbInt16 ReadFreeBlockHeader( xbUInt32 ulBlockNo, xbUInt32 &ulNextBlock, xbUInt32 &ulFreeBlockCnt );
+ #endif
+
+ protected:
+ virtual xbInt16 FindBlockSetInChain( xbUInt32 ulBlocksNeeded, xbUInt32 &ulLastDataBlock, xbUInt32 &ulLocation, xbUInt32 &ulPrevNode, xbBool &bFound );
+ virtual xbInt16 FreeMemoBlockChain( xbUInt32 ulBlockNo );
+ virtual xbInt16 FreeMemoBlockChain( xbUInt32 ulBlockNo, xbUInt32 &ulLastDataBlock );
+ virtual xbInt16 GetBlockSetFromChain( xbUInt32 ulBlocksNeeded, xbUInt32 ulLocation, xbUInt32 ulPrevNode );
+ virtual xbInt16 ReadDbtHeader( xbInt16 iOption );
+ virtual xbInt16 ReadBlockHeader( xbUInt32 ulBlockNo, xbInt16 iOption );
+ virtual xbInt16 UpdateHeaderName ();
+ virtual xbInt16 WriteBlockHeader( xbUInt32 ulBlockNo, xbInt16 iOption );
+ virtual xbInt16 Zap();
+
+ private:
+ xbString sDbfFileNameWoExt;
+ xbUInt32 ulNextFreeBlock;
+ xbUInt32 ulFreeBlockCnt;
+ xbInt16 iField1;
+ xbInt16 iStartPos;
+ xbUInt32 ulFieldLen;
+
+ xbLinkList<xbUInt32> llOldBlocks; // list of previously used memo blocks for field, used by Commit() / Abort()
+ xbLinkList<xbUInt32> llNewBlocks; // list of newly updated memo blocks for field, used by Commit() / Abort()
+
+};
+#endif
+
+
+} /* namespace xb */
+#endif /* XB_MEMO_SUPPORT */
+#endif /* __XB_MEMO_H__ */
+
diff --git a/src/include/xbretcod.h b/src/include/xbretcod.h
new file mode 100755
index 0000000..6b73527
--- /dev/null
+++ b/src/include/xbretcod.h
@@ -0,0 +1,94 @@
+/* xbretcod.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_RETCODES_H__
+#define __XB_RETCODES_H__
+
+/***********************************************/
+/* Return Codes and Error Messages */
+
+namespace xb{
+
+ #define XB_NO_ERROR 0 // general
+ #define XB_NO_MEMORY -100 // general
+ #define XB_INVALID_OPTION -101 // general
+ #define XB_DUP_TABLE_OR_ALIAS -110 // table manager
+ #define XB_INVALID_NODELINK -120 // linklist
+ #define XB_KEY_NOT_UNIQUE -121 // linklist
+
+ #define XB_FILE_EXISTS -200 // file
+ #define XB_ALREADY_OPEN -201 // file
+ #define XB_DBF_FILE_NOT_OPEN -202 // file
+ #define XB_FILE_NOT_FOUND -203 // file
+ #define XB_FILE_TYPE_NOT_SUPPORTED -204 // file
+ #define XB_RENAME_ERROR -205 // file
+ #define XB_INVALID_OBJECT -206 // file
+ #define XB_NOT_OPEN -207 // file
+ #define XB_NOT_FOUND -208 // file
+ #define XB_OPEN_ERROR -209 // file
+ #define XB_CLOSE_ERROR -210 // file
+ #define XB_SEEK_ERROR -211 // file
+ #define XB_READ_ERROR -212 // file
+ #define XB_WRITE_ERROR -213 // file
+ #define XB_EOF -214 // file
+ #define XB_BOF -215 // file
+ #define XB_INVALID_BLOCK_SIZE -216 // file
+ #define XB_INVALID_BLOCK_NO -217 // file
+ #define XB_INVALID_RECORD -218 // file
+ #define XB_DELETE_FAILED -219 // file
+ #define XB_INVALID_TABLE_NAME -220 // file
+ #define XB_EMPTY -221 // file
+ #define XB_LIMIT_REACHED -222 // file
+
+ #define XB_INVALID_FIELD_TYPE -300 // field
+ #define XB_INVALID_FIELD_NO -301 // field
+ #define XB_INVALID_DATA -302 // field
+ #define XB_INVALID_FIELD_NAME -303 // field
+ #define XB_INVALID_MEMO_FIELD -304 // field
+ #define XB_INVALID_FIELD -305 // field
+ #define XB_INVALID_FIELD_LEN -306 // field
+ #define XB_INVALID_DATE -307 // date field
+
+ #define XB_INVALID_LOCK_OPTION -400 // lock
+ #define XB_LOCK_FAILED -401 // lock
+ #define XB_TABLE_NOT_LOCKED -402 // lock - need table locked for operation
+
+ #define XB_PARSE_ERROR -500 // expression
+ #define XB_INVALID_FUNCTION -501 // expression
+ #define XB_INVALID_PARM -502 // expression
+ #define XB_INCONSISTENT_PARM_LENS -503 // expression
+ #define XB_INCOMPATIBLE_OPERANDS -504 // expression
+ #define XB_UNBALANCED_PARENS -505 // expression
+ #define XB_UNBALANCED_QUOTES -506 // expression
+ #define XB_INVALID_EXPRESSION -507 // expression
+
+ #define XB_INVALID_KEYNO -600 // index
+ #define XB_INVALID_INDEX -601 // index file error
+ #define XB_INVALID_TAG -602 // invalid index tag name, must be <= 10 bytes
+ #define XB_INVALID_PAGE -603 // invalid index page
+
+
+ #define XB_SYNTAX_ERROR -700 // sql syntax error
+
+
+ #define XB_MAX_ERROR_NO -999
+
+
+/* when updating this table, also need to update messages in xbssv.cpp */
+
+
+} /* namespace */
+#endif /* __XB_RETCODES_H__ */
+
diff --git a/src/include/xbsql.h b/src/include/xbsql.h
new file mode 100755
index 0000000..3869995
--- /dev/null
+++ b/src/include/xbsql.h
@@ -0,0 +1,69 @@
+/* xbsql.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
+
+This class manages a list of open tables, open indices are connected to the open tables
+
+*/
+
+
+#ifndef __XB_XBSQL_H__
+#define __XB_XBSQL_H__
+
+#ifdef CMAKE_COMPILER_IS_GNUCC
+#pragma interface
+#endif
+
+
+#ifdef XB_SQL_SUPPORT
+
+namespace xb{
+
+
+class XBDLLEXPORT xbSql : public xbSsv {
+ public:
+ // xbSql();
+ xbSql( xbXBase *x );
+ ~xbSql();
+
+ xbInt16 ExecuteNonQuery( const xbString &sCmdLine );
+ xbXBase *GetXbasePtr() const;
+
+ protected:
+
+ private:
+
+ xbInt16 SqlCreateTable( const xbString &sCmdLine );
+ xbInt16 SqlCreateIndex( const xbString &sCmdLine );
+
+ xbInt16 SqlDropIndex( const xbString &sCmdLine );
+ xbInt16 SqlDropTable( const xbString &sCmdLine );
+
+
+// xbInt16 SqlCreateView( const xbString &sCmdLine );
+// xbInt16 SqlDropView( const xbString &sCmdLine );
+// xbInt16 SqlUpdate( const xbString &sCmdLine );
+// xbInt16 SqlSelect( const xbString &sCmdLine );
+
+ void SqlHelp() const;
+ xbInt16 SqlInsert( const xbString &sCmLine );
+ xbInt16 SqlSet( const xbString &sCmdLine );
+ xbInt16 SqlUse( const xbString &sCmdLine );
+
+ xbXBase *xbase;
+ xbUda uda;
+
+};
+
+} /* namespace xb */
+#endif /* XB_SQL_SUPPORT */
+#endif /* __XB_XBSQL_H__ */ \ No newline at end of file
diff --git a/src/include/xbssv.h b/src/include/xbssv.h
new file mode 100755
index 0000000..80da2d0
--- /dev/null
+++ b/src/include/xbssv.h
@@ -0,0 +1,177 @@
+/* xbssv.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_XBSSV_H__
+#define __XB_XBSSV_H__
+
+#ifdef CMAKE_COMPILER_IS_GNUCC
+#pragma interface
+#endif
+
+
+namespace xb{
+
+class XBDLLEXPORT xbXBase;
+
+///@cond DOXYOFF
+struct XBDLLEXPORT xbErrorMessage{
+ xbInt16 iErrorNo;
+ const char *sErrorText;
+};
+///@endcond DOXYOFF
+
+
+//! @brief Class for handling shared system variables.
+/*!
+This class defines static variables which are referenced across class instances.
+
+This class is designed to have the variables set when the xbXBase class constructor is called
+(xbXBase is a derived class). The xbXbase class is designed to be called first in an application
+programs, and it is only called once. The static values in this class are typically initialized at
+program startup and don't require additional updates.
+
+*/
+
+
+// By design, DBase allows mutliple records in a table all having the same key, but only one entry in a unique index
+// XB_HALT_ON_DUP_KEY tells the library to not allow appending records which generate duplicate keys in a unique index
+//
+#if defined (XB_NDX_SUPPORT) || defined (XB_MDX_SUPPORT)
+#define XB_HALT_ON_DUPKEY 0
+#define XB_EMULATE_DBASE 1
+#endif
+
+
+
+class XBDLLEXPORT xbSsv{
+ public:
+ xbSsv();
+ const static char *ErrorCodeText[];
+
+ void DisplayError ( xbInt16 ErrorCode ) const;
+ xbString& GetDefaultDateFormat () const;
+ xbString& GetDataDirectory () const;
+ xbInt16 GetEndianType () const;
+
+ const char *GetErrorMessage ( xbInt16 ErrorCode ) const;
+ void SetDataDirectory ( const xbString &sDataDirectory );
+ void SetDefaultDateFormat ( const xbString &sDefaultDateFormat );
+
+
+ xbBool BitSet ( unsigned char c, xbInt16 iBitNo ) const;
+ #ifdef XB_DEBUG_SUPPORT
+ void BitDump ( unsigned char c ) const;
+ void BitDump ( char c ) const;
+ #endif
+
+ xbBool GetDefaultAutoCommit () const;
+ void SetDefaultAutoCommit ( xbBool bDefaultAutoCommit );
+
+ xbString& GetDefaultLogDirectory () const;
+ xbString& GetDefaultLogFileName () const;
+ void SetDefaultLogDirectory ( const xbString &sDefaultLogDirectory );
+
+ xbBool GetMultiUser () const;
+ void SetMultiUser ( xbBool bMultiUser );
+
+ #if defined (XB_NDX_SUPPORT) || defined (XB_MDX_SUPPORT)
+ xbInt16 GetUniqueKeyOpt () const;
+ xbInt16 SetUniqueKeyOpt ( xbInt16 iUniqueKeyOpt );
+ #endif
+
+ #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 ();
+ #endif
+
+ #ifdef XB_MDX_SUPPORT
+ xbInt16 GetCreateMdxBlockSize() const;
+ xbInt16 SetCreateMdxBlockSize( xbInt16 ulBlockSize );
+ #endif
+
+ protected:
+
+ void SetEndianType ();
+
+ static xbInt16 iEndianType; // B=Big Endian L=Little Endian
+ static xbString sNullString; // Null String
+
+
+ private:
+
+ static xbString sDefaultDateFormat;
+ static xbString sDataDirectory; //Data file directory
+
+ #ifdef XB_LOGGING_SUPPORT
+ static xbString sDefaultLogDirectory; //Default location to store log files
+ static xbString sDefaultLogFileName; //Default LogFileName
+ #endif
+
+ static xbInt16 iDefaultFileVersion; // 3 = DBase 3
+ // 4 = DBase 4
+ // default version used in CreateTable command
+ // can be over ridden at the Xbase level, or table level
+ // Different versions can be open simultaneously
+
+ static xbBool bDefaultAutoCommit; // Default dbf auto commit switch
+
+ static xbBool bMultiUser; // True if multi user mode is turned on
+ // Turn this off for better performance in single user mode
+ // This needs to be turned on or off before any data tables are opened
+ // turning this on after tables are opened, can result in out of date
+ // file buffers if multiple users are sharing the files
+
+#ifdef XB_LOCKING_SUPPORT
+ static xbInt32 lDefaultLockWait; // Number of milliseconds between lock retries
+ static xbInt16 iDefaultLockRetries; // Number of times to retry a lock before conceding
+ static xbInt16 bDefaultAutoLock; // Autolocking enabled?
+ static xbInt16 iDefaultLockFlavor; // 1 = DBase
+ // 2 = Clipper - not developed yet
+ // 3 = FoxPro - not developed yet
+ // 9 = Xbase64 - not developed yet
+#endif
+
+
+
+#if defined (XB_NDX_SUPPORT) || defined (XB_MDX_SUPPORT)
+
+ static xbInt16 iUniqueKeyOpt;
+
+ // is one of:
+ // XB_HALT_ON_DUPKEY
+ // XB_EMULATE_DBASE
+
+#endif
+
+
+#ifdef XB_MDX_SUPPORT
+ static xbInt16 iCreateMdxBlockSize; // System level Mdx Block Size
+#endif // XB_MDX_SUPPORT
+
+
+
+};
+
+} /* namespace xb */
+#endif /* __XB_XBSSV_H__ */ \ No newline at end of file
diff --git a/src/include/xbstring.h b/src/include/xbstring.h
new file mode 100755
index 0000000..c2f15cd
--- /dev/null
+++ b/src/include/xbstring.h
@@ -0,0 +1,183 @@
+/* xbstring.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 __XBSTRING_H__
+#define __XBSTRING_H__
+
+#ifdef CMAKE_COMPILER_IS_GNUCC
+#pragma interface
+#endif
+
+#include <stdlib.h>
+#include <iostream>
+
+namespace xb{
+
+
+//! @brief Class for handling string data.
+
+/*!
+This class defines a basic string class with all the functions one would expect in a string class.
+
+For purposes of the xbString class, a string is defined as a variable sized array of one byte
+characters terminated with a null (0x00 or \0) byte.<br><br>
+
+This version of the xbString class does not support wide (wchar_t) characters. Perhaps you would
+be interested in creating a class for supporting wide characters.<br><br>
+
+This string class handle strings in a 1-based (not 0 based) fashion.
+Any string routines taking an offset use a 1-based value. That is, the first position of
+the string is position 1, not 0.<br><br>
+
+Position 1 (not 0) is considered the first position in a string.
+A return of 0 would indicate a not found condition. A return of 1, would be the
+first byte.
+*/
+
+
+class XBDLLEXPORT xbString {
+
+ public:
+ //Various constructors
+ xbString(xbUInt32 size);
+ xbString(char c);
+ xbString(const char *s, xbUInt32 lMaxLen);
+ xbString(const xbString &s);
+ xbString(const char * = "");
+ xbString( xbDouble d );
+ ~xbString();
+
+ //operators
+ xbString &operator= (const xbString &s);
+ xbString &operator= (const char *s);
+ operator const char *() const;
+ char &operator[](xbUInt32 n) const;
+ char &operator[](xbInt32 n) const;
+
+ xbString &operator+=(const xbString &s);
+ xbString &operator+=(const char *s);
+ xbString &operator+=(char c);
+ xbString &operator-=(const xbString &s);
+ xbString &operator-=(const char *s);
+ xbString &operator-=(char c);
+
+ xbBool operator == ( const xbString& ) const;
+ xbBool operator == ( const char * ) const;
+ xbBool operator != ( const xbString& ) const;
+ xbBool operator != ( const char * ) const;
+
+ xbBool operator < ( const xbString& ) const;
+ xbBool operator > ( const xbString& ) const;
+ xbBool operator <= ( const xbString& ) const;
+ xbBool operator >= ( const xbString& ) const;
+
+ xbString operator-( const xbString &s );
+ xbString operator+( const char *s );
+ xbString operator+( const xbString &s );
+ xbString operator+( const char c );
+
+ xbString &AddBackSlash( char c );
+ xbString &Append(const xbString &s);
+ xbString &Append(const char *s);
+ xbString &Append(const char *s, xbUInt32 iByteCount );
+ xbString &Append(char c);
+ xbString &Assign(const char *srcStr, xbUInt32 lStartPos, xbUInt32 lCopyLen );
+ xbString &Assign(const char *srcStr, xbUInt32 lStartPos );
+ xbString &Assign(const xbString &s, xbUInt32 pos, xbUInt32 n );
+ xbString &Assign(const xbString &s, xbUInt32 n );
+
+ xbString Copy() const;
+ xbUInt32 CountChar( char c ) const;
+ xbUInt32 CountChar( char c, xbInt16 iOpt ) const;
+ xbInt16 CvtHexChar( char &cOut );
+ xbInt16 CvtHexString( xbString &sOut );
+ xbInt16 CvtULongLong( xbUInt64 &ullOut );
+ xbInt16 CvtLongLong( xbInt64 &llOut );
+
+ #ifdef XB_DEBUG_SUPPORT
+ void Dump( const char *title ) const;
+ void Dump( const char *title, xbInt16 iOption ) const;
+ void DumpHex( const char *title ) const;
+ #endif
+
+ xbString &ExtractElement(const char *src, char delim, xbUInt32 iCnt, xbInt16 iOpt = 0 );
+ char GetCharacter( xbUInt32 lPos ) const;
+ xbUInt32 GetLastPos(char c) const;
+ xbUInt32 GetLastPos(const char *s) const;
+ char GetPathSeparator() const;
+ xbUInt32 GetSize() const;
+
+ xbBool HasAlphaChars() const;
+ xbBool IsEmpty() const;
+ xbBool IsNull() const;
+
+ xbString &Left( xbUInt32 ulLen );
+ xbUInt32 Len() const; // returns the length of the string
+ xbString &Ltrim();
+ xbString &Ltrunc( xbUInt32 ulCnt );
+
+ xbString &Mid(xbUInt32 ulPos, xbUInt32 lLen );
+ xbString &PadLeft( char c, xbUInt32 ulLen );
+ xbString &PadRight( char c, xbUInt32 ulLen );
+ xbUInt32 Pos(char c) const;
+ xbUInt32 Pos(const char *s) const;
+ xbString &PutAt(xbUInt32 ulPos, char c);
+
+ xbString &Remove( xbUInt32 ulPos, xbUInt32 ulN );
+ xbString &Resize( xbUInt32 lSize );
+ xbString &Rtrim();
+
+ xbString &Set( const char *s );
+ xbString &Set( const xbString &s );
+ xbString &Set( const char *s, xbUInt32 ulSize );
+ xbString &SetNum( xbInt32 lNum );
+ xbString &Sprintf(const char *format, ...);
+
+ const char *Str() const;
+ char *strncpy( char * cDest, xbUInt32 n ) const;
+ xbString &SwapChars( char from, char to );
+
+ xbString &ToLowerCase();
+ xbString &ToUpperCase();
+ xbString &Trim();
+
+ xbBool ValidLogicalValue() const;
+ xbBool ValidNumericValue() const;
+ xbString &ZapChar( char c );
+ xbString &ZapLeadingChar( char c );
+ xbString &ZapTrailingChar( char c );
+
+ friend std::ostream& operator<< ( std::ostream& os, const xbString& s );
+
+ private:
+
+ static const char * NullString;
+ static char cJunkBuf;
+
+ char *data; // pointer to actual string data
+ xbUInt32 size; // size of string plus null terminating byte
+
+ void ctor(const char *s);
+// xbUInt32 CalcSprintfBufSize(const char *format, ...);
+
+// char * xb_realloc( char *pIn, xbUInt32 iLen );
+
+ // next routine could result in buffer over runs if used with improperly sized buffers
+ char * xb_strcpy ( char *target, const char *source);
+
+};
+
+} /* namespace */
+#endif /* __XBSTRING_H__ */
diff --git a/src/include/xbtag.h b/src/include/xbtag.h
new file mode 100755
index 0000000..9b518a3
--- /dev/null
+++ b/src/include/xbtag.h
@@ -0,0 +1,74 @@
+/* xbtag.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_XBTAG_H__
+#define __XB_XBTAG_H__
+
+//#ifdef CMAKE_COMPILER_IS_GNUCC
+//#pragma interface
+//#endif
+
+namespace xb{
+
+
+#ifdef XB_INDEX_SUPPORT
+
+class XBDLLEXPORT xbIx;
+
+
+
+//! @brief xbTag is used for linking index tags to a table (aka dbf file).
+/*!
+
+ Each dbf file (or table) can have zero, one or many tags.
+ Each tag is maintained in a linked list of xbTags.
+
+ NDX index files contain only one index tag.<br>
+ MDX index files can contain one to 47 index tags. The production MDX file is opened automatically
+ and the tags are added to the tag list.
+
+*/
+
+class XBDLLEXPORT xbTag {
+
+ public:
+ xbTag( xbIx *pIx, void *vpTag, xbString &sType, xbString &sTagName, xbString &sExpression, xbString &sFilter, xbBool bUnique, xbBool bSort );
+
+ xbIx *GetIx() const;
+ void *GetVpTag() const;
+ const xbString &GetType() const;
+ const xbString &GetTagName() const;
+ const xbString &GetExpression() const;
+ const xbString &GetFilter() const;
+ xbBool GetUnique() const;
+ xbBool GetSort() const;
+
+ private:
+ xbIx *pIx;
+ void *vpTag;
+ xbString sType;
+ xbString sTagName;
+ xbString sExpression;
+ xbString sFilter;
+ xbBool bUnique;
+ xbBool bSort; // 0 = Ascending, 1 = Descending
+};
+
+#endif // XB_INDEX_SUPPORT
+
+
+} /* namespace xb */
+#endif /* __XB_TAG_H__ */
diff --git a/src/include/xbtblmgr.h b/src/include/xbtblmgr.h
new file mode 100755
index 0000000..d551002
--- /dev/null
+++ b/src/include/xbtblmgr.h
@@ -0,0 +1,61 @@
+/* xbtblmgr.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
+
+This class manages a list of open tables, open indices are connected to the open tables
+
+*/
+
+
+#ifndef __XB_XBMGR_H__
+#define __XB_XBMGR_H__
+
+#ifdef CMAKE_COMPILER_IS_GNUCC
+#pragma interface
+#endif
+
+namespace xb{
+
+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 */
+ xbDbf *pDbf;
+};
+
+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 DisplayTableList () const;
+ xbDbf * GetDbfPtr ( const xbString &sTblAlias ) const;
+ xbDbf * GetDbfPtr ( xbInt16 sItemNo ) const;
+ xbInt16 GetOpenTableCount () const;
+ xbInt16 RemoveTblFromTblList ( const xbString &sTblAlias );
+ xbInt16 RemoveTblFromTblList ( xbDbf *d );
+
+ protected:
+
+ private:
+ xbTblList * TblList; // List of open database tables
+ xbInt16 iOpenTableCount; // Number of open tables
+
+};
+
+} /* namespace xb */
+
+#endif /* __XB_XBMGR_H__ */ \ No newline at end of file
diff --git a/src/include/xbtypes.h b/src/include/xbtypes.h
new file mode 100755
index 0000000..99b6c22
--- /dev/null
+++ b/src/include/xbtypes.h
@@ -0,0 +1,55 @@
+/* xbtypes.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_XTYPES_H__
+#define __XB_XTYPES_H__
+
+namespace xb{
+
+
+typedef float xbFloat;
+typedef double xbDouble;
+typedef short int xbBool;
+typedef xbUInt64 xbOffT;
+
+
+#define xbTrue 1
+#define xbFalse 0
+
+
+#ifdef HAVE__FILENO_F
+ #define xbFileNo _fileno
+#else
+ #define xbFileNo fileno
+#endif
+
+#ifdef XB_LOCKING_SUPPORT
+ #if defined( HAVE_LONG_LONG )
+ #define LK4026531839 4026531839LL
+ #define LK4026531838 4026531838LL
+ #define LK3026531838 3026531838LL
+ #define LK1000000000 1000000000LL
+ #else
+ #define LK4026531839 4026531839L
+ #define LK4026531838 4026531838L
+ #define LK3026531838 3026531838L
+ #define LK1000000000 1000000000L
+ #endif
+#endif
+
+
+
+} /* namespace */
+#endif /* __XB_XTYPES_H__ */
diff --git a/src/include/xbuda.h b/src/include/xbuda.h
new file mode 100755
index 0000000..84eccee
--- /dev/null
+++ b/src/include/xbuda.h
@@ -0,0 +1,52 @@
+/* xbuda.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
+
+This class manages the user data area (UDA)
+
+*/
+
+
+#ifndef __XB_XBUDA_H__
+#define __XB_XBUDA_H__
+
+#ifdef CMAKE_COMPILER_IS_GNUCC
+#pragma interface
+#endif
+
+
+#ifdef XB_EXPRESSION_SUPPORT
+
+
+namespace xb{
+
+class XBDLLEXPORT xbUda {
+
+ public:
+ xbUda();
+ ~xbUda();
+
+ xbInt16 AddTokenForKey( const xbString &sKey, const xbString &sToken );
+ void Clear();
+ xbInt16 DelTokenForKey( const xbString &sKey );
+ xbInt16 GetTokenCnt() const;
+ xbInt16 GetTokenForKey( const xbString &sKey, xbString &sData );
+ xbInt16 UpdTokenForKey( const xbString &sKey, const xbString &sToken );
+ void DumpUda() const;
+
+ private:
+ xbLinkListOrd<xbString> llOrd;
+
+};
+} /* namespace */
+#endif /* XB_EXPRESSION_SUPPORT */
+#endif /* __XBUDA_H__ */ \ No newline at end of file
diff --git a/src/include/xbxbase.h b/src/include/xbxbase.h
new file mode 100755
index 0000000..204e744
--- /dev/null
+++ b/src/include/xbxbase.h
@@ -0,0 +1,222 @@
+/* xbxbase.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_XBDBLIST_H__
+#define __XB_XBDBLIST_H__
+
+#ifdef CMAKE_COMPILER_IS_GNUCC
+#pragma interface
+#endif
+
+namespace xb{
+
+class XBDLLEXPORT xbLog;
+
+/************************************************************************/
+/*
+ Xbase functions
+
+ Min Parm Count is the minimum number of input parms needed by the function
+
+ Return Type
+ C Char or string
+ D Date
+ L Logical
+ N Numeric
+ 1 Varies - pull return type from first sibling
+ 2 Varies - pull return type from second sibling
+*/
+
+#ifdef XB_FUNCTION_SUPPORT
+
+/*
+struct XBDLLEXPORT xbFunctionInfo {
+ const char * FuncName; // function name
+ char ReturnType; // return type of function
+ xbInt16 iReturnLenCalc; // used to calculate the function return value is
+ // 1 = use value specified in iReturnLenVal
+ // 2 = use length of operand specified in col 4
+ // 3 = use valued of numeric operand specified in col 4
+ // 4 = length of parm 1 * numeric value parm
+ // 5 = larger length of parm 2 or length of parm 3
+ // 6 = if two or more parms, use numeric value from second parm,
+ // otherwise use col4 value
+ xbInt16 iReturnLenVal; // Used in combination with iReturnLenCalc
+
+};
+*/
+/*
+static xbFunctionInfo FunctionList[] =
+// Func Return -Rtrn Len-
+// Name Type -Calc Val-
+{
+ { "ABS", 'N', 1, 4 },
+ { "ALLTRIM", 'C', 2, 1 },
+ { "ASC", 'N', 1, 4 },
+ { "AT", 'N', 1, 4 },
+ { "CDOW", 'C', 1, 9 },
+ { "CHR", 'C', 1, 1 },
+ { "CMONTH", 'C', 1, 9 },
+ { "CTOD", 'D', 1, 8 },
+ { "DATE", 'D', 1, 8 },
+ { "DAY", 'N', 1, 4 },
+ { "DEL", 'C', 1, 1 },
+ { "DELETED", 'L', 1, 1 },
+ { "DESCEND", '1', 2, 1 },
+ { "DOW", 'N', 1, 4 },
+ { "DTOC", 'C', 1, 8 },
+ { "DTOS", 'C', 1, 8 },
+ { "EXP", 'N', 1, 4 },
+ { "IIF", 'C', 5, 0 },
+ { "INT", 'N', 1, 4 },
+ { "ISALPHA", 'L', 1, 1 },
+ { "ISLOWER", 'L', 1, 1 },
+ { "ISUPPER", 'L', 1, 1 },
+ { "LEFT", 'C', 3, 2 },
+ { "LEN", 'N', 1, 4 },
+ { "LOG", 'N', 1, 4 },
+ { "LOWER", 'C', 2, 1 },
+ { "LTRIM", 'C', 2, 1 },
+ { "MAX", 'N', 1, 4 },
+ { "MIN", 'N', 1, 4 },
+ { "MONTH", 'N', 1, 4 },
+ { "RECNO", 'N', 1, 4 },
+ { "RECCOUNT", 'N', 1, 4 },
+ { "REPLICATE", 'C', 4, 0 },
+ { "RIGHT", 'C', 3, 2 },
+ { "RTRIM", 'C', 2, 1 },
+ { "SPACE", 'C', 3, 1 },
+ { "SQRT", 'N', 1, 4 },
+ { "STOD", 'D', 1, 8 },
+ { "STR", 'C', 6, 10 },
+ { "STRZERO", 'C', 3, 2 },
+ { "SUBSTR", 'C', 3, 3 },
+ { "TRIM", 'C', 2, 1 },
+ { "UPPER", 'C', 2, 1 },
+ { "VAL", 'N', 1, 4 },
+ { "YEAR", 'N', 1, 4 },
+ { 0, 0, 0, 0 },
+};
+*/
+#endif
+
+
+
+//! @brief xbXbase class.
+/*!
+ The xbXBase class is the core class that needs to be in every application program.
+*/
+
+class XBDLLEXPORT xbXBase : public xbTblMgr{
+ public:
+ xbXBase();
+ ~xbXBase();
+
+ xbInt16 CloseAllTables();
+ void DisableMsgLogging();
+ void EnableMsgLogging ();
+ xbInt16 FlushLog();
+
+ const xbString &GetLogDirectory () const;
+ const xbString &GetLogFileName () const;
+ const xbString &GetLogFqFileName() const;
+ xbBool GetLogStatus () const;
+
+ xbInt16 OpenHighestVersion( const xbString &sTableName, const xbString &sAlias, xbDbf &dbf, int dummy );
+ xbInt16 OpenHighestVersion( const xbString &sTableName, const xbString &sAlias, xbDbf **dbf );
+
+ xbDbf * Open( const xbString &sTableName, xbInt16 &iRc );
+ xbDbf * Open( const xbString &sTableName, const xbString &sAlias, xbInt16 iOpenMode, xbInt16 iShareMode, xbInt16 iVersion, xbInt16 &iRc );
+ void SetLogDirectory( const xbString &sLogFileDirectory );
+ void SetLogFileName ( const xbString &sLogFileName );
+ void SetLogSize ( size_t lSize );
+ xbInt16 WriteLogMessage( const xbString &sLogMessage, xbInt16 iOutputOpt = 0 );
+ xbInt16 WriteLogBytes ( xbUInt32 lCnt, const char *p );
+
+ void xbSleep ( xbInt32 lMillisecs );
+
+
+ /* xbase functions */
+ #ifdef XB_FUNCTION_SUPPORT
+ xbInt16 ABS( xbDouble dIn, xbDouble &dOut );
+ xbInt16 ALLTRIM( const xbString &sIn, xbString &sOut );
+ xbInt16 ASC( const xbString &s, xbDouble &dAscOut );
+ xbInt16 AT( const xbString &sSrchFor, const xbString &sBase, xbDouble &dPos );
+ xbInt16 CDOW( xbDate &dInDate, xbString &sOutDow );
+ xbInt16 CHR( xbDouble dAsciCd, xbString &sOut );
+ xbInt16 CMONTH( xbDate &dInDate, xbString &sOutMonth );
+ xbInt16 CTOD( const xbString &sInDate, xbDate &dOutDate );
+ xbInt16 DATE( xbDate &dOutDate );
+ xbInt16 DAY( const xbDate &dInDate, xbDouble &dOutDay );
+ xbInt16 DEL( xbDbf * d, xbString &sOut, xbInt16 iRecBufSw = 0 );
+ xbInt16 DELETED( xbDbf * d, xbBool &bOut, xbInt16 iRecBufSw = 0 );
+ xbInt16 DESCEND( const xbString &sIn, xbString &sOut );
+ xbInt16 DESCEND( const xbDate &dInDate, xbDate &dOutDate );
+ xbInt16 DESCEND( const xbDouble dIn, xbDouble &dsOut );
+ xbInt16 DOW( const xbDate &sInDate, xbDouble &dDowOut );
+ xbInt16 DTOC( xbDate &dInDate, xbString &sOutFmtDate );
+ xbInt16 DTOS( xbDate &dInDate, xbString &sOutFmtDate );
+ xbInt16 EXP( xbDouble dIn, xbDouble &dOut );
+ xbInt16 IIF( xbBool bResult, const xbString &sTrueResult, const xbString &sFalseResult, xbString &sResult );
+ xbInt16 INT( xbDouble dIn, xbDouble &dOut );
+ xbInt16 ISALPHA( const xbString &s, xbBool &bResult );
+ xbInt16 ISLOWER( const xbString &s, xbBool &bResult );
+ xbInt16 ISUPPER( const xbString &s, xbBool &bResult );
+ xbInt16 LEFT( const xbString &sIn, xbUInt32 lCharCnt, xbString &sOut );
+ xbInt16 LEN( const xbString &sIn, xbDouble &dLen );
+ xbInt16 LOG( xbDouble dIn, xbDouble &dOut );
+ xbInt16 LOWER( const xbString &sIn, xbString &sOut );
+ xbInt16 LTRIM( const xbString &sIn, xbString & sOut );
+ xbInt16 MAX( xbDouble dIn1, xbDouble dIn2, xbDouble &dOut );
+ xbInt16 MIN( xbDouble dIn1, xbDouble dIn2, xbDouble &dOut );
+ xbInt16 MONTH( xbDate &dInDate, xbDouble &dMonthOut );
+ xbInt16 RECCOUNT( xbDbf * d, xbDouble &dRecOut );
+ xbInt16 RECNO( xbDbf * d, xbDouble &dRecOut );
+ xbInt16 REPLICATE( const xbString &sIn, xbUInt32 ulRepCnt, xbString &sOut );
+ xbInt16 RIGHT( const xbString &sIn, xbUInt32 iCharCnt, xbString &sOut );
+ xbInt16 RTRIM( const xbString &sIn, xbString &sOut );
+ xbInt16 SPACE( xbInt32 lCnt, xbString &sOut );
+ xbInt16 SQRT( xbDouble dBase, xbDouble &dSqrRt );
+ xbInt16 STOD( const xbString &sIn, xbDate &sDateOut );
+ xbInt16 STR( xbDouble dIn, xbString &sOut );
+ xbInt16 STR( xbDouble dIn, xbUInt32 ulLen, xbString &sOut );
+ xbInt16 STR( xbDouble dIn, xbUInt32 ulLen, xbUInt32 ulDec, xbString &sOut );
+ xbInt16 STR( xbDouble dIn, xbUInt32 ulLen, xbUInt32 ulDec, xbString &sPadChar, xbString &sOut );
+ xbInt16 STRZERO( xbDouble dIn, xbUInt32 ulLen, xbUInt32 ulDec, xbString &sOut );
+ xbInt16 SUBSTR( const xbString &sIn, xbUInt32 ulStartPos, xbUInt32 ulLen, xbString &sOut );
+ xbInt16 TRIM( const xbString &sIn, xbString &sOut );
+ xbInt16 UPPER( const xbString &sIn, xbString &sOut );
+ xbInt16 VAL( const xbString &sIn, xbDouble &dOut );
+ xbInt16 YEAR( xbDate &dInDate, xbDouble &dOutYear );
+ #endif
+
+ protected:
+ friend class xbBcd;
+ friend class xbExp;
+
+ 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 );
+
+ private:
+
+#ifdef XB_LOGGING_SUPPORT
+ xbLog *xLog;
+#endif
+
+};
+
+} /* namespace xb */
+#endif /* __XB_DBLIST_H__ */ \ No newline at end of file
diff --git a/src/sql/xbcrix.cpp b/src/sql/xbcrix.cpp
new file mode 100755
index 0000000..b24782e
--- /dev/null
+++ b/src/sql/xbcrix.cpp
@@ -0,0 +1,279 @@
+/* xbcrix.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{
+
+
+/***********************************************************************/
+xbInt16 xbSql::SqlCreateIndex( const xbString &sCmdLine ){
+
+ // std::cout << "CREATE INDEX " << sCmdLine << std::endl;
+
+ // expected format to create an Dbase 3, NDX index:
+ // CREATE INDEX ixname.ndx ON tablename.dbf ( EXPRESSION ) [ASSOCIATE]
+
+ // expected format to create an Dbase 4, tag on an MDX index:
+ // CREATE [UNIQUE] INDEX tagname ON tablename.dbf ( EXPRESSION ) [DESC] [FILTER .NOT. DELETED()]
+
+ // The ASSOCIATE parameter is specific to Xbase64 library, it is used to associate
+ // a non production (NDX) index file to a dbf file so it will be automatically
+ // opened with the dbf file whenever the dbf file is opened by the xbase64 routines.
+
+ // The [ASSOCIATE] parameter is not used with MDX production indices
+
+ // This method first looks for ".NDX" in the file name to determine if an NDX
+ // index should be created.
+ // if .NDX is not in the filename, it looks in the uda for "IXTYPE" for either
+ // NDX or MDX to detmermine the index type to create
+ // if IXTYPE not found, create an MDX tag
+
+ // The optional DESC parameter defines an entire index key as descending. This is
+ // different than other SQL implementations where specific fields can be descending.
+
+ // The optional FILTER parameter is specific to the XBASE64 library, is it used to
+ // assign a filter to a tag in an MDX style index. Everything to the right of
+ // the keyword FILTER is considered part of the filter.
+
+ // The original DBASE indices used to '+' to create an index on more than one field
+ // ie: FIELD1+FIELD2+FIELD3
+ // SQL uses commas: ie: FIELD1, FIELD2, FIELD3
+ // The Xbase library supports either '+' or ',' when creating mutli field indices.
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbString sTableName;
+ xbString sIxName;
+ xbString sIxType;
+ xbUInt32 ulPos;
+ xbString sCmd = sCmdLine;
+ xbString sNode;
+ xbBool bUnique = xbFalse;
+ xbDbf * dbf = NULL;
+
+ try{
+
+ // std::cout << "xbSql::CreateIx()\n" ;
+
+ // drop off the first node
+ ulPos = sCmd.Pos( ' ' );
+ sCmd.Ltrunc( ulPos );
+ sCmd.Ltrim();
+
+ sNode.ExtractElement( sCmd, ' ', 1, 0 );
+ sNode.ToUpperCase();
+
+ if( sNode == "UNIQUE" ){
+ //std::cout << "unique ix\n";
+ bUnique = xbTrue;
+ ulPos = sCmd.Pos( ' ' );
+ sCmd.Ltrunc( ulPos );
+ sCmd.Ltrim();
+ }
+
+ // go past the index keyword
+ ulPos = sCmd.Pos( ' ' );
+ sCmd.Ltrunc( ulPos );
+ sCmd.Ltrim();
+
+ // pull the index name off the cmd line
+ sIxName.ExtractElement( sCmd, ' ', 1, 0 );
+
+ #ifdef XB_NDX_SUPPORT
+ xbString sTemp = sIxName;
+ sTemp.ToUpperCase();
+ ulPos = sTemp.Pos( ".NDX" );
+ if(ulPos == (sTemp.Len() - 3) )
+ sIxType = "NDX";
+ #endif // XB_NDX_SUPPORT
+
+ if( sIxType == "" ){
+ if(( iRc = uda.GetTokenForKey( "IXTYPE", sIxType )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+
+ #ifdef XB_NDX_SUPPORT
+ if( sIxType == "NDX" ){
+ xbFile f( xbase );
+ f.SetFileName( sIxName );
+ if( f.FileExists()){
+ iErrorStop = 30;
+ iRc = XB_FILE_EXISTS;
+ throw iRc;
+ }
+ }
+ #endif // XB_NDX_SUPPORT
+
+ // skip past index name
+ ulPos = sCmd.Pos( ' ' );
+ sCmd.Ltrunc( ulPos );
+ sCmd.Ltrim();
+
+ // skip past "ON"
+ ulPos = sCmd.Pos( ' ' );
+ sCmd.Ltrunc( ulPos );
+ sCmd.Ltrim();
+
+ // get the table name
+ ulPos = sCmd.Pos( '(' );
+ sTableName.ExtractElement( sCmd, '(', 1, 0 );
+ sTableName.Trim();
+
+ xbFile fDbf( xbase );
+ fDbf.SetFileName( sTableName );
+
+ // if not open, attempt to open it
+ dbf = xbase->GetDbfPtr( fDbf.GetFqFileName());
+ if( !dbf ){
+ if(( iRc = xbase->OpenHighestVersion( sTableName, "", &dbf )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ }
+ if( dbf == NULL ){
+ iErrorStop = 50;
+ iRc = XB_FILE_NOT_FOUND;
+ throw iRc;
+ }
+ sCmd.Ltrunc( ulPos );
+
+ // std::cout << "cp1 ulPos = " << ulPos << " scmd = " << sCmd << "\n";
+
+ //ulPos = sCmd.GetLastPos( ')' );
+ xbString sKeyExpression;
+ xbBool bDone = xbFalse;
+ xbUInt32 lPos = 1;
+ xbInt16 iParenCtr = 0;
+ while( !bDone && lPos < sCmd.Len()){
+ if( sCmd[lPos] == '(' ){
+ iParenCtr++;
+ sKeyExpression.Append( sCmd[lPos] );
+ } else if( sCmd[lPos] == ')' ){
+ if( iParenCtr > 0 ){
+ iParenCtr--;
+ sKeyExpression.Append( sCmd[lPos] );
+ } else {
+ bDone = xbTrue;
+ }
+ } else if( sCmd[lPos] == ',' ){
+ sKeyExpression.Append( '+' );
+ } else if( sCmd[lPos] != ' ' ){
+ sKeyExpression.Append( sCmd[lPos] );
+ }
+ lPos++;
+ }
+// std::cout << "Key Expression =[" << sKeyExpression << "]\n";
+ sCmd.Ltrunc( lPos );
+ sCmd.Trim();
+
+ xbBool bDesc = xbFalse;
+// std::cout << "sCmd - looking for DESC [" << sCmd << "]\n";
+ if( sCmd.Len() > 4 ){
+ sNode = sCmd;
+ sNode.ToUpperCase();
+ ulPos = sNode.Pos( "DESC" );
+ if( ulPos > 0 ){
+ bDesc = xbTrue;
+ sCmd.Ltrunc( 4 );
+ sCmd.Trim();
+ // std::cout << "Descending\n";
+ }
+ }
+
+// std::cout << "sCmd - looking for FILTER stuff [" << sCmd << "]\n";
+ xbString sFilter;
+ if( sCmd.Len() > 6 ){
+ sNode = sCmd;
+ sNode.ToUpperCase();
+ ulPos = sNode.Pos( "FILTER" );
+ if( ulPos > 0 ){
+ sFilter = sCmd;
+ sFilter.Ltrunc( ulPos + 7 );
+ sFilter.Trim();
+ }
+ }
+// std::cout << "sCmd - FILTER = [" << sFilter << "]\n";
+
+ #ifdef XB_LOCKING_SUPPORT
+ if(( iRc = dbf->LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc;
+ }
+ #endif // XB_LOCKING_SUPPORT
+
+// std::cout << "SqlCreateIndex() - ixtype = " << sIxType << "\n";
+
+ xbIx *pIx;
+ void *vpTag;
+
+ if(( iRc = dbf->CreateTag( sIxType, sIxName, sKeyExpression, sFilter, bDesc, bUnique, xbFalse, &pIx, &vpTag )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw iRc;
+ }
+// std::cout << "SqlCreateIndex() - back from tag create\n";
+ #ifdef XB_NDX_SUPPORT
+ if( sIxType == "NDX"){
+ sCmd.Ltrunc( ulPos );
+ sCmd.Trim();
+ if( sCmd.Len() > 0 ){
+ sCmd.ToUpperCase();
+ if( sCmd.Pos( "ASSOCIATE" )){
+ if(( iRc = dbf->AssociateIndex( "NDX", sIxName, 0 )) != XB_NO_ERROR ){
+ iErrorStop = 80;
+ throw iRc;
+ }
+ }
+ }
+ }
+ if( sIxType == "NDX"){
+ if(( iRc = pIx->Reindex( &vpTag )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ }
+ #endif // XB_NDX_SUPPORT
+
+ #ifdef XB_LOCKING_SUPPORT
+ if(( iRc = dbf->LockTable( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc;
+ }
+ #endif // XB_LOCKING_SUPPORT
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbSql::SqlCreateIndex() Exception Caught. Error Stop = [%d] rc = [%d] table = [%s]", iErrorStop, iRc, sTableName.Str() );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+
+ }
+
+ #ifdef XB_LOCKING_SUPPORT
+ dbf->LockTable( XB_UNLOCK );
+ #endif // XB_LOCKING_SUPPORT
+
+ return iRc;
+}
+
+/***********************************************************************/
+} /* namespace */
+#endif /* XB_SQL_SUPPORT */
+
diff --git a/src/sql/xbcrtbl.cpp b/src/sql/xbcrtbl.cpp
new file mode 100755
index 0000000..4193d01
--- /dev/null
+++ b/src/sql/xbcrtbl.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 fields 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 = 10;
+ 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 = 20;
+ 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 = 30;
+ 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 XB_DBF3_SUPPORT
+ dbf = new xbDbf3( xbase );
+ #endif
+ if(( iRc = dbf->CreateTable( sTableName, "", schema, 0, XB_MULTI_USER )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ 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/xbdrpix.cpp b/src/sql/xbdrpix.cpp
new file mode 100755
index 0000000..9e3bc3b
--- /dev/null
+++ b/src/sql/xbdrpix.cpp
@@ -0,0 +1,143 @@
+/* xbdrpix.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{
+
+
+/***********************************************************************/
+xbInt16 xbSql::SqlDropIndex( const xbString &sCmdLine ){
+
+ // std::cout << "DROP INDEX [" << sCmdLine << "]\n";
+
+ // expected format:
+ // DROP INDEX [IF EXISTS] ixname.ndx ON tablename.dbf
+
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbString sTableName;
+ xbString sIxName;
+ xbUInt32 ulPos;
+ xbString sCmd = sCmdLine;
+ xbString sNode;
+ xbBool bIfExists = xbFalse;
+ xbDbf * dbf = NULL;
+
+ try{
+
+ // drop off the first node "DROP"
+ ulPos = sCmd.Pos( ' ' );
+ sCmd.Ltrunc( ulPos );
+ sCmd.Ltrim();
+
+ // drop off the second node "INDEX"
+ ulPos = sCmd.Pos( ' ' );
+ sCmd.Ltrunc( ulPos );
+ sCmd.Ltrim();
+
+ sNode.ExtractElement( sCmd, ' ', 1, 0 );
+ sNode.Trim();
+ sNode.ToUpperCase();
+
+ if( sNode == "IF" ){
+ ulPos = sCmd.Pos( ' ' );
+ sCmd.Ltrunc( ulPos );
+ sCmd.Ltrim();
+ sNode.ExtractElement( sCmd, ' ', 1, 0 );
+ sNode.Trim();
+ sNode.ToUpperCase();
+ if( sNode != "EXISTS" ){
+ iErrorStop = 10;
+ iRc = XB_SYNTAX_ERROR;
+ throw iRc;
+ } else {
+ ulPos = sCmd.Pos( ' ' );
+ sCmd.Ltrunc( ulPos );
+ sCmd.Ltrim();
+ bIfExists = xbTrue;
+ }
+ }
+
+ // get the index name
+ sIxName.ExtractElement( sCmd, ' ', 1, 0 );
+ sIxName.Trim();
+
+ ulPos = sCmd.Pos( ' ' );
+ sCmd.Ltrunc( ulPos );
+ sCmd.Ltrim();
+
+ // go past "ON"
+ ulPos = sCmd.Pos( ' ' );
+ sCmd.Ltrunc( ulPos );
+ sCmd.Ltrim();
+
+ sTableName = sCmd;
+ sTableName.Trim();
+
+ xbFile fDbf( xbase );
+ fDbf.SetFileName( sTableName );
+
+ // if not open, attempt to open it
+ dbf = xbase->GetDbfPtr( fDbf.GetFqFileName());
+ if( !dbf ){
+ if(( iRc = xbase->OpenHighestVersion( sTableName, "", &dbf )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+ if( dbf == NULL ){
+ iErrorStop = 40;
+ iRc = XB_FILE_NOT_FOUND;
+ throw iRc;
+ }
+
+ #ifdef XB_LOCKING_SUPPORT
+ if(( iRc = dbf->LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+ #endif // XB_LOCKING_SUPPORT
+
+ iRc = dbf->DeleteTag( "NDX", sIxName );
+ if( iRc == XB_FILE_NOT_FOUND && !bIfExists ){
+ iErrorStop = 60;
+ throw( iRc );
+ } else if( iRc != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbSql::SqlDropIndex() Exception Caught. Error Stop = [%d] rc = [%d] table = [%s]", iErrorStop, iRc, sTableName.Str() );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+
+ #ifdef XB_LOCKING_SUPPORT
+ dbf->LockTable( XB_UNLOCK );
+ #endif // XB_LOCKING_SUPPORT
+
+ return iRc;
+}
+
+/***********************************************************************/
+} /* namespace */
+#endif /* XB_SQL_SUPPORT */
+
diff --git a/src/sql/xbdrptbl.cpp b/src/sql/xbdrptbl.cpp
new file mode 100755
index 0000000..e2cfa9d
--- /dev/null
+++ b/src/sql/xbdrptbl.cpp
@@ -0,0 +1,125 @@
+/* xbdrptbl.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{
+
+
+/***********************************************************************/
+xbInt16 xbSql::SqlDropTable( const xbString &sCmdLine ){
+
+ // std::cout << "DROP TABLE [" << sCmdLine << "]\n";
+ // expected format:
+ // DROP TABLE [IF EXISTS] tablename.dbf
+
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbString sTableName = "";
+ xbUInt32 ulPos = 0;
+ xbString sCmd = sCmdLine;
+ xbString sNode = "";
+ xbBool bIfExists = xbFalse;
+ xbDbf * dbf = NULL;
+
+ try{
+
+ // drop off the first node "DROP"
+ ulPos = sCmd.Pos( ' ' );
+ sCmd.Ltrunc( ulPos );
+ sCmd.Ltrim();
+
+ // drop off the second node "TABLE"
+ ulPos = sCmd.Pos( ' ' );
+ sCmd.Ltrunc( ulPos );
+ sCmd.Ltrim();
+
+ sNode.ExtractElement( sCmd, ' ', 1, 0 );
+ sNode.Trim();
+ sNode.ToUpperCase();
+
+ if( sNode == "IF" ){
+ ulPos = sCmd.Pos( ' ' );
+ sCmd.Ltrunc( ulPos );
+ sCmd.Ltrim();
+ sNode.ExtractElement( sCmd, ' ', 1, 0 );
+ sNode.Trim();
+ sNode.ToUpperCase();
+ if( sNode != "EXISTS" ){
+ iErrorStop = 10;
+ iRc = XB_SYNTAX_ERROR;
+ throw iRc;
+ } else {
+ ulPos = sCmd.Pos( ' ' );
+ sCmd.Ltrunc( ulPos );
+ sCmd.Ltrim();
+ bIfExists = xbTrue;
+ }
+ }
+
+ // get the table name
+ sTableName.ExtractElement( sCmd, ' ', 1, 0 );
+ sTableName.Trim();
+
+ xbFile fDbf( xbase );
+ fDbf.SetFileName( sTableName );
+
+ if( bIfExists && ! fDbf.FileExists())
+ return XB_NO_ERROR;
+
+ // if not open, attempt to open it
+ dbf = xbase->GetDbfPtr( fDbf.GetFqFileName());
+
+ if( !dbf ){
+ dbf = xbase->Open( sTableName, iRc );
+ if( iRc != XB_NO_ERROR ){
+ if( iRc == XB_FILE_NOT_FOUND && bIfExists ){
+ return XB_NO_ERROR;
+ } else {
+ iErrorStop = 20;
+ throw iRc;
+ }
+ }
+ }
+ if( dbf == NULL ){
+ iErrorStop = 40;
+ iRc = XB_OPEN_ERROR;
+ throw iRc;
+ }
+
+ if(( dbf->DeleteTable()) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+
+ }
+
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbSql::SqlDropTable() Exception Caught. Error Stop = [%d] rc = [%d] table = [%s]", iErrorStop, iRc, sTableName.Str() );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+
+ return iRc;
+}
+
+/***********************************************************************/
+} /* namespace */
+#endif /* XB_SQL_SUPPORT */
+
diff --git a/src/sql/xbinsert.cpp b/src/sql/xbinsert.cpp
new file mode 100755
index 0000000..1095202
--- /dev/null
+++ b/src/sql/xbinsert.cpp
@@ -0,0 +1,190 @@
+/* xbinsert.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{
+
+
+/***********************************************************************/
+xbInt16 xbSql::SqlInsert( const xbString &sCmdLine ){
+
+ // expected format:
+ // INSERT INTO tablename (field1, field2, field3,...) VALUES ( 'charval', numval, 'what is the correct odbc date format to use? CCYYMMDD');
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbString sTableName;
+ xbDbf * dbf = NULL;
+
+ xbString sWork1;
+ xbString sFieldList;
+ xbString sDataList;
+ xbString sFieldName;
+ xbString sFieldData;
+
+ // queue the memo data to post after the append occurs
+ // dbase does not support usage of memo fields with insert commands
+ xbLinkList <xbInt16> llMemoFieldNos;
+ xbLinkList <xbString> llMemoFieldData;
+
+ try{
+ // retrieve table name
+ sTableName.ExtractElement( sCmdLine, ' ', 3, 0 );
+ sTableName.Trim();
+
+ // if not open, attempt to open it
+ dbf = xbase->GetDbfPtr( sTableName );
+
+ if( !dbf ){
+ if(( iRc = xbase->OpenHighestVersion( sTableName, "", &dbf )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ }
+
+ if( !dbf ){
+ iErrorStop = 20;
+ iRc = XB_FILE_NOT_FOUND;
+ throw iRc;
+ }
+
+ // blank the record buffer
+ dbf->BlankRecord();
+
+ sWork1.ExtractElement( sCmdLine, ')', 1, 0 );
+ sFieldList.ExtractElement( sWork1, '(', 2, 0 );
+
+ sDataList.ExtractElement( sCmdLine, '(', 3, 0 );
+ sDataList.Trim();
+ sDataList.ZapTrailingChar( ')' );
+
+ xbUInt32 iFldCnt = sFieldList.CountChar( ',' );
+ xbUInt32 iDataCnt = sDataList.CountChar( ',', 1 );
+
+ // verify there are the same count in the field list and values list
+ if( iFldCnt != iDataCnt ){
+ iErrorStop = 30;
+ iRc = XB_SYNTAX_ERROR;
+ throw iRc;
+ }
+
+ iFldCnt++;
+ xbInt16 iFldNo = -1;
+ char cFldType = 0x00;
+ for( xbUInt32 i = 1; i <= iFldCnt; i++ ){
+ sFieldName.ExtractElement( sFieldList, ',', i, 0 );
+ sFieldName.Trim();
+ if(( iRc = dbf->GetFieldNo( sFieldName, iFldNo )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc;
+ }
+ if(( iRc = dbf->GetFieldType( iFldNo, cFldType )) != XB_NO_ERROR ){
+ iErrorStop = 50;
+ throw iRc;
+ }
+
+ // get the field data here
+ sFieldData.ExtractElement( sDataList, ',', i, 1 );
+ sFieldData.Trim();
+
+ // remove beginning and ending quotes
+ if(( sFieldData[1] == '\'' && sFieldData[sFieldData.Len()] == '\'') || (sFieldData[1] == '"' && sFieldData[sFieldData.Len()] == '"' )){
+ sFieldData.Remove( sFieldData.Len(), 1 );
+ sFieldData.Remove( 1, 1 );
+ }
+
+ switch( cFldType ){
+ case 'C':
+ case 'N':
+ case 'L':
+ if(( iRc = dbf->PutField( iFldNo, sFieldData )) != XB_NO_ERROR ){
+ iErrorStop = 100;
+ throw iRc;
+ }
+ break;
+
+ case 'D':
+ // assumes input date format of yyyy-mm-dd
+ if( sFieldData.Len() != 10 || sFieldData[5] != '-' || sFieldData[8] != '-' ){
+ iErrorStop = 110;
+ iRc = XB_INVALID_DATA;
+ throw iRc;
+ }
+ sWork1 = sFieldData;
+ sWork1.Remove( 8, 1 );
+ sWork1.Remove( 5, 1 );
+ if(( iRc = dbf->PutField( iFldNo, sWork1 )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc;
+ }
+ break;
+
+ case 'M':
+ llMemoFieldNos.InsertAtFront( iFldNo );
+ llMemoFieldData.InsertAtFront( sFieldData );
+ break;
+
+ default:
+ iErrorStop= 150;
+ iRc = XB_INVALID_FIELD_TYPE;
+ throw iRc;
+ }
+ }
+
+ if(( iRc = dbf->AppendRecord()) != XB_NO_ERROR ){
+ iErrorStop = 300;
+ throw iRc;
+ }
+
+ // Add any memo fields
+ xbLinkListNode<xbInt16> * llN = llMemoFieldNos.GetHeadNode();
+ xbLinkListNode<xbString> * llD = llMemoFieldData.GetHeadNode();
+ xbUInt32 ulCnt = llMemoFieldNos.GetNodeCnt();
+ for( xbUInt32 i = 0; i < ulCnt; i++ ){
+ iFldNo = llN->GetKey();
+ sFieldData = llD->GetKey();
+ if(( iRc = dbf->UpdateMemoField( iFldNo, sFieldData )) != XB_NO_ERROR ){
+ iErrorStop = 400;
+ throw iRc;
+ }
+ llN = llN->GetNextNode();
+ llD = llD->GetNextNode();
+ }
+
+ if(( iRc == dbf->Commit()) != XB_NO_ERROR ){
+ iErrorStop = 500;
+ throw iRc;
+ }
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ xbase->WriteLogMessage( sCmdLine );
+ sMsg.Sprintf( "xbSql::SqlInsert() Exception Caught. Error Stop = [%d] rc = [%d] table = [%s] field = [%s] data = [%s]", iErrorStop, iRc, sTableName.Str(), sFieldName.Str(), sFieldData.Str() );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ if( dbf )
+ dbf->Abort();
+ }
+ return iRc;
+
+}
+
+/***********************************************************************/
+} /* namespace */
+#endif /* XB_SQL_SUPPORT */
+
diff --git a/src/sql/xbset.cpp b/src/sql/xbset.cpp
new file mode 100755
index 0000000..98de309
--- /dev/null
+++ b/src/sql/xbset.cpp
@@ -0,0 +1,91 @@
+/* xbset.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{
+
+
+/***********************************************************************/
+xbInt16 xbSql::SqlSet( const xbString &sCmdLine ){
+
+ // std::cout << "SET [" << sCmdLine << "]\n";
+ // expected format:
+ // SET ATTRIBUTE = DATAVALUE
+ // SET ATTRIBUTE = ^ (to delete an entry)
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbUInt32 ulPos;
+
+ try{
+
+ xbString sCmd = sCmdLine;
+ sCmd.Trim();
+ sCmd.ZapTrailingChar( ';' );
+ sCmd.Trim();
+
+ // drop off the first node "SET"
+ ulPos = sCmd.Pos( ' ' );
+ sCmd.Ltrunc( ulPos );
+ sCmd.Ltrim();
+
+ xbString sNode1 = sCmd;
+ sNode1.ToUpperCase();
+
+ if( sNode1 == "SET" ) {
+ uda.DumpUda();
+
+ } else {
+
+ xbString sKey;
+ sKey.ExtractElement( sCmd, '=', 1, 0 );
+ sKey.Trim();
+
+ xbString sToken;
+ sToken.ExtractElement( sCmd, '=', 2, 0 );
+ sToken.Trim();
+
+
+ if( sToken == '^' ){
+ if(( iRc = uda.DelTokenForKey( sKey )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ } else {
+ if(( iRc = uda.UpdTokenForKey( sKey, sToken )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ throw iRc;
+ }
+ }
+ }
+
+ }
+ catch (xbInt16 iRc ){
+ xbString sMsg;
+ sMsg.Sprintf( "xbSql::SqlSet() Exception Caught. Error Stop = [%d] rc = [%d]", iErrorStop, iRc );
+ xbase->WriteLogMessage( sMsg.Str() );
+ xbase->WriteLogMessage( GetErrorMessage( iRc ));
+ }
+
+ return iRc;
+}
+
+/***********************************************************************/
+} /* namespace */
+#endif /* XB_SQL_SUPPORT */
+
diff --git a/src/sql/xbsql.cpp b/src/sql/xbsql.cpp
new file mode 100755
index 0000000..25cd2c8
--- /dev/null
+++ b/src/sql/xbsql.cpp
@@ -0,0 +1,143 @@
+/* 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{
+
+/***********************************************************************/
+xbSql::xbSql( xbXBase *x ){
+ xbase = x;
+ xbString sIxType;
+
+ #ifdef XB_MDX_SUPPORT
+ sIxType = "MDX";
+ #endif
+
+ #ifdef XB_NDX_SUPPORT
+ if( sIxType == "" )
+ sIxType = "NDX";
+ #endif
+
+ if( sIxType != "" )
+ uda.AddTokenForKey( "IXTYPE", sIxType );
+
+}
+/***********************************************************************/
+xbSql::~xbSql(){
+}
+
+/***********************************************************************/
+xbInt16 xbSql::ExecuteNonQuery( const xbString &sCmdLine ) {
+
+// std::cout << "\n\n\nExecute() " << sCmdLine.Str() << "\n";
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbString sCmd = sCmdLine;
+
+ sCmd.Trim();
+ xbString sNode1;
+ sNode1.ExtractElement( sCmd.Str(), ' ', 1, 0 );
+ sNode1.ToUpperCase();
+ sNode1.Trim();
+
+// std::cout << "node 1 = " << sNode1.Str() << std::endl;
+
+ if( sNode1 == "CREATE" ){
+
+ xbString sNode2;
+ sNode2.ExtractElement( sCmd.Str(), ' ', 2, 0 );
+ sNode2.ToUpperCase();
+ sNode2.Trim();
+ if( sNode2 == "TABLE" )
+ iRc = SqlCreateTable( sCmd );
+ else if( sNode2 == "INDEX" || sNode2 == "UNIQUE" )
+ iRc = SqlCreateIndex( sCmd );
+
+ else
+ iRc = XB_INVALID_FUNCTION;
+
+ } else if( sNode1 == "DROP" ){
+
+ xbString sNode2;
+ sNode2.ExtractElement( sCmd.Str(), ' ', 2, 0 );
+ sNode2.ToUpperCase();
+ sNode2.Trim();
+
+ if( sNode2 == "TABLE" )
+ iRc = SqlDropTable( sCmd );
+
+ else if( sNode2 == "INDEX" )
+ iRc = SqlDropIndex( sCmd );
+
+ } else if( sNode1 == "HELP" )
+ SqlHelp();
+
+ else if( sNode1 == "INSERT" ){
+
+ iRc = SqlInsert( sCmd );
+
+ // else if( sNode1 == "UPDATE" )
+ // iRc = SqlUpdate( sCmd );
+ }
+ else if( sNode1 == "USE" )
+ iRc = SqlUse( sCmd );
+
+ else if( sNode1 == "SET" )
+ iRc = SqlSet( sCmd );
+
+ else
+ return XB_INVALID_FUNCTION;
+
+ return iRc;
+}
+
+/***********************************************************************/
+xbXBase *xbSql::GetXbasePtr() const {
+ return xbase;
+}
+
+
+/***********************************************************************/
+void xbSql::SqlHelp() const {
+ std::cout << "************************" << std::endl;
+ std::cout << "Valid XBase SQL commands" << std::endl << std::endl;
+ std::cout << "HELP" << std::endl;
+ std::cout << "USE /dir/to/dbf/tables" << std::endl;
+ std::cout << "CREATE TABLE" << std::endl << std::endl << std::endl;
+}
+
+/***********************************************************************/
+xbInt16 xbSql::SqlUse( const xbString &sCmdLine ){
+
+ xbString sNode2;
+ sNode2.ExtractElement( sCmdLine.Str(), ' ', 2, 0 );
+ sNode2.Trim();
+ xbase->SetDataDirectory( sNode2 );
+// std::cout << "USE " << sNode2 << std::endl;
+ return XB_NO_ERROR;
+}
+
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+/***********************************************************************/
+
+/***********************************************************************/
+} /* namespace */
+#endif /* XB_SQL_SUPPORT */
diff --git a/src/tests/tstfuncs.cpp b/src/tests/tstfuncs.cpp
new file mode 100755
index 0000000..c499d3f
--- /dev/null
+++ b/src/tests/tstfuncs.cpp
@@ -0,0 +1,581 @@
+/* tstfuncs.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
+
+*/
+
+time_t timer;
+
+xbDouble ChronTime();
+void InitTime();
+
+xbBool dblEquals( xbDouble a, xbDouble b, xbDouble epsilon );
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, const xbString &result, const char * expectedResult, size_t expectedLen );
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, char result, char expectedResult );
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbInt32 result, xbInt32 expectedResult );
+//xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbUInt32 result, xbUInt32 expectedResult );
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbUInt64 result, xbUInt64 expectedResult );
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbFloat result, xbFloat expectedResult );
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbDouble result, xbDouble expectedResult );
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbDouble result, xbDouble expectedResult, xbDouble dEpsilon );
+
+
+xbInt16 FileCompare( xbXBase &x, xbInt16 iPo, const xbString &sFile1, const xbString &sFile2, const xbString &sSkipBytes );
+
+
+#ifdef XB_LOCKING_SUPORT
+xbInt16 SetCmd( xbXBase &x, const xbString &sFileName, const xbString &sCmd, const char cSrc, xbInt16 iPo );
+xbInt16 GetCmd( xbXBase &x, const xbString &sFileName, xbString &sCmd, const char cSrc, xbInt16 iPo );
+#endif
+
+#if defined( XB_DBF4_SUPPORT ) && defined( XB_MEMO_SUPPORT )
+
+xbInt16 TestDbt4Method( xbInt16 PrintOption, const char * title, xbMemo * m, xbUInt32 ulHdrNext, xbUInt32 ulBlockCnt, xbString sNodeChain );
+xbInt16 TestDbt4Method( xbInt16 PrintOption, const char * title, xbMemo * m, xbUInt32 ulHdrNext, xbUInt32 ulBlockCnt, xbString sNodeChain ){
+
+ xbUInt32 ulLastDataBlock = 0L;
+ xbUInt32 ulHdrNextBlock = 0L;
+ xbInt16 iRc = 0;
+
+ iRc = m->GetHdrNextBlock( ulHdrNextBlock );
+ if( iRc != XB_NO_ERROR ){
+ std::cout << std::endl << "[FAIL 1] " << title << std::endl;
+ std::cout << "Error [" << iRc << "] in GetHdrNextBlock" << std::endl;
+ return -1;
+ }
+
+ iRc = m->CalcLastDataBlock( ulLastDataBlock );
+ if( iRc != XB_NO_ERROR ){
+ std::cout << std::endl << "[FAIL 2] " << title << std::endl;
+ std::cout << "Error [" << iRc << "] in CalcLastDataBlock" << std::endl;
+ return -1;
+ }
+
+ if( ulHdrNext > 0 ){
+ if( ulHdrNextBlock != ulHdrNext ){
+ std::cout << std::endl << "[FAIL 3] " << title << std::endl;
+ std::cout << "Expected Header Next Block = [" << ulHdrNext << "] Actual = [" << ulHdrNextBlock << "]" << std::endl;
+ return -1;
+ }
+ if( PrintOption == 2 ){
+ xbString sMsg;
+ sMsg.Sprintf( "[PASS][%3.4f] %s Expected matches actual Len=[%ld] Data=[%lds]\n",
+ ChronTime(), title, ulHdrNextBlock, ulHdrNext );
+ std::cout << sMsg.Str();
+ // std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual HdrBlock=[" << ulHdrNextBlock << "] Data=[" << ulHdrNext << "]" << std::endl;
+ } else if( PrintOption == 1 )
+ std::cout << "[PASS] " << title << std::endl;
+ }
+
+ if( ulBlockCnt > 0 ){
+ if( ulLastDataBlock != ulBlockCnt ){
+ std::cout << std::endl << "[FAIL 4] " << title << std::endl;
+ std::cout << "Expected Block Count = [" << ulBlockCnt << "] Actual = [" << ulLastDataBlock << "]" << std::endl;
+ return -1;
+ }
+ if( PrintOption == 2 ){
+ xbString sMsg;
+ sMsg.Sprintf( "[PASS][%3.4f] %s Expected matches actual Len=[%ld] Data=[%lds]\n",
+ ChronTime(), title, ulLastDataBlock, ulBlockCnt );
+ std::cout << sMsg.Str();
+ // std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual LastBlock=[" << ulLastDataBlock << "] Data=[" << ulBlockCnt << "]" << std::endl;
+ } else if( PrintOption == 1 )
+ std::cout << "[PASS] " << title << std::endl;
+ }
+
+ #ifdef XB_DEBUG_SUPPORT
+ xbMemoDbt4 *m4 = (xbMemoDbt4 *) m;
+ if( sNodeChain != "-1" ){
+ xbUInt32 ulNode = ulHdrNextBlock;
+ xbUInt32 ulNextBlock;
+ xbUInt32 ulFreeBlockCnt;
+ xbString sActualNodeChain;
+
+ while( ulNode < ulLastDataBlock ){
+ iRc = m4->ReadFreeBlockHeader( ulNode, ulNextBlock, ulFreeBlockCnt );
+ if( iRc != XB_NO_ERROR ){
+ std::cout << std::endl << "[FAIL 5] " << title << std::endl;
+ std::cout << "Error [" << iRc << "] in CalcLastDataBlock" << std::endl;
+ return -1;
+ }
+ if( sActualNodeChain != "" )
+ sActualNodeChain += ",";
+ sActualNodeChain.Sprintf( "%s%ld,%ld,%ld", sActualNodeChain.Str(), ulNode, ulFreeBlockCnt, ulNextBlock );
+ ulNode = ulNextBlock;
+ }
+ if( sNodeChain != sActualNodeChain ){
+ std::cout << std::endl << "[FAIL 6] " << title << std::endl;
+ std::cout << "Expected Block Chain = [" << sNodeChain.Str() << "] Actual = [" << sActualNodeChain.Str() << "]" << std::endl;
+ return -1;
+ }
+ if( PrintOption == 2 ){
+ xbString sMsg;
+ sMsg.Sprintf( "[PASS][%3.4f] %s Expected matches actual Len=[%d] Data=[%s]\n", ChronTime(), title, sNodeChain.Str() );
+ std::cout << sMsg.Str();
+ //std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual BlockChain=[" << sNodeChain.Str() << "]" << std::endl;
+ } else if( PrintOption == 1 )
+ std::cout << "[PASS] " << title << std::endl;
+ }
+ #endif // XB_DEBUG_SUPPORT"
+
+ return 0;
+}
+#endif
+
+
+
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, const xbString &sResult, const char * expectedResult, size_t expectedLen ){
+ xbInt16 rc = 0;
+
+ if( sResult == expectedResult && sResult.Len() == expectedLen ){
+ if( PrintOption == 2 ){
+ xbString sMsg;
+ sMsg.Sprintf( "[PASS][%3.4f] %s Expected matches actual Len=[%d] Data=[%s]\n", ChronTime(), title, expectedLen, expectedResult );
+ std::cout << sMsg.Str();
+ } else if( PrintOption == 1 ) {
+ std::cout << "[PASS] " << title << std::endl;
+ }
+ } else {
+ std::cout << std::endl << "[FAIL 1] " << title << std::endl;
+ std::cout << " Expected Len = [" << expectedLen << "] Expected Data = [" << expectedResult << "]" << std::endl;
+ std::cout << " Actual Len = [" << sResult.Len() << "] Actual Data = [" << sResult.Str() << "]" << std::endl;
+
+ if( sResult.Len() == expectedLen )
+ printf( "lengths match\n" );
+ else
+ printf( "lengths dont match\n" );
+
+ if( sResult == expectedResult )
+ printf( "result matches\n" );
+ else
+ printf( "result does not match\n" );
+
+ rc = -1;
+ }
+ return rc;
+}
+
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, char result, char expectedResult ){
+ xbInt16 rc = 0;
+ if( result == expectedResult ){
+ if( PrintOption == 2 ){
+ xbString sMsg;
+ sMsg.Sprintf( "[PASS][%3.4f] %s Expected matches actual Data=[%c]\n", ChronTime(), title, expectedResult );
+ std::cout << sMsg.Str();
+ // std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual Data=[" << expectedResult << "]" << std::endl;
+ } else if( PrintOption == 1 )
+ std::cout << "[PASS] " << title << std::endl;
+ rc = 0;
+ } else {
+ std::cout << std::endl << "[FAIL 2] " << title << std::endl;
+ std::cout << " Expected Data = [" << expectedResult << "]" << std::endl;
+ std::cout << " Actual Data = [" << result << "]" << std::endl;
+ rc = -1;
+ }
+ return rc;
+}
+
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbInt32 result, xbInt32 expectedResult ){
+ xbInt16 rc = 0;
+ if( result == expectedResult ){
+ if( PrintOption == 2 ){
+ xbString sMsg;
+ sMsg.Sprintf( "[PASS][%3.4f] %s Expected matches actual Data=[%d]\n", ChronTime(), title, expectedResult );
+ std::cout << sMsg.Str();
+ // std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual Data=[" << expectedResult << "]" << std::endl;
+ } else if( PrintOption == 1 )
+ std::cout << "[PASS] " << title << std::endl;
+ rc = 0;
+ } else {
+ std::cout << std::endl << "[FAIL 3] " << title << std::endl;
+ std::cout << " Expected Data = [" << expectedResult << "]" << std::endl;
+ std::cout << " Actual Data = [" << result << "]" << std::endl;
+ rc = -1;
+ }
+ return rc;
+}
+
+
+/*
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbUInt32 result, xbUInt32 expectedResult ){
+ xbInt16 rc = 0;
+ if( result == expectedResult ){
+ if( PrintOption == 2 )
+ std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual Data=[" << expectedResult << "]" << std::endl;
+ else if( PrintOption == 1 )
+ std::cout << "[PASS] " << title << std::endl;
+ rc = 0;
+ } else {
+ std::cout << std::endl << "[FAIL 3] " << title << std::endl;
+ std::cout << " Expected Data = [" << expectedResult << "]" << std::endl;
+ std::cout << " Actual Data = [" << result << "]" << std::endl;
+ rc = -1;
+ }
+ return rc;
+}
+*/
+
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbUInt64 result, xbUInt64 expectedResult ){
+ xbInt16 rc = 0;
+ if( result == expectedResult ){
+ if( PrintOption == 2 ){
+ xbString sMsg;
+ sMsg.Sprintf( "[PASS][%f] %3.4s Expected matches actual Data=[%ld]\n", ChronTime(), title, expectedResult );
+ std::cout << sMsg.Str();
+ // std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual Data=[" << expectedResult << "]" << std::endl;
+ } else if( PrintOption == 1 )
+ std::cout << "[PASS] " << title << std::endl;
+ rc = 0;
+ } else {
+ std::cout << std::endl << "[FAIL 4] " << title << std::endl;
+ std::cout << " Expected Data = [" << expectedResult << "]" << std::endl;
+ std::cout << " Actual Data = [" << result << "]" << std::endl;
+ rc = -1;
+ }
+ return rc;
+}
+
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbFloat result, xbFloat expectedResult ){
+ xbInt16 rc = 0;
+ if( result == expectedResult ){
+ if( PrintOption == 2 ){
+ xbString sMsg;
+ sMsg.Sprintf( "[PASS][%f] %3.4s Expected matches actual Data=[%f]\n", ChronTime(), title, expectedResult );
+ std::cout << sMsg.Str();
+ // std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual Data=[" << expectedResult << "]" << std::endl;
+ } else if( PrintOption == 1 )
+ std::cout << "[PASS] " << title << std::endl;
+ rc = 0;
+ } else {
+ std::cout << std::endl << "[FAIL 5] " << title << std::endl;
+ std::cout << " Expected Data = [" << expectedResult << "]" << std::endl;
+ std::cout << " Actual Data = [" << result << "]" << std::endl;
+ rc = -1;
+ }
+ return rc;
+}
+
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbDouble result, xbDouble expectedResult ){
+ xbInt16 rc = 0;
+ if( result == expectedResult ){
+ // if( dblEquals( result, expectedResult ) == 0 ){
+ if( PrintOption == 2 ){
+ xbString sMsg;
+ sMsg.Sprintf( "[PASS][%3.4f] %s Expected matches actual Data=[%f]\n", ChronTime(), title, expectedResult );
+ std::cout << sMsg.Str();
+ //std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual Data=[" << expectedResult << "]" << std::endl;
+ } else if( PrintOption == 1 )
+ std::cout << "[PASS] " << title << std::endl;
+ rc = 0;
+ } else {
+ std::cout << std::endl << "[FAIL 6] " << title << std::endl;
+ std::cout << " Expected Data = [" << expectedResult << "]" << std::endl;
+ std::cout << " Actual Data = [" << result << "]" << std::endl;
+ rc = -1;
+ }
+ return rc;
+}
+
+
+// next three routines used to do a compare on double values
+xbDouble dblMax( xbDouble a, xbDouble b ){
+ if( a > b )
+ return a;
+ else
+ return b;
+}
+xbDouble dblMin( xbDouble a, xbDouble b ){
+ if( a < b )
+ return a;
+ else
+ return b;
+}
+xbBool dblEquals( xbDouble a, xbDouble b, xbDouble epsilon = 0.0001 ){
+
+ // std::cout << "a=[" << a << "] b=[ " << b << "] dblmax [" << dblAbsMax( a, b ) << "] min [" << dblAbsMin( a, b ) << "]\n";
+ if( a < 0 && b >= 0 )
+ return xbFalse;
+ else if( a >= 0 && b < 0 )
+ return xbFalse;
+ if( (dblMax( a ,b ) - dblMin( a, b )) < epsilon )
+ return xbTrue;
+ else
+ {
+// std::cout << "no match a=[" << a << "] b=[" << b << "] dblmax [" << dblAbsMax( a, b ) << "] min [" << dblAbsMin( a, b ) << "]\n";
+ return xbFalse;
+ }
+}
+
+xbInt16 TestMethod( xbInt16 PrintOption, const char * title, xbDouble result, xbDouble expectedResult, xbDouble dEpsilon ){
+ xbInt16 rc;
+ if( dblEquals( result, expectedResult, dEpsilon ) == xbTrue ){
+ if( PrintOption == 2 ){
+ xbString sMsg;
+ sMsg.Sprintf( "[PASS][%3.4f] %s Expected matches actual Data=[%f]\n", ChronTime(), title, expectedResult );
+ std::cout << sMsg.Str();
+ //std::cout << "[PASS][" << ChronTime() << "] " << title << " Expected matches actual Data=[" << expectedResult << "]" << std::endl;
+ } else if( PrintOption == 1 )
+ std::cout << "[PASS] " << title << std::endl;
+ rc = 0;
+ } else {
+ std::cout << std::endl << "[FAIL 6] " << title << std::endl;
+ std::cout << " Expected Data = [" << expectedResult << "]" << std::endl;
+ std::cout << " Actual Data = [" << result << "]" << std::endl;
+ rc = -1;
+ }
+ return rc;
+}
+
+
+#ifdef XB_LOCKING_SUPPORT
+
+xbInt16 GetCmd( xbXBase &x, const xbString &sFileName, xbString &sCmd, const char cSrc, xbInt16 iPo ){
+ xbInt16 iTryCnt = 0;
+ xbInt16 iMaxTries = 10;
+ char cInBuf[256];
+ FILE *f;
+ xbBool bDone = xbFalse;
+ xbString sMsg;
+
+ while( !bDone && iTryCnt < iMaxTries ){
+
+ #ifdef HAVE__FSOPEN_F
+ // 0x40 is SH_DENYNO or _SH_DENYNO
+ if(( f = _fsopen( sFileName.Str(), "r", 0x40 )) == NULL){
+ sMsg.Sprintf( "GetCmd _fsopen() error opening [%s]", sFileName.Str() );
+ x.WriteLogMessage( sMsg );
+ std::cout << sMsg.Str() << "\n";
+ x.xbSleep( 250 );
+ iTryCnt++;
+ }
+
+ #else
+
+ if(( f = fopen( sFileName.Str(), "r" )) == NULL ){
+ sMsg.Sprintf( "GetCmd fopen() error opening [%s]", sFileName.Str() );
+ x.WriteLogMessage( sMsg );
+ std::cout << sMsg.Str() << "\n";
+ x.xbSleep( 250 );
+ iTryCnt++;
+ }
+ #endif
+
+ else {
+ memset( cInBuf, 0x00, 256 );
+ fgets( cInBuf, 256, f );
+ fclose( f );
+ sCmd = cInBuf;
+ if( sCmd != "" )
+ bDone = xbTrue;
+ else{
+ x.xbSleep( 250 );
+ }
+ }
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ if( iPo > 0 ){
+ sMsg.Sprintf( "[%c] GetCmd [%s]", cSrc, sCmd.Str());
+ x.WriteLogMessage( sMsg );
+ x.FlushLog();
+ }
+ #endif
+
+ if( iTryCnt >= iMaxTries )
+ return -1;
+ else
+ return 0;
+}
+
+xbInt16 SetCmd( xbXBase &x, const xbString &sFileName, const xbString &sCmd, const char cSrc, xbInt16 iPo ){
+
+ xbInt16 iTryCnt = 0;
+ FILE *f;
+ xbBool bDone = xbFalse;
+
+ #ifdef XB_LOGGING_SUPPORT
+ if( iPo > 0 ){
+ xbString sMsg;
+ sMsg.Sprintf( "[%c] SetCmd [%s] FileName [%s]", cSrc, sCmd.Str(), sFileName.Str());
+ x.WriteLogMessage( sMsg );
+ x.FlushLog();
+ }
+ #endif
+
+ while( !bDone && iTryCnt < 10 ){
+
+ #ifdef HAVE__FSOPEN_F
+ // 0x40 is SH_DENYNO or _SH_DENYNO
+ if(( f = _fsopen( sFileName.Str(), "r", 0x40 )) == NULL){
+ x.xbSleep( 250 );
+ iTryCnt++;
+ }
+
+ #else
+ if(( f = fopen( sFileName.Str(), "w" )) == NULL ){
+ x.xbSleep( 250 );
+ iTryCnt++;
+ }
+ #endif
+
+ else {
+ fputs( sCmd.Str(), f );
+ fflush( f );
+ fclose( f );
+ bDone = xbTrue;
+ }
+ }
+ if( iTryCnt == 10 )
+ return -1;
+ else{
+ x.xbSleep( 250 );
+ return 0;
+ }
+}
+
+
+
+#endif
+void InitTime(){
+ time( &timer );
+}
+
+
+xbDouble ChronTime(){
+ time_t tWork = timer;
+ time( &timer );
+ return difftime( timer, tWork );
+
+}
+
+
+
+xbInt16 FileCompare( xbXBase &x, xbInt16 iPo, const xbString &sFile1, const xbString &sFile2, const xbString &sSkipBytes ){
+
+/*
+ iPo print option
+ sFile1 - File 1
+ sFile2 - File 2
+ sSkipBytes - comma separated list of bytes to skip the compare on
+*/
+
+ xbInt16 iRc = 0;
+ xbInt16 iErrorStop = 0;
+ xbInt16 iErrorCnt = 0;
+ xbFile f1( &x );
+ xbFile f2( &x );
+ xbString sMsg;
+ char c1;
+ char c2;
+
+ if( iPo > 0 ){
+ std::cout << "FileCompare\n";
+ std::cout << "Skip bytes = " << sSkipBytes.Str() << std::endl;
+ std::cout << sFile1.Str() << std::endl;
+ std::cout << sFile2.Str() << std::endl;
+ }
+
+ xbLinkListOrd<xbInt32> llO;
+ llO.SetDupKeys( 0 );
+ if( sSkipBytes.Len() > 0 ){
+ xbString sNode;
+ xbUInt32 iCommaCnt = sSkipBytes.CountChar( ',' );
+ for( xbUInt32 i = 0; i < (iCommaCnt+1); i++ ){
+ sNode.ExtractElement( sSkipBytes, ',', i+1, 0 );
+ //std::cout << "Adding key = " << atol( sNode.Str()) << std::endl;
+ llO.InsertKey( atol( sNode.Str()));
+ }
+ }
+
+ xbInt32 iPos = 0;
+ try{
+
+ if(( iRc = f1.xbFopen( "r", sFile1, XB_SINGLE_USER )) != XB_NO_ERROR ){
+ iErrorStop = 10;
+ iErrorCnt++;
+ throw iRc;
+ }
+
+ if(( iRc = f2.xbFopen( "r", sFile2, XB_SINGLE_USER )) != XB_NO_ERROR ){
+ iErrorStop = 20;
+ iErrorCnt++;
+ throw iRc;
+ }
+
+ xbUInt64 uiFs1;
+ xbUInt64 uiFs2;
+
+ if(( iRc = f1.GetFileSize( uiFs1 )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ iErrorCnt++;
+ throw iRc;
+ }
+
+ if(( iRc = f2.GetFileSize( uiFs2 )) != XB_NO_ERROR ){
+ iErrorStop = 40;
+ iErrorCnt++;
+ throw iRc;
+ }
+
+ // std::cout << "file size " << uiFs1 << " " << uiFs2 << "\n";
+
+ f1.xbRewind();
+ f2.xbRewind();
+
+ while( !f1.xbFeof() && !f2.xbFeof()){
+ f1.xbFgetc( c1 );
+ f2.xbFgetc( c2 );
+ if( c1 != c2 ){
+ if( !llO.KeyExists( iPos )){
+ iErrorCnt++;
+ if( iPo > 0 ){
+ sMsg.Sprintf( "Diff %ld %x %x\n", iPos, c1, c2 );
+ std::cout << sMsg.Str();
+ }
+ }
+ }
+ iPos++;
+ }
+ }
+
+ catch( xbInt16 ){
+ if( iPo > 0 ){
+ std::cout << "File Compare Error Count = " << iErrorCnt << std::endl;
+
+ switch( iErrorStop ){
+ case 10:
+ std::cout << "Error opening file = " << sFile1.Str() << std::endl;
+ break;
+ case 20:
+ std::cout << "Error opening file = " << sFile2.Str() << std::endl;
+ break;
+ case 30:
+ std::cout << "GetFileSize() error " << sFile1.Str() << std::endl;
+ break;
+ case 40:
+ std::cout << "GetFileSize() error " << sFile2.Str() << std::endl;
+ break;
+ default:
+ break;
+ }
+ }
+ }
+
+ if( f1.FileIsOpen() )
+ f1.xbFclose();
+ if( f1.FileIsOpen() )
+ f1.xbFclose();
+
+ return iRc;
+}
+
+
diff --git a/src/tests/xb_test_bcd.cpp b/src/tests/xb_test_bcd.cpp
new file mode 100755
index 0000000..1eab20f
--- /dev/null
+++ b/src/tests/xb_test_bcd.cpp
@@ -0,0 +1,128 @@
+/* xb_test_bcd.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2017,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
+
+*/
+
+// This program tests the xb bcd functions
+// usage: xb_test_expnode QUITE|NORMAL|VERBOSE
+
+#include "xbase.h"
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+/**************************************************************************/
+
+int main( int argCnt, char **av )
+{
+
+ #ifdef XB_INDEX_SUPPORT
+
+ xbInt16 iRc = 0;
+ xbInt16 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;
+
+ #ifdef XB_LOGGING_SUPPORT
+ 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
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+
+
+ if( iPo > 0 ){
+ std::cout << "XBase bcd testing program.." << std::endl;
+ std::cout << "This program tests the bcd logic." << std::endl;
+ }
+
+ iRc += TestMethod( iPo, "sizeof( xbBcdStruct )", (xbInt32) sizeof( xbBcdStruct ), (xbInt32) 12 );
+
+ xbString s1( -12345.60 );
+ xbBcd bcd1( s1 );
+ xbDouble d1;
+ bcd1.ToDouble( d1 );
+ xbString s2( d1 );
+ bcd1.ToString( s2 );
+
+ iRc += TestMethod( iPo, "String Constructor1", d1, -12345.6 );
+ iRc += TestMethod( iPo, "String Constructor2", s2.Str(), "-12345.6", 8 );
+
+ d1 = 0034.04;
+ xbBcd bcd2( d1 );
+ bcd2.ToString( s2 );
+ iRc += TestMethod( iPo, "xbDouble Constructor1", s2.Str(), "34.04", 5 );
+
+ // test the sign comparison logic
+ xbInt16 iComp = bcd1.Compare( bcd2 );
+ iRc += TestMethod( iPo, "Sign Compare 1", iComp, -1 );
+ iComp = bcd2.Compare( bcd1 );
+ iRc += TestMethod( iPo, "Sign Compare 2", iComp, 1 );
+
+ // bcd length compare scenarios
+ bcd1.Set( 123 );
+ iRc += TestMethod( iPo, "Length Compare 1", bcd1.Compare( 12 ), 1 );
+ iRc += TestMethod( iPo, "Length Compare 2", bcd1.Compare( 1234 ), -1 );
+ bcd1.Set( -456 );
+ iRc += TestMethod( iPo, "Length Compare 3", bcd1.Compare( -12 ), -1 );
+ iRc += TestMethod( iPo, "Length Compare 4", bcd1.Compare( -1234 ), 1 );
+
+ // same length, value compares
+ bcd1.Set( 11 );
+ iRc += TestMethod( iPo, "Value Compare 1", bcd1.Compare( 10 ), 1 );
+
+ bcd1.Set( 111 );
+ iRc += TestMethod( iPo, "Value Compare 2", bcd1.Compare( 110 ), 1 );
+
+
+ bcd1.Set( 111.111 );
+ iRc += TestMethod( iPo, "Value Compare 3", bcd1.Compare( 111.112 ), -1 );
+
+ bcd1.Set( -100 );
+ iRc += TestMethod( iPo, "Value Compare 4", bcd1.Compare( -111 ), 1 );
+ iRc += TestMethod( iPo, "Value Compare 5", bcd1.Compare( -99 ), -1 );
+
+ bcd1.Set( (xbDouble) 0 );
+ iRc += TestMethod( iPo, "Value Compare 6", bcd1.Compare( (xbDouble) 0 ), 0 );
+
+ 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], iRc * -1 );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ return iRc;
+ #else
+ return XB_NO_ERROR;
+ #endif // XB_INDEX_SUPPORT
+
+}
diff --git a/src/tests/xb_test_date.cpp b/src/tests/xb_test_date.cpp
new file mode 100755
index 0000000..1d9b523
--- /dev/null
+++ b/src/tests/xb_test_date.cpp
@@ -0,0 +1,189 @@
+/* xb_test_date.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
+
+*/
+
+// This program tests the date class xbDate
+
+// usage: xb_test_date QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+ int iRc = 0;
+ xbInt16 po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+#ifdef XB_LOGGING_SUPPORT
+ xbXBase x;
+ x.EnableMsgLogging();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+#endif
+ InitTime();
+
+ xbDate d1;
+#ifdef XB_DEBUG_SUPPORT
+ if( po > 0 )
+ d1.DumpDateTables();
+#endif
+
+ xbDate d2( "19890209" );
+ xbString s3 = "20120709";
+ xbDate d3( s3 );
+ xbString s4;
+ xbString sFmt = "";
+ xbString sOutDate;
+ xbString s;
+
+ iRc += TestMethod( po, "FormatDate( '', sOutDate ) (sys default format)", d3.FormatDate( sFmt, sOutDate ), 0 );
+ iRc += TestMethod( po, "FormatDate( '', sOutDate ) (sys default format)", sOutDate, "07/09/12", 8 );
+ iRc += TestMethod( po, "CenturyOf()" , d3.CenturyOf(), 20 );
+ iRc += TestMethod( po, "YearOf()", d3.YearOf(), 2012 );
+ iRc += TestMethod( po, "MonthOf()", d3.MonthOf(), 7 );
+
+ iRc += TestMethod( po, "DayOf( XB_FMT_DAY )", d3.DayOf( XB_FMT_WEEK ), 2 );
+ iRc += TestMethod( po, "DayOf( XB_FMT_MONTH )", d3.DayOf( XB_FMT_MONTH ), 9 );
+ iRc += TestMethod( po, "DayOf( XB_FMT_YEAR )", d3.DayOf( XB_FMT_YEAR ), 191 );
+
+ iRc += TestMethod( po, "DateIsValid( '12345678' )", d3.DateIsValid( "12345678" ), 0 );
+ iRc += TestMethod( po, "d3.DateIsValid( '20120708' )", d3.DateIsValid( "20120708" ), 1 );
+ iRc += TestMethod( po, "d3.IsLeapYear()", d3.IsLeapYear(), 1 );
+ iRc += TestMethod( po, "d2.IsLeapYear()", d2.IsLeapYear(), 0 );
+
+ d1.Set( "20010102" );
+ iRc += TestMethod( po, "d1.Set('20010102')", d1.Str(), "20010102", 8 );
+ iRc += TestMethod( po, "d1.CalcRollingCenturyForYear(10)", d1.CalcRollingCenturyForYear( 10 ), 20 );
+
+ iRc += TestMethod( po, "d1.JulianDays()", d1.JulianDays(), 2451912 );
+
+
+ iRc += TestMethod( po, "d1.Set( '20140709' )", d1.Set( "20140709" ) , 0 );
+ d1.CharDayOf( s );
+ iRc += TestMethod( po, "d1.CharDayOf(s)", s, "Wednesday", 9 );
+
+ d1.CharMonthOf( s );
+ iRc += TestMethod( po, "d1.CharMonthOf()", s, "July", 4 );
+
+ iRc += TestMethod( po, "d1.JulToDate8( 2451913 )", d1.JulToDate8( 2451912 ), 0 );
+ iRc += TestMethod( po, "d1.JulToDate8( 2451913 )", d1.Str(), "20010102", 8 );
+ iRc += TestMethod( po, "d1.LastDayOfMonth()", d1.LastDayOfMonth(), 0 );
+ iRc += TestMethod( po, "d1.LastDayOfMonth()", d1.Str(), "20010131", 8 );
+
+ iRc += TestMethod( po, "d1.CTOD( '12/01/02' )", d1.CTOD( "12/01/02" ), 0 );
+ iRc += TestMethod( po, "d1.CTOD( '12/01/02' )", d1.Str(), "20021201", 8 );
+
+ xbString s1, s2;
+ s1 = "MM-DD-YY";
+ d1 = "20130402";
+ iRc+= TestMethod( po, "d1.FormatDate( s1, sOutDate )", d1.FormatDate( s1, sOutDate ), 0 );
+ iRc+= TestMethod( po, "d1.FormatDate( s1, sOutDate )", sOutDate, "04-02-13", 8 );
+
+ d1 = "20120203";
+ iRc += TestMethod( po, "d1=20120203", d1.Str(), "20120203", 8 );
+
+ s1 = "20130405";
+ d1 = s1;
+ iRc += TestMethod( po, "d1=s1", d1.Str(), "20130405", 8 );
+
+ d2 = d1;
+ iRc += TestMethod( po, "d2=d1", d2.Str(), "20130405", 8 );
+
+ d2+=5;
+ iRc += TestMethod( po, "d2+=5", d2.Str(), "20130410", 8 );
+
+ d2-=7;
+ iRc += TestMethod( po, "d2-=5", d2.Str(), "20130403", 8 );
+
+ d2++;
+ iRc += TestMethod( po, "d2++", d2.Str(), "20130404", 8 );
+
+ d2--;
+ iRc+= TestMethod( po, "d2--", d2.Str(), "20130403", 8 );
+ iRc+= TestMethod( po, "d2-d1", d1-d2, 2 );
+ iRc+= TestMethod( po, "d1+2", d1+2, "20130407", 8 );
+ iRc+= TestMethod( po, "d1-5", d1-5, "20130402", 8 );
+
+// d1.Dump( "d1" );
+// d2.Dump( "d2" );
+
+ iRc+= TestMethod( po, "d1==d2", d1==d2, 0 );
+ d2 = d1;
+ iRc+= TestMethod( po, "d1==d2", d1==d2, 1 );
+ iRc+= TestMethod( po, "d1>=d2", d1>=d2, 1 );
+ iRc+= TestMethod( po, "d1<=d2", d1<=d2, 1 );
+ iRc+= TestMethod( po, "d1!=d2", d1!=d2, 0 );
+ d2++;
+ iRc+= TestMethod( po, "d1!=d2", d1!=d2, 1 );
+
+ iRc+= TestMethod( po, "d1>d2", d1>d2, 0 );
+ iRc+= TestMethod( po, "d1>=d2", d1>=d2, 0 );
+ iRc+= TestMethod( po, "d1<d2", d1<d2, 1 );
+ iRc+= TestMethod( po, "d1<=d2", d1<=d2, 1 );
+
+ d2-=2;
+ iRc+= TestMethod( po, "d1>d2", d1>d2, 1 );
+ iRc+= TestMethod( po, "d1>=d2", d1>=d2, 1 );
+ iRc+= TestMethod( po, "d1<d2", d1<d2, 0 );
+ iRc+= TestMethod( po, "d1<=d2", d1<=d2, 0 );
+ iRc+= TestMethod( po, "d1-d2", d1-d2, 1 );
+
+/*
+ xbDate d4( "20171015" );
+ std::cout << "day of [" << d4.Str() << "][" << d4.DayOf( XB_FMT_WEEK ) << "]\n";
+ d4++;
+ std::cout << "day of [" << d4.Str() << "][" << d4.DayOf( XB_FMT_WEEK ) << "]\n";
+ d4++;
+ std::cout << "day of [" << d4.Str() << "][" << d4.DayOf( XB_FMT_WEEK ) << "]\n";
+ d4++;
+ std::cout << "day of [" << d4.Str() << "][" << d4.DayOf( XB_FMT_WEEK ) << "]\n";
+ d4++;
+ std::cout << "day of [" << d4.Str() << "][" << d4.DayOf( XB_FMT_WEEK ) << "]\n";
+ d4++;
+ std::cout << "day of [" << d4.Str() << "][" << d4.DayOf( XB_FMT_WEEK ) << "]\n";
+ d4++;
+ std::cout << "day of [" << d4.Str() << "][" << d4.DayOf( XB_FMT_WEEK ) << "]\n";
+ d4++;
+ std::cout << "day of [" << d4.Str() << "][" << d4.DayOf( XB_FMT_WEEK ) << "]\n";
+*/
+
+ if( po > 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], iRc * -1 );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ return iRc;
+}
diff --git a/src/tests/xb_test_dbf_v3_memos.cpp b/src/tests/xb_test_dbf_v3_memos.cpp
new file mode 100755
index 0000000..e364741
--- /dev/null
+++ b/src/tests/xb_test_dbf_v3_memos.cpp
@@ -0,0 +1,233 @@
+/* xb_test_xbdbf_v3_memos.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
+
+*/
+
+// This program tests the version III memo field logic
+
+// usage: xb_test_dbf_v3_memos QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+ int rc = 0;
+ int rc2 = 0;
+ int po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+
+ xbSchema MyV3Record[] =
+ {
+ { "RECID", XB_NUMERIC_FLD, 8, 0 },
+ { "MEMOFLD1", XB_MEMO_FLD, 10, 0 },
+ { "MEMOFLD2", XB_MEMO_FLD, 10, 0 },
+ { "",0,0,0 }
+ };
+
+
+ xbXBase x;
+
+#ifdef XB_LOGGING_SUPPORT
+
+ x.EnableMsgLogging();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+
+#endif
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+ x.DisableDefaultAutoLock();
+ InitTime();
+
+ if( po > 0 )
+ std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+ xbDbf3 V3Dbf( &x ); /* version 3 dbf file */
+
+ rc2 = V3Dbf.CreateTable( "TestV3_memos.DBF", "TestV3", MyV3Record, XB_OVERLAY, XB_MULTI_USER );
+ rc += TestMethod( po, "CreateTable()", (xbInt32) rc2, XB_NO_ERROR );
+
+
+ if( rc2 )
+ x.DisplayError( rc2 );
+ else{
+
+ xbInt16 fldRecId = V3Dbf.GetFieldNo( "RECID" );
+ xbInt16 fldMemo1 = V3Dbf.GetFieldNo( "MEMOFLD1" );
+ xbInt16 fldMemo2 = V3Dbf.GetFieldNo( "MEMOFLD2" );
+ xbString sData;
+
+ // Record 1
+ rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "1" ), XB_NO_ERROR );
+ sData = "Memo data";
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+
+ sData = "Some other memo data";
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+ // Record 2
+ rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "2" ), XB_NO_ERROR );
+ sData = "Memo data Rec 2 ..[";
+ sData.PadRight( 'Z', 1036 );
+ sData += ']';
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Some other memo data Rec 2 ... [";
+ sData.PadRight( 'W', 1555 );
+ sData += ']';
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+ // Check memo header file
+ xbUInt32 ulNextBlock;
+ xbMemo *Memo = V3Dbf.GetMemoPtr();
+ rc += TestMethod( po, "GetHdrNextBlock()", Memo->GetHdrNextBlock( ulNextBlock ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetHdrNextBlock()", (xbInt32) ulNextBlock, 10 );
+
+
+ // Zap a table with memo fields
+ rc += TestMethod( po, "Zap(0)", V3Dbf.Zap(), XB_NO_ERROR );
+ xbUInt32 ulRecCnt = 0;
+ rc += TestMethod( po, "GetRecCount()", V3Dbf.GetRecordCnt( ulRecCnt ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetRecCount() b", (xbInt32) ulRecCnt, 0 );
+ Memo = V3Dbf.GetMemoPtr();
+ rc += TestMethod( po, "GetHdrNextBlock()", Memo->GetHdrNextBlock( ulNextBlock ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetHdrNextBlock()", (xbInt32) ulNextBlock, 1 );
+
+
+
+ // Add records back into the table
+ // Record 1
+ rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "1" ), XB_NO_ERROR );
+ sData = "Memo data rec 1 memo 1";
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+
+ sData = "Memo data rec 1 memo 2";
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+ // Record 2
+ rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "2" ), XB_NO_ERROR );
+ sData = "Memo data Rec 2 memo 1..[";
+ sData.PadRight( 'Z', 1036 );
+ sData += ']';
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Some other memo data Rec 2 memo 2 ... [";
+ sData.PadRight( 'W', 1555 );
+ sData += ']';
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+ // Record 3
+ rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "3" ), XB_NO_ERROR );
+ sData = "Memo data Rec 3 memo 1";
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+
+ sData = "Memo data Rec 3 memo 2";
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+
+ // Record 4
+ rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "4" ), XB_NO_ERROR );
+ sData = "Memo data Rec 4 memo 1";
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Memo data Rec 4 memo 2";
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+
+ // Record 5
+ rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "5" ), XB_NO_ERROR );
+ sData = "Memo data Rec 5 memo 1";
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Memo data Rec 5 memo 2";
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+
+ // Record 6
+ rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "6" ), XB_NO_ERROR );
+ sData = "Memo data Rec 6 memo 1";
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Memo data Rec 6 memo 2";
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+
+ // Record 7
+ rc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V3Dbf.PutField( fldRecId, "7" ), XB_NO_ERROR );
+ sData = "Memo data Rec 7 memo 1";
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Memo data Rec 7 memo 2";
+ rc += TestMethod( po, "UpdateMemoField()", V3Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+
+ // Flag 1, 3, 5 and 7 for deletion
+ rc += TestMethod( po, "GetRecord()", V3Dbf.GetRecord( 1 ), XB_NO_ERROR );
+ rc += TestMethod( po, "DeleteRecord()", V3Dbf.DeleteRecord(), XB_NO_ERROR );
+
+ rc += TestMethod( po, "GetRecord()", V3Dbf.GetRecord( 3 ), XB_NO_ERROR );
+ rc += TestMethod( po, "DeleteRecord()", V3Dbf.DeleteRecord(), XB_NO_ERROR );
+
+ rc += TestMethod( po, "GetRecord()", V3Dbf.GetRecord( 5 ), XB_NO_ERROR );
+ rc += TestMethod( po, "DeleteRecord()", V3Dbf.DeleteRecord(), XB_NO_ERROR );
+
+ rc += TestMethod( po, "GetRecord()", V3Dbf.GetRecord( 7 ), XB_NO_ERROR );
+ rc += TestMethod( po, "DeleteRecord()", V3Dbf.DeleteRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "Pack()", V3Dbf.Pack(), XB_NO_ERROR );
+ rc += TestMethod( po, "Close()", V3Dbf.Close(), XB_NO_ERROR );
+ }
+
+ if( po > 0 || rc < 0 )
+ fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+
+#ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ return rc;
+}
diff --git a/src/tests/xb_test_dbf_v3_nomemos.cpp b/src/tests/xb_test_dbf_v3_nomemos.cpp
new file mode 100755
index 0000000..aab118f
--- /dev/null
+++ b/src/tests/xb_test_dbf_v3_nomemos.cpp
@@ -0,0 +1,323 @@
+/* xb_test_xbdbf_v3_nomemos.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
+
+*/
+
+// This program tests the class xbXdbf
+
+// usage: xb_test_dbf_v3_nomemos QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+ int iRc = 0;
+ int iRc2 = 0;
+ int po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+
+ xbSchema MyV3Record[] =
+ {
+ { "FIRSTNAME", XB_CHAR_FLD, 15, 0 },
+ { "LASTNAME", XB_CHAR_FLD, 20, 0 },
+ { "MIDDLEINIT", XB_CHAR_FLD, 1, 0 },
+ { "BIRTHDATE", XB_DATE_FLD, 8, 0 },
+ { "STARTDATE", XB_DATE_FLD, 8, 0 },
+ { "AMOUNT", XB_NUMERIC_FLD, 9, 2 },
+ { "TESTNUM", XB_NUMERIC_FLD, 12, 4 },
+ { "SWITCH", XB_LOGICAL_FLD, 1, 0 },
+ { "ZIPCODE", XB_NUMERIC_FLD, 5, 0 },
+ { "",0,0,0 }
+ };
+
+
+ xbXBase x;
+
+#ifdef XB_LOGGING_SUPPORT
+ x.EnableMsgLogging();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+ x.DisableDefaultAutoLock();
+ InitTime();
+
+ if( po > 0 )
+ std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+
+ xbDbf3 V3Dbf( &x ); /* version 3 dbf file */
+
+ iRc2 = V3Dbf.CreateTable( "TestV3.DBF", "TestV3", MyV3Record, XB_OVERLAY, XB_MULTI_USER );
+
+ iRc += TestMethod( po, "CreateTable()", (xbInt32) iRc2, XB_NO_ERROR );
+ if( iRc2 )
+ x.DisplayError( iRc2 );
+
+ if( po == 2 ){
+ std::cout << "There should be one entry in the table list" << std::endl;
+ x.DisplayTableList();
+ }
+
+ xbDbf3 V3Dbf2( &x );
+ // next occurrence should error as a dup
+ x.WriteLogMessage( "Second create attempt" );
+ 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 ){
+ x.DisplayError( iRc2 );
+ }
+
+ if( po == 2 ){
+ std::cout << "There should be one entry in the table list" << std::endl;
+ x.DisplayTableList();
+ }
+
+ iRc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetFieldNo()", V3Dbf.GetFieldNo("LASTNAME"), 1 );
+ iRc += TestMethod( po, "GetFieldNo()", V3Dbf.GetFieldNo("MIDDLEINIT"), 2 );
+
+ xbInt16 fldLastName = V3Dbf.GetFieldNo( "LASTNAME" );
+
+ iRc += TestMethod( po, "PutField()", V3Dbf.PutField( fldLastName, "NELSON" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "FIRSTNAME", "WILLIE" ), XB_NO_ERROR );
+
+ iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "AMOUNT", "12.34" ), XB_NO_ERROR );
+ xbDate d( "19991201" );
+ iRc += TestMethod( po, "PutDateField()", V3Dbf.PutDateField( "STARTDATE", d ), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "STARTDATE", "19991301" ), XB_INVALID_DATA );
+ iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "STARTDATE", "19991201" ), XB_NO_ERROR );
+
+
+ iRc += TestMethod( po, "PutLongField()", V3Dbf.PutLongField( "ZIPCODE", 12345 ), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutLogicalField()", V3Dbf.PutLogicalField( "SWITCH", "Y" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutFloatField()", V3Dbf.PutFloatField( "TESTNUM", (xbFloat) 1234.5678 ), XB_NO_ERROR );
+ iRc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+ xbString sf;
+ iRc += TestMethod( po, "GetField1()", V3Dbf.GetField( fldLastName, sf, 0 ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetField2()", sf, "NELSON ", 20 );
+ iRc += TestMethod( po, "GetField3()", V3Dbf.GetField( fldLastName, sf ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetField4()", sf, "NELSON ", 20 );
+ iRc += TestMethod( po, "GetField5()", V3Dbf.GetField( "LASTNAME", sf ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetField6()", sf, "NELSON ", 20 );
+ xbInt16 iNoOfDecimals;
+ iRc += TestMethod( po, "GetFieldDecimal()", V3Dbf.GetFieldDecimal( "AMOUNT", iNoOfDecimals ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetFieldDecimal()", iNoOfDecimals, 2 );
+
+ char FieldType;
+ iRc += TestMethod( po, "GetFieldType()", V3Dbf.GetFieldType( "STARTDATE", FieldType ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetFieldType()", FieldType , 'D' );
+
+ xbInt16 iFieldLen;
+ iRc += TestMethod( po, "GetFieldLen()", V3Dbf.GetFieldLen( "STARTDATE", iFieldLen ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetFieldLen()", iFieldLen, 8 );
+
+ xbInt16 fldAMT = V3Dbf.GetFieldNo( "AMOUNT" );
+ iRc += TestMethod( po, "GetRawField1()", V3Dbf.GetField( fldAMT, sf ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetRawField2()", sf, " 12.34", 9 );
+
+ xbInt32 lZip;
+ iRc += TestMethod( po, "GetLongField()", V3Dbf.GetLongField( "ZIPCODE", lZip ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetLongField()", lZip, 12345 );
+
+ xbString sSwitch;
+ iRc += TestMethod( po, "GetLogicalField()", V3Dbf.GetLogicalField( "SWITCH", sSwitch ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetLogicalField()", sSwitch, "Y", 1 );
+
+ xbFloat fNum;
+ iRc += TestMethod( po, "GetFloatField()", V3Dbf.GetFloatField( "TESTNUM", fNum ), 0 );
+ iRc += TestMethod( po, "GetFloatField()", fNum, (xbFloat) 1234.5678 );
+
+ iRc += TestMethod( po, "GetDateField()", V3Dbf.GetDateField( "STARTDATE", d ), 0 );
+ iRc += TestMethod( po, "GetDateField()", d.Str(), "19991201", 8 );
+
+ // init a second record for more testing
+ iRc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutLogicalField()", V3Dbf.PutLogicalField( "SWITCH", xbTrue ), XB_NO_ERROR );
+ iRc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+ xbBool bSwitch;
+ iRc += TestMethod( po, "GetLogicalField()", V3Dbf.GetLogicalField( "SWITCH", bSwitch ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetLogicalField()", bSwitch, xbTrue );
+
+ // init a third record for more testing
+ iRc += TestMethod( po, "BlankRecord()", V3Dbf.BlankRecord(), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutLogicalField()", V3Dbf.PutLogicalField( "SWITCH", xbFalse ), XB_NO_ERROR );
+ iRc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+
+ iRc += TestMethod( po, "GetLogicalField()", V3Dbf.GetLogicalField( "SWITCH", bSwitch ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetLogicalField()", bSwitch, xbFalse );
+
+ iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "TESTNUM", "12345678" ), XB_INVALID_DATA );
+ iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "TESTNUM", "1234567" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "TESTNUM", "1234567.12345" ), XB_INVALID_DATA );
+ iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "TESTNUM", ".12345" ), XB_INVALID_DATA );
+ iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "TESTNUM", ".1234" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "TESTNUM", "12345678.1234" ), XB_INVALID_DATA );
+ iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "TESTNUM", "1234567.1234" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "AppendRecord()", V3Dbf.AppendRecord(), XB_NO_ERROR );
+
+ iRc += TestMethod( po, "GetFieldCnt()", V3Dbf.GetFieldCnt(), 9 );
+ iRc += TestMethod( po, "GetTblAlias()", V3Dbf.GetTblAlias(), "TestV3", 6 );
+ iRc += TestMethod( po, "GetDbfStatus()", V3Dbf.GetDbfStatus(), XB_OPEN );
+ iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 4 );
+ iRc += TestMethod( po, "GetFirstRecord()", V3Dbf.GetFirstRecord(), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 1 );
+ iRc += TestMethod( po, "GetNextRecord()", V3Dbf.GetNextRecord(), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 2 );
+ iRc += TestMethod( po, "GetLastRecord()", V3Dbf.GetLastRecord(), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 4 );
+ iRc += TestMethod( po, "GetPrevRecord()", V3Dbf.GetPrevRecord(), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 3 );
+ iRc += TestMethod( po, "GetRecordLen()", V3Dbf.GetRecordLen(), 80 );
+
+ iRc += TestMethod( po, "GetFirstRecord( XB_ALL_RECS )", V3Dbf.GetFirstRecord( XB_ALL_RECS ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 1 );
+ iRc += TestMethod( po, "GetNextRecord( XB_ALL_RECS )", V3Dbf.GetNextRecord( XB_ALL_RECS ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 2 );
+ iRc += TestMethod( po, "GetLastRecord( XB_ALL_RECS )", V3Dbf.GetLastRecord( XB_ALL_RECS ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 4 );
+ iRc += TestMethod( po, "GetPrevRecord( XB_ALL_RECS )", V3Dbf.GetPrevRecord( XB_ALL_RECS ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 3 );
+
+ iRc += TestMethod( po, "GetFirstRecord( XB_DELETED_RECS )", V3Dbf.GetFirstRecord( XB_DELETED_RECS ), XB_EOF );
+ iRc += TestMethod( po, "GetLastRecord( XB_DELETED_RECS )", V3Dbf.GetLastRecord( XB_DELETED_RECS ), XB_EOF );
+
+ iRc += TestMethod( po, "GetFirstRecord( XB_ALL_RECS )", V3Dbf.GetFirstRecord( XB_ALL_RECS ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetNextRecord( XB_DELETED_RECS )", V3Dbf.GetNextRecord( XB_DELETED_RECS ), XB_EOF );
+
+ iRc += TestMethod( po, "GetLastRecord( XB_ALL_RECS )", V3Dbf.GetLastRecord( XB_ALL_RECS ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetPrevRecord( XB_DELETED_RECS )", V3Dbf.GetPrevRecord( XB_DELETED_RECS ), XB_BOF );
+
+ iRc += TestMethod( po, "DeleteAllRecords()", V3Dbf.DeleteAllRecords(), XB_NO_ERROR );
+
+
+ iRc += TestMethod( po, "GetFirstRecord()", V3Dbf.GetFirstRecord(), XB_EOF );
+ iRc += TestMethod( po, "GetLastRecord()", V3Dbf.GetLastRecord(), XB_EOF );
+
+ iRc += TestMethod( po, "GetFirstRecord( XB_ALL_RECS )", V3Dbf.GetFirstRecord( XB_ALL_RECS ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 1 );
+
+ iRc += TestMethod( po, "GetNextRecord( XB_ALL_RECS )", V3Dbf.GetNextRecord( XB_ALL_RECS ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 2 );
+
+ iRc += TestMethod( po, "GetNextRecord()", V3Dbf.GetNextRecord(), XB_EOF );
+
+ iRc += TestMethod( po, "GetLastRecord( XB_ALL_RECS )", V3Dbf.GetLastRecord( XB_ALL_RECS ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 4 );
+
+ iRc += TestMethod( po, "GetPrevRecord( XB_ALL_RECS )", V3Dbf.GetPrevRecord( XB_ALL_RECS ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetCurRecNo()", (xbInt32) V3Dbf.GetCurRecNo(), 3 );
+
+ iRc += TestMethod( po, "UndeleteAllRecords()", V3Dbf.UndeleteAllRecords(), XB_NO_ERROR );
+
+ char * p = V3Dbf.GetRecordBuf();
+ iRc += TestMethod( po, "GetRecordBuf()", p[0], ' ' );
+
+ if( po == 2 ){
+ V3Dbf.DumpHeader( 3 );
+ V3Dbf.DumpRecord( 4 );
+ }
+
+
+
+ iRc += TestMethod( po, "PutField()", V3Dbf.PutField( "LASTNAME", "CLINTON" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutRecord()", V3Dbf.PutRecord(), XB_NO_ERROR );
+ iRc += TestMethod( po, "DeleteRecord()", V3Dbf.DeleteRecord(), XB_NO_ERROR );
+ iRc += TestMethod( po, "UndeleteRecord()", V3Dbf.UndeleteRecord(), XB_NO_ERROR );
+ xbUInt32 ulRecCnt = 0;
+ iRc += TestMethod( po, "GetRecordCnt()", V3Dbf.GetRecordCnt( ulRecCnt ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetRecordCnt()b",(xbInt32) ulRecCnt, 4 );
+ iRc += TestMethod( po, "DeleteAllRecords()", V3Dbf.DeleteAllRecords(), XB_NO_ERROR );
+ iRc += TestMethod( po, "UndeleteAllRecords()", V3Dbf.UndeleteAllRecords(), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetRecord()", V3Dbf.GetRecord( 4 ), XB_NO_ERROR );
+ iRc += TestMethod( po, "DeleteRecord()", V3Dbf.DeleteRecord(), XB_NO_ERROR );
+ iRc += TestMethod( po, "Commit()", V3Dbf.Commit(), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetDbfStatus()", V3Dbf.GetDbfStatus(), XB_OPEN );
+
+ if( po == 2 ){
+ V3Dbf.DumpRecord( 4 );
+ }
+
+ xbDbf3 CopyDbf( &x );
+ iRc += TestMethod( po, "CopyDbfStructure()", V3Dbf.CopyDbfStructure( &CopyDbf, "CopyStructureV3NoMemos", "CopyAliasV3NoMemos", XB_OVERLAY, XB_MULTI_USER ), XB_NO_ERROR );
+ iRc += TestMethod( po, "CopyDbf.Close()", CopyDbf.Close(), XB_NO_ERROR );
+
+ if( po == 2 ){
+ std::cout << "There should be one entry in the table list" << std::endl;
+ x.DisplayTableList();
+ }
+
+ iRc += TestMethod( po, "GetDbfStatus()", CopyDbf.GetDbfStatus(), XB_CLOSED );
+ iRc += TestMethod( po, "Open()", CopyDbf.xbDbf::Open( "CopyStructureV3NoMemos.DBF", "CopyAliasV3NoMemos" ), XB_NO_ERROR );
+
+ if( po == 2 ){
+ std::cout << "There should be two entries in the table list" << std::endl;
+ x.DisplayTableList();
+ }
+
+ iRc += TestMethod( po, "CopyDbf.Close()", CopyDbf.Close(), XB_NO_ERROR );
+
+ #ifdef XB_DEBUG_SUPPORT
+ #ifdef XB_LOCKING_SUPPORT
+ V3Dbf.DumpTableLockStatus();
+ #endif
+ #endif
+
+ iRc += TestMethod( po, "PackTable( 0, 0 )", V3Dbf.Pack(), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetDbfStatus()", V3Dbf.GetDbfStatus(), XB_OPEN );
+
+ iRc += TestMethod( po, "Zap()", V3Dbf.Zap(), XB_NO_ERROR );
+ if( po == 2 )
+ x.DisplayTableList();
+
+ iRc += TestMethod( po, "Close()", V3Dbf.Close(), XB_NO_ERROR );
+ if( po == 2 )
+ x.DisplayTableList();
+
+ if( po > 0 || iRc < 0 )
+ fprintf( stdout, "Total Errors = %d\n", iRc * -1 );
+
+
+ V3Dbf.Abort(); // don't crash the program if uncommited updates
+
+#ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ return iRc;
+}
diff --git a/src/tests/xb_test_dbf_v4_memos.cpp b/src/tests/xb_test_dbf_v4_memos.cpp
new file mode 100755
index 0000000..e92b5b2
--- /dev/null
+++ b/src/tests/xb_test_dbf_v4_memos.cpp
@@ -0,0 +1,335 @@
+/* xb_test_xbdbf_v4_memos.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
+
+*/
+
+// This program tests the version III memo field logic
+// usage: xb_test_dbf_v4_memos QUITE|NORMAL|VERBOSE
+
+#include "xbase.h"
+using namespace xb;
+#include "tstfuncs.cpp"
+
+int main( int argCnt, char **av )
+{
+ int rc = 0;
+ int rc2 = 0;
+ int po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+ xbSchema MyV4Record[] =
+ {
+ { "RECID", XB_NUMERIC_FLD, 8, 0 },
+ { "MEMOFLD1", XB_MEMO_FLD, 10, 0 },
+ { "MEMOFLD2", XB_MEMO_FLD, 10, 0 },
+ { "MEMOFLD3", XB_MEMO_FLD, 10, 0 },
+ { "",0,0,0 }
+ };
+
+ xbXBase x;
+
+#ifdef XB_LOGGING_SUPPORT
+
+ x.EnableMsgLogging();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+
+#endif
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+ x.DisableDefaultAutoLock();
+ InitTime();
+
+
+ if( po > 0 )
+ std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+ xbDbf4 V4Dbf( &x );
+ rc += TestMethod( po, "SetCreateMemoBlockSize", V4Dbf.SetCreateMemoBlockSize( 1024 ), XB_NO_ERROR );
+ rc2 = V4Dbf.CreateTable( "TestV4_memos.DBF", "TestV4", MyV4Record, XB_OVERLAY, XB_MULTI_USER );
+
+ xbUInt64 ullDbfOrigFileSize = 0;
+ xbUInt64 ullDbtOrigFileSize = 0;
+ rc = V4Dbf.GetFileSize( ullDbfOrigFileSize );
+ rc = V4Dbf.GetMemoPtr()->GetFileSize( ullDbtOrigFileSize );
+
+ rc += TestMethod( po, "CreateTable()", (xbInt32) rc2, XB_NO_ERROR );
+ if( rc2 )
+ x.DisplayError( rc2 );
+ else{
+
+ xbInt16 fldRecId = V4Dbf.GetFieldNo( "RECID" );
+ xbInt16 fldMemo1 = V4Dbf.GetFieldNo( "MEMOFLD1" );
+ xbInt16 fldMemo2 = V4Dbf.GetFieldNo( "MEMOFLD2" );
+ xbInt16 fldMemo3 = V4Dbf.GetFieldNo( "MEMOFLD3" );
+ xbString sData;
+
+
+
+
+ // Record 1
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "1" ), XB_NO_ERROR );
+ sData = "Memo data";
+
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Add one block", V4Dbf.GetMemoPtr(), 2, 2, "" );
+
+ sData = "Some other memo data";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Add one block", V4Dbf.GetMemoPtr(), 3, 3, "" );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+
+
+
+ // Record 2
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "2" ), XB_NO_ERROR );
+ sData = "Memo data Rec 2 ..[";
+ sData.PadRight( 'Z', 1036 );
+ sData += ']';
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Some other memo data Rec 2 ... [";
+ sData.PadRight( 'W', 1555 );
+ sData += ']';
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Add 7 blocks", V4Dbf.GetMemoPtr(), 7, 7, "" );
+
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, "" ), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Delete 2 blocks", V4Dbf.GetMemoPtr(), 3, 7, "3,2,7" );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+ // Record 3
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "3" ), XB_NO_ERROR );
+ sData = "Memo data r3f1";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Add one block", V4Dbf.GetMemoPtr(), 4, 7, "4,1,7" );
+ sData = "Memo data r3f2";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Add one block", V4Dbf.GetMemoPtr(), 7, 7, "" );
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, "" ), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Delete one block", V4Dbf.GetMemoPtr(), 3, 7, "3,1,7" );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+ // Record 4
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "4" ), XB_NO_ERROR );
+ sData = "Memo data Rec 4 fld1 ..[";
+ sData.PadRight( 'Q', 1036 );
+ sData += ']';
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Update Memo Field", V4Dbf.GetMemoPtr(), 3, 9, "3,1,9" );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+ // go back a record and delete a memo field and test if all blocks filled in
+ rc += TestMethod( po, "GetPrevRecord()", V4Dbf.GetPrevRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, "" ), XB_NO_ERROR );
+ rc += TestMethod( po, "Commit()", V4Dbf.Commit(), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Delete one block", V4Dbf.GetMemoPtr(), 3, 9, "3,2,9" );
+
+ // Record 5
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "5" ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+ // Zap a table with memo fields
+ rc += TestMethod( po, "Zap()", V4Dbf.Zap(), XB_NO_ERROR );
+ xbUInt32 ulRecCnt = 0;
+ rc += TestMethod( po, "GetRecCount()", V4Dbf.GetRecordCnt( ulRecCnt ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetRecCount()b", (xbInt32) ulRecCnt, 0 );
+
+ // Add records back into the table, and verify the block chains created as designed
+ // Record 1
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "1" ), XB_NO_ERROR );
+ sData = "Memo data rec 1 memo 1";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Update Memo Field", V4Dbf.GetMemoPtr(), 2, 2, "" );
+
+ // Revise the memo field
+ sData = "Updated memo data rec1 memo 1";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "Commit()", V4Dbf.Commit(), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "UpdateMemoField", V4Dbf.GetMemoPtr(), 2, 2, "" );
+
+ sData = "Memo data rec 1 memo 2";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "Commit()", V4Dbf.Commit(), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "UpdateMemoField", V4Dbf.GetMemoPtr(), 3, 3, "" );
+
+ // Record 2
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "2" ), XB_NO_ERROR );
+ sData = "Memo data rec 2 memo 1";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Memo data rec 2 memo 2";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Add one block", V4Dbf.GetMemoPtr(), 5, 5, "" );
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, "" ), XB_NO_ERROR );
+ rc += TestMethod( po, "Commit()", V4Dbf.Commit(), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "UpdateMemoField", V4Dbf.GetMemoPtr(), 3, 5, "3,1,5" );
+
+ sData = "Test the abort code";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "Abort()", V4Dbf.Abort(), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "UpdateMemoField", V4Dbf.GetMemoPtr(), 3, 5, "3,1,5" );
+
+ sData = "Test mulitple updates before commit";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Test mulitple updates before commit2";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "UpdateMemoField", V4Dbf.GetMemoPtr(), 5, 5, "" );
+ sData = "Test mulitple updates before commit3";
+
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "Commit()", V4Dbf.Commit(), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "UpdateMemoField", V4Dbf.GetMemoPtr(), 5, 5, "" );
+
+// V4Dbf.GetMemoPtr()->DumpMemoInternals();
+
+ rc += TestMethod( po, "Zap(0)", V4Dbf.Zap(), XB_NO_ERROR );
+
+ xbUInt64 ullDbfPostZapFileSize = 0;
+ xbUInt64 ullDbtPostZapFileSize = 0;
+ rc += V4Dbf.GetFileSize( ullDbfPostZapFileSize );
+ rc += V4Dbf.GetMemoPtr()->GetFileSize( ullDbtPostZapFileSize );
+
+ rc += TestMethod( po, "Zap()", ullDbfPostZapFileSize, ullDbfOrigFileSize );
+ rc += TestMethod( po, "Memo->Zap()", ullDbtPostZapFileSize, ullDbtOrigFileSize );
+ rc += TestDbt4Method( po, "Zap() block check", V4Dbf.GetMemoPtr(), 1, 1, "" );
+
+ rc += TestMethod( po, "GetRecCount()", V4Dbf.GetRecordCnt( ulRecCnt ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetRecCount()", (xbInt32) ulRecCnt, 0 );
+
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "1" ), XB_NO_ERROR );
+ sData = "Memo data rec 1 memo 1";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Memo data rec 1 memo 2";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ sData = "Memo data rec 1 memo 3";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo3, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+ sData = "Memo data rec 1 memo 1 A";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Memo data rec 1 memo 2 A";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ sData = "Memo data rec 1 memo 3A ";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo3, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "Commit()", V4Dbf.Commit(), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Update Memo Field", V4Dbf.GetMemoPtr(), 4, 4, "" );
+
+ // Record 2
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "2" ), XB_NO_ERROR );
+ sData = "Memo data rec 2 memo 1";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Memo data rec 2 memo 2";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Add two blocks", V4Dbf.GetMemoPtr(), 6, 6, "" );
+
+ // Record 3
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "3" ), XB_NO_ERROR );
+ sData = "Memo data rec 3 memo 1";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Memo data rec 3 memo 2";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Add two blocks", V4Dbf.GetMemoPtr(), 8, 8, "" );
+
+ // Record 4
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "4" ), XB_NO_ERROR );
+ sData = "Memo data rec 4 memo 1";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Memo data rec 4 memo 2";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Add two blocks", V4Dbf.GetMemoPtr(), 10, 10, "" );
+
+ // Record 5
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "5" ), XB_NO_ERROR );
+ sData = "Memo data rec 5 memo 1";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Memo data rec 5 memo 2";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Add two blocks", V4Dbf.GetMemoPtr(), 12, 12, "" );
+
+ // Record 6
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "6" ), XB_NO_ERROR );
+ sData = "Memo data rec 6 memo 1";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Memo data rec 6 memo 2";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Add two blocks", V4Dbf.GetMemoPtr(), 14, 14, "" );
+
+ // Record 7
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldRecId, "7" ), XB_NO_ERROR );
+ sData = "Memo data rec 6 memo 1";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo1, sData ), XB_NO_ERROR );
+ sData = "Memo data rec 6 memo 2";
+ rc += TestMethod( po, "UpdateMemoField()", V4Dbf.UpdateMemoField( fldMemo2, sData ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+ rc += TestDbt4Method( po, "Add two blocks", V4Dbf.GetMemoPtr(), 16, 16, "" );
+
+ // delete records 1, 3, 5, 7
+ rc += TestMethod( po, "GetRecord()", V4Dbf.GetRecord( 1 ), XB_NO_ERROR );
+ rc += TestMethod( po, "DeleteRecord()", V4Dbf.DeleteRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetRecord()", V4Dbf.GetRecord( 3 ), XB_NO_ERROR );
+ rc += TestMethod( po, "DeleteRecord()", V4Dbf.DeleteRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetRecord()", V4Dbf.GetRecord( 5 ), XB_NO_ERROR );
+ rc += TestMethod( po, "DeleteRecord()", V4Dbf.DeleteRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetRecord()", V4Dbf.GetRecord( 7 ), XB_NO_ERROR );
+ rc += TestMethod( po, "DeleteRecord()", V4Dbf.DeleteRecord(), XB_NO_ERROR );
+
+
+ rc += TestMethod( po, "Pack()", V4Dbf.Pack(), XB_NO_ERROR );
+ rc += TestMethod( po, "Close()", V4Dbf.Close(), XB_NO_ERROR );
+ }
+
+ if( po > 0 || rc < 0 )
+ fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+
+#ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ return rc;
+}
diff --git a/src/tests/xb_test_dbf_v4_nomemos.cpp b/src/tests/xb_test_dbf_v4_nomemos.cpp
new file mode 100755
index 0000000..68ecda0
--- /dev/null
+++ b/src/tests/xb_test_dbf_v4_nomemos.cpp
@@ -0,0 +1,330 @@
+/* xb_test_xbdbf_v4_nomemos.cpp
+
+XBase 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
+
+*/
+
+// This program tests the class xbXdbf
+
+// usage: xb_test_dbf_v4_nomemos QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+ int rc = 0;
+ int rc2 = 0;
+ int po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+ xbSchema MyV4Record[] =
+ {
+ { "FIRSTNAME", XB_CHAR_FLD, 15, 0 },
+ { "LASTNAME", XB_CHAR_FLD, 20, 0 },
+ { "MIDDLEINIT", XB_CHAR_FLD, 1, 0 },
+ { "BIRTHDATE", XB_DATE_FLD, 8, 0 },
+ { "STARTDATE", XB_DATE_FLD, 8, 0 },
+ { "AMOUNT", XB_NUMERIC_FLD, 9, 2 },
+ { "TESTNUM", XB_NUMERIC_FLD, 12, 4 },
+ { "SWITCH", XB_LOGICAL_FLD, 1, 0 },
+ { "ZIPCODE", XB_NUMERIC_FLD, 5, 0 },
+ { "DBLFLDTST", XB_FLOAT_FLD, 14, 4 },
+ { "",0,0,0 }
+ };
+
+ xbXBase x;
+
+#ifdef XB_LOGGING_SUPPORT
+ x.EnableMsgLogging();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+ x.DisableDefaultAutoLock();
+ InitTime();
+
+ if( po > 0 )
+ std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+ xbDbf4 V4Dbf( &x ); // version 4 dbf file
+ rc2 = V4Dbf.CreateTable( "TestV4.DBF", "TestV4", MyV4Record, XB_OVERLAY, XB_MULTI_USER );
+ rc += TestMethod( po, "CreateTable()", (xbInt32) rc2, XB_NO_ERROR );
+ if( rc2 )
+ x.DisplayError( rc2 );
+
+ xbUInt64 ullFileSize;
+ rc2 = V4Dbf.GetFileSize( ullFileSize );
+
+ rc = TestMethod( po, "CheckTableSize", ullFileSize, (xbUInt64) 353 );
+
+ if( po == 2 ){
+ std::cout << "There should be one entry in the table list" << std::endl;
+ x.DisplayTableList();
+ }
+
+ xbDbf4 V4Dbf2( &x );
+
+ // next occurrence should error as a dup
+ x.WriteLogMessage( "Second create attempt" );
+ rc2 = V4Dbf2.CreateTable( "TestV4.DBF", "TestV4", MyV4Record, XB_DONTOVERLAY, XB_MULTI_USER );
+ rc += TestMethod( po, "CreateTable()", rc2, XB_FILE_EXISTS );
+ if( rc2 != XB_FILE_EXISTS ){
+ x.DisplayError( rc2 );
+ }
+
+ if( po == 2 ){
+ std::cout << "There should be one entry in the table list" << std::endl;
+ x.DisplayTableList();
+ }
+
+
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetFieldNo()", V4Dbf.GetFieldNo("LASTNAME"), 1 );
+ rc += TestMethod( po, "GetFieldNo()", V4Dbf.GetFieldNo("MIDDLEINIT"), 2 );
+
+ xbInt16 fldLastName = V4Dbf.GetFieldNo( "LASTNAME" );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldLastName, "NELSON" ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "FIRSTNAME", "WILLIE" ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "AMOUNT", "12.34" ), XB_NO_ERROR );
+ xbDate dt( "19500209" );
+ rc += TestMethod( po, "PutDateField()", V4Dbf.PutDateField( "BIRTHDATE", dt ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutLongField()", V4Dbf.PutLongField( "ZIPCODE", 12345 ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutLogicalField()", V4Dbf.PutLogicalField( "SWITCH", "Y" ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutFloatField()", V4Dbf.PutFloatField( "TESTNUM", (xbFloat) 1234.5678 ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutDoubleField()", V4Dbf.PutDoubleField( "DBLFLDTST", (xbDouble) 9876.5432 ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+
+ xbString sf;
+ rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldLastName, sf, 0 ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetField()", sf, "NELSON ", 20 );
+ rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldLastName, sf ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetField()", sf, "NELSON ", 20 );
+ rc += TestMethod( po, "GetField()", V4Dbf.GetField( "LASTNAME", sf ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetField()", sf, "NELSON ", 20 );
+ xbInt16 iNoOfDecimals;
+ rc += TestMethod( po, "GetFieldDecimal()", V4Dbf.GetFieldDecimal( "AMOUNT", iNoOfDecimals ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetFieldDecimal()", iNoOfDecimals, 2 );
+
+ xbDouble d;
+ rc += TestMethod( po, "GetDoubleField()", V4Dbf.GetDoubleField( "DBLFLDTST", d ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetDoubleField()-b", d, (xbDouble) 9876.5432 );
+
+ char FieldType;
+ rc += TestMethod( po, "GetFieldType()", V4Dbf.GetFieldType( "STARTDATE", FieldType ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetFieldType()", FieldType , 'D' );
+
+ xbInt16 iFieldLen;
+ rc += TestMethod( po, "GetFieldLen()", V4Dbf.GetFieldLen( "STARTDATE", iFieldLen ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetFieldLen()", iFieldLen, 8 );
+
+ xbInt16 fldAMT = V4Dbf.GetFieldNo( "AMOUNT" );
+ rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldAMT, sf ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetField()", sf, " 12.34", 9 );
+
+ xbInt32 lZip;
+ rc += TestMethod( po, "GetLongField()", V4Dbf.GetLongField( "ZIPCODE", lZip ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetLongField()", lZip, 12345 );
+
+ xbString sSwitch;
+ rc += TestMethod( po, "GetLogicalField()", V4Dbf.GetLogicalField( "SWITCH", sSwitch ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetLogicalField()", sSwitch, "Y", 1 );
+
+ xbFloat fNum;
+ rc += TestMethod( po, "GetFloatField()", V4Dbf.GetFloatField( "TESTNUM", fNum ), 0 );
+ rc += TestMethod( po, "GetFloatField()", fNum, (xbFloat) 1234.5678 );
+
+ // init a second record for more testing
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutLogicalField()", V4Dbf.PutLogicalField( "SWITCH", xbTrue ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+ xbBool bSwitch;
+ rc += TestMethod( po, "GetLogicalField()", V4Dbf.GetLogicalField( "SWITCH", bSwitch ), 0 );
+ rc += TestMethod( po, "GetLogicalField()", bSwitch, xbTrue );
+
+ // init a third record for more testing
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutLogicalField()", V4Dbf.PutLogicalField( "SWITCH", xbFalse ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetLogicalField()", V4Dbf.GetLogicalField( "SWITCH", bSwitch ), 0 );
+ rc += TestMethod( po, "GetLogicalField()", bSwitch, xbFalse );
+
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "TESTNUM", "12345678" ), XB_INVALID_DATA );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "TESTNUM", "1234567" ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "TESTNUM", "1234567.12345" ), XB_INVALID_DATA );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "TESTNUM", ".12345" ), XB_INVALID_DATA );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "TESTNUM", ".1234" ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "TESTNUM", "12345678.1234" ), XB_INVALID_DATA );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "TESTNUM", "1234567.1234" ), XB_NO_ERROR );
+
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+ rc += TestMethod( po, "GetFieldCnt()", V4Dbf.GetFieldCnt(), 10 );
+ rc += TestMethod( po, "GetTblAlias()", V4Dbf.GetTblAlias(), "TestV4", 6 );
+ rc += TestMethod( po, "GetDbfStatus()", V4Dbf.GetDbfStatus(), XB_OPEN );
+ rc += TestMethod( po, "GetCurRecNo()", (xbInt32) V4Dbf.GetCurRecNo(), 4 );
+ rc += TestMethod( po, "GetFirstRecord()", V4Dbf.GetFirstRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetCurRecNo()", (xbInt32) V4Dbf.GetCurRecNo(), 1 );
+ rc += TestMethod( po, "GetNextRecord()", V4Dbf.GetNextRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetCurRecNo()", (xbInt32) V4Dbf.GetCurRecNo(), 2 );
+ rc += TestMethod( po, "GetLastRecord()", V4Dbf.GetLastRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetCurRecNo()", (xbInt32) V4Dbf.GetCurRecNo(), 4 );
+ rc += TestMethod( po, "GetPrevRecord()", V4Dbf.GetPrevRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetCurRecNo()", (xbInt32) V4Dbf.GetCurRecNo(), 3 );
+ rc += TestMethod( po, "GetRecordLen()", (xbInt32) V4Dbf.GetRecordLen(), 94 );
+
+ char * p = V4Dbf.GetRecordBuf();
+ rc += TestMethod( po, "GetRecordBuf()", p[0], ' ' );
+
+ if( po == 2 ){
+ V4Dbf.DumpHeader( 3 );
+ V4Dbf.DumpRecord( 4 );
+ }
+
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "LASTNAME", "CLINTON" ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutRecord()", V4Dbf.PutRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "DeleteRecord()", V4Dbf.DeleteRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "UndeleteRecord()", V4Dbf.UndeleteRecord(), XB_NO_ERROR );
+ xbUInt32 ulRecCnt = 0;
+ rc += TestMethod( po, "GetRecordCnt()", V4Dbf.GetRecordCnt( ulRecCnt ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetRecordCnt()", (xbInt32) ulRecCnt, 4 );
+ rc += TestMethod( po, "DeleteAllRecords()", V4Dbf.DeleteAllRecords(), XB_NO_ERROR );
+ rc += TestMethod( po, "UndeleteAllRecords()", V4Dbf.UndeleteAllRecords(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetRecord()", V4Dbf.GetRecord( 2L ), XB_NO_ERROR );
+ rc += TestMethod( po, "DeleteRecord()", V4Dbf.DeleteRecord(), XB_NO_ERROR );
+
+ if( po == 2 ){
+ V4Dbf.DumpRecord( 4 );
+ }
+
+ xbDbf4 CopyDbf( &x );
+ rc += TestMethod( po, "CopyDbfStructure()", V4Dbf.CopyDbfStructure( &CopyDbf, "CopyStructureV4NoMemos", "CopyAliasV4NoMemos", XB_OVERLAY, XB_MULTI_USER ), XB_NO_ERROR );
+ rc += TestMethod( po, "CopyDbf.Close()", CopyDbf.Close(), XB_NO_ERROR );
+
+ if( po == 2 ){
+ std::cout << "There should be one entry in the table list" << std::endl;
+ x.DisplayTableList();
+ }
+
+ rc += TestMethod( po, "GetDbfStatus()", CopyDbf.GetDbfStatus(), XB_CLOSED );
+ rc += TestMethod( po, "Open()", CopyDbf.xbDbf::Open( "CopyStructureV4NoMemos.DBF", "CopyAliasV4NoMemos" ), XB_NO_ERROR );
+
+ if( po == 2 ){
+ std::cout << "There should be two entries in the table list" << std::endl;
+ x.DisplayTableList();
+ }
+
+ rc += TestMethod( po, "Pack()", V4Dbf.Pack(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetDbfStatus()", V4Dbf.GetDbfStatus(), XB_OPEN );
+
+ rc += TestMethod( po, "Zap()", V4Dbf.Zap(), XB_NO_ERROR );
+ if( po == 2 )
+ x.DisplayTableList();
+
+ xbUInt64 ullFileSize2 = 0;
+ rc2 = V4Dbf.GetFileSize( ullFileSize2 );
+ rc = TestMethod( po, "CheckTableSize", ullFileSize2, ullFileSize );
+
+// Test of auto commit code here
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldLastName, "NELSON" ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "FIRSTNAME", "WILLIE" ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "AMOUNT", "12.34" ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutLongField()", V4Dbf.PutLongField( "ZIPCODE", 12345 ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutLogicalField()", V4Dbf.PutLogicalField( "SWITCH", "Y" ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutFloatField()", V4Dbf.PutFloatField( "TESTNUM", (xbFloat) 1234.5678 ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutDoubleField()", V4Dbf.PutDoubleField( "DBLFLDTST", (xbDouble) 9876.5432 ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+ rc += TestMethod( po, "BlankRecord()", V4Dbf.BlankRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( fldLastName, "JOHNSON" ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "FIRSTNAME", "JIMMY" ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "AMOUNT", "555.33" ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutLongField()", V4Dbf.PutLongField( "ZIPCODE", 76523 ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutLogicalField()", V4Dbf.PutLogicalField( "SWITCH", "N" ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutFloatField()", V4Dbf.PutFloatField( "TESTNUM", (xbFloat) 8765.4321 ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutDoubleField()", V4Dbf.PutDoubleField( "DBLFLDTST", (xbDouble) 9876.5432 ), XB_NO_ERROR );
+ rc += TestMethod( po, "AppendRecord()", V4Dbf.AppendRecord(), XB_NO_ERROR );
+
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "AMOUNT", "666.22" ), XB_NO_ERROR );
+ rc += TestMethod( po, "Abort()", V4Dbf.Abort(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetField()", V4Dbf.GetField( "AMOUNT", sf ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetField()", sf, " 555.33", 9 );
+
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "AMOUNT", "666.22" ), XB_NO_ERROR );
+ rc += TestMethod( po, "Commit()", V4Dbf.Commit(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldAMT, sf ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetField()", sf, " 666.22", 9 );
+
+ rc += TestMethod( po, "GetPrevRecord()", V4Dbf.GetPrevRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetNextRecord()", V4Dbf.GetNextRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldAMT, sf ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetField()", sf, " 666.22", 9 );
+
+ rc += TestMethod( po, "AutoCommit()", V4Dbf.SetAutoCommit( 0 ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "AMOUNT", "999.33" ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetPrevRecord()", V4Dbf.GetPrevRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetNextRecord()", V4Dbf.GetNextRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldAMT, sf ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetField()", sf, " 666.22", 9 );
+
+ rc += TestMethod( po, "AutoCommit()", V4Dbf.SetAutoCommit( -1 ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "AMOUNT", "999.33" ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetCurRecNo()", (xbInt32) V4Dbf.GetCurRecNo(), 2 );
+ rc += TestMethod( po, "GetPrevRecord()", V4Dbf.GetPrevRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetNextRecord()", V4Dbf.GetNextRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldAMT, sf ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetField()", sf, " 999.33", 9 );
+
+ rc += TestMethod( po, "AutoCommit()", V4Dbf.SetAutoCommit( 1 ), XB_NO_ERROR );
+ rc += TestMethod( po, "PutField()", V4Dbf.PutField( "AMOUNT", "432.55" ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetCurRecNo()", (xbInt32) V4Dbf.GetCurRecNo(), 2 );
+ rc += TestMethod( po, "GetPrevRecord()", V4Dbf.GetPrevRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetNextRecord()", V4Dbf.GetNextRecord(), XB_NO_ERROR );
+ rc += TestMethod( po, "GetField()", V4Dbf.GetField( fldAMT, sf ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetField()", sf, " 432.55", 9 );
+
+ rc += TestMethod( po, "Close()", V4Dbf.Close(), XB_NO_ERROR );
+ if( po == 2 )
+ x.DisplayTableList();
+
+ if( po > 0 || rc < 0 )
+ fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+
+#ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ return rc;
+}
diff --git a/src/tests/xb_test_expnode.cpp b/src/tests/xb_test_expnode.cpp
new file mode 100755
index 0000000..3fb716d
--- /dev/null
+++ b/src/tests/xb_test_expnode.cpp
@@ -0,0 +1,123 @@
+/* xb_test_expnode.cpp
+
+XBase Software Library
+
+Copyright (c) 1997,2003,2014,2017,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
+
+*/
+
+// This program tests the xb expression node functions
+// usage: xb_test_expnode QUITE|NORMAL|VERBOSE
+
+#include "xbase.h"
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+/**************************************************************************/
+
+int main( int argCnt, char **av )
+{
+ xbInt16 iRc = 0;
+ xbInt16 po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+ xbXBase x;
+
+ #ifdef XB_LOGGING_SUPPORT
+ x.EnableMsgLogging();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+ InitTime();
+
+ if( po > 0 ){
+ std::cout << "XBase Expression Node testing program.." << std::endl;
+ std::cout << "This program tests the XBase expression node logic." << std::endl;
+ }
+
+ xbString s1 = "TestNode1";
+ xbExpNode *n1 = new xbExpNode();
+ n1->SetNodeText( s1 );
+ n1->SetNodeType( XB_EXP_OPERATOR );
+ n1->SetReturnType( XB_EXP_LOGICAL );
+
+ iRc += TestMethod( po, "GetNodeType()", n1->GetNodeType(), 'O' );
+ iRc += TestMethod( po, "GetReturnType()", n1->GetReturnType(), 'L' );
+
+ xbString s2 = "TestNode2";
+ xbExpNode *n2 = new xbExpNode( s2, XB_EXP_FUNCTION, XB_EXP_CHAR );
+
+ xbString s3 = "TestNode3";
+ xbExpNode *n3 = new xbExpNode( s3, XB_EXP_CONSTANT, XB_EXP_NUMERIC );
+
+ xbString s4 = "TestNode4";
+ xbExpNode *n4 = new xbExpNode( s4, XB_EXP_OPERATOR, XB_EXP_DATE );
+
+ xbString s5 = "TestNode5";
+ xbExpNode *n5 = new xbExpNode( s5, XB_EXP_FIELD, XB_EXP_LOGICAL );
+
+ n1->AddChild( n2 );
+ n1->AddChild( n3 );
+ n1->AddChild( n4 );
+ n1->AddChild( n5 );
+
+ iRc += TestMethod( po, "GetChildCnt()", (xbInt32) n1->GetChildCnt(), 4 );
+
+ n1->SetResult( s1 );
+ iRc += TestMethod( po, "SetResult() / GetStringResult()", s1, n1->GetStringResult(), 9 );
+
+ xbBool bVal = xbTrue;
+ n1->SetResult( bVal );
+ iRc += TestMethod( po, "SetResult() / GetBoolResult()", xbTrue, n1->GetBoolResult() );
+
+ xbDouble d = 123456.789;
+ n1->SetResult( d );
+ iRc += TestMethod( po, "SetResult() / GetNumericResult()", d, n1->GetNumericResult() );
+
+ #ifdef XB_DEBUG_SUPPORT
+ if( po > 0 ){
+ n1->DumpNode( xbTrue );
+ n1->GetChild( 0 )->DumpNode( xbTrue );
+ n1->GetChild( 1 )->DumpNode( xbTrue );
+ n1->GetChild( 2 )->DumpNode( xbTrue );
+ n1->GetChild( 3 )->DumpNode( xbTrue );
+ }
+ #endif
+
+ delete n1;
+
+ if( po > 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], iRc * -1 );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ return iRc;
+}
diff --git a/src/tests/xb_test_expression.cpp b/src/tests/xb_test_expression.cpp
new file mode 100755
index 0000000..e3b47cc
--- /dev/null
+++ b/src/tests/xb_test_expression.cpp
@@ -0,0 +1,791 @@
+/* xb_test_expression.cpp
+
+XBase 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
+
+*/
+
+// This program tests the class xbExp
+// usage: xb_test_expression QUITE|NORMAL|VERBOSE
+
+#include "xbase.h"
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+/**************************************************************************/
+///@cond DOXYOFF
+
+class xbExpTest : public xbExp {
+
+ public:
+ xbExpTest( xbXBase * x );
+ xbInt16 GetNextTokenTest( xbExpToken &t );
+ xbInt16 OperatorWeightTest( const xbString &sOperator );
+ xbExpNode *GetNextNodeTest( xbExpNode * );
+};
+
+/**************************************************************************/
+xbExpTest::xbExpTest( xbXBase * x ) : xbExp( x ){
+}
+/**************************************************************************/
+xbExpNode *xbExpTest::GetNextNodeTest( xbExpNode *n ){
+ return GetNextNode( n );
+}
+/**************************************************************************/
+xbInt16 xbExpTest::GetNextTokenTest( xbExpToken &t ){
+ return GetNextToken( t );
+}
+/**************************************************************************/
+xbInt16 xbExpTest::OperatorWeightTest( const xbString &sOperator ){
+ return OperatorWeight( sOperator );
+}
+///@endcond DOXYOFF
+
+
+/**************************************************************************/
+xbInt16 DevTester( xbXBase * xb, xbDbf * dbf, const char * sExpIn ){
+
+ xbExpTest exp( xb );
+ xbExpNode *n;
+
+ std::cout << "going to parse expression [" << sExpIn << "]\n";
+ xbInt16 iRc = exp.ParseExpression( dbf, sExpIn );
+
+ std::cout << "back from parse expression\n";
+ std::cout << "dump nodes\n";
+ n = exp.GetNextNodeTest( NULL );
+ if( iRc == XB_NO_ERROR ){
+ exp.DumpTree( xbTrue );
+ std::cout << "dump nodes\n";
+ n = exp.GetNextNodeTest( NULL );
+ if( !n ){
+ std::cout << "n is null\n";
+ } else {
+ xbInt16 i = 0;
+ while( n && i < 30 ){
+ std::cout << "Node Text = [" << n->GetStringResult().Str() << "]\n";
+ n = exp.GetNextNodeTest( n );
+ i++;
+ }
+ }
+ std::cout << "end dump nodes\n";
+ return 0;
+ }else{
+ std::cout << "Parse Error [" << iRc << "]\n";
+ return -1;
+ }
+ return 0;
+}
+
+/**************************************************************************/
+xbInt16 TestWeight( xbXBase * xb, xbInt16 iPrintOption, const char * title, const char *sOperator, xbInt16 iExpectedWeight );
+xbInt16 TestWeight( xbXBase * xb, xbInt16 iPrintOption, const char * title, const char *sOperator, xbInt16 iExpectedWeight ){
+
+ xbInt16 iRc = 0;
+ xbExpTest expT1( xb );
+
+ if(( iRc = expT1.OperatorWeightTest( sOperator )) != iExpectedWeight ){
+ std::cout << std::endl << "[FAIL O1] " << title << std::endl;
+ std::cout << " Operator [" << sOperator << "] Weight [" << iRc << "] Expected [" << iExpectedWeight << "]" << std::endl;
+ return -1;
+ }
+
+ if( iPrintOption == 2 )
+ std::cout << "[PASS] " << title << " Expected matches actual Data=[" << sOperator << "][" << iExpectedWeight << "]" << std::endl;
+ else if( iPrintOption == 1 )
+ std::cout << "[PASS] " << title << std::endl;
+
+ return XB_NO_ERROR;
+}
+/**************************************************************************/
+xbInt16 TestTokenMethod( xbXBase *xb, xbInt16 iPrintOption, const char * title, const char *sExpression,
+ const char *sExpectedToken, const char *sExpectedRemainder, char cExpectedNodeType,
+ char cExpectedReturnType, xbInt16 iErc, xbInt16 iTrc );
+
+xbInt16 TestTokenMethod( xbXBase *xb, xbInt16 iPrintOption, const char * title, const char *sExpression,
+ const char *sExpectedToken, const char *sExpectedRemainder, char cExpectedNodeType,
+ char cExpectedReturnType, xbInt16 iErc, xbInt16 iTrc ){
+
+ xbExpTest expT1( xb );
+ xbExpToken t;
+ xbInt16 iRc = XB_NO_ERROR;
+ t.sExpression = sExpression;
+
+ if(( iRc = expT1.GetNextTokenTest( t )) != iErc ){
+ std::cout << std::endl << "[FAIL T1] " << title << std::endl;
+ std::cout << " Expression [" << sExpression << "]" << std::endl;
+ std::cout << " GetNextToken iRc = [" << iRc << "]" << std::endl;
+ return -1;
+ }
+
+ if( iTrc != t.iSts ){
+ std::cout << std::endl << "[FAIL T2] " << title << std::endl;
+ std::cout << " Expression [" << sExpression << "]" << std::endl;
+ std::cout << " GetNextToken Token Return Code = [" << iTrc << "]" << std::endl;
+ return -1;
+ }
+ if( iErc == XB_NO_ERROR && iTrc == XB_NO_ERROR && t.sToken != sExpectedToken ){
+ std::cout << std::endl << "[FAIL T3] " << title << std::endl;
+ std::cout << " Expression " << sExpression << std::endl;
+ std::cout << " Expected Result = [" << sExpectedToken << "] Actual = [" << t.sToken.Str() << "]\n";
+ return -1;
+ }
+ if( iErc == XB_NO_ERROR && iTrc == XB_NO_ERROR && t.sExpression != sExpectedRemainder ){
+ std::cout << std::endl << "[FAIL T4] " << title << std::endl;
+ std::cout << " Expression " << sExpression << std::endl;
+ std::cout << " Expected Remainder = [" << sExpectedRemainder << "] Actual = [" << t.sExpression.Str() << "]\n";
+ return -1;
+ }
+ if( iErc == XB_NO_ERROR && iTrc == XB_NO_ERROR&& t.cNodeType != cExpectedNodeType ){
+ std::cout << std::endl << "[FAIL T5] " << title << std::endl;
+ std::cout << " Expression " << sExpression << std::endl;
+ std::cout << " Expected Node type = [" << cExpectedNodeType << "] Actual = [" << t.cNodeType << "]\n";
+ return -1;
+ }
+ if( iErc == XB_NO_ERROR && iTrc == XB_NO_ERROR&& t.cReturnType != cExpectedReturnType ){
+ std::cout << std::endl << "[FAIL T6] " << title << std::endl;
+ std::cout << " Expression " << sExpression << std::endl;
+ std::cout << " Expected Return type = [" << cExpectedReturnType << "] Actual = [" << t.cReturnType << "]\n";
+ return -1;
+ }
+ if( iPrintOption == 2 ){
+ if( iErc == XB_NO_ERROR )
+ std::cout << "[PASS] " << title << " Expected matches actual Data=[" << sExpectedToken << "]" << std::endl;
+ else
+ std::cout << "[PASS] " << title << " Expected return code matches actual =[" << iErc << "]" << std::endl;
+ } else if( iPrintOption == 1 )
+ std::cout << "[PASS] " << title << std::endl;
+
+ return 0;
+}
+
+/**************************************************************************/
+xbInt16 TestMethod( xbXBase *xb, xbDbf *d, xbInt16 PrintOption, const char * title,
+ const xbString &sExpression, const char * sExpectedResult, xbInt16 iExpectedResultLen );
+
+xbInt16 TestMethod( xbXBase *xb, xbDbf *d, xbInt16 PrintOption, const char * title,
+ const xbString &sExpression, const char * sExpectedResult, xbInt16 iExpectedResultLen ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+ xbString sResult;
+ xbExp exp( xb );
+
+ if(( iRc = exp.ParseExpression( d, sExpression )) != XB_NO_ERROR ){
+ std::cout << std::endl << "[FAIL 1] " << title << std::endl;
+ std::cout << " Return Code = [" << iRc << "]" << std::endl;
+ return -1;
+ }
+ if(( iRc = exp.GetReturnType()) != XB_EXP_CHAR ){
+ std::cout << std::endl << "[FAIL 2] " << title << std::endl;
+ std::cout << " Result type not XB_EXP_CHAR = [" << exp.GetReturnType() << "]" << std::endl;
+ return -1;
+ }
+ if(( iRc = exp.ProcessExpression()) != XB_NO_ERROR ){
+ std::cout << std::endl << "[FAIL 3] " << title << std::endl;
+ std::cout << " Return Code = [" << iRc << "]" << std::endl;
+ return -1;
+ }
+ if(( iRc = exp.GetStringResult( sResult )) != XB_NO_ERROR ){
+ std::cout << std::endl << "[FAIL 4] " << title << std::endl;
+ std::cout << " Return Code = [" << iRc << "]" << std::endl;
+ return -1;
+ }
+ if( sResult != sExpectedResult ){
+ std::cout << std::endl << "[FAIL 5] " << title << std::endl;
+ std::cout << " Expected Result = [" << sExpectedResult << "] Actual Result =[" << sResult.Str() << "]" << std::endl;
+ exp.DumpTree( 1 );
+ return -1;
+ }
+ if( exp.GetResultLen() != iExpectedResultLen ){
+ std::cout << std::endl << "[FAIL 6] " << title << std::endl;
+ std::cout << " Expected Result Len = [" << iExpectedResultLen << "] Actual Result =[" << exp.GetResultLen() << "]" << std::endl;
+ exp.DumpTree( 1 );
+ return -1;
+ }
+ if( PrintOption == 2 )
+ std::cout << "[PASS] " << title << " Expected [" << sExpectedResult << "] matches actual [" << exp.GetResultLen() << "]" << std::endl;
+ else if( PrintOption == 1 )
+ std::cout << "[PASS] " << title << std::endl;
+
+ return 0;
+}
+
+/**************************************************************************/
+xbInt16 TestMethod( xbXBase * xb, xbDbf * d, xbInt16 PrintOption, const char * title,
+ const xbString &sExpression, xbDouble dExpectedResult );
+
+xbInt16 TestMethod( xbXBase * xb, xbDbf * d, xbInt16 PrintOption, const char * title,
+ const xbString &sExpression, xbDouble dExpectedResult ){
+
+ xbDouble dResult;
+ xbInt16 iRc = XB_NO_ERROR;
+ xbExp exp( xb );
+
+ if(( iRc = exp.ParseExpression( d, sExpression )) != XB_NO_ERROR ){
+ std::cout << std::endl << "[FAIL 1] " << title << std::endl;
+ std::cout << " Return Code = [" << iRc << "]" << std::endl;
+ return -1;
+ }
+ if(( iRc = exp.GetReturnType()) != XB_EXP_NUMERIC ){
+ std::cout << std::endl << "[FAIL 2] " << title << std::endl;
+ std::cout << " Result type not XB_EXP_NUMERIC = [" << exp.GetReturnType() << "]" << std::endl;
+ return -1;
+ }
+ if(( iRc = exp.ProcessExpression()) != XB_NO_ERROR ){
+ std::cout << std::endl << "[FAIL 3] " << title << std::endl;
+ std::cout << " Return Code = [" << iRc << "]" << std::endl;
+ return -1;
+ }
+ if(( iRc = exp.GetNumericResult( dResult )) != XB_NO_ERROR ){
+ std::cout << std::endl << "[FAIL 4] " << title << std::endl;
+ std::cout << " Return Code = [" << iRc << "]" << std::endl;
+ return -1;
+ }
+ if( !dblEquals( dResult, dExpectedResult, .01 )){
+ std::cout << std::endl << "[FAIL 5] " << title << std::endl;
+ std::cout << " Expected Result = [" << dExpectedResult << "] Actual Result =[" << dResult << "]" << std::endl;
+ // dump out the tree
+ exp.DumpTree( 1 );
+ return -1;
+ }
+ if( PrintOption == 2 )
+ std::cout << "[PASS] " << title << " Expected [" << dExpectedResult << "] matches actual [" << exp.GetResultLen() << "]" << std::endl;
+ else if( PrintOption == 1 )
+ std::cout << "[PASS] " << title << std::endl;
+ return 0;
+}
+/**************************************************************************/
+xbInt16 TestMethod( xbXBase * xb, xbDbf * d, xbInt16 PrintOption, const char * title,
+ const xbString &sExpression, xbDate dtExpectedResult );
+xbInt16 TestMethod( xbXBase * xb, xbDbf * d, xbInt16 PrintOption, const char * title,
+ const xbString &sExpression, xbDate dtExpectedResult ){
+
+ xbDate dtResult;
+ xbInt16 iRc = XB_NO_ERROR;
+ xbExp exp( xb );
+ if(( iRc = exp.ParseExpression( d, sExpression )) != XB_NO_ERROR ){
+ std::cout << std::endl << "[FAIL 1] " << title << std::endl;
+ std::cout << " Return Code = [" << iRc << "]" << std::endl;
+ return -1;
+ }
+ if(( iRc = exp.GetReturnType()) != XB_EXP_DATE ){
+ std::cout << std::endl << "[FAIL 2] " << title << std::endl;
+ std::cout << " Result type not XB_EXP_DATE = [" << exp.GetReturnType() << "]" << std::endl;
+ return -1;
+ }
+ if(( iRc = exp.ProcessExpression()) != XB_NO_ERROR ){
+ std::cout << std::endl << "[FAIL 3] " << title << std::endl;
+ std::cout << " Return Code = [" << iRc << "]" << std::endl;
+ return -1;
+ }
+ if(( iRc = exp.GetDateResult( dtResult )) != XB_NO_ERROR ){
+ std::cout << std::endl << "[FAIL 4] " << title << std::endl;
+ std::cout << " Return Code = [" << iRc << "]" << std::endl;
+ return -1;
+ }
+ if( dtResult != dtExpectedResult ){
+ std::cout << std::endl << "[FAIL 5] " << title << std::endl;
+ std::cout << " Expected Result = [" << dtExpectedResult.Str() << "] Actual Result =[" << dtResult.Str() << "]" << std::endl;
+ // dump out the tree
+ exp.DumpTree( 1 );
+ return -1;
+ }
+ if( PrintOption == 2 )
+ std::cout << "[PASS] " << title << " Expected [" << dtExpectedResult.Str() << "] matches actual [" << exp.GetResultLen() << "]" << std::endl;
+ else if( PrintOption == 1 )
+ std::cout << "[PASS] " << title << std::endl;
+
+ return 0;
+}
+/**************************************************************************/
+xbInt16 TestMethod( xbXBase * xb, xbDbf * d, xbInt16 PrintOption, const char * title,
+ const xbString &sExpression, xbBool bExpectedResult );
+xbInt16 TestMethod( xbXBase * xb, xbDbf * d, xbInt16 PrintOption, const char * title,
+ const xbString &sExpression, xbBool bExpectedResult ){
+
+ xbInt16 iRc = XB_NO_ERROR;
+
+ xbBool bResult;
+ xbExp exp( xb );
+ if(( iRc = exp.ParseExpression( d, sExpression )) != XB_NO_ERROR ){
+ std::cout << std::endl << "[FAIL 1] " << title << std::endl;
+ std::cout << " Return Code = [" << iRc << "]" << std::endl;
+ return -1;
+ }
+ if(( iRc = exp.GetReturnType()) != XB_EXP_LOGICAL ){
+ std::cout << std::endl << "[FAIL 2] " << title << std::endl;
+ std::cout << " Result type not XB_EXP_LOGICAL = [" << exp.GetReturnType() << "]" << std::endl;
+ return -1;
+ }
+ if(( iRc = exp.ProcessExpression()) != XB_NO_ERROR ){
+ std::cout << std::endl << "[FAIL 3] " << title << std::endl;
+ std::cout << " Return Code = [" << iRc << "]" << std::endl;
+ return -1;
+ }
+ if(( iRc = exp.GetBoolResult( bResult )) != XB_NO_ERROR ){
+ std::cout << std::endl << "[FAIL 4] " << title << std::endl;
+ std::cout << " Return Code = [" << iRc << "]" << std::endl;
+ return -1;
+ }
+ if( bResult != bExpectedResult ){
+ std::cout << std::endl << "[FAIL 5] " << title << std::endl;
+ std::cout << " Expected Result = [" << bExpectedResult << "] Actual Result =[" << bResult << "]" << std::endl;
+ // dump out the tree
+ exp.DumpTree( 1 );
+ return -1;
+ }
+ if( PrintOption == 2 )
+ std::cout << "[PASS] " << title << " Expected [" << bExpectedResult << "] matches actual [" << bResult << "]" << std::endl;
+ else if( PrintOption == 1 )
+ std::cout << "[PASS] " << title << std::endl;
+ return 0;
+}
+/**************************************************************************/
+int main( int argCnt, char **av )
+{
+ xbInt16 iRc = 0;
+ xbInt16 rc2 = 0;
+ xbInt16 po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+ xbSchema MyRecord[] =
+ {
+ { "CHAR1", XB_CHAR_FLD, 5, 0 },
+ { "CHAR2", XB_CHAR_FLD, 7, 0 },
+ { "DATE1", XB_DATE_FLD, 8, 0 },
+ { "DATE2", XB_DATE_FLD, 8, 0 },
+ { "NUM1", XB_NUMERIC_FLD, 9, 2 },
+ { "",0,0,0 }
+ };
+
+ xbXBase x;
+ xbDbf * MyFile;
+ xbDate d;
+
+ #ifdef XB_LOGGING_SUPPORT
+ x.EnableMsgLogging();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+ InitTime();
+
+ if( po > 0 ){
+ std::cout << "XBase Expression testing program.." << std::endl;
+ std::cout << "This program tests the XBase expression logic." << std::endl;
+ std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+ }
+
+// return 0;
+
+ #ifdef XB_DBF4_SUPPORT
+ MyFile = new xbDbf4( &x ); /* version 4 dbf file */
+ #else
+ MyFile = new xbDbf3( &x ); /* version 3 dbf file */
+ #endif
+
+
+
+// return 0;
+
+ rc2 = MyFile->CreateTable( "ExpTest.DBF", "ExpTest", MyRecord, XB_OVERLAY, XB_MULTI_USER );
+
+// return 0;
+
+ iRc += TestMethod( po, "CreateTable()", rc2, XB_NO_ERROR );
+ iRc += TestMethod( po, "PutField()", MyFile->PutField( "CHAR1", "TEST" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutField()", MyFile->PutField( "CHAR2", "TEST7B" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutField()", MyFile->PutFloatField( "NUM1", 5 ), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutField()", MyFile->PutField( "DATE1", "19890303" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutField()", MyFile->PutField ( "DATE2", "20120708" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "AppendRecord()", MyFile->AppendRecord(), XB_NO_ERROR );
+
+
+// return 0;
+
+
+ iRc += TestTokenMethod( &x, po, "EOX Test1", "", "", "", '?', XB_EXP_UNKNOWN, XB_NO_ERROR, XB_END_OF_EXPRESSION );
+ iRc += TestTokenMethod( &x, po, "EOX Test2 ", " ", "", "", '?', XB_EXP_UNKNOWN, XB_NO_ERROR, XB_END_OF_EXPRESSION );
+ iRc += TestTokenMethod( &x, po, "Paren Test1 ", "(SOMETOKEN)+5-100", "SOMETOKEN", "+5-100", XB_EXP_NOTROOT, XB_EXP_UNKNOWN, XB_NO_ERROR , XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Paren Test2 ", "{ANOTHERTOKEN} + 55-100", "ANOTHERTOKEN", " + 55-100", XB_EXP_NOTROOT, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Paren Test3 ", "{{NESTED}TOKEN} + 55-100", "{NESTED}TOKEN", " + 55-100", XB_EXP_NOTROOT, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+
+ // next line generates log message
+ iRc += TestTokenMethod( &x, po, "Paren Test4 ", "{{NESTED}TOKEN + 55-100", "{NESTED}TOKEN", " + 55-100", XB_EXP_NOTROOT, XB_EXP_UNKNOWN, XB_PARSE_ERROR, XB_UNBALANCED_PARENS );
+ iRc += TestTokenMethod( &x, po, "Paren Test5 ", " (SOMETOKEN )+5-100", "SOMETOKEN ", "+5-100", XB_EXP_NOTROOT, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Quote Test1 ", "\"SOMETOKEN\"+5-100", "SOMETOKEN", "+5-100", XB_EXP_CONSTANT, XB_EXP_CHAR, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Quote Test2 ", "'SOMETOKEN2'", "SOMETOKEN2", "", XB_EXP_CONSTANT, XB_EXP_CHAR, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Quote Test3 ", " 'SOMETOKEN3 '", "SOMETOKEN3 ", "", XB_EXP_CONSTANT, XB_EXP_CHAR, XB_NO_ERROR, XB_NO_ERROR );
+
+
+
+ // next line generates log message
+
+ iRc += TestTokenMethod( &x, po, "Quote Test3 ", " 'SOMETOKEN4 ", "SOMETOKEN3 ", "", XB_EXP_CONSTANT, XB_EXP_CHAR, XB_PARSE_ERROR, XB_UNBALANCED_QUOTES );
+
+
+ iRc += TestTokenMethod( &x, po, "Logical Constant1 ", ".T.", "T", "", XB_EXP_CONSTANT, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Logical Constant2 ", ".F.", "F", "", XB_EXP_CONSTANT, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Logical Constant3 ", ".TRUE.", "T", "", XB_EXP_CONSTANT, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Logical Constant4 ", ".FALSE.", "F", "", XB_EXP_CONSTANT, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Logical Constant5 ", ".T. and x", "T", " and x", XB_EXP_CONSTANT, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Numeric Constant1 ", "123", "123", "", XB_EXP_CONSTANT, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+
+
+
+ iRc += TestTokenMethod( &x, po, "Numeric Constant2 ", "-123", "-123", "", XB_EXP_CONSTANT, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Numeric Constant3 ", " - 123", "-123", "", XB_EXP_CONSTANT, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Numeric Constant4 ", " - .456", "-.456", "", XB_EXP_CONSTANT, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Numeric Constant5 ", " -.002", "-.002", "", XB_EXP_CONSTANT, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Numeric Constant6 ", " - .002 + 1", "-.002", " + 1", XB_EXP_CONSTANT, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 1", "-", "-", "", XB_EXP_OPERATOR, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 2", "+", "+", "", XB_EXP_OPERATOR, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 3", "*", "*", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 4", "/", "/", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 5", "^", "^", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 6", "%", "%", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 7", "=", "=", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 8", "<", "<", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 9", ">", ">", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 10", "$", "$", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 11", "**", "**", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 12", "++", "++", "", XB_EXP_POST_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 13", "--", "--", "", XB_EXP_POST_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 14", "-- ", "--", " ", XB_EXP_POST_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 15", "--X", "--", "X", XB_EXP_PRE_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 16", "++X", "++", "X", XB_EXP_PRE_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 17", "+=", "+=", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 18", "-=", "-=", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 19", "*=", "*=", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 20", "/=", "/=", "", XB_EXP_OPERATOR, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 21", "<>", "<>", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 22", "<=", "<=", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 23", ">=", ">=", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 24", ">= grapes", ">=", " grapes", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 25", "< apples ", "<", " apples ", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 26", ".NOT.", ".NOT.", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 27", ".AND.", ".AND.", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Operator 28", ".OR.", ".OR.", "", XB_EXP_OPERATOR, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+
+ iRc += TestTokenMethod( &x, po, "Function 1", "STOD ( \"08252017\" )", "STOD ( \"08252017\" )", "", XB_EXP_FUNCTION, XB_EXP_DATE, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Function 2", "STR( 8 )", "STR( 8 )", "", XB_EXP_FUNCTION, XB_EXP_CHAR, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Function 3", "STR( (8-3)+3 )", "STR( (8-3)+3 )", "", XB_EXP_FUNCTION, XB_EXP_CHAR, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Function 4", "STR( (8-3)+3 ) + \"A\"", "STR( (8-3)+3 )", " + \"A\"", XB_EXP_FUNCTION, XB_EXP_CHAR, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Function 5", "ISALPHA( \"A\" )", "ISALPHA( \"A\" )", "", XB_EXP_FUNCTION, XB_EXP_LOGICAL, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Function 6", "EXP( 6 )", "EXP( 6 )", "", XB_EXP_FUNCTION, XB_EXP_NUMERIC, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Field 1", "NUM1", "NUM1", "", XB_EXP_FIELD, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Field 2", "NUM1 + X", "NUM1", " + X", XB_EXP_FIELD, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Field 3", "ExpTest->NUM1", "ExpTest->NUM1", "", XB_EXP_FIELD, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Field 4", "ExpTest ->NUM1", "ExpTest ->NUM1", "", XB_EXP_FIELD, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Field 5", "ExpTest -> NUM1", "ExpTest -> NUM1", "", XB_EXP_FIELD, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+ iRc += TestTokenMethod( &x, po, "Field 6", "ExpTest -> NUM1+1", "ExpTest -> NUM1", "+1", XB_EXP_FIELD, XB_EXP_UNKNOWN, XB_NO_ERROR, XB_NO_ERROR );
+
+ iRc += TestWeight( &x, po, "Weight Test", "", 0 );
+ iRc += TestWeight( &x, po, "Weight Test", "toobig", 0 );
+ iRc += TestWeight( &x, po, ".OR. Weight Test", ".OR.", 1 );
+ iRc += TestWeight( &x, po, ".AND. Weight Test", ".AND.", 2 );
+ iRc += TestWeight( &x, po, ".NOT. Weight Test", ".NOT.", 3 );
+ iRc += TestWeight( &x, po, "> Weight Test", ">", 4 );
+ iRc += TestWeight( &x, po, ">= Weight Test", ">=", 4 );
+ iRc += TestWeight( &x, po, "< Weight Test", "<", 4 );
+ iRc += TestWeight( &x, po, "<= Weight Test", "<=", 4 );
+ iRc += TestWeight( &x, po, "<> Weight Test", "<>", 4 );
+ iRc += TestWeight( &x, po, "# Weight Test", "#", 4 );
+ iRc += TestWeight( &x, po, "$ Weight Test", "$", 4 );
+ iRc += TestWeight( &x, po, "= Weight Test", "=", 4 );
+ iRc += TestWeight( &x, po, "-- Prefix decrement Weight Test", "--0", 9 );
+ iRc += TestWeight( &x, po, "++ Prefix increment Weight Test", "++0", 9 );
+ iRc += TestWeight( &x, po, "** Weight Test", "**", 8 );
+ iRc += TestWeight( &x, po, "^ Weight Test", "^", 8 );
+ iRc += TestWeight( &x, po, "* Weight Test", "*", 7 );
+ iRc += TestWeight( &x, po, "* Weight Test", "/", 7 );
+ iRc += TestWeight( &x, po, "* Weight Test", "%", 7 );
+ iRc += TestWeight( &x, po, "* Weight Test", "*=", 7 );
+ iRc += TestWeight( &x, po, "* Weight Test", "/=", 7 );
+ iRc += TestWeight( &x, po, "+ Weight Test", "+", 6 );
+ iRc += TestWeight( &x, po, "- Weight Test", "-", 6 );
+ iRc += TestWeight( &x, po, "+= Weight Test", "+=", 6 );
+ iRc += TestWeight( &x, po, "-= Weight Test", "-=", 6 );
+ iRc += TestWeight( &x, po, "-- Postfix decrement Weight Test", "--1", 5 );
+ iRc += TestWeight( &x, po, "++ Postfix increment Weight Test", "++1", 5 );
+
+ iRc += TestMethod( &x, MyFile, po, "CharTest1", "CHAR1", "TEST ", 5 );
+ iRc += TestMethod( &x, MyFile, po, "CharTest2", "ExpTest->CHAR1", "TEST ", 5 );
+ iRc += TestMethod( &x, MyFile, po, "CharTest3", "ExpTest->CHAR1+CHAR1", "TEST TEST ", 10 );
+ iRc += TestMethod( &x, MyFile, po, "CharTest4", "\"PRE_ \"+\" _POST\"", "PRE_ _POST", 11 );
+ iRc += TestMethod( &x, MyFile, po, "CharTest5", "\"PRE_ \"-\" _POST\"", "PRE_ _POST ", 11 );
+ iRc += TestMethod( &x, MyFile, po, "CharTest6", "\"PRE_\"+ExpTest->CHAR1+\"_POST\"", "PRE_TEST _POST", 14 );
+ iRc += TestMethod( &x, MyFile, po, "CharTest7", "STR(123)", " 123", 10 );
+ iRc += TestMethod( &x, MyFile, po, "CharTest8", "STR(123)+LTRIM(STR(456))", " 123456", 20 );
+ iRc += TestMethod( &x, MyFile, po, "CharTest9", "STR(8)+STR(7)", " 8 7", 20 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest1", "ALLTRIM( \" ABCD \" )", "ABCD", 11 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest2", "CDOW( STOD( \"20171014\" ))", "Saturday", 9 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest3", "CHR( 66 )", "B", 1 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest4", "CMONTH( STOD( \"20171114\" ) )", "November", 9 );
+
+ // next line causes MAC compiler to cough up a furball
+ //iRc += TestMethod( &x, MyFile, po, "FuncTest5", "DESCEND( \"ABCDE\" )", "¾½¼»º", 5 );
+
+ char sDescendResult[6]; // = "¾½¼»º";
+ sDescendResult[0] = (char) 0xBE;
+ sDescendResult[1] = (char) 0xBD;
+ sDescendResult[2] = (char) 0xBC;
+ sDescendResult[3] = (char) 0xBB;
+ sDescendResult[4] = (char) 0xBA;
+ sDescendResult[5] = (char) 0x00;
+ iRc += TestMethod( &x, MyFile, po, "FuncTest5", "DESCEND( \"ABCDE\" )", sDescendResult, 5 );
+
+ iRc += TestMethod( &x, MyFile, po, "FuncTest6", "DTOC( STOD( \"20171114\" ))", "11/14/17", 8 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest7", "DTOS( STOD( \"20171114\" ))", "20171114", 8 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest8", "LEFT( \"ABCDEFGH\", 5 )", "ABCDE", 5 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest9", "LOWER( \"ABCDEFGH\" )", "abcdefgh", 8 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest10", "LTRIM( \" ABC\" )", "ABC", 6 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest11", "REPLICATE( \"ABC\", 3 )", "ABCABCABC", 9 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest12", "RIGHT( \"ABCDEFGH\", 5 )", "DEFGH", 5 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest13", "RTRIM( \"ABCD \" )", "ABCD", 7 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest14", "SPACE( 5 )", " ", 5 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest15", "STR( 8 )", " 8", 10 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest16", "STR( 3, 4 )", " 3", 4 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest17", "STR( 12.7, 5, 2 )", "12.70", 5 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest18", "STR( 43.17, 9, 4, \"0\" )", "0043.1700", 9 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest19", "STRZERO( 56.21, 9, 4 )", "0056.2100", 9 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest20", "SUBSTR( \"SOMESTRING\", 3, 5 )", "MESTR", 5 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest21", "TRIM( \" abc123 \" )", " abc123", 12 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest22", "UPPER( \"abc123RRR\" )", "ABC123RRR", 9 );
+
+ // numeric logic tests
+ iRc += TestMethod( &x, MyFile, po, "NumericTest1", "1 + 1", (xbDouble) 2 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest2", "6 - 1", (xbDouble) 5 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest3", "6 * 4", (xbDouble) 24 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest4", "8 / 2", (xbDouble) 4 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest5", "3 ^ 3", (xbDouble) 27 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest6", "4 ** 4", (xbDouble) 256 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest7", "NUM1", (xbDouble) 5 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest8", "NUM1 + 2.3", (xbDouble) 7.3 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest9", "++NUM1", (xbDouble) 6 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest10", "NUM1++", (xbDouble) 5 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest11", "--NUM1", (xbDouble) 4 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest12", "NUM1--", (xbDouble) 5 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest13", "3++", (xbDouble) 3 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest14", "++3", (xbDouble) 4 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest15", "4--", (xbDouble) 4 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest16", "--4", (xbDouble) 3 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest17", "3 += 12", (xbDouble) 15 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest18", "3 -= 12", (xbDouble) -9 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest19", "3 *= 12", (xbDouble) 36 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest20", "12 /= 3", (xbDouble) 4 );
+ iRc += TestMethod( &x, MyFile, po, "NumericTest21", "(12+3)*(15-13)", (xbDouble) 30 );
+
+ // numeric functions
+ iRc += TestMethod( &x, MyFile, po, "FuncTest23", "ABS( -22 )", (xbDouble) 22 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest24", "ABS( 23 )", (xbDouble) 23 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest25", "ASC( \"A\" )", (xbDouble) 65 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest26", "AT( \",\", \"Booth, Joseph\" )", (xbDouble) 6 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest27", "DAY( STOD( \"20171017\" ))", (xbDouble) 17 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest28", "DESCEND( 1991 )", (xbDouble) -1991 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest29", "DOW( STOD( \"20171017\" ) )", (xbDouble) 3 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest30", "DOW( STOD( \"20171021\" ) )", (xbDouble) 0 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest31", "EXP( 0 )", (xbDouble) 1 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest32", "INT( 123.45 )", (xbDouble) 123 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest33", "LEN( \"ABC123\" )", (xbDouble) 6 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest34", "LOG( 10 )", (xbDouble) 2.3 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest35", "MAX( 10, 20 )", (xbDouble) 20 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest36", "MIN( 10, 20 )", (xbDouble) 10 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest37", "MONTH( STOD( \"20171017\" ))", (xbDouble) 10 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest38", "RECCOUNT()", (xbDouble) 1 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest39", "RECNO()", (xbDouble) 1 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest40", "SQRT( 9 )", (xbDouble) 3 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest41", "VAL( \"89\" )", (xbDouble) 89 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest42", "VAL( \"22.13 and some text\" )", (xbDouble) 22.13 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest43", "YEAR( STOD( \"20171017\" ))", (xbDouble) 2017 );
+
+ // date logic tests
+ xbDate dtTest1( "19890303" );
+ xbDate dtTest2( "20120708" );
+ iRc += TestMethod( &x, MyFile, po, "DateTest1", "ExpTest->DATE1", dtTest1 );
+ iRc += TestMethod( &x, MyFile, po, "DateTest2", "DATE1", dtTest1 );
+ iRc += TestMethod( &x, MyFile, po, "DateTest3", "ExpTest->DATE2", dtTest2 );
+ iRc += TestMethod( &x, MyFile, po, "DateTest4", "DATE2", dtTest2 );
+ iRc += TestMethod( &x, MyFile, po, "DateTest5", "DATE2 - DATE1", (xbDouble) 8528 );
+
+ dtTest1.Set( "20120705" );
+ iRc += TestMethod( &x, MyFile, po, "DateTest6", "DATE2 - 3", dtTest1 );
+ iRc += TestMethod( &x, MyFile, po, "DateTest7", "DATE2 -= 3", dtTest1 );
+
+ dtTest1.Set( "20120718" );
+ iRc += TestMethod( &x, MyFile, po, "DateTest8", "DATE2 + 10", dtTest1 );
+ iRc += TestMethod( &x, MyFile, po, "DateTest9", "DATE2 += 10", dtTest1 );
+
+ dtTest1.Set( "20120709" );
+ iRc += TestMethod( &x, MyFile, po, "DateTest10", "++DATE2", dtTest1 );
+ dtTest1.Set( "20120707" );
+ iRc += TestMethod( &x, MyFile, po, "DateTest11", "--DATE2", dtTest1 );
+
+ dtTest1.Set( "20120708" );
+ iRc += TestMethod( &x, MyFile, po, "DateTest12", "DATE2++", dtTest1 );
+ iRc += TestMethod( &x, MyFile, po, "DateTest13", "DATE2--", dtTest1 );
+
+ iRc += TestMethod( &x, MyFile, po, "DateTest14", "{07/08/12}", dtTest1 );
+ iRc += TestMethod( &x, MyFile, po, "DateTest15", "{07/08/2012}", dtTest1 );
+
+ iRc += TestMethod( &x, MyFile, po, "DateTest16", "{07/11/12} -3", dtTest1 );
+ iRc += TestMethod( &x, MyFile, po, "DateTest17", "{07/06/2012} + 2", dtTest1 );
+
+ iRc += TestMethod( &x, MyFile, po, "FuncTest44", "CTOD( \"07\\08\\12\" )", dtTest1 );
+
+ xbDate dtToday;
+ iRc += TestMethod( &x, MyFile, po, "FuncTest45", "DATE()", dtToday );
+
+ dtTest2 = "28870625";
+ iRc += TestMethod( &x, MyFile, po, "FuncTest46", "DESCEND( DATE2 )", dtTest2 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest47", "STOD( \"20120708\" )", dtTest1 );
+
+ // boolean logic tests
+ iRc += TestMethod( &x, MyFile, po, "LogicTest1", "3=5", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest2", "5=5", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest3", "\"abc\"=\"def\"", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest4", "\"abc\"=\"abc\"", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest5", "CTOD( \"07\\08\\12\" ) = CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest6", "CTOD( \"07\\09\\12\" ) = CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest7", "3<>5", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest8", "5<>5", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest9", "3!=5", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest10", "5!=5", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest11", "3 # 5", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest12", "5#5", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest13", "\"3\"<>\"5\"", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest14", "\"5\"<>\"5\"", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest15", "\"3\"!=\"5\"", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest16", "\"5\"!=\"5\"", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest17", "\"3\" # \"5\"", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest18", "\"5\"#\"5\"", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest19", "CTOD( \"07\\08\\12\" ) <> CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest20", "CTOD( \"07\\09\\12\" ) <> CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest21", "CTOD( \"07\\08\\12\" ) != CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest22", "CTOD( \"07\\09\\12\" ) != CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest23", "CTOD( \"07\\08\\12\" ) # CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest24", "CTOD( \"07\\09\\12\" ) # CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest25", "3<5", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest26", "5<5", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest27", "5<4", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest28", "\"a\"<\"b\"", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest29", "\"a\"<\"a\"", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest30", "\"c\"<\"b\"", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest31", "CTOD( \"07\\07\\12\" ) < CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest32", "CTOD( \"07\\08\\12\" ) < CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest33", "CTOD( \"07\\09\\12\" ) < CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest34", "3>5", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest35", "5>5", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest36", "5>4", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest37", "\"a\">\"b\"", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest38", "\"a\">\"a\"", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest39", "\"c\">\"b\"", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest40", "CTOD( \"07\\07\\12\" ) > CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest41", "CTOD( \"07\\08\\12\" ) > CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest42", "CTOD( \"07\\09\\12\" ) > CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest43", "3<=5", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest44", "5<=5", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest45", "5<=4", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest46", "\"a\"<=\"b\"", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest47", "\"a\"<=\"a\"", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest48", "\"c\"<=\"b\"", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest49", "CTOD( \"07\\07\\12\" ) <= CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest50", "CTOD( \"07\\08\\12\" ) <= CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest51", "CTOD( \"07\\09\\12\" ) <= CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest52", "3>=5", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest53", "5>=5", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest54", "5>=4", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest55", "\"a\">=\"b\"", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest56", "\"a\">=\"a\"", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest57", "\"c\">=\"b\"", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest58", "CTOD( \"07\\07\\12\" ) >= CTOD ( \"07\\08\\12\" )", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest59", "CTOD( \"07\\08\\12\" ) >= CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest60", "CTOD( \"07\\09\\12\" ) >= CTOD ( \"07\\08\\12\" )", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest61", "\"abc123\" $ \"abc\"", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest62", "\"abc\" $ \"abc123\"", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest63", "\"abc\" $ \"zzabc123\"", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest64", ".T.", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest65", ".F.", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest66", ".TRUE.", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest67", ".FALSE.", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest68", ".NOT. .F.", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest69", " NOT .F.", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest70", ".NOT. .T.", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest71", " NOT .T.", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest72", ".T. .AND. .T.", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest73", ".T. AND .T.", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest74", ".T. .AND. .NOT. .T.", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest75", ".T. AND NOT .T.", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest76", ".NOT. .T. .AND. .T.", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest77", " NOT .T. AND .T.", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest78", ".NOT. .T. .AND. .NOT. .T.", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest79", " NOT .T. AND NOT .T.", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest80", ".T. .OR. .T.", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest81", ".T. OR .T.", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest82", ".T. .OR. .NOT. .T.", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest83", ".T. OR NOT .T.", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest84", ".NOT. .T. .OR. .T.", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest85", " NOT .T. OR .T.", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest86", ".NOT. .T. .OR. .NOT. .T.", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "LogicTest87", " NOT .T. OR NOT .T.", (xbBool) xbFalse );
+
+ iRc += TestMethod( &x, MyFile, po, "FuncTest48", "ISALPHA( \"12345\" )", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest49", "ISALPHA( \"ABCDEF\" )", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest50", "ISALPHA( \"A1234\" )", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest51", "ISLOWER( \"12345\" )", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest52", "ISLOWER( \"ABCDEF\" )", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest53", "ISLOWER( \"abc123\" )", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest54", "ISLOWER( \"xyz\" )", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest55", "ISUPPER( \"12345\" )", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest56", "ISUPPER( \"ABCDEF\" )", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest57", "ISUPPER( \"abc123\" )", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest58", "ISUPPER( \"xyz\" )", (xbBool) xbFalse );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest59", "ISUPPER( \"Xyz\" )", (xbBool) xbTrue );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest60", "IIF( .T., \"TRUE \", \"FALSE\" )", "TRUE ", 5 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest61", "IIF( .F., \"TRUE \", \"FALSE\" )", "FALSE", 5 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest62", "DEL()", " ", 1 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest63", "DELETED()", (xbBool) xbFalse );
+ iRc += TestMethod( po, "DeleteRecord()", MyFile->DeleteRecord(), XB_NO_ERROR );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest64", "DEL()", "*", 1 );
+ iRc += TestMethod( &x, MyFile, po, "FuncTest65", "DELETED()", (xbBool) xbTrue );
+ iRc += TestMethod( po, "UndeleteRecord()", MyFile->UndeleteRecord(), XB_NO_ERROR );
+
+
+ iRc += TestMethod( po, "Close()", MyFile->Close(), XB_NO_ERROR );
+ delete MyFile;
+
+ if( po > 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], iRc * -1 );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ return iRc;
+}
diff --git a/src/tests/xb_test_file.cpp b/src/tests/xb_test_file.cpp
new file mode 100755
index 0000000..ca32693
--- /dev/null
+++ b/src/tests/xb_test_file.cpp
@@ -0,0 +1,212 @@
+/* xb_test_file.cpp
+
+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
+
+*/
+
+// This program tests the file functions
+
+// usage: xb_test_file QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+
+using namespace xb;
+
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+ int rc = 0;
+ int po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+#ifdef XB_LOGGING_SUPPORT
+ xbXBase x;
+ x.EnableMsgLogging();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ InitTime();
+ xbFile f( &x );
+ xbString sWrkStr;
+ xbString sWrkStr2;
+ sWrkStr = PROJECT_DATA_DIR;
+ f.SetDataDirectory( PROJECT_DATA_DIR );
+
+ #ifdef WIN32
+ sWrkStr.SwapChars( '/', '\\' );
+ #else
+ sWrkStr.SwapChars( '\\', '/' );
+ #endif
+
+ rc += TestMethod( po, "Set/GetDataDirectory()", f.GetDataDirectory(), sWrkStr, sWrkStr.Len());
+
+ f.SetFileName( "TestFile.txt" );
+ sWrkStr = "TestFile.txt";
+ rc += TestMethod( po, "Set/GetFileName()", f.GetFileName(), sWrkStr, sWrkStr.Len());
+
+ f.GetFileType( sWrkStr );
+ rc += TestMethod( po, "GetFileType()", sWrkStr, "TXT", 3 );
+
+ #ifdef WIN32
+ sWrkStr = "\\my\\directory\\";
+ #else
+ sWrkStr = "/my/directory/";
+ #endif
+
+ f.SetDirectory( sWrkStr );
+ rc += TestMethod( po, "Set/GetDirectory()", f.GetDirectory(), sWrkStr, sWrkStr.Len());
+
+ sWrkStr += "TestFile.txt";
+ rc += TestMethod( po, "GetFqFileName()", f.GetFqFileName(), sWrkStr, 26 );
+
+#ifdef WIN32
+ sWrkStr = "\\some\\directory\\myfile.dat";
+ sWrkStr2 = "\\some\\directory\\";
+#else
+ sWrkStr = "/some/directory/myfile.dat";
+ sWrkStr2 = "/some/directory/";
+#endif
+
+
+ f.SetFqFileName( sWrkStr );
+ rc += TestMethod( po, "GetDirectory()", f.GetDirectory(), sWrkStr2, 16 );
+ rc += TestMethod( po, "GetFileName()", f.GetFileName(), "myfile.dat", 10 );
+
+ rc += TestMethod( po, "NameSuffixMissing()", f.NameSuffixMissing( "myfile.dbf", 1 ), 0 );
+ rc += TestMethod( po, "NameSuffixMissing()", f.NameSuffixMissing( "myfile", 1 ), 1 );
+ rc += TestMethod( po, "NameSuffixMissing()", f.NameSuffixMissing( "MYFILE", 1 ), 2 );
+
+ f.SetDirectory( PROJECT_DATA_DIR );
+ f.SetFileName( "xbfile.txt" );
+
+ rc += TestMethod( po, "xbFopen()", f.xbFopen( "w+b", XB_MULTI_USER ), XB_NO_ERROR );
+
+
+ xbString sTest;
+ sTest = "Test Data";
+ rc += TestMethod( po, "xbWrite()", f.xbFwrite( sTest.Str(), 9, 1 ), XB_NO_ERROR );
+ rc += TestMethod( po, "xbFclose()", f.xbFclose(), XB_NO_ERROR );
+
+ rc += TestMethod( po, "xbFopen()", f.xbFopen( "r+b", XB_MULTI_USER ), XB_NO_ERROR );
+ rc += TestMethod( po, "xbFseek()", f.xbFseek( 0, SEEK_SET ), XB_NO_ERROR );
+ char buf[10];
+ for( int i = 0; i < 10; i++ )
+ buf[i] = 0x00;
+ rc += TestMethod( po, "xbFread()", f.xbFread( buf, 5, 1 ), XB_NO_ERROR );
+ rc += TestMethod( po, "xbFread()", buf, "Test ", 5 );
+
+ rc += TestMethod( po, "xbFclose()", f.xbFclose(), XB_NO_ERROR );
+ rc += TestMethod( po, "xbRemove()", f.xbRemove(), XB_NO_ERROR );
+ xbInt16 iWork = 100;
+ char cBuf[9];
+ char *p = cBuf;
+ f.ePutInt16( cBuf, iWork );
+ rc += TestMethod( po, "Put/GetShort()", f.eGetInt16( p ), 100 );
+
+ xbInt32 lWork = 10101;
+ f.ePutInt32( p, lWork );
+ rc += TestMethod( po, "Put/GetLong()", f.eGetInt32( p ), 10101 );
+
+ lWork = 2147483647;
+ f.ePutInt32( p, lWork );
+ rc += TestMethod( po, "Put/GetLong()", f.eGetInt32( p ), 2147483647 );
+ rc += TestMethod( po, "Put/GetLong()", (xbInt32) f.eGetUInt32( p ), 2147483647 );
+
+ xbDouble d = 123456.789;
+ f.ePutDouble( p, d );
+ rc += TestMethod( po, "Put/GetDouble()", f.eGetDouble( p ), 123456.789 );
+
+ xbString sFqnS;
+ xbString sFqnT;
+ xbFile f2( &x );
+ rc += TestMethod( po, "CreateUniqueFileName()", f2.CreateUniqueFileName( PROJECT_DATA_DIR, "dbf", sFqnS ), XB_NO_ERROR );
+
+ rc += TestMethod( po, "FileExists()", f2.FileExists( sFqnS ), xbFalse );
+ rc += TestMethod( po, "xbFopen()", f2.xbFopen( "w+b", sFqnS, XB_SINGLE_USER ), XB_NO_ERROR );
+ rc += TestMethod( po, "xbFclose()", f2.xbFclose(), XB_NO_ERROR );
+ rc += TestMethod( po, "FileExists()", f2.FileExists( sFqnS ), xbTrue );
+
+ rc += TestMethod( po, "CreateUniqueFileName()", f2.CreateUniqueFileName( PROJECT_DATA_DIR, "dbf", sFqnT ), XB_NO_ERROR );
+ rc += TestMethod( po, "xbRename()", f2.xbRename( sFqnS, sFqnT ), XB_NO_ERROR );
+ rc += TestMethod( po, "xbRemove()", f.xbRemove( sFqnT ), XB_NO_ERROR );
+
+ xbString sFn;
+ rc += TestMethod( po, "GetFileNamePart()", f2.GetFileNamePart( sFqnS , sFn ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetFileExtPart()", f2.GetFileExtPart( sFqnS , sFn ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetFileExtPart()", f2.GetFileDirPart( sFqnS , sFn ), XB_NO_ERROR );
+
+
+ rc += TestMethod( po, "SetBlockSize()", f.SetBlockSize( 100 ), XB_INVALID_BLOCK_SIZE );
+ rc += TestMethod( po, "SetBlockSize()", f.SetBlockSize( 512 ), XB_NO_ERROR );
+ rc += TestMethod( po, "GetBlockSize()", (xbInt32) f.GetBlockSize(), 512 );
+
+
+ char BlockBuf[513];
+ memset( BlockBuf, 0x00, 513 );
+ rc += TestMethod( po, "xbFopen()", f.xbFopen( "w+b", XB_SINGLE_USER ), XB_NO_ERROR );
+
+ for( int i = 0; i < 512; i++ )
+ BlockBuf[i] = 'A';
+ rc += TestMethod( po, "WriteBlock()", f.WriteBlock( 0L, 512, BlockBuf ), XB_NO_ERROR );
+
+ for( int i = 0; i < 512; i++ )
+ BlockBuf[i] = 'B';
+ rc += TestMethod( po, "WriteBlock()", f.WriteBlock( 1L, 512, BlockBuf ), XB_NO_ERROR );
+
+ for( int i = 0; i < 512; i++ )
+ BlockBuf[i] = 'C';
+ rc += TestMethod( po, "WriteBlock()", f.WriteBlock( 2L, 512, BlockBuf ), XB_NO_ERROR );
+
+ char BlockBuf2[513];
+ memset( BlockBuf2, 0x00, 513 );
+ rc += TestMethod( po, "ReadBlock()", f.ReadBlock( 2L, 512, BlockBuf2 ), XB_NO_ERROR );
+
+ xbString s1 = BlockBuf;
+ xbString s2 = BlockBuf2;
+
+ rc += TestMethod( po, "ReadBlock()", s1, s2, 512 );
+
+ rc += TestMethod( po, "xbTruncate()", f.xbTruncate( 1000 ), XB_NO_ERROR );
+
+ xbUInt64 ullFsize;
+ rc += TestMethod( po, "GetFileSize()", f.GetFileSize( ullFsize ), XB_NO_ERROR );
+ rc += TestMethod( po, "xbGetFileSize()", (xbInt32) ullFsize, 1000 );
+ rc += TestMethod( po, "xbFclose()", f.xbFclose(), XB_NO_ERROR );
+
+ if( po > 0 || rc < 0 )
+ fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+
+#ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ return rc;
+}
+
diff --git a/src/tests/xb_test_filter.cpp b/src/tests/xb_test_filter.cpp
new file mode 100755
index 0000000..2aeade3
--- /dev/null
+++ b/src/tests/xb_test_filter.cpp
@@ -0,0 +1,185 @@
+/* xb_test_filter.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2020,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
+
+*/
+
+// This program tests the class xbIxFilter
+
+// usage: xb_test_filter QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+ int iRc = 0;
+ int 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;
+ }
+
+
+ xbSchema MyV4Record[] =
+ {
+ { "CFLD", XB_CHAR_FLD, 6, 0 },
+ { "NFLD", XB_NUMERIC_FLD, 6, 0 },
+ { "ZFLD", XB_CHAR_FLD, 1, 0 },
+ { "",0,0,0 }
+ };
+
+
+ xbXBase x;
+#ifdef XB_LOGGING_SUPPORT
+ 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 );
+ x.SetLogSize( 1000000 );
+#endif
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+
+ char c;
+ xbString s;
+ xbInt32 lRecCnt = 0;
+ iRc = 0;
+
+ if( iPo > 0 )
+ std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+ xbDbf *V4Dbf = new xbDbf4( &x );
+
+ iRc2 = V4Dbf->CreateTable( "TestFilt.DBF", "TestFilter", MyV4Record, XB_OVERLAY, XB_MULTI_USER );
+ iRc += TestMethod( iPo, "CreateTable()", (xbInt32) iRc2, XB_NO_ERROR );
+
+
+ #ifdef XB_NDX_SUPPORT
+ xbIx *ixPtr;
+ void *ndx;
+ iRc2 = V4Dbf->CreateTag( "NDX", "TestFilt.NDX", "CFLD", "", 0, 0, XB_OVERLAY, &ixPtr, &ndx );
+ iRc += TestMethod( iPo, "CreateTag()", (xbInt32) iRc2, XB_NO_ERROR );
+ if( iRc2 )
+ x.DisplayError( iRc2 );
+ #endif // XB_NDX_SUPPORT
+
+
+ if( iRc2 )
+ x.DisplayError( iRc2 );
+
+ for( xbUInt16 i = 0; i < 5 && iRc == XB_NO_ERROR; i++ ){
+ // for( xbUInt16 j = 0; j < 26 && iRc == XB_NO_ERROR; j++ ){
+ for( xbInt16 j = 25; j >= 0 && iRc == XB_NO_ERROR; j-- ){
+ c = j + 65;
+ s = c;
+ s.PadRight( c, (xbUInt32) i + 1 );
+ V4Dbf->BlankRecord();
+ V4Dbf->PutField( "CFLD", s );
+ V4Dbf->PutLongField( "NFLD", ++lRecCnt );
+ iRc = V4Dbf->AppendRecord();
+ }
+ }
+
+ iRc += TestMethod( iPo, "SetCurTag()", V4Dbf->SetCurTag( "" ), XB_NO_ERROR );
+ xbFilter f1( &x, V4Dbf );
+ xbString sMyFilterExpression = "LEFT( CFLD, 2 ) = 'YY'";
+ iRc += TestMethod( iPo, "Set()", f1.Set( sMyFilterExpression ), XB_NO_ERROR );
+
+ iRc += TestMethod( iPo, "SetCurTag()", V4Dbf->SetCurTag( "" ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "Set()", f1.Set( sMyFilterExpression ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetFirstRecord()", f1.GetFirstRecord(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 28 );
+ iRc += TestMethod( iPo, "GetNextRecord()", f1.GetNextRecord(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 54 );
+ iRc += TestMethod( iPo, "GetNextRecord()", f1.GetNextRecord(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 80 );
+ iRc += TestMethod( iPo, "GetLast()", f1.GetLastRecord(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 106 );
+ iRc += TestMethod( iPo, "GetPrev()", f1.GetPrevRecord(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 80 );
+
+ sMyFilterExpression = "LEFT( CFLD, 2 ) = 'CC'";
+ iRc += TestMethod( iPo, "Set()", f1.Set( sMyFilterExpression ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetFirstRecord()", f1.GetFirstRecord(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 50 );
+ iRc += TestMethod( iPo, "GetNextRecord()", f1.GetNextRecord(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 76 );
+ iRc += TestMethod( iPo, "GetNextRecord()", f1.GetNextRecord(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 102 );
+ iRc += TestMethod( iPo, "GetLast()", f1.GetLastRecord(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 128 );
+ iRc += TestMethod( iPo, "GetPrev()", f1.GetPrevRecord(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 102 );
+
+
+ #ifdef XB_NDX_SUPPORT
+ f1.SetLimit( 0 );
+
+ // change things up a bit
+ iRc += TestMethod( iPo, "GetRecord()", V4Dbf->GetRecord( 32 ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "PutField()", V4Dbf->PutField( "ZFLD", "Z" ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetRecord()", V4Dbf->GetRecord( 52 ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "PutField()", V4Dbf->PutField( "ZFLD", "Z" ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetRecord()", V4Dbf->GetRecord( 76 ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "PutField()", V4Dbf->PutField( "ZFLD", "Z" ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetRecord()", V4Dbf->GetRecord( 103 ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "PutField()", V4Dbf->PutField( "ZFLD", "Z" ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "Commit()", V4Dbf->Commit(), XB_NO_ERROR );
+
+ iRc += TestMethod( iPo, "SetCurTag()", V4Dbf->SetCurTag( "TestFilt" ), XB_NO_ERROR );
+ sMyFilterExpression = "ZFLD = 'Z'";
+ iRc += TestMethod( iPo, "Set()", f1.Set( sMyFilterExpression ), XB_NO_ERROR );
+
+ iRc += TestMethod( iPo, "GetFirstRecord()", f1.GetFirstRecord(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 52 );
+ iRc += TestMethod( iPo, "GetNextRecord()", f1.GetNextRecord(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 103 );
+ iRc += TestMethod( iPo, "GetNextRecord()", f1.GetNextRecord(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 76 );
+ iRc += TestMethod( iPo, "GetLast()", f1.GetLastRecord(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 32 );
+ iRc += TestMethod( iPo, "GetPrev()", f1.GetPrevRecord(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4Dbf->GetCurRecNo(), 76 );
+
+ #endif // XB_NDX_SUPPORT
+
+
+ iRc += TestMethod( iPo, "Close()", V4Dbf->Close(), XB_NO_ERROR );
+ delete V4Dbf;
+
+ 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], iRc * -1 );
+ x.WriteLogMessage( sMsg, 2 );
+#endif
+
+ return iRc;
+}
diff --git a/src/tests/xb_test_funcs.cpp b/src/tests/xb_test_funcs.cpp
new file mode 100755
index 0000000..07e2c17
--- /dev/null
+++ b/src/tests/xb_test_funcs.cpp
@@ -0,0 +1,288 @@
+/* xb_test_funcs.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
+
+*/
+
+// This program tests the xb functions
+// usage: xb_test_funcs QUITE|NORMAL|VERBOSE
+
+#include "xbase.h"
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+/**************************************************************************/
+
+int main( int argCnt, char **av )
+{
+ xbInt16 iRc = 0;
+ xbInt16 rc2 = 0;
+ xbInt16 po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+ xbSchema MyRecord[] =
+ {
+ { "NUM1", XB_NUMERIC_FLD, 9, 2 },
+ { "DATE1", XB_DATE_FLD, 8, 0 },
+ { "DATE2", XB_DATE_FLD, 8, 0 },
+ { "",0,0,0 }
+ };
+
+
+ xbXBase x;
+ xbDbf * MyFile;
+ xbDate d;
+
+ xbString sResult;
+ xbDate dtResult;
+ xbDouble dResult;
+ xbBool bResult;
+ xbDate dtIn( "19890209" );
+
+
+ #ifdef XB_LOGGING_SUPPORT
+ x.EnableMsgLogging();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+ InitTime();
+
+ if( po > 0 ){
+ std::cout << "XBase Expression testing program.." << std::endl;
+ std::cout << "This program tests the XBase expression logic." << std::endl;
+ std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+ }
+
+ #ifdef XB_DBF4_SUPPORT
+ MyFile = new xbDbf4( &x ); /* version 4 dbf file */
+ #else
+ MyFile = new xbDbf3( &x ); /* version 3 dbf file */
+ #endif
+
+ rc2 = MyFile->CreateTable( "Functest.DBF", "ExpTest", MyRecord, XB_OVERLAY, XB_MULTI_USER );
+ iRc += TestMethod( po, "CreateTable()", rc2, XB_NO_ERROR );
+ iRc += TestMethod( po, "PutField()", MyFile->PutFloatField( "NUM1", 5 ), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutField()", MyFile->PutField( "DATE1", "19890303" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutField()", MyFile->PutField ( "DATE2", "20120708" ), XB_NO_ERROR );
+
+ MyFile->SetAutoLock( xbFalse );
+ iRc += TestMethod( po, "AppendRecord()", MyFile->AppendRecord(), XB_NO_ERROR );
+
+ iRc += TestMethod( po, "ABS( -222, dResult )", x.ABS( -222, dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "ABS( -222, dResult )", -222, -222 );
+ iRc += TestMethod( po, "ABS( 333, dResult )", x.ABS( 333, dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "ABS( 333, dResult )", 333, 333 );
+
+ iRc += TestMethod( po, "x.ALLTRIM( \" zzz \", sResult )", x.ALLTRIM( " zzz ", sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.ALLTRIM( \" zzz \", sResult )", sResult, "zzz", 3 );
+
+ iRc += TestMethod( po, "ASC( \"A\", dResult )", x.ASC( "A", dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "ASC( \"A\" )", dResult, (xbDouble) 65 );
+ iRc += TestMethod( po, "ASC( \"B\", dResult )", x.ASC( "B", dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "ASC( \"B\" )", dResult, (xbDouble) 66 );
+ iRc += TestMethod( po, "AT( \"ABC\", \"XYZABC\", 4 )", x.AT( "ABC", "XYZABC", dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "AT( \"ABC\", \"XYZABC\", 4 )", dResult, (xbDouble) 4 );
+ iRc += TestMethod( po, "CDOW( dtIn, sResult )", x.CDOW( dtIn, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "CDOW( dtIn, sResult )", sResult, "Thursday", 8 );
+ iRc += TestMethod( po, "CHR( 101, sResult )", x.CHR( 101, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "CHR( 101, sResult )", sResult, "e", 1 );
+
+ dtIn = "19870103";
+ iRc += TestMethod( po, "CMONTH( dtIn, sResult )", x.CMONTH( dtIn, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "CMONTH( dtIn, sResult )", sResult, "January", 7 );
+ iRc += TestMethod( po, "CTOD( \"01\\03\\87\", dtResult )", x.CTOD( "01\\03\\87", dtResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "CTOD( \"01\\03\\87\", dtResult )", dtResult.Str(), "19870103", 8 );
+ iRc += TestMethod( po, "DATE( dtResult )", x.DATE( dtResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "DATE( dtResult )", dtResult.Str(), d.Str(), 8 );
+ iRc += TestMethod( po, "DAY(\"19870103\", dResult )", x.DAY( "19870103", dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "DAY(\"19870103\", dResult )", dResult, (xbDouble) 3 );
+
+ iRc += TestMethod( po, "DEL( MyFile, sResult )", x.DEL( MyFile, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "DEL( MyFile, sResult )", sResult, " ", 1 );
+
+ iRc += TestMethod( po, "DELETED( MyFile, bResult )", x.DELETED( MyFile, bResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "DELETED( MyFile, bResult )", (xbInt32) bResult, xbFalse );
+
+ iRc += TestMethod( po, "DeleteRecord()", MyFile->DeleteRecord(), XB_NO_ERROR );
+
+ iRc += TestMethod( po, "DEL( MyFile, sResult )", x.DEL( MyFile, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "DEL( MyFile, sResult )", sResult, "*", 1 );
+ iRc += TestMethod( po, "DELETED( MyFile, bResult )", x.DELETED( MyFile, bResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "DELETED( MyFile, bResult )", (xbInt32) bResult, xbTrue );
+
+ iRc += TestMethod( po, "UndeleteRecord()", MyFile->UndeleteRecord(), XB_NO_ERROR );
+
+ iRc += TestMethod( po, "DESCEND(\"ABCDE\", sResult )", x.DESCEND( "ABCDE", sResult ), XB_NO_ERROR );
+
+ char sDescendResult[6]; // = "¾½¼»º";
+ sDescendResult[0] = (char) 0xBE;
+ sDescendResult[1] = (char) 0xBD;
+ sDescendResult[2] = (char) 0xBC;
+ sDescendResult[3] = (char) 0xBB;
+ sDescendResult[4] = (char) 0xBA;
+ sDescendResult[5] = (char) 0x00;
+ iRc += TestMethod( po, "DESCEND(\"ABCDE\", sResult )", sResult, sDescendResult, 5 );
+
+ iRc += TestMethod( po, "DESCEND( 12345, dResult )", x.DESCEND( 12345, dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "DESCEND( 12345, dResult )", dResult, (xbDouble) -12345 );
+ dtIn = "19890303";
+ iRc += TestMethod( po, "DESCEND( dtIn, dtResult )", x.DESCEND( dtIn, dtResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "DESCEND( dtIn, dtResult )", dtResult.Str(), "29101031", 8 );
+ dtIn = "20120708";
+ iRc += TestMethod( po, "DESCEND( dtIn, dtResult )", x.DESCEND( dtIn, dtResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "DESCEND( dtIn, dtResult )", dtResult.Str(), "28870625" , 8 );
+
+ dtIn = "20171014";
+ iRc += TestMethod( po, "DOW( dtIn, dResult )", x.DOW( dtIn, dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "DOW(\"20171015\", dResult )", dResult, (xbDouble) 0 );
+ dtIn++;
+ iRc += TestMethod( po, "DOW( dtIn, dResult )", x.DOW( dtIn, dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "DOW(\"20171016\", dResult )", dResult, (xbDouble) 1 );
+ dtIn++;
+ iRc += TestMethod( po, "DOW( dtIn, dResult )", x.DOW( dtIn, dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "DOW(\"20171021\", dResult )", dResult, (xbDouble) 2 );
+
+ dtIn = "20000101";
+ iRc += TestMethod( po, "DTOC( dtIn, sResult )", x.DTOC( dtIn, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "DTOC( dtIn, sResult )", sResult, "01/01/00", 8 );
+ iRc += TestMethod( po, "DTOS( dtIn, sResult )", x.DTOS( dtIn, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "DTOS( dtIn, sResult )", sResult, "20000101", 8 );
+ iRc += TestMethod( po, "EXP( 1, dResult )", x.EXP( 1, dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "EXP( 1, dResult )", dResult, 2.71828, .001 );
+ iRc += TestMethod( po, "x.INT( 621.5, dResult )", x.INT( 621.5, dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.INT( 621.5, dResult )", dResult, (xbDouble) 621 );
+ iRc += TestMethod( po, "x.ISALPHA( \"1\", bResult )", x.ISALPHA( "1", bResult ), 0 );
+ iRc += TestMethod( po, "x.ISALPHA( \"1\", bResult )", (xbInt32) bResult, xbFalse );
+ iRc += TestMethod( po, "x.ISALPHA( \"A\", bResult )", x.ISALPHA( "A", bResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.ISALPHA( \"A\", bResult )", (xbInt32) bResult, xbTrue );
+ iRc += TestMethod( po, "x.ISLOWER( \"A\", bResult )", x.ISLOWER( "A", bResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.ISLOWER( \"A\", bResult )", bResult, xbFalse );
+ iRc += TestMethod( po, "x.ISLOWER( \"a\", bResult )", x.ISLOWER( "a", bResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.ISLOWER( \"a\", bResult )", bResult, xbTrue );
+ iRc += TestMethod( po, "x.ISUPPER( \"A\", bResult )", x.ISUPPER( "A", bResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.ISUPPER( \"A\", bResult )", bResult, xbTrue );
+ iRc += TestMethod( po, "x.ISUPPER( \"a\", bResult )", x.ISUPPER( "a", bResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.ISUPPER( \"a\", bResult )", bResult, xbFalse );
+ iRc += TestMethod( po, "x.LEFT( \"STRING\", 3, sResult )", x.LEFT( "STRING", 3, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.LEFT( \"STRING\", 3, sResult )", sResult, "STR", 3 );
+ iRc += TestMethod( po, "x.LEN( \"AAAAA\", dResult )", x.LEN( "AAAAA", dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.LEN( \"AAAAA\", dResult )", dResult, (xbDouble) 5 );
+ iRc += TestMethod( po, "x.LOG( 2, dResult )", x.LOG( 2, dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.LOG( 2, dResult )", dResult, (xbDouble) 0.69314700, .0001 );
+ iRc += TestMethod( po, "x.LOWER( \"AAAA\", sResult )", x.LOWER( "AAAA", sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.LOWER( \"AAAA\", sResult )", sResult, "aaaa", 4 );
+ iRc += TestMethod( po, "x.LTRIM( \" xxxxxx\" )", x.LTRIM( " xxxxxx", sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.LTRIM( \" xxxxxx\" )", sResult, "xxxxxx", 6 );
+ iRc += TestMethod( po, "x.MAX( 10, 27, dResult )", x.MAX( 10, 27, dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.MAX( 10, 27, dResult )", dResult, (xbDouble) 27 );
+ iRc += TestMethod( po, "x.MIN( 10, 5, dResult )", x.MIN( 10, 5, dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.MIN( 10, 5, dResult )", dResult, (xbDouble) 5 );
+ iRc += TestMethod( po, "x.MONTH( dtIn, dResult )", x.MONTH( dtIn, dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.MONTH( dtIn, dResult )", dResult, (xbDouble) 1 );
+ iRc += TestMethod( po, "x.RECCOUNT( MyFile, dResult)", x.RECNO( MyFile, dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.RECCOUNT( MyFile, dResult)", dResult, (xbDouble) 1 );
+ iRc += TestMethod( po, "x.RECNO( MyFile, dResult)", x.RECNO( MyFile, dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.RECNO( MyFile, dResult)", dResult, (xbDouble) 1 );
+ iRc += TestMethod( po, "x.REPLICATE( \"abc\", 3, sResult )", x.REPLICATE( "abc", 3, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.REPLICATE( \"abc\", 3, sResult )", sResult, "abcabcabc", 9 );
+ iRc += TestMethod( po, "x.RIGHT( \"STRING\", 3, sResult )", x.RIGHT( "STRING", 3, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.RIGHT( \"STRING\", 3, sResult )", sResult, "ING", 3 );
+ iRc += TestMethod( po, "x.RIGHT( \"STRING\", 3, sResult )", x.RIGHT( "STRING", 5, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.RIGHT( \"STRING\", 3, sResult )", sResult, "TRING", 5 );
+ iRc += TestMethod( po, "x.RIGHT( \"STRING\", 3, sResult )", x.RIGHT( "STRING", 6, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.RIGHT( \"STRING\", 3, sResult )", sResult, "STRING", 6 );
+ iRc += TestMethod( po, "x.RIGHT( \"STRING\", 3, sResult )", x.RIGHT( "STRING", 7, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.RIGHT( \"STRING\", 3, sResult )", sResult, "STRING", 6 );
+ iRc += TestMethod( po, "x.RTRIM( \"zzz \", sResult )", x.RTRIM( "zzz ", sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.RTRIM( \"zzz \", sResult )", sResult, "zzz", 3 );
+ iRc += TestMethod( po, "x.TRIM( \"aaa \", sResult )", x.TRIM( "aaa ", sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.TRIM( \"aaa \", sResult )", sResult, "aaa", 3 );
+ iRc += TestMethod( po, "x.SPACE( 3, sResult )", x.SPACE( 3, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.SPACE( 3, sResult )", sResult, " ", 3 );
+ iRc += TestMethod( po, "x.SQRT( 9, dResult )", x.SQRT( 9, dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.SQRT( 9, dResult )", dResult, (xbDouble) 3 );
+ iRc += TestMethod( po, "x.STOD( \"20000101\", dtResult )", x.STOD( "20000101", dtResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.STOD( \"20000101\", dtResult )",dtResult.Str(), "20000101", 8 );
+
+ xbString sPadChar = " ";
+ iRc += TestMethod( po, "x.STR( 2001, 4, 0, sPadChar, sResult )", x.STR( 2001, 4, 0, sPadChar, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.STR( 2001, 4, 0, sPadChar, sResult )", sResult, "2001", 4 );
+ iRc += TestMethod( po, "x.STR( 2002, 3, 0, sPadChar, sResult )", x.STR( 2002, 3, 0, sPadChar, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.STR( 2002, 3, 0, sPadChar, sResult )", sResult, "***", 3 );
+ iRc += TestMethod( po, "x.STR( 203.2, 6, 2, sPadChar, sResult )", x.STR( 203.2, 6, 2, sPadChar, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.STR( 203.2, 6, 2, sPadChar, sResult )", sResult, "203.20", 6 );
+ iRc += TestMethod( po, "x.STR( 204.11, 8, 2, sPadChar, sResult )", x.STR( 204.11, 8, 2, sPadChar, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.STR( 204.11, 8, 2, sPadChar, sResult )", sResult, " 204.11", 8 );
+ iRc += TestMethod( po, "x.STR( -205.45, 8, 2, sPadChar, sResult )", x.STR( -205.45, 8, 2, sPadChar, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.STR( -205.45, 8, 2, sPadChar, sResult )", sResult, " -205.45", 8 );
+ iRc += TestMethod( po, "x.STR( -306.45, 8, 2, sPadChar, sResult )", x.STR( -306.45, 8, 2, sPadChar, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.STR( -306.45, 8, 2, sPadChar, sResult )", sResult, " -306.45", 8 );
+ iRc += TestMethod( po, "x.STR( 6.56, 5, 0, sResult )", x.STR( 6.56, 5, 0, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.STR( 6.56, 5, 0, sResult )", sResult, " 7", 5 );
+ iRc += TestMethod( po, "x.STR( 7.77, 5, sResult )", x.STR( 7.77, 5, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.STR( 7.77, 5, sResult )", sResult, " 8", 5 );
+ iRc += TestMethod( po, "x.STR( 8, sResult )", x.STR( 8, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.STR( 8, sResult )", sResult, " 8", 10 );
+
+ sPadChar = "0";
+ iRc += TestMethod( po, "x.STR( -5.2, 10, 2, sPadChar, sResult )", x.STR( -5.2, 10, 2, sPadChar, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.STR( -5.2, 10, 2, sPadChar, sResult )", sResult, "00000-5.20", 10 );
+ iRc += TestMethod( po, "x.STRZERO( 8, 8, 0, sResult )", x.STRZERO( 8, 8, 0, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.STRZERO( 8, 8, 0, sResult )", sResult, "00000008", 8 );
+ iRc += TestMethod( po, "x.STRZERO( -8, 8, 0, sResult )", x.STRZERO( -8, 8, 0, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.STRZERO( -8, 8, 0, sResult )", sResult, "-0000008", 8 );
+ iRc += TestMethod( po, "x.STRZERO( -205.45, 10, 3 )", x.STRZERO( -205.45, 10, 3, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.STRZERO( -205.45, 10, 3 )", sResult, "-00205.450", 10 );
+ iRc += TestMethod( po, "x.STRZERO( -205.45, 3, 1 )", x.STRZERO( -205.45, 3, 1, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.STRZERO( -205.45, 3, 1 )", sResult, "***", 3 );
+ iRc += TestMethod( po, "x.SUBSTR( \"TESTSTRING\", 5, 2, sResult )", x.SUBSTR( "TESTSTRING", 5, 2, sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.SUBSTR( \"TESTSTRING\", 5, 2, sResult )", sResult, "ST", 2 );
+ iRc += TestMethod( po, "x.UPPER( \"abababa\", sResult )", x.UPPER( "abababa", sResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.UPPER( \"abababa\", sResult )", sResult, "ABABABA", 7 );
+ iRc += TestMethod( po, "x.VAL( \"65\", dResult )", x.VAL( "65", dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.VAL( \"65\", dResult )", dResult, (xbDouble) 65 );
+ iRc += TestMethod( po, "x.YEAR( dtIn, dResult )", x.YEAR( dtIn, dResult ), XB_NO_ERROR );
+ iRc += TestMethod( po, "x.YEAR( dtIn, dResult )", dResult, (xbDouble) 2000 );
+
+
+ iRc += TestMethod( po, "Close()", MyFile->Close(), XB_NO_ERROR );
+
+
+ delete MyFile;
+ if( po > 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], iRc * -1 );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ return iRc;
+}
diff --git a/src/tests/xb_test_linklist.cpp b/src/tests/xb_test_linklist.cpp
new file mode 100755
index 0000000..dc253af
--- /dev/null
+++ b/src/tests/xb_test_linklist.cpp
@@ -0,0 +1,340 @@
+/* xb_test_linklist.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
+
+*/
+
+// This program tests the class xblnklst and xblnknod
+// usage: xb_test_linklist QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+
+int main( int argCnt, char **av )
+{
+ int rc = 0;
+
+ int po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+ xbXBase x;
+#ifdef XB_LOGGING_SUPPORT
+ x.EnableMsgLogging();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+#endif
+ InitTime();
+
+ xbLinkList<xbString> ll;
+ ll.InsertAtFront( "A" );
+ ll.InsertAtFront( "B" );
+ ll.InsertAtFront( "C" );
+ ll.InsertAtFront( "D" );
+ ll.InsertAtFront( "E" );
+ ll.InsertAtFront( "F" );
+ ll.InsertAtFront( "G" );
+ ll.InsertAtFront( "H" );
+ ll.InsertAtFront( "I" );
+ ll.InsertAtFront( "J" );
+ ll.InsertAtFront( "K" );
+ ll.InsertAtFront( "L" );
+ ll.InsertAtFront( "M" );
+ ll.InsertAtFront( "N" );
+ ll.InsertAtFront( "O" );
+
+ xbLinkListNode<xbString> * llN = ll.GetHeadNode();
+ xbString s;
+ xbString s2;
+ xbUInt32 ulCnt = ll.GetNodeCnt();
+ for( xbUInt32 i = 0; i < ulCnt; i++ ){
+ s2 = llN->GetKey();
+ s.Sprintf( "%s%s", s.Str(), s2.Str() );
+ llN = llN->GetNextNode();
+ }
+ rc += TestMethod( po, "InsertAtFront()", s, "ONMLKJIHGFEDCBA", 15 );
+
+ s = "";
+ llN = ll.GetHeadNode();
+ while( llN ){
+ s2 = llN->GetKey();
+ s.Sprintf( "%s%s", s.Str(), s2.Str() );
+ llN = llN->GetNextNode();
+ }
+ rc += TestMethod( po, "GetNextNode()", s, "ONMLKJIHGFEDCBA", 15 );
+
+ s = "";
+ llN = ll.GetEndNode();
+ while( llN ){
+ s2 = llN->GetKey();
+ s.Sprintf( "%s%s", s.Str(), s2.Str() );
+ llN = llN->GetPrevNode();
+ }
+ rc += TestMethod( po, "GetNextNode()", s, "ABCDEFGHIJKLMNO", 15 );
+
+
+ ll.RemoveFromFront( s );
+ rc += TestMethod( po, "RemoveFromFront()", s, "O", 1 );
+
+ llN = ll.GetHeadNode();
+ ulCnt = ll.GetNodeCnt();
+ rc += TestMethod( po, "RemoveFromFront()", (xbInt32) ulCnt, 14 );
+
+ s = "";
+ for( xbUInt32 i = 0; i < ulCnt; i++ ){
+ s2 = llN->GetKey();
+ s.Sprintf( "%s%s", s.Str(), s2.Str() );
+ llN = llN->GetNextNode();
+ }
+ rc += TestMethod( po, "RemoveFromFront()", s, "NMLKJIHGFEDCBA", 14 );
+
+
+ s = "";
+ llN = ll.GetHeadNode();
+ while( llN ){
+ s2 = llN->GetKey();
+ s.Sprintf( "%s%s", s.Str(), s2.Str() );
+ llN = llN->GetNextNode();
+ }
+ rc += TestMethod( po, "RemoveFromFront()", s, "NMLKJIHGFEDCBA", 14 );
+
+
+ s = "";
+ llN = ll.GetEndNode();
+ while( llN ){
+ s2 = llN->GetKey();
+ s.Sprintf( "%s%s", s.Str(), s2.Str() );
+ llN = llN->GetPrevNode();
+ }
+ rc += TestMethod( po, "RemoveFromFront()", s, "ABCDEFGHIJKLMN", 14 );
+
+
+ ll.RemoveFromEnd( s );
+ rc = TestMethod( po, "RemoveFromEnd()", s, "A", 1 );
+ ulCnt = ll.GetNodeCnt();
+ rc += TestMethod( po, "RemoveFromFront()", (xbInt32) ulCnt, 13 );
+
+ s = "";
+ llN = ll.GetHeadNode();
+ for( xbUInt32 i = 0; i < ulCnt; i++ ){
+ s2 = llN->GetKey();
+ s.Sprintf( "%s%s", s.Str(), s2.Str() );
+ llN = llN->GetNextNode();
+ }
+ rc += TestMethod( po, "RemoveFromEnd()", s, "NMLKJIHGFEDCB", 13 );
+
+ s = "";
+ llN = ll.GetHeadNode();
+ while( llN ){
+ s2 = llN->GetKey();
+ s.Sprintf( "%s%s", s.Str(), s2.Str() );
+ llN = llN->GetNextNode();
+ }
+ rc += TestMethod( po, "RemoveFromEnd()", s, "NMLKJIHGFEDCB", 13 );
+
+ s = "";
+ llN = ll.GetEndNode();
+ while( llN ){
+ s2 = llN->GetKey();
+ s.Sprintf( "%s%s", s.Str(), s2.Str() );
+ llN = llN->GetPrevNode();
+ }
+ rc += TestMethod( po, "RemoveFromEnd()", s, "BCDEFGHIJKLMN", 13 );
+
+ s = "J";
+ ll.RemoveByVal( s );
+ rc += TestMethod( po, "RemoveByVal()", s, "J", 1 );
+ ulCnt = ll.GetNodeCnt();
+ rc += TestMethod( po, "RemoveByVal()", (xbInt32) ulCnt, 12 );
+
+ llN = ll.GetHeadNode();
+ s = "";
+ for( xbUInt32 i = 0; i < ulCnt; i++ ){
+ s2 = llN->GetKey();
+ s.Sprintf( "%s%s", s.Str(), s2.Str() );
+ llN = llN->GetNextNode();
+ }
+ rc += TestMethod( po, "RemoveByVal()", s, "NMLKIHGFEDCB", 12 );
+
+ s = "";
+ llN = ll.GetHeadNode();
+ while( llN ){
+ s2 = llN->GetKey();
+ s.Sprintf( "%s%s", s.Str(), s2.Str() );
+ llN = llN->GetNextNode();
+ }
+ rc += TestMethod( po, "RemoveByVal()", s, "NMLKIHGFEDCB", 12 );
+
+ s = "";
+ llN = ll.GetEndNode();
+ while( llN ){
+ s2 = llN->GetKey();
+ s.Sprintf( "%s%s", s.Str(), s2.Str() );
+ llN = llN->GetPrevNode();
+ }
+ rc += TestMethod( po, "RemoveByVal()", s, "BCDEFGHIKLMN", 12 );
+
+
+// ordered link list
+ xbLinkListOrd<xbString> llO;
+ llO.SetDupKeys( 0 );
+ rc += TestMethod( po, "InsertKey( J )", llO.InsertKey( "J" ), 0);
+ rc += TestMethod( po, "InsertKey( J )", llO.InsertKey( "J" ), XB_KEY_NOT_UNIQUE );
+ rc += TestMethod( po, "InsertKey( M )", llO.InsertKey( "M" ), 0 );
+ rc += TestMethod( po, "InsertKey( C )", llO.InsertKey( "C" ), 0 );
+ rc += TestMethod( po, "InsertKey( F )", llO.InsertKey( "F" ), 0 );
+ rc += TestMethod( po, "InsertKey( Q )", llO.InsertKey( "Q" ), 0 );
+ rc += TestMethod( po, "InsertKey( A )", llO.InsertKey( "A" ), 0 );
+ rc += TestMethod( po, "InsertKey( T )", llO.InsertKey( "T" ), 0 );
+
+ if( po > 1 ){
+ std::cout << "dumping node chain from beginning to end\n";
+ llN = llO.GetHeadNode();
+ while( llN ){
+ s2 = llN->GetKey();
+ std::cout << "node = " << s2.Str() << "\n";
+ llN = llN->GetNextNode();
+ }
+
+ std::cout << "dumping node chain from beginning to beginning\n";
+ llN = llO.GetHeadNode();
+ while( llN ){
+ s2 = llN->GetKey();
+ std::cout << "node = " << s2.Str() << "\n";
+ llN = llN->GetPrevNode();
+ }
+
+ std::cout << "dumping node chain from end to end\n";
+ llN = llO.GetEndNode();
+ while( llN ){
+ s2 = llN->GetKey();
+ std::cout << "node = " << s2.Str() << "\n";
+ llN = llN->GetNextNode();
+ }
+
+ std::cout << "dumping node chain from end to beginning\n";
+ llN = llO.GetEndNode();
+ while( llN ){
+ s2 = llN->GetKey();
+ std::cout << "node = " << s2.Str() << "\n";
+ llN = llN->GetPrevNode();
+ }
+
+
+ }
+
+ // xbLinkListNode<xbString> * psN;
+ s2 = "A";
+ rc += TestMethod( po, "KeyExists('A')", llO.KeyExists( s2 ), xbTrue );
+ rc += TestMethod( po, "RemoveKey('A')", llO.RemoveKey( s2 ), 0 );
+ s2 = "J";
+ rc += TestMethod( po, "RemoveKey('J')", llO.RemoveKey( s2 ), 0 );
+ s2 = "T";
+ rc += TestMethod( po, "RemoveKey('T')", llO.RemoveKey( s2 ), 0 );
+ rc += TestMethod( po, "RemoveKey('T')", llO.RemoveKey( s2 ), XB_NOT_FOUND );
+ rc += TestMethod( po, "KeyExists('T')", llO.KeyExists( s2 ), xbFalse );
+
+
+
+ xbLinkListOrd<xbUInt32> lloi;
+ lloi.SetDupKeys( 0 );
+ xbUInt32 i = 3;
+
+ rc += TestMethod( po, "InsertKey( 1 )", lloi.InsertKey( i ), 0 );
+ rc += TestMethod( po, "RemoveKey( 1 )", lloi.RemoveKey( i ), 0 );
+ rc += TestMethod( po, "RemoveKey( 1 )", lloi.RemoveKey( i ), XB_NOT_FOUND );
+
+
+ if( po > 1 ){
+ std::cout << "dumping node chains after delete\n";
+ std::cout << "dumping node chain from beginning to end\n";
+ llN = llO.GetHeadNode();
+ while( llN ){
+ s2 = llN->GetKey();
+ std::cout << "node = " << s2.Str() << "\n";
+ llN = llN->GetNextNode();
+ }
+
+ std::cout << "dumping node chain from beginning to beginning\n";
+ llN = llO.GetHeadNode();
+ while( llN ){
+ s2 = llN->GetKey();
+ std::cout << "node = " << s2.Str() << "\n";
+ llN = llN->GetPrevNode();
+ }
+
+ std::cout << "dumping node chain from end to end\n";
+ llN = llO.GetEndNode();
+ while( llN ){
+ s2 = llN->GetKey();
+ std::cout << "node = " << s2.Str() << "\n";
+ llN = llN->GetNextNode();
+ }
+
+ std::cout << "dumping node chain from end to beginning\n";
+ llN = llO.GetEndNode();
+ while( llN ){
+ s2 = llN->GetKey();
+ std::cout << "node = " << s2.Str() << "\n";
+ llN = llN->GetPrevNode();
+ }
+ }
+
+
+ xbLinkListOrd<xbUInt32> ll32;
+ // xbLinkListNode<xbUInt32> * ll32n;
+
+// for( xbUInt32 ul = 0; ul < 1; ul++ )
+// ll32.InsertKey( ul, ul );
+
+
+ xbUInt32 ul3 = 0;
+// ll32.InsertKey( 1, "1" );
+
+ ll32.InsertKey( ul3, ul3 );
+
+ ll.Clear();
+
+
+
+#ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ if( po > 0 || rc < 0 )
+ fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+
+ return rc;
+}
+
+
+
+
diff --git a/src/tests/xb_test_lock.cpp b/src/tests/xb_test_lock.cpp
new file mode 100755
index 0000000..7e9865b
--- /dev/null
+++ b/src/tests/xb_test_lock.cpp
@@ -0,0 +1,874 @@
+/* xb_test_lock.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
+
+*/
+
+// This program tests the locking functions of xbase
+// usage: xb_test_lock QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+/****************************************************************/
+int main( int argCnt, char **av )
+{
+ xbInt16 iRc = 0;
+ xbInt16 iRc2;
+ xbInt16 po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ xbInt16 iErrorStop = 0;
+ xbString sLockFile = "locktest.txt";
+ xbString sLockCmd;
+ xbString sResult;
+
+ xbXBase x;
+ xbDbf * MyFile;
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+ xbSchema MyRecord[] =
+ {
+ { "LOCKTEST", XB_CHAR_FLD, 5, 0 },
+ #ifdef XB_MEMO_SUPPORT
+ { "MEMOTEST", XB_MEMO_FLD, 10, 0 },
+ #endif
+ { "",0,0,0 }
+ };
+
+
+ #ifdef XB_LOGGING_SUPPORT
+ x.EnableMsgLogging();
+ if( po > 0 ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+ InitTime();
+ #ifdef XB_DBF4_SUPPORT
+ MyFile = new xbDbf4( &x ); /* version 4 dbf file */
+ #else
+ MyFile = new xbDbf3( &x ); /* version 3 dbf file */
+ #endif
+
+ iRc2 = MyFile->CreateTable( "LockTest.DBF", "LockTest", MyRecord, XB_OVERLAY, XB_MULTI_USER );
+ iRc += TestMethod( po, "CreateTable()", iRc2, XB_NO_ERROR );
+ iRc += TestMethod( po, "PutField()", MyFile->PutField( "LOCKTEST", "TEST" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "AppendRecord()", MyFile->AppendRecord(), XB_NO_ERROR );
+ iRc += TestMethod( po, "Close()", MyFile->Close(), XB_NO_ERROR );
+ MyFile->Close();
+
+ //unlink( sLockFile );
+ remove( sLockFile );
+
+ #if defined (HAVE_FORK_F)
+ pid_t pid;
+ if(( pid = fork()) < 0 ){
+ std::cout << "fork error\n";
+ exit(1);
+ }
+
+ if( pid == 0 ){
+ // child task
+ xbDbf * MyFileChld;
+ xbInt16 iRcChld = 0;
+ xbBool bTblOpenChld = xbFalse;
+ xbInt32 iChildLoop = 0;
+ xbBool bDone = xbFalse;
+ xbString sLastLockCmd;
+
+ #ifdef XB_DBF4_SUPPORT
+ MyFileChld = new xbDbf4( &x ); /* version 4 dbf file */
+ #else
+ MyFileChld = new xbDbf3( &x ); /* version 3 dbf file */
+ #endif
+
+ x.xbSleep( 250 );
+
+ while( !bDone ){
+ iRc2 = GetCmd( x, sLockFile, sLockCmd, 'C', po );
+
+ if( sLockCmd == sLastLockCmd )
+ iChildLoop++;
+ else
+ sLastLockCmd = sLockCmd;
+
+ #ifdef XB_LOGGING_SUPPORT
+ if( sLockCmd != "OK" && sLockCmd != "FAIL" ){
+ sMsg.Sprintf( "Program [%s] Child task retrieved command=[%s] RC=[%d]", av[0], sLockCmd.Str(), iRc2 );
+ x.WriteLogMessage( sMsg );
+ }
+ #endif
+
+ if( iRc2 == 0 ){
+
+ if( sLockCmd == "OK" || sLockCmd == "FAIL" )
+ x.xbSleep( 250 );
+
+ else if( sLockCmd == "EXIT" ){
+ bDone = xbTrue;
+
+ } else if( sLockCmd == "START" && bTblOpenChld ){
+ // came back before the parent task could process the result
+ x.xbSleep( 250 );
+
+ } else {
+
+ if( sLockCmd == "START" ){
+ // begin the process
+ iRcChld = MyFileChld->Open( "LockTest.DBF" );
+ if( iRcChld != XB_NO_ERROR ){
+ sResult = "FAIL";
+ } else {
+ sResult = "OK";
+ bTblOpenChld = xbTrue;
+ }
+
+ } else if( sLockCmd == "TL" ){
+ // table lock
+ if(( iRcChld = MyFileChld->LockTable( XB_LOCK )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+
+ } else if( sLockCmd == "TU" ){
+ // table unlock
+ if(( iRcChld = MyFileChld->LockTable( XB_UNLOCK )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+
+ } else if( sLockCmd == "RL" ){
+ // record lock
+ if(( iRcChld = MyFileChld->LockRecord( XB_LOCK, 1 )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+
+ } else if( sLockCmd == "RU" ){
+ // record unlock
+ if(( iRcChld = MyFileChld->LockRecord( XB_UNLOCK, 1 )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+
+ } else if( sLockCmd == "ML" ){
+ // memo lock
+ #ifdef XB_MEMO_SUPPORT
+ if(( iRcChld = MyFileChld->LockMemo( XB_LOCK )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+ #else
+ sLockCmd = "OK";
+ #endif
+
+ } else if( sLockCmd == "MU" ){
+ // memo unlock
+ #ifdef XB_MEMO_SUPPORT
+ if(( iRcChld = MyFileChld->LockMemo( XB_UNLOCK )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+ #else
+ sLockCmd = "OK";
+ #endif
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Child task [%s] Result [%s] RC = [%d]", av[0], sLockCmd.Str(), sResult.Str(), iRcChld );
+ x.WriteLogMessage( sMsg );
+ #endif
+ SetCmd( x, sLockFile, sResult, 'C', po );
+ if( sResult == "FAIL" ){
+ bDone = xbTrue;
+ MyFileChld->Close();
+ delete MyFileChld;
+ }
+ }
+
+ } else {
+ iRc = iRc2;
+ bDone = xbTrue;
+ }
+ //std::cout << "clc [" << iChildLoop++ << "][" << bDone << "][" << sLockCmd.Str() << "]\n";
+ x.xbSleep( 250 );
+ if( iChildLoop > 15 )
+ bDone = xbTrue;
+ }
+ MyFileChld->Close();
+ delete MyFile;
+ delete MyFileChld;
+
+ if( po > 0 )
+ std::cout << "Exiting child\n";
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Child task terminating", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+
+ } else {
+
+ // parent logic
+ xbInt16 iLoopCtr = 0;
+
+ try{
+
+ // start
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing START command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "START";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 10;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ // table lock
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing TL command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "TL";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 20;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ // attempt to lock table, should fail
+ if(( iRc2 = MyFile->Open( "LockTest.DBF" )) != XB_NO_ERROR ){
+ iErrorStop = 30;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockTable( XB_LOCK )) == XB_NO_ERROR ){
+ iErrorStop = 40;
+ throw iRc2;
+ }
+
+ if( po > 0 )
+ std::cout << "[PASS] LockTable Test 1\n";
+
+ // table unlock
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing TU command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "TU";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 50;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 60;
+ throw iRc2;
+ }
+ if( po > 0 )
+ std::cout << "[PASS] LockTable Test 2\n";
+
+ if(( iRc2 = MyFile->LockTable( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 70;
+ throw iRc2;
+ }
+
+ /* record lock */
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing RL command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "RL";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 80;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockRecord( XB_LOCK, 1 )) == XB_NO_ERROR ){
+ iErrorStop = 90;
+ throw iRc2;
+ }
+ if( po > 0 )
+ std::cout << "[PASS] LockRecord Test 1\n";
+
+ /* record unlock */
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing RU command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "RU";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 100;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockRecord( XB_LOCK, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 110;
+ throw iRc2;
+ }
+
+ std::cout << "[PASS] LockRecord Test 2\n";
+ if(( iRc2 = MyFile->LockRecord( XB_UNLOCK, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 120;
+ throw iRc2;
+ }
+
+
+ /* memo lock */
+ #ifdef XB_MEMO_SUPPORT
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing ML command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "ML";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 130;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockMemo( XB_LOCK )) == XB_NO_ERROR ){
+ iErrorStop = 140;
+ throw iRc2;
+ }
+ if( po > 0 )
+ std::cout << "[PASS] LockMemo Test 1\n";
+
+ /* memo unlock */
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing MU command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "MU";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 30 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 150;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockMemo( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 160;
+ throw iRc2;
+ }
+
+ std::cout << "[PASS] LockMemo Test 2\n";
+ if(( iRc2 = MyFile->LockMemo( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 170;
+ throw iRc2;
+ }
+ #endif
+
+ // exit
+ sLockCmd = "EXIT";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+
+ } catch (xbInt16 iRc3 ){
+ iRc = iRc3;
+ if( po > 0 )
+ std::cout << "Parent lock task exiting on failure [" << sLockCmd.Str() << "][" << iErrorStop << "]\n";
+
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task terminating with errors [%s][%d][%d][%d]...", av[0], sLockCmd.Str(), iErrorStop, iLoopCtr, iRc3 );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task terminating", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( po > 0 )
+ std::cout << "Exiting parent\n";
+
+ sLockCmd = "EXIT";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ MyFile->Close();
+ delete MyFile;
+ }
+ #elif defined (HAVE_CREATEPROCESSW_F)
+
+ STARTUPINFO si;
+ PROCESS_INFORMATION pi;
+ ZeroMemory( &si, sizeof( si ));
+ si.cb = sizeof( si );
+ ZeroMemory( &pi, sizeof( pi ));
+
+ xbString strCmdLine = "xb_test_lock2";
+ if( argCnt > 1 ){
+ strCmdLine += " ";
+ strCmdLine += av[1];
+ }
+
+ char sCmdLineBuf[25];
+ memset( sCmdLineBuf, 0x00, 25 );
+ for( xbUInt32 i = 0; i < strCmdLine.Len(); i++ )
+ sCmdLineBuf[i] = strCmdLine[i+1];
+
+ if( !CreateProcess( NULL, sCmdLineBuf, NULL, NULL, FALSE, 0, NULL, NULL, &si, &pi )){
+ sMsg.Sprintf( "Program [%s] error in CreateProcess call. Processing aborted" );
+ #ifdef XB_LOGGING_SUPPORT
+ x.WriteLogMessage( sMsg );
+ #endif
+ std::cout << sMsg.Str() << "\n";
+ iRc -=1;
+ } else {
+
+ xbInt16 iLoopCtr = 0;
+
+ try{
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing START command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+
+ sLockCmd = "START";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ // table lock
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing TL command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "TL";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 200;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ // attempt to lock table, should fail
+ if(( iRc2 = MyFile->Open( "LockTest.DBF" )) != XB_NO_ERROR ){
+ iErrorStop = 210;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockTable( XB_LOCK )) == XB_NO_ERROR ){
+ iErrorStop = 220;
+ throw iRc2;
+ }
+
+ if( po > 0 ){
+ std::cout << "[PASS] LockTable Test 1\n";
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task LockTable Test 1 Success.", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+ }
+
+ // table unlock
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing TU command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "TU";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 230;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockTable( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 240;
+ throw iRc2;
+ }
+ if( po > 0 ){
+ std::cout << "[PASS] LockTable Test 2\n";
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task LockTable Test 1 Success.", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+ }
+
+ if(( iRc2 = MyFile->LockTable( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 250;
+ throw iRc2;
+ }
+
+ /* record lock */
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing RL command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "RL";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 260;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockRecord( XB_LOCK, 1 )) == XB_NO_ERROR ){
+ iErrorStop = 270;
+ throw iRc2;
+ }
+ if( po > 0 )
+ std::cout << "[PASS] LockRecord Test 1\n";
+
+ /* record unlock */
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing RU command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "RU";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 280;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockRecord( XB_LOCK, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 290;
+ throw iRc2;
+ }
+
+ std::cout << "[PASS] LockRecord Test 2\n";
+ if(( iRc2 = MyFile->LockRecord( XB_UNLOCK, 1 )) != XB_NO_ERROR ){
+ iErrorStop = 300;
+ throw iRc2;
+ }
+
+
+ /* memo lock */
+ #ifdef XB_MEMO_SUPPORT
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing ML command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "ML";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 310;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockMemo( XB_LOCK )) == XB_NO_ERROR ){
+ iErrorStop = 320;
+ throw iRc2;
+ }
+ if( po > 0 )
+ std::cout << "[PASS] LockMemo Test 1\n";
+
+ /* memo unlock */
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task issuing MU command", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "MU";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ sResult = "";
+
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ while( sResult != "OK" && sResult != "FAIL" && iLoopCtr < 10 ){
+ GetCmd( x, sLockFile, sResult, 'P', po );
+ x.xbSleep( 250 );
+ iLoopCtr++;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task retrieved result [%s]", av[0], sResult.Str() );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( sResult != "OK" ){
+ iErrorStop = 330;
+ iRc2 = -1;
+ throw iRc2;
+ }
+
+ if(( iRc2 = MyFile->LockMemo( XB_LOCK )) != XB_NO_ERROR ){
+ iErrorStop = 340;
+ throw iRc2;
+ }
+
+ std::cout << "[PASS] LockMemo Test 2\n";
+ if(( iRc2 = MyFile->LockMemo( XB_UNLOCK )) != XB_NO_ERROR ){
+ iErrorStop = 350;
+ throw iRc2;
+ }
+ #endif
+
+ // exit
+ sLockCmd = "EXIT";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+
+ } catch (xbInt16 iRc3 ){
+ if( po > 0 )
+ std::cout << "Parent lock task exiting on failure [" << sLockCmd.Str() << "][" << iErrorStop << "]\n";
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Parent task terminating with errors [%s][%d][%d][%d]...", av[0], sLockCmd.Str(), iErrorStop, iLoopCtr, iRc3 );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ sLockCmd = "EXIT";
+ SetCmd( x, sLockFile, sLockCmd, 'P', po );
+ MyFile->Close();
+ delete MyFile;
+ }
+ }
+
+ #else
+ iRc--;
+ sMsg.Sprintf( "Program [%s] not executed. Library does not support 'fork' or 'CreateProcess' function call", av[0] );
+ #ifdef XB_LOGGING_SUPPORT
+ x.WriteLogMessage( sMsg );
+ #endif
+ if( po > 0 )
+ std::cout << sMsg.Str() << "\n";
+ #endif
+
+ if( po > 0 || iRc < 0 )
+ fprintf( stdout, "[%s] Total Errors = %d\n", av[0], iRc * -1 );
+
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ return iRc;
+}
+
diff --git a/src/tests/xb_test_lock2.cpp b/src/tests/xb_test_lock2.cpp
new file mode 100755
index 0000000..3dd4b57
--- /dev/null
+++ b/src/tests/xb_test_lock2.cpp
@@ -0,0 +1,208 @@
+/* xb_test_lock2.cpp
+
+XBase 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
+
+*/
+
+// This program tests the locking functions
+// This program is the child process that is called if used
+// in an environment that supports the CreateProcess library function (ie Windows)
+
+// usage: xb_test_lock QUITE|NORMAL|VERBOSE
+
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+/****************************************************************/
+int main( int argCnt, char **av )
+{
+ xbInt16 iRc = 0;
+ xbInt16 iRc2;
+ xbInt16 po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ xbBool bDone = xbFalse;
+// xbInt16 iErrorStop = 0;
+ xbString sLockFile = "locktest.txt";
+ xbString sLockCmd;
+ xbString sResult;
+ xbInt32 iChildLoop = 0;
+
+ xbXBase x;
+ xbDbf * MyFile;
+
+ xbBool bTblOpen = xbFalse;
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+ #ifdef XB_LOGGING_SUPPORT
+ xbString sLogFileName = x.GetLogFqFileName().Str();
+
+ sLogFileName.Resize( sLogFileName.Len() - 3 );
+ sLogFileName += "_l2.txt";
+ x.SetLogFileName( sLogFileName );
+ x.EnableMsgLogging();
+ if( po > 0 ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+ InitTime();
+
+ #ifdef XB_DBF4_SUPPORT
+ MyFile = new xbDbf4( &x ); /* version 4 dbf file */
+ #else
+ MyFile = new xbDbf3( &x ); /* version 3 dbf file */
+ #endif
+
+ x.xbSleep( 250 );
+ while( !bDone ){
+ iRc2 = GetCmd( x, sLockFile, sLockCmd, 'C', po );
+
+ #ifdef XB_LOGGING_SUPPORT
+ if( sLockCmd != "OK" && sLockCmd != "FAIL" ){
+ sMsg.Sprintf( "Program [%s] Child task retrieved command=[%s] RC=[%d]", av[0], sLockCmd.Str(), iRc2 );
+ x.WriteLogMessage( sMsg );
+ }
+ #endif
+
+ if( iRc2 == 0 ){
+
+ if( sLockCmd == "OK" || sLockCmd == "FAIL" )
+ x.xbSleep( 250 );
+
+ else if( sLockCmd == "EXIT" ){
+ bDone = xbTrue;
+
+ } else if( sLockCmd == "START" && bTblOpen ){
+ // came back before the parent task could process the result
+ x.xbSleep( 250 );
+
+ } else {
+
+ if( sLockCmd == "START" ){
+
+ // begin the process
+ iRc2 = MyFile->Open( "LockTest.DBF" );
+ if( iRc2 != XB_NO_ERROR ){
+ sResult = "FAIL";
+ } else {
+ sResult = "OK";
+ bTblOpen = xbTrue;
+ }
+
+ } else if( sLockCmd == "TL" ){
+ // table lock
+ if(( iRc2 = MyFile->LockTable( XB_LOCK )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+
+ } else if( sLockCmd == "TU" ){
+ // table unlock
+ if(( iRc2 = MyFile->LockTable( XB_UNLOCK )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+
+ } else if( sLockCmd == "RL" ){
+ // record lock
+ if(( iRc2 = MyFile->LockRecord( XB_LOCK, 1 )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+
+
+ } else if( sLockCmd == "RU" ){
+ // record unlock
+ if(( iRc2 = MyFile->LockRecord( XB_UNLOCK, 1 )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+
+ } else if( sLockCmd == "ML" ){
+ // memo lock
+ #ifdef XB_MEMO_SUPPORT
+ if(( iRc2 = MyFile->LockMemo( XB_LOCK )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+ #else
+ sLockCmd = "OK";
+ #endif
+
+ } else if( sLockCmd == "MU" ){
+ // memo unlock
+ #ifdef XB_MEMO_SUPPORT
+ if(( iRc2 = MyFile->LockMemo( XB_UNLOCK )) != XB_NO_ERROR )
+ sResult = "FAIL";
+ else
+ sResult = "OK";
+ #else
+ sLockCmd = "OK";
+ #endif
+ }
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Child task [%s] Result [%s] RC = [%d]", av[0], sLockCmd.Str(), sResult.Str(), iRc2 );
+ x.WriteLogMessage( sMsg );
+ #endif
+ SetCmd( x, sLockFile, sResult, 'C', po );
+ }
+ } else {
+ iRc = iRc2;
+ bDone = xbTrue;
+ }
+
+ // std::cout << "clc [" << iChildLoop++ << "][" << bDone << "][" << sLockCmd << "]\n";
+ x.xbSleep( 250 );
+ if( iChildLoop > 10 )
+ bDone = xbTrue;
+ }
+ MyFile->Close();
+ delete MyFile;
+ if( po > 0 )
+ std::cout << "Exiting child\n";
+
+ remove( sLockFile );
+ #ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] Child task terminating", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ if( po > 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], iRc * -1 );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ ExitProcess( iRc );
+}
+
diff --git a/src/tests/xb_test_log.cpp b/src/tests/xb_test_log.cpp
new file mode 100755
index 0000000..613b7dd
--- /dev/null
+++ b/src/tests/xb_test_log.cpp
@@ -0,0 +1,88 @@
+/* xb_test_log.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
+
+*/
+
+// This program tests the class xbLog
+
+// usage: xb_test_log QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+
+int main( int argCnt, char **av )
+{
+ int rc = 0;
+
+#ifdef XB_LOGGING_SUPPORT
+
+
+ int po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+ xbXBase x;
+ x.EnableMsgLogging();
+ InitTime();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ 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();
+
+ 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 );
+
+ if( po > 0 || rc < 0 )
+ fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+
+
+ #endif /* XB_LOGGING_SUPPORT */
+
+
+ return rc;
+}
+
+
+
+
diff --git a/src/tests/xb_test_mdx.cpp b/src/tests/xb_test_mdx.cpp
new file mode 100755
index 0000000..9351e4d
--- /dev/null
+++ b/src/tests/xb_test_mdx.cpp
@@ -0,0 +1,243 @@
+/* xb_test_ndx.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
+
+*/
+
+// This program tests the class xbIxNdx
+
+// usage: xb_test_ndx QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+int main( int argCnt, char **av )
+{
+ int iRc = 0;
+ int iRc2;
+ int iPo = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ xbString sMsg;
+ char c;
+ xbString s;
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ iPo = 0;
+ else if( av[1][0] == 'V' )
+ iPo = 2;
+ }
+
+
+ xbSchema MyV4Record[] =
+ {
+ { "CITY", XB_CHAR_FLD, 100, 0 },
+ { "STATE", XB_CHAR_FLD, 2, 0 },
+ { "ZIP", XB_NUMERIC_FLD, 9, 0 },
+ { "DATE1", XB_DATE_FLD, 8, 0 },
+ { "",0,0,0 }
+ };
+
+
+ xbXBase x;
+
+#ifdef XB_LOGGING_SUPPORT
+ x.EnableMsgLogging();
+ if( iPo ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+ x.SetMultiUser( false );
+ InitTime();
+
+ if( iPo > 0 )
+ std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+
+ xbFile f( &x );
+ xbIx *pIx;
+ void *pTag;
+ xbDate dt = "19890209";
+ xbString sKey;
+
+ xbDbf *V4DbfX1 = new xbDbf4( &x );
+
+
+ iRc2 = V4DbfX1->CreateTable( "TMDXDB01.DBF", "TestMdxX2", MyV4Record, XB_OVERLAY, XB_MULTI_USER );
+ iRc += TestMethod( iPo, "CreateTable(1)", iRc2, 0 );
+
+ /*
+ CreateTag( const xbString &sIxType, const xbString &sName, const xbString &sKey, const xbString &sFilter,
+ 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 );
+
+ iRc2 = V4DbfX1->CreateTag( "MDX", "ZIP_TAG", "ZIP", "", xbTrue, 0, XB_OVERLAY, &pIx, &pTag );
+ iRc += TestMethod( iPo, "CreateTag(2)", iRc2, 0 );
+
+ iRc2 = V4DbfX1->CreateTag( "MDX", "DATE_TAG", "DATE1", "", 0, xbTrue, XB_OVERLAY, &pIx, &pTag );
+ iRc += TestMethod( iPo, "CreateTag(3)", iRc2, 0 );
+
+
+ // std::cout << "Cur Tag Name = " << V4DbfX1->GetCurTagName().Str() << "\n";
+
+ // xbDouble d = 4000;
+// iRc2 = V4DbfX1->Find( d );
+// 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++ ){
+
+ c = j + 65;
+ s = c;
+ s.PadRight( c, (xbUInt32) i + 1 );
+ //std::cout << "*********** adding s=[" << s.Str() << "] length = " << s.Len() << "\n";
+ iRc2 = V4DbfX1->BlankRecord();
+ if( iRc2 != XB_NO_ERROR )
+ iRc += TestMethod( iPo, "BlankRecord()", iRc2, XB_NO_ERROR );
+
+ iRc2 = V4DbfX1->PutField( "CITY", s );
+ if( iRc2 != XB_NO_ERROR )
+ iRc += TestMethod( iPo, "PutField()", iRc2, XB_NO_ERROR );
+
+ iRc2 = V4DbfX1->PutLongField( "ZIP", uZip++ );
+ if( iRc2 != XB_NO_ERROR )
+ iRc += TestMethod( iPo, "PutField()", iRc2, XB_NO_ERROR );
+
+ iRc2 = V4DbfX1->PutDateField( "DATE1", dt );
+ dt++;
+ if( iRc2 != XB_NO_ERROR )
+ iRc += TestMethod( iPo, "PutField()", iRc2, XB_NO_ERROR );
+
+ iRc2 = V4DbfX1->AppendRecord();
+ if( iRc2 != XB_NO_ERROR )
+ iRc += TestMethod( iPo, "AppendRecord()", iRc2, XB_NO_ERROR );
+
+ iRc2 = V4DbfX1->Commit();
+ if( iRc2 != XB_NO_ERROR )
+ iRc += TestMethod( iPo, "Commit()", iRc2, XB_NO_ERROR );
+ }
+ }
+
+
+ iRc += TestMethod( iPo, "CheckTagIntegrity()", V4DbfX1->CheckTagIntegrity( 1, 2 ), XB_NO_ERROR );
+
+ // attempt to add a dup key, should fail with XB_KEY_NOT_UNIQUE
+ iRc2 = V4DbfX1->BlankRecord();
+ if( iRc2 != XB_NO_ERROR )
+ iRc += TestMethod( iPo, "BlankRecord()", iRc2, XB_NO_ERROR );
+
+ iRc2 = V4DbfX1->PutField( "CITY", "Tampa" );
+ if( iRc2 != XB_NO_ERROR )
+ iRc += TestMethod( iPo, "PutField()", iRc2, XB_NO_ERROR );
+
+ iRc2 = V4DbfX1->PutLongField( "ZIP", uZip++ );
+ if( iRc2 != XB_NO_ERROR )
+ iRc += TestMethod( iPo, "PutField()", iRc2, XB_NO_ERROR );
+
+ dt.Set( "19890209" );
+ iRc2 = V4DbfX1->PutDateField( "DATE1", dt );
+ dt++;
+ if( iRc2 != XB_NO_ERROR )
+ iRc += TestMethod( iPo, "PutField()", iRc2, XB_NO_ERROR );
+
+ iRc2 = V4DbfX1->AppendRecord();
+ if( iRc2 != XB_KEY_NOT_UNIQUE )
+ iRc += TestMethod( iPo, "AppendRecord()", iRc2, XB_NO_ERROR );
+
+ iRc2 = V4DbfX1->Abort();
+ if( iRc2 != XB_NO_ERROR )
+ 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 );
+
+ iRc2 = V4DbfX1->CreateTag( "MDX", "CITY_TAGF", "CITY", ".NOT. DELETED()", 0, 0, XB_OVERLAY, &pIx, &pTag );
+ iRc += TestMethod( iPo, "CreateTag(4)", iRc2, 0 );
+
+ iRc2 = V4DbfX1->SetCurTag( "CITY_TAGF" );
+ 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 );
+
+ 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, "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 );
+
+ // 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 );
+
+ // 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 );
+
+ // std::cout << "Cur Tag Name = " << V4DbfX1->GetCurTagName().Str() << "\n";
+ sKey = "abc";
+ iRc += TestMethod( iPo, "Find()", V4DbfX1->Find( sKey ), XB_NOT_FOUND );
+ sKey = "EEEEE";
+ iRc += TestMethod( iPo, "Find()", V4DbfX1->Find( sKey ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4DbfX1->GetCurRecNo(), (xbInt32) 61 );
+
+ iRc += TestMethod( iPo, "GetNextKey()", V4DbfX1->GetNextKey(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4DbfX1->GetCurRecNo(), (xbInt32) 75 );
+
+ iRc += TestMethod( iPo, "GetPrevKey()", V4DbfX1->GetPrevKey(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4DbfX1->GetCurRecNo(), (xbInt32) 61 );
+
+ iRc += TestMethod( iPo, "GetLastKey()", V4DbfX1->GetLastKey(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4DbfX1->GetCurRecNo(), (xbInt32) 490 );
+
+ iRc += TestMethod( iPo, "GetFirstKey()", V4DbfX1->GetFirstKey(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurRecNo()", (xbInt32) V4DbfX1->GetCurRecNo(), (xbInt32) 1 );
+
+
+ x.CloseAllTables();
+ delete V4DbfX1;
+
+ 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], iRc * -1 );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ return iRc;
+}
diff --git a/src/tests/xb_test_ndx.cpp b/src/tests/xb_test_ndx.cpp
new file mode 100755
index 0000000..31306c0
--- /dev/null
+++ b/src/tests/xb_test_ndx.cpp
@@ -0,0 +1,330 @@
+/* xb_test_ndx.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
+
+*/
+
+// This program tests the class xbIxNdx
+
+// usage: xb_test_ndx QUITE|NORMAL|VERBOSE
+
+
+
+// fix me - this program needs to test GetUnique
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+ int iRc = 0;
+ int 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;
+ }
+
+
+ xbSchema MyV3Record[] =
+ {
+ { "CFLD", XB_CHAR_FLD, 30, 0 },
+ { "DFLD", XB_DATE_FLD, 8, 0 },
+ { "NFLD", XB_NUMERIC_FLD, 12, 0 },
+ { "",0,0,0 }
+ };
+
+
+ xbXBase x;
+#ifdef XB_LOGGING_SUPPORT
+ 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 );
+ x.SetLogSize( 1000000 );
+#endif
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+// x.DisableDefaultAutoLock();
+ InitTime();
+
+ char c;
+ xbString s;
+ xbInt32 lRecCnt = 0;
+ iRc = 0;
+
+
+ if( iPo > 0 )
+ std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+ xbDbf *V3Dbf = new xbDbf3( &x );
+
+ xbIx *ixPtr;
+ void *ndx;
+
+ iRc2 = V3Dbf->CreateTable( "TestNdx.DBF", "TestNdx", MyV3Record, XB_OVERLAY, XB_MULTI_USER );
+ iRc += TestMethod( iPo, "CreateTable()", (xbInt32) iRc2, XB_NO_ERROR );
+
+ if( iRc2 )
+ x.DisplayError( iRc2 );
+
+
+ iRc2 = V3Dbf->CreateTag( "NDX", "TestNdxC.NDX", "CFLD", "", 0, 0, XB_OVERLAY, &ixPtr, &ndx );
+ iRc += TestMethod( iPo, "CreateTag()", (xbInt32) iRc2, XB_NO_ERROR );
+ if( iRc2 )
+ x.DisplayError( iRc2 );
+
+ iRc2 = V3Dbf->AssociateIndex( "NDX", "TestNdxC.NDX", 0 );
+ iRc += TestMethod( iPo, "Associate()", (xbInt32) iRc2, XB_NO_ERROR );
+
+ iRc2 = V3Dbf->CreateTag( "NDX", "TestNdxD.NDX", "DFLD", "", 0, 0, XB_OVERLAY, &ixPtr, &ndx );
+ iRc += TestMethod( iPo, "CreateTag()", (xbInt32) iRc2, XB_NO_ERROR );
+ if( iRc2 )
+ x.DisplayError( iRc2 );
+
+ iRc2 = V3Dbf->AssociateIndex( "NDX", "TestNdxD.NDX", 0 );
+ iRc += TestMethod( iPo, "Associate()", (xbInt32) iRc2, XB_NO_ERROR );
+
+ iRc2 = V3Dbf->CreateTag( "NDX", "TestNdxN.NDX", "NFLD", "", 0, 0, XB_OVERLAY, &ixPtr, &ndx );
+ iRc += TestMethod( iPo, "CreateTag()", (xbInt32) iRc2, XB_NO_ERROR );
+ if( iRc2 )
+ x.DisplayError( iRc2 );
+
+ iRc2 = V3Dbf->AssociateIndex( "NDX", "TestNdxN.NDX", 0 );
+ iRc += TestMethod( iPo, "Associate()", (xbInt32) iRc2, XB_NO_ERROR );
+
+
+ iRc += TestMethod( iPo, "GetCurTagName()", V3Dbf->GetCurTagName().Str(), "TestNdxC", 8 );
+ iRc += TestMethod( iPo, "SetCurTag()", V3Dbf->SetCurTag( "TestNdxN" ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurTagName()", V3Dbf->GetCurTagName().Str(), "TestNdxN", 8 );
+ xbDouble dbl = 100;
+ iRc += TestMethod( iPo, "Find( 100 )", V3Dbf->Find( dbl ), XB_NOT_FOUND );
+
+ iRc += TestMethod( iPo, "SetCurTag()", V3Dbf->SetCurTag( "TestNdxD" ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurTagName()", V3Dbf->GetCurTagName().Str(), "TestNdxD", 8 );
+ xbDate dt;
+ iRc += TestMethod( iPo, "Find( dt )", V3Dbf->Find( dt ), XB_NOT_FOUND );
+
+ iRc += TestMethod( iPo, "GetFirstKey()", ixPtr->GetFirstKey(), XB_EMPTY );
+ iRc += TestMethod( iPo, "GetNextKey()", ixPtr->GetFirstKey(), XB_EMPTY );
+ iRc += TestMethod( iPo, "GetLasttKey()", ixPtr->GetLastKey(), XB_EMPTY );
+ iRc += TestMethod( iPo, "GetPrevKey()", ixPtr->GetPrevKey(), XB_EMPTY );
+ iRc += TestMethod( iPo, "FindKey()", ixPtr->FindKey( NULL, "19611101", 8, 0 ), XB_NOT_FOUND );
+
+ iRc += TestMethod( iPo, "BlankRecord()", V3Dbf->BlankRecord(), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "Putfield()", V3Dbf->PutField( "CFLD", "AAA" ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "Putfield()", V3Dbf->PutField( "DFLD", "19611109" ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "PutfieldDouble()", V3Dbf->PutDoubleField( "NFLD", 50 ), XB_NO_ERROR );
+
+ iRc += TestMethod( iPo, "AppendRecord()", V3Dbf->AppendRecord(), XB_NO_ERROR );
+
+ xbDate d( "19890209" );
+
+ //for( xbUInt16 i = 0; i < 35 && iRc == XB_NO_ERROR; i++ ){
+ for( xbUInt16 i = 0; i < 2 && iRc == XB_NO_ERROR; i++ ){
+ for( xbUInt16 j = 0; j < 35 && iRc == XB_NO_ERROR; j++ ){
+ c = j + 65;
+ s = c;
+ s.PadRight( c, (xbUInt32) i + 1 );
+ V3Dbf->BlankRecord();
+ V3Dbf->PutField( "CFLD", s );
+ V3Dbf->PutLongField( "NFLD", ++lRecCnt );
+ V3Dbf->PutField( "DFLD", d.Str() );
+ d++;
+
+ iRc = V3Dbf->AppendRecord();
+ }
+ }
+
+ iRc += TestMethod( iPo, "SetCurTag()", V3Dbf->SetCurTag( "TestNdxN" ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurTagName()", V3Dbf->GetCurTagName().Str(), "TestNdxN", 8 );
+
+ dbl = 55.0;
+ iRc += TestMethod( iPo, "Find( 55.0 )", V3Dbf->Find( dbl ), XB_NO_ERROR );
+
+ iRc += TestMethod( iPo, "SetCurTag()", V3Dbf->SetCurTag( "TestNdxC" ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurTagName()", V3Dbf->GetCurTagName().Str(), "TestNdxC", 8 );
+
+ s = "AAA";
+ iRc += TestMethod( iPo, "Find( 'AAA' )", V3Dbf->Find( s ), XB_NO_ERROR );
+
+ s = "AzAA";
+ iRc += TestMethod( iPo, "Find( 'AzAA' )", V3Dbf->Find( s ), XB_NOT_FOUND );
+
+ iRc += TestMethod( iPo, "SetCurTag()", V3Dbf->SetCurTag( "TestNdxD" ), XB_NO_ERROR );
+ iRc += TestMethod( iPo, "GetCurTagName()", V3Dbf->GetCurTagName().Str(), "TestNdxD", 8 );
+
+ std::cout << d.Str() << "\n";
+ iRc += TestMethod( iPo, "Find( '19890420' )", V3Dbf->Find( d ), XB_NOT_FOUND );
+
+ V3Dbf->GetRecord( 26 );
+ V3Dbf->PutField( "CFLD", "AAA" );
+ V3Dbf->PutRecord( 26 );
+
+ V3Dbf->GetRecord( 14 );
+ V3Dbf->PutField( "CFLD", "AAAA" );
+ V3Dbf->PutRecord( 14 );
+
+ V3Dbf->GetRecord( 11 );
+ V3Dbf->PutField( "CFLD", "III" );
+ V3Dbf->PutRecord( 11 );
+
+ V3Dbf->GetRecord( 25 );
+ V3Dbf->PutField( "CFLD", "DDD" );
+ V3Dbf->PutRecord( 25 );
+
+ V3Dbf->GetRecord( 12 );
+ V3Dbf->PutField( "CFLD", "EEE" );
+ V3Dbf->PutRecord( 12 );
+
+ V3Dbf->GetRecord( 26 );
+ V3Dbf->PutField( "CFLD", "CCC" );
+ V3Dbf->PutRecord( 26 );
+
+ V3Dbf->GetRecord( 13 );
+ V3Dbf->PutField( "CFLD", "CCCC" );
+ V3Dbf->PutRecord( 13 );
+
+ V3Dbf->GetRecord( 27 );
+ V3Dbf->PutField( "CFLD", "AAA" );
+ V3Dbf->PutRecord( 27 );
+
+ V3Dbf->GetRecord( 28 );
+ V3Dbf->PutField( "CFLD", "CCC" );
+ V3Dbf->PutRecord( 28 );
+
+ V3Dbf->GetRecord( 24 );
+ V3Dbf->PutField( "CFLD", "FFF" );
+ V3Dbf->PutRecord( 24 );
+
+ V3Dbf->GetRecord( 10 );
+ V3Dbf->PutField( "CFLD", "HHH" );
+ V3Dbf->PutRecord( 10 );
+
+
+ for( xbUInt16 i = 0; i < 35 && iRc == XB_NO_ERROR; i++ ){
+ for( xbUInt16 j = 0; j < 14 && iRc == XB_NO_ERROR; j++ ){
+ c = j + 65;
+ s = c;
+ s.PadRight( c, (xbUInt32) i + 1 );
+ V3Dbf->BlankRecord();
+ V3Dbf->PutField( "CFLD", s );
+ V3Dbf->PutLongField( "NFLD", ++lRecCnt );
+ V3Dbf->PutField( "DFLD", d.Str() );
+ d++;
+ iRc = V3Dbf->AppendRecord();
+ }
+ }
+
+ for( xbUInt16 i = 0; i < 2 && iRc == XB_NO_ERROR; i++ ){
+ for( xbUInt16 j = 0; j < 14 && iRc == XB_NO_ERROR; j++ ){
+ c = j + 65;
+ s = c;
+ s.PadRight( c, (xbUInt32) i + 1 );
+
+ V3Dbf->BlankRecord();
+ V3Dbf->PutField( "CFLD", s );
+ V3Dbf->PutLongField( "NFLD", ++lRecCnt );
+ V3Dbf->PutField( "DFLD", d.Str() );
+ d++;
+
+ iRc = V3Dbf->AppendRecord();
+ }
+ }
+
+ V3Dbf->GetRecord( 26 );
+ V3Dbf->PutField( "CFLD", "AAA" );
+ V3Dbf->PutRecord( 26 );
+
+ V3Dbf->GetRecord( 14 );
+ V3Dbf->PutField( "CFLD", "AAAA" );
+ V3Dbf->PutRecord( 14 );
+
+ V3Dbf->GetRecord( 11 );
+ V3Dbf->PutField( "CFLD", "III" );
+ V3Dbf->PutRecord( 11 );
+
+ V3Dbf->GetRecord( 25 );
+ V3Dbf->PutField( "CFLD", "DDD" );
+ V3Dbf->PutRecord( 25 );
+
+ V3Dbf->GetRecord( 12 );
+ V3Dbf->PutField( "CFLD", "EEE" );
+ V3Dbf->PutRecord( 12 );
+
+ V3Dbf->GetRecord( 26 );
+ V3Dbf->PutField( "CFLD", "CCC" );
+ V3Dbf->PutRecord( 26 );
+
+ V3Dbf->GetRecord( 13 );
+ V3Dbf->PutField( "CFLD", "CCCC" );
+ V3Dbf->PutRecord( 13 );
+
+ V3Dbf->GetRecord( 27 );
+ V3Dbf->PutField( "CFLD", "AAA" );
+ V3Dbf->PutRecord( 27 );
+
+ V3Dbf->GetRecord( 28 );
+ V3Dbf->PutField( "CFLD", "CCC" );
+ V3Dbf->PutRecord( 28 );
+
+ V3Dbf->GetRecord( 24 );
+ V3Dbf->PutField( "CFLD", "FFF" );
+ V3Dbf->PutRecord( 24 );
+
+ V3Dbf->GetRecord( 10 );
+ V3Dbf->PutField( "CFLD", "HHH" );
+ V3Dbf->PutRecord( 10 );
+
+ // just in case there are any issues outstanding
+ V3Dbf->Abort();
+
+ xbIxList *ixl = V3Dbf->GetIxList();
+ xbIxNdx *ix;
+ xbString sTagName;
+ while( ixl ){
+ if( *ixl->sFmt == "NDX" ){
+ ix = (xbIxNdx *) ixl->ix;
+ //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;
+ }
+ }
+
+ iRc += TestMethod( iPo, "Close()", V3Dbf->Close(), XB_NO_ERROR );
+ delete V3Dbf;
+
+ 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], iRc * -1 );
+ x.WriteLogMessage( sMsg, 2 );
+#endif
+
+ return iRc;
+}
diff --git a/src/tests/xb_test_ndx2.cpp b/src/tests/xb_test_ndx2.cpp
new file mode 100755
index 0000000..f406b05
--- /dev/null
+++ b/src/tests/xb_test_ndx2.cpp
@@ -0,0 +1,145 @@
+/* xb_test_ndx2.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:
+
+ xb64-devel@lists.sourceforge.net
+ xb64-users@lists.sourceforge.net
+
+*/
+
+// This program tests the class xbIxNdx
+
+// usage: xb_test_ndx QUITE|NORMAL|VERBOSE
+
+
+
+// fix me - this program needs to test GetUnique
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+ int iRc = 0;
+ int iRc2 = 0;
+ int po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+
+ xbSchema MyV3Record[] =
+ {
+ { "CFLD", XB_CHAR_FLD, 30, 0 },
+ { "DFLD", XB_DATE_FLD, 8, 0 },
+ { "NFLD", XB_NUMERIC_FLD, 12, 0 },
+ { "",0,0,0 }
+ };
+
+
+ xbXBase x;
+#ifdef XB_LOGGING_SUPPORT
+ x.EnableMsgLogging();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+ x.SetLogSize( 1000000 );
+#endif
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+// x.DisableDefaultAutoLock();
+
+ x.SetUniqueKeyOpt( XB_EMULATE_DBASE );
+ InitTime();
+ xbString s;
+ iRc = 0;
+
+ if( po > 0 )
+ std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+ xbDbf *V3Dbf = new xbDbf3( &x );
+ xbIx *ixPtr;
+ void *ndx;
+
+ iRc2 = V3Dbf->CreateTable( "TestNdx.DBF", "TestNdx", MyV3Record, XB_OVERLAY, XB_MULTI_USER );
+ iRc += TestMethod( po, "CreateTable()", (xbInt32) iRc2, XB_NO_ERROR );
+
+ if( iRc2 )
+ x.DisplayError( iRc2 );
+
+ iRc2 = V3Dbf->CreateTag( "NDX", "TestNdxC.NDX", "CFLD", "", 0, xbTrue, XB_OVERLAY, &ixPtr, &ndx );
+ iRc += TestMethod( po, "CreateTag()", (xbInt32) iRc2, XB_NO_ERROR );
+ if( iRc2 )
+ x.DisplayError( iRc2 );
+
+ iRc2 = V3Dbf->AssociateIndex( "NDX", "TestNdxC.NDX", 0 );
+ iRc += TestMethod( po, "Associate()", (xbInt32) iRc2, XB_NO_ERROR );
+
+
+ iRc += TestMethod( po, "BlankRecord()", V3Dbf->BlankRecord(), XB_NO_ERROR );
+ iRc += TestMethod( po, "Putfield()", V3Dbf->PutField( "CFLD", "AAA" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "Putfield()", V3Dbf->PutField( "DFLD", "19611109" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutfieldDouble()", V3Dbf->PutDoubleField( "NFLD", 50 ), XB_NO_ERROR );
+ iRc += TestMethod( po, "AppendRecord()", V3Dbf->AppendRecord(), XB_NO_ERROR );
+
+
+ iRc += TestMethod( po, "BlankRecord()", V3Dbf->BlankRecord(), XB_NO_ERROR );
+ iRc += TestMethod( po, "Putfield()", V3Dbf->PutField( "CFLD", "BBB" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "Putfield()", V3Dbf->PutField( "DFLD", "19611109" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutfieldDouble()", V3Dbf->PutDoubleField( "NFLD", 50 ), XB_NO_ERROR );
+ iRc += TestMethod( po, "AppendRecord()", V3Dbf->AppendRecord(), XB_NO_ERROR );
+
+ iRc += TestMethod( po, "BlankRecord()", V3Dbf->BlankRecord(), XB_NO_ERROR );
+ iRc += TestMethod( po, "Putfield()", V3Dbf->PutField( "CFLD", "BBB" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "Putfield()", V3Dbf->PutField( "DFLD", "19611109" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "PutfieldDouble()", V3Dbf->PutDoubleField( "NFLD", 50 ), XB_NO_ERROR );
+ iRc += TestMethod( po, "AppendRecord()", V3Dbf->AppendRecord(), XB_NO_ERROR );
+
+
+ xbIxList *ixl = V3Dbf->GetIxList();
+ xbIxNdx *ix;
+ xbString sTagName;
+ while( ixl ){
+ if( *ixl->sFmt == "NDX" ){
+ ix = (xbIxNdx *) ixl->ix;
+ //ix->GetTagName( 0, sTagName );
+ sMsg.Sprintf( "CheckTagIntegrity() - [%s]", ix->GetTagName(ix->GetCurTag()).Str());
+ iRc += TestMethod( po, sMsg, ix->CheckTagIntegrity( ix->GetCurTag(), 2 ), XB_NO_ERROR );
+ ixl = ixl->next;
+ }
+ }
+
+ iRc += TestMethod( po, "Close()", V3Dbf->Close(), XB_NO_ERROR );
+ delete V3Dbf;
+
+ if( po > 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], iRc * -1 );
+ x.WriteLogMessage( sMsg, 2 );
+#endif
+
+ return iRc;
+}
diff --git a/src/tests/xb_test_sql.cpp b/src/tests/xb_test_sql.cpp
new file mode 100755
index 0000000..630cc89
--- /dev/null
+++ b/src/tests/xb_test_sql.cpp
@@ -0,0 +1,107 @@
+/* xb_test_sql.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:
+
+ xb64-devel@lists.sourceforge.net
+ xb64-users@lists.sourceforge.net
+
+*/
+
+// This program tests the SQL functions
+
+// usage: xb_test_sql QUITE|NORMAL|VERBOSE
+
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+ int iRc = 0;
+ int iRc2 = 0;
+ int po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+
+ xbSchema MySqlRecord[] =
+ {
+ { "CITY", XB_CHAR_FLD, 30, 0 },
+ { "STATE", XB_CHAR_FLD, 2, 0 },
+ { "ZIPCODE", XB_NUMERIC_FLD, 9, 0 },
+ { "NOTES", XB_MEMO_FLD, 10, 0 },
+ { "LASTUPDATE", XB_DATE_FLD, 8, 1 },
+ { "ACTIVE", XB_LOGICAL_FLD, 1, 0 },
+ { "",0,0,0 }
+ };
+
+
+ xbXBase x;
+#ifdef XB_LOGGING_SUPPORT
+ x.EnableMsgLogging();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+#endif
+
+
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+ InitTime();
+
+ xbSql sql( &x );
+
+ if( po > 0 )
+ std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+
+ xbDbf4 SqlDbf( &x ); // version 4 dbf file
+ iRc2 = SqlDbf.CreateTable( "TestSQL.DBF", "TestSQL", MySqlRecord, XB_OVERLAY, XB_MULTI_USER );
+ iRc += TestMethod( po, "CreateTable()", (xbInt32) iRc2, XB_NO_ERROR );
+ if( iRc2 )
+ x.DisplayError( iRc2 );
+
+
+ xbString 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')";
+
+ iRc2 = sql.ExecuteNonQuery( sSql );
+ iRc += TestMethod( po, "Insert()", (xbInt32) iRc2, XB_NO_ERROR );
+ if( iRc2 )
+ x.DisplayError( iRc2 );
+
+ iRc += TestMethod( po, "Close()", SqlDbf.Close(), XB_NO_ERROR );
+
+ if( po > 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], iRc * -1 );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ return iRc;
+}
+
diff --git a/src/tests/xb_test_string.cpp b/src/tests/xb_test_string.cpp
new file mode 100755
index 0000000..f39c101
--- /dev/null
+++ b/src/tests/xb_test_string.cpp
@@ -0,0 +1,397 @@
+/* xb_test_string.cpp
+
+XBase63 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
+
+*/
+
+// This program tests the string class xbString
+
+// usage: xb_test_string QUIET|NORMAL|VERBOSE
+
+#define VERBOSE
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+int main( int argCnt, char **av = NULL )
+
+//int main( int argCnt, char *argv[] )
+{
+ int rc = 0;
+ int po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+ xbXBase x;
+
+ #ifdef XB_LOGGING_SUPPORT
+ x.EnableMsgLogging();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+ #endif
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+
+ InitTime();
+
+ // create a string, assign a value
+ xbString s1;
+ s1 = "Test String 1";
+ rc += TestMethod( po, "Constructor s1" , s1, "Test String 1", 13 );
+
+ // create another string, copy the value from s1 into it
+ xbString s2;
+ s2 = s1;
+ rc += TestMethod( po, "Operator '=' " , s2, "Test String 1", 13 );
+
+ // create another string with a single character
+ xbString s3( 'X' );
+
+ //std::cout << "s3 = [" << s3 << "]" << std::endl;
+ rc += TestMethod( po, "Constructor s3" , s3, "X", 1 );
+
+ // create another string and assign data to it yet another way
+ xbString s4( "Class constructor test 4" );
+ rc += TestMethod( po, "Constructor s4" , s4, "Class constructor test 4", 24 );
+
+ // create another string with a size limit
+ xbString s5( "Class constructor test 4", 7 );
+ rc += TestMethod( po, "Constructor s5" , s5, "Class c", 7 );
+
+ // create another string from a string
+ xbString s6( s5 );
+ rc += TestMethod( po, "Constructor s6" , s6, "Class c", 7 );
+
+ // create 15 byte string with nothing in it
+ xbString s7( (xbUInt32) 15 );
+ rc += TestMethod( po, "Constructor s7" , s7, "", 0 );
+
+ xbString s8( "some test data", 6 );
+ rc += TestMethod( po, "Constructor s8" , s8, "some t", 6 );
+
+ xbString s9( "some test data", 30 );
+ rc += TestMethod( po, "Constructor s9" , s9, "some test data", 14 );
+
+ // Extract character from a particular position in the string
+ rc += TestMethod( po, "Operator [] ", s1[7], 't' );
+ rc += TestMethod( po, "Operator [] ", s1.GetCharacter(7), 't' );
+
+ s1[6] = 'X';
+ rc += TestMethod( po, "Operator assignment [] ", s1.GetCharacter(6), 'X' );
+
+ // set string 7 to a character
+ s7 = 'Z';
+ rc += TestMethod( po, "Operator =", s7.Str(), "Z", 1 );
+
+ // Concatenation tests - I
+ s1 = " part 1 ";
+ s1 += " part 2 ";
+ s2 = " part 3 ";
+ s1 += s2;
+ s1 += 'Z';
+ rc += TestMethod( po, "Concatenation test 1", s1, " part 1 part 2 part 3 Z", 25 );
+
+ // Concatenation tests - II
+ s1 = "part 1 ";
+ s1 -= "part 2 ";
+ s1 -= 'X';
+ s1 -= s2;
+ rc += TestMethod( po, "Concatenation test 2", s1, "part 1part 2X part 3", 20 );
+
+ // Concatenation tests - III
+ s1 = "s1data ";
+ s2 = "s2data ";
+ s3 = s1 - s2;
+ rc += TestMethod( po, "Concatenation test 3", s3, "s1datas2data", 12 );
+
+ // Concatenation tests - IV
+ s3 = s1 + s2;
+ rc += TestMethod( po, "Concatenation test 4", s3, "s1data s2data ", 15 );
+
+ // Concatenation tests - V
+ s3 = s1 + " (char * data) " + "xyz " + s2 + 'z';
+ rc += TestMethod( po, "Concatenation test 1", s3, "s1data (char * data) xyz s2data z", 36 );
+
+ //Operator tests
+ s1 = "aaa";
+ s2 = "bbb";
+ rc += TestMethod( po, "Operator == ", s1 == s2, 0 );
+ rc += TestMethod( po, "Operator != ", s1 != s2, 1 );
+ rc += TestMethod( po, "Operator < ", s1 < s2, 1 );
+ rc += TestMethod( po, "Operator > ", s1 > s2, 0 );
+ rc += TestMethod( po, "Operator < ", s1 <= s2, 1 );
+ rc += TestMethod( po, "Operator > ", s1 >= s2, 0 );
+
+ s1 = s2;
+ rc += TestMethod( po, "Operator == ", s1 == s2, 1 );
+ rc += TestMethod( po, "Operator != ", s1 == s2, 1 );
+ rc += TestMethod( po, "Operator < ", s1 < s2, 0 );
+ rc += TestMethod( po, "Operator > ", s1 > s2, 0 );
+ rc += TestMethod( po, "Operator < ", s1 <= s2, 1 );
+ rc += TestMethod( po, "Operator > ", s1 >= s2, 1 );
+
+ s1 = "XYZ";
+ rc += TestMethod( po, "Operator * ", (const char *) s1, "XYZ", 3 );
+
+ s1 = 'Z';
+ rc += TestMethod( po, "Operator = ", s1, "Z", 1 );
+
+ s1 = "ABC,xyz";
+ rc += TestMethod( po, "CountChar(c,1) ", (xbInt32) s1.CountChar( ',',1 ), 1 );
+
+ s1 = "ABC,xy,z";
+ rc += TestMethod( po, "CountChar(c,1) ", (xbInt32) s1.CountChar( ',',1 ), 2 );
+
+ s1 = "ABC,xy,z'asad,as'adss";
+ rc += TestMethod( po, "CountChar(c,1) ", (xbInt32) s1.CountChar( ',',1 ), 2 );
+
+ s1 = "ABADFDSGA";
+ rc += TestMethod( po, "CountChar() ", (xbInt32) s1.CountChar( 'A' ), 3 );
+
+ s1.Ltrunc( 4 );
+ rc += TestMethod( po, "Ltrunc(4) ", s1, "FDSGA", 5 );
+
+ s1.PutAt( 3, 'Z' );
+ rc += TestMethod( po, "PutAt(3,'Z') ", s1, "FDZGA", 5 );
+
+ s1.AddBackSlash( 'Z' );
+ rc += TestMethod( po, "AddBackSlash( 'Z' ) ", s1, "FD\\ZGA", 6 );
+
+ s1 = "ABCDEFG";
+ rc += TestMethod( po, "s1.Append( 'Z' )", s1.Append( 'Z' ).Str(), "ABCDEFGZ", 8 );
+ rc += TestMethod( po, "s1.Append( '999' )", s1.Append( "999" ), "ABCDEFGZ999", 11 );
+ s2 = "!@#";
+ rc += TestMethod( po, "s1.Append( '!@#' )", s1.Append( s2 ), "ABCDEFGZ999!@#", 14 );
+
+ rc += TestMethod( po, "s1.Assign( 'ABCDE', 3, 2 )", s1.Assign( "ABCDE", 3, 2 ), "CD", 2 );
+ rc += TestMethod( po, "s1.Assign( 'ABCDE', 2, 7 )", s1.Assign( "ABCDE", 2, 7 ), "BCDE", 4 );
+ rc += TestMethod( po, "s1.Assign( 'ABCDE', 1, 4 )", s1.Assign( "ABCDE", 1, 4 ), "ABCD", 4 );
+ rc += TestMethod( po, "s1.Assign( 'ABCDE', 5, 5 )", s1.Assign( "ABCDE", 5, 5 ), "E", 1 );
+ rc += TestMethod( po, "s1.Assign( 'ABCDE', 15, 5 )", s1.Assign( "ABCDE", 15, 5 ), "", 0 );
+
+ rc += TestMethod( po, "s1.Assign( 'ABCDE', 1 )", s1.Assign( "ABCDE", 1 ), "ABCDE", 5 );
+ rc += TestMethod( po, "s1.Assign( 'ABCDE', 3 )", s1.Assign( "ABCDE", 3 ), "CDE", 3 );
+ rc += TestMethod( po, "s1.Assign( 'ABCDE', 10 )", s1.Assign( "ABCDE", 10 ), "", 0 );
+
+ s2 = "ABCDE";
+ rc += TestMethod( po, "s1.Assign( s2, 3, 2 )", s1.Assign( s2, 3, 2 ), "CD", 2 );
+ rc += TestMethod( po, "s1.Assign( s2, 2, 7 )", s1.Assign( s2, 2, 7 ), "BCDE", 4 );
+ rc += TestMethod( po, "s1.Assign( s2, 1, 4 )", s1.Assign( s2, 1, 4 ), "ABCD", 4 );
+ rc += TestMethod( po, "s1.Assign( s2, 5, 5 )", s1.Assign( s2, 5, 5 ), "E", 1 );
+ rc += TestMethod( po, "s1.Assign( s2, 15, 5 )", s1.Assign( s2, 15, 5 ), "", 0 );
+
+ rc += TestMethod( po, "s1.Assign( s2, 1 )", s1.Assign( s2, 1 ), "ABCDE", 5 );
+ rc += TestMethod( po, "s1.Assign( s2, 3 )", s1.Assign( s2, 3 ), "CDE", 3 );
+ rc += TestMethod( po, "s1.Assign( s2, 10 )", s1.Assign( s2, 10 ), "", 0 );
+
+ s2 = "1234567890";
+ s1 = s2.Copy();
+ rc += TestMethod( po, "Copy() ", s1, "1234567890", 10 );
+
+ s1 = "0x35";
+ char hexChar;
+ s1.CvtHexChar( hexChar );
+ rc += TestMethod( po, "CvtHexChar(hexChar) ", hexChar, '5' );
+
+ s1 = "0x610x620x630x640x65";
+ s1.CvtHexString( s2 );
+ rc += TestMethod( po, "CvtHexString() ", s2, "abcde", 5 );
+
+ s1 = "123";
+ s2 = "ABC";
+ rc += TestMethod( po, "HasAlphaChars()", s1.HasAlphaChars(), 0 );
+ rc += TestMethod( po, "HasAlphaChars()", s2.HasAlphaChars(), 1 );
+
+ s1 = "\\ABC\\XYZ";
+ rc += TestMethod( po, "GetPathSeparator()", s1.GetPathSeparator(), '\\' );
+
+ s1 = "/ABC/XYZ";
+ rc += TestMethod( po, "GetPathSeparator()", s1.GetPathSeparator(), '/' );
+
+ s2 = "";
+ rc += TestMethod( po, "IsEmpty()", s2.IsEmpty(), 1 );
+
+ // trim tests
+ s1 = " ABC ";
+ rc += TestMethod( po, "Ltrim()", s1.Ltrim(), "ABC ", 6 );
+ s1 = " ABC ";
+ rc += TestMethod( po, "Rtrim()", s1.Rtrim(), " ABC", 6 );
+ s1 = " ABC ";
+ rc += TestMethod( po, "Trim() ", s1.Trim(), "ABC", 3 );
+
+ s1 = "ABC ";
+ rc += TestMethod( po, "Ltrim()", s1.Ltrim(), "ABC ", 6 );
+
+ s1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ rc += TestMethod( po, "Mid(3,0) ", s1.Mid(3,0), "", 0 );
+
+ s1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ rc += TestMethod( po, "Mid(4,5) ", s1.Mid(4,5), "DEFGH", 5 );
+
+ rc += TestMethod( po, "Pos('G') ", (xbInt32) s1.Pos( 'G' ), 4 );
+ rc += TestMethod( po, "Pos(\"EFG\") ", (xbInt32) s1.Pos( "EFG" ), 2 );
+
+ rc += TestMethod( po, "Pos('0') ", (xbInt32) s1.Pos( '0' ), 0 );
+ rc += TestMethod( po, "Pos(\"000\") ", (xbInt32) s1.Pos( "000" ), 0 );
+ rc += TestMethod( po, "Pos(\"DEF\") ", (xbInt32) s1.Pos( "DEF" ), 1 );
+
+ s1 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
+ rc += TestMethod( po, "Remove(3,5) ", s1.Remove( 3, 5 ), "ABHIJKLMNOPQRSTUVWXYZ", 21 );
+
+ s1 = "ABCABCABZ";
+ s1.SwapChars( 'A', '9' );
+ rc += TestMethod( po, "SwapChars() ", s1, "9BC9BC9BZ", 9 );
+
+ s1.ToLowerCase();
+ rc += TestMethod( po, "ToLowerCase() ", s1, "9bc9bc9bz", 9 );
+
+ s1.ToUpperCase();
+ rc += TestMethod( po, "ToUpperCase() ", s1, "9BC9BC9BZ", 9 );
+
+ s1.ZapChar( '9' );
+ rc += TestMethod( po, "ZapChar('9') ", s1, "BCBCBZ", 6 );
+
+ s1.ZapLeadingChar( 'B' );
+ rc += TestMethod( po, "ZapLeadingChar('B') ", s1, "CBCBZ", 5 );
+
+ s1.ZapTrailingChar( 'Z' );
+ rc += TestMethod( po, "ZapLeadingChar('B') ", s1, "CBCB", 4 );
+
+ s1.ExtractElement( "aaaa|bbbb|cccc|dddd", '|', 2, 0 );
+ rc += TestMethod( po, "ExtractElement() ", s1, "bbbb", 4 );
+
+ s1.ExtractElement( "aaaa|b'bb|c'ccc|dddd", '|', 3, 1 );
+ rc += TestMethod( po, "ExtractElement() ", s1, "dddd", 4 );
+
+ s1 = "123";
+ s1.PadLeft( '0', 9 );
+ rc += TestMethod( po, "PadLeft() ", s1, "000000123", 9 );
+
+ s1 = "abc";
+ s1.PadRight( 'Z', 9 );
+ rc += TestMethod( po, "PadRight() ", s1, "abcZZZZZZ", 9 );
+
+ s1.Left( 4 );
+ rc += TestMethod( po, "Left(4) ", s1, "abcZ", 4 );
+
+ s1.Left( 1 );
+ rc += TestMethod( po, "Left(1) ", s1, "a", 1 );
+
+ s1.Left( 0 );
+ rc += TestMethod( po, "Left(0) ", s1, "", 0 );
+
+
+ char buf[5];
+ buf[0] = 'W';
+ buf[1] = 'X';
+ buf[2] = 'Y';
+ buf[3] = 'Z';
+ buf[4] = 0x00;
+ xbInt32 l = 1234567;
+ xbFloat f = (xbFloat) 12.35;
+ s2 = "test string";
+
+ rc += TestMethod( po, "s1.Sprintf()", s1.Sprintf( "%s %d %s %ld", buf, 12, s2.Str(), l ), "WXYZ 12 test string 1234567", 27 );
+
+ // %f format varies depending on compiler
+ s1.Sprintf( "%6.2f", f );
+ s1.Ltrim();
+ rc += TestMethod( po, "s1.Sprintf()/s.Trim()", s1, "12.35", 5 );
+
+ s1.SetNum( (long) 123456 );
+ rc += TestMethod( po, "SetNum() ", s1, "123456", 6 );
+
+ s1 = "T";
+ rc += TestMethod( po, "ValidLogicalValue", s1.ValidLogicalValue(), 1 );
+
+ s1 = "xyz";
+ rc += TestMethod( po, "ValidLogicalValue", s1.ValidLogicalValue(), 0 );
+
+ s1 = "-123456.89";
+ rc += TestMethod( po, "ValidNumericValue", s1.ValidNumericValue(), 1 );
+
+ s1 = "ABC-123456.89";
+ rc += TestMethod( po, "ValidNumericValue", s1.ValidNumericValue(), 0 );
+
+ s1 = "abcabcabx";
+ rc += TestMethod( po, "GetLastPos", (xbInt16) s1.GetLastPos( 'b' ), 8 );
+ s1 = "abcabcabx";
+ rc += TestMethod( po, "GetLastPos", (xbInt16) s1.GetLastPos( 'x' ), 9 );
+ s1 = "abcabcabx";
+ rc += TestMethod( po, "GetLastPos", (xbInt16) s1.GetLastPos( '$' ), 0 );
+ rc += TestMethod( po, "GetLastPos", (xbInt16) s1.GetLastPos( "ab" ), 7 );
+
+ s1 = ")";
+ rc += TestMethod( po, "GetLastPos", (xbInt16) s1.GetLastPos( ')' ), 1 );
+ s1 = "))))";
+ rc += TestMethod( po, "GetLastPos", (xbInt16) s1.GetLastPos( ')' ), 4 );
+
+ char * p;
+ p = (char *) malloc( 5 );
+ p[0] = '1';
+ p[1] = '2';
+ p[2] = '3';
+ p[3] = '4';
+ p[4] = 0x00;
+ s1.Set( p, 5 );
+ free( p );
+ rc += TestMethod( po, "Set", s1, "1234", 4 );
+
+
+ xbDouble d = 12345678.876543;
+ xbString sD( d );
+ rc += TestMethod( po, "xbDouble Constructor", sD, "12345678.876543", 15 );
+
+ xbString sSet;
+ sSet.Set( sD );
+ rc += TestMethod( po, "Set", sD, sD, 15 );
+ sSet.Set( s2 );
+ rc += TestMethod( po, "Set", sSet, s2, 11 );
+ sSet.Set( "" );
+ rc += TestMethod( po, "Set", sSet, "", 0 );
+
+ s1.Sprintf( "string %d", 1 );
+ s2.Sprintf( "string %1.1f", 2.0 );
+ s3.Sprintf( "%s and %s", s1.Str(), s2.Str());
+ rc += TestMethod( po, "Sprintf", s3, "string 1 and string 2.0", 23 );
+
+ xbInt16 iErrorStop = 10;
+ xbInt16 iRc = -100;
+ sMsg.Sprintf( "class::method() Exception Caught. Error Stop = [%d] iRc = [%d] Expression = [%s]", iErrorStop, iRc, s3.Str() );
+
+ if( po > 0 || rc < 0 )
+ fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+
+#ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ return rc;
+}
+
diff --git a/src/tests/xb_test_tblmgr.cpp b/src/tests/xb_test_tblmgr.cpp
new file mode 100755
index 0000000..26ec96a
--- /dev/null
+++ b/src/tests/xb_test_tblmgr.cpp
@@ -0,0 +1,167 @@
+/* xb_test_tblmgr.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
+
+*/
+
+// This program tests the class xbXBase
+// usage: xb_test_tblmgr QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+int main( int argCnt, char **av )
+{
+ int rc = 0;
+ int po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+ xbXBase x;
+
+#ifdef XB_LOGGING_SUPPORT
+ x.EnableMsgLogging();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+#endif
+ InitTime();
+
+ if( po == 2 ){
+ std::cout << "DisplayError Test ==> ";
+ x.DisplayError( 0 );
+ #ifdef WIN32
+ std::cout << "WIN32 environment" << std::endl;
+ #else
+ std::cout << "Not WIN32 environment" << std::endl;
+ #endif
+ }
+
+ xbDbf * d1;
+ xbDbf * d2;
+
+ #if defined (XB_DBF3_SUPPORT )
+ d1 = new xbDbf3( &x );
+ #elif defined( XB_DBF4_SUPPORT )
+ d1 = new xbDbf4( &x );
+ #else
+ std::cout << "No dbf file support built into library" << std::endl;
+ 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 );
+
+
+ // Next line should generate an exception
+ rc += TestMethod( po, "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();
+
+ d2 = (xbDbf *) x.GetDbfPtr( "TestTableA" );
+ if( d2 )
+ std::cout << "[PASS] GetDbfPtr()" << std::endl;
+ else{
+ std::cout << "[FAIL] GetDbfPtr()" << std::endl;
+ rc--;
+ }
+
+
+std::cout << "cp0\n";
+ x.SetDataDirectory( "/ABCDEFG/" );
+
+ #ifdef WIN32
+ rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(), "\\ABCDEFG\\", 9 );
+ #else
+ rc += TestMethod( po, "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 );
+ #else
+ rc += TestMethod( po, "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 );
+ #else
+ rc += TestMethod( po, "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 );
+ #else
+ rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(), "/ABCDEFG", 8 );
+ #endif
+
+
+ std::cout << "cp4\n";
+
+
+ x.SetDataDirectory( "ABCDEFG" );
+ rc += TestMethod( po, "Set/GetDataDirectory()", x.GetDataDirectory(), "ABCDEFG", 7 );
+
+
+ rc += TestMethod( po, "RemoveTblFromDbList()", x.RemoveTblFromTblList( "TestTableB" ), 0 );
+ rc += TestMethod( po, "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 );
+
+
+ delete d1;
+
+ if( po > 0 || rc < 0 )
+ fprintf( stdout, "Total Errors = %d\n", rc * -1 );
+
+
+#ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], rc * -1 );
+ x.WriteLogMessage( sMsg );
+#endif
+
+
+ return rc;
+}
+
diff --git a/src/tests/xb_test_uda.cpp b/src/tests/xb_test_uda.cpp
new file mode 100755
index 0000000..dec41fa
--- /dev/null
+++ b/src/tests/xb_test_uda.cpp
@@ -0,0 +1,98 @@
+/* xb_test_uda.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
+
+*/
+
+// This program tests the uda (user data area) functions
+
+// usage: xb_test_uda QUITE|NORMAL|VERBOSE
+
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+
+int main( int argCnt, char **av )
+{
+ int iRc = 0;
+ //int iRc2 = 0;
+ int po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+
+
+ xbXBase x;
+#ifdef XB_LOGGING_SUPPORT
+ x.EnableMsgLogging();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+#endif
+
+
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ x.EnableMsgLogging();
+
+ xbUda uda;
+ iRc += TestMethod( po, "GetTokencCnt()", uda.GetTokenCnt(), 0 );
+ xbString s1;
+ xbString s2;
+ iRc += TestMethod( po, "AddTokenForKey()", uda.AddTokenForKey( "B", "BBBB" ), XB_NO_ERROR );
+ s1 = "C";
+ iRc += TestMethod( po, "AddTokenForKey()", uda.AddTokenForKey( s1, "CCCC" ), XB_NO_ERROR );
+ s2 = "DDDD";
+ iRc += TestMethod( po, "AddTokenForKey()", uda.AddTokenForKey( "D", s2 ), XB_NO_ERROR );
+
+ s1 = "A";
+ s2 = "AAAA";
+ iRc += TestMethod( po, "AddTokenForKey()", uda.AddTokenForKey( s1, s2 ), XB_NO_ERROR );
+ iRc += TestMethod( po, "AddTokenForKey()", uda.AddTokenForKey( "AA", "AAAAA" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "AddTokenForKey()", uda.AddTokenForKey( "BB", "BBBBB" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "AddTokenForKey()", uda.AddTokenForKey( "CC", "CCCCC" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "AddTokenForKey()", uda.AddTokenForKey( "DD", "DDDDD" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetTokencCnt()", uda.GetTokenCnt(), 8);
+
+ iRc += TestMethod( po, "UpdTokenForKey()", uda.UpdTokenForKey( "BB", "9999" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "UpdTokenForKey()", uda.DelTokenForKey( "CC" ), XB_NO_ERROR );
+ iRc += TestMethod( po, "GetTokencCnt()", uda.GetTokenCnt(), 7 );
+
+#ifdef XB_DEBUG_SUPPORT
+ uda.DumpUda();
+#endif // XB_DEBUG_SUPPORT
+
+ uda.Clear();
+ iRc += TestMethod( po, "GetTokencCnt()", uda.GetTokenCnt(), 0 );
+
+#ifdef XB_LOGGING_SUPPORT
+ sMsg.Sprintf( "Program [%s] terminating with [%d] errors...", av[0], iRc * -1 );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ return iRc;
+}
diff --git a/src/tests/xb_test_xbase.cpp b/src/tests/xb_test_xbase.cpp
new file mode 100755
index 0000000..6dad3f7
--- /dev/null
+++ b/src/tests/xb_test_xbase.cpp
@@ -0,0 +1,106 @@
+/* xb_test_xbase.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
+
+*/
+
+// This program tests the class xbXBase
+
+// usage: xb_test_xbase QUITE|NORMAL|VERBOSE
+
+
+#include "xbase.h"
+
+using namespace xb;
+
+#include "tstfuncs.cpp"
+
+int main( int argCnt, char **av )
+{
+ int iRc = 0;
+ int po = 1; /* print option */
+ /* 0 - QUIET */
+ /* 1 - NORMAL */
+ /* 2 - VERBOSE */
+
+ if( argCnt > 1 ) {
+ if( av[1][0] == 'Q' )
+ po = 0;
+ else if( av[1][0] == 'V' )
+ po = 2;
+ }
+
+
+ xbXBase x;
+
+
+#ifdef XB_LOGGING_SUPPORT
+ x.EnableMsgLogging();
+ if( po ){
+ std::cout << "Logfile is [" << x.GetLogFqFileName().Str() << "]" << std::endl;
+ }
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[0] );
+ x.WriteLogMessage( sMsg );
+#endif
+ InitTime();
+
+
+ x.SetDefaultDateFormat( "YY-MM-DD" );
+ iRc += TestMethod( po, "SetDefaultDateFormat", x.GetDefaultDateFormat(), "YY-MM-DD", 8 );
+
+ if( po == 2 ){
+ if( x.GetEndianType() == 'L' )
+ std::cout << "Little Endian Architecture" << std::endl;
+ else if( x.GetEndianType() == 'B' )
+ std::cout << "Big Endian Architecture" << std::endl;
+ else
+ std::cout << "Undefine Endian Architecture" << std::endl;
+ }
+
+ iRc += TestMethod( po, "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());
+
+ xbString sLogName = CMAKE_SYSTEM_NAME;
+ sLogName += "_";
+ sLogName += XB_PLATFORM;
+ sLogName += ".xbLog.txt";
+ iRc += TestMethod( po, "GetDefaultLogFileName()", x.GetDefaultLogFileName(), sLogName, sLogName.Len());
+
+ x.WriteLogMessage( "test" );
+#endif
+
+ x.xbSleep( 250 );
+
+
+
+ if( po == 2 ){
+ std::cout << "DisplayError Test ==> ";
+ x.DisplayError( 0 );
+ }
+
+ if( po > 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], iRc * -1 );
+ x.WriteLogMessage( sMsg );
+#endif
+
+ return iRc;
+}
+
diff --git a/src/utils/checkndx.cpp b/src/utils/checkndx.cpp
new file mode 100755
index 0000000..adb5e1c
--- /dev/null
+++ b/src/utils/checkndx.cpp
@@ -0,0 +1,71 @@
+/*
+ Xbase64 project source code
+
+ Copyright (C) 1997,2003 Gary A. Kunkel
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ Contact:
+
+ Email:
+
+ xbase64-devel@lists.sourceforge.net
+ xbase64-users@lists.sourceforge.net
+
+*/
+
+
+// FIXME - program needs to be updated
+
+#include <xbase64/xbase64.h>
+
+int main(int ac,char** av)
+{
+#ifdef XBASE_DEBUG
+ xbXBase x;
+ xbDbf d( &x );
+ xbNdx i( &d );
+ xbInt16 rc;
+
+ if( 3 != ac ){
+ std::cout <<
+ "\nUsage: checkndx dbf_file index_file\n";
+ return 1;
+ }
+
+ if(( rc = d.Open( av[1] )) != XB_NO_ERROR )
+ {
+ std::cout << "\nCould not open file " << av[1] << " rc = " << rc << "\n";
+ return 2;
+ }
+
+ if(( rc = i.OpenIndex( av[2] )) != XB_NO_ERROR )
+ {
+ std::cout << "\nCould not open file " << av[2] << " rc = " << rc << "\n";
+ return 3;
+ }
+
+ std::cout << "\nRunning...\n";
+ rc = i.CheckIndexIntegrity( 1 );
+ std::cout << "\nNdx integrity check = " << rc << "\n";
+
+ i.DumpHdrNode(0);
+
+ d.Close();
+#else
+ std::cout << "\nXBASE_DEBUG is not compiled in\n";
+#endif
+ return 0;
+}
diff --git a/src/utils/dbfxtrct.cpp b/src/utils/dbfxtrct.cpp
new file mode 100755
index 0000000..17752c1
--- /dev/null
+++ b/src/utils/dbfxtrct.cpp
@@ -0,0 +1,182 @@
+/*
+ Xbase64 project source code
+
+ This program extracts data from a dbf data file and puts it in
+ a comma delimited output file, suitable for input into an awk or
+ perl script
+
+ This program excludes all memo fields
+
+ Copyright (C) 1997,2003 Gary A. Kunkel
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ Contact:
+
+ Email:
+
+ xbase64-devel@lists.sourceforge.net
+ xbase64-users@lists.sourceforge.net
+
+*/
+
+#include <xbase64/xbase64.h>
+
+
+// FIXME - program need to be updated
+
+/*************************************************************************/
+void Usage();
+void Usage()
+{
+ std::cout << "\nUsage: dbfxtrct -iDATABASE.DBF -sINDEX.N[TD]X -f -F -dMM/DD/YY\n";
+ std::cout << "\nWhere DATABASE.DBF is the name of the database file to dump\n";
+ std::cout << "INDEX.NTX or .NDX is an optional index sort paramater\n";
+ std::cout << "-f optional field name list in first record\n";
+ std::cout << "-F optional field name and attributes in first record\n";
+ std::cout << "MM/DD/YY is an optional output date format for any date fields\n";
+ std::cout << "\nThis program creates output suitable for awk and perl scripts\n";
+ std::cout << "\nThis program does not support memo fields (yet).\n";
+}
+/*************************************************************************/
+int main(int ac,char** av)
+{
+ xbXBase x;
+ xbDbf d( &x );
+ xbInt16 rc, FieldOption = 0;
+ xbIndex *ix = 0;
+ xbNdx z(&d);
+
+ char *dbfname = NULL;
+ char *ixname = NULL;
+ char *p;
+ char buf[200];
+ xbExpn exp( &x );
+
+/* Get the input paramaters
+
+ -i input datafile name
+ -s optional sort index name
+ -f optional field names in record one
+ -F optional field names and attributes in record one
+ -d date format
+*/
+ for( int i = 1; i < ac; i++ )
+ {
+ p = av[i];
+ if( *p != '-' ){
+ std::cout << "Invalid paramater " << *p << std::endl;
+ Usage();
+ return 1;
+ }
+ p++;
+ if( *p == 'i' )
+ dbfname = ++p;
+ else if( *p == 's' )
+ ixname = ++p;
+ else if( *p == 'f' )
+ FieldOption = 1;
+ else if( *p == 'F' )
+ FieldOption = 2;
+ else if( *p == 'd' )
+ x.SetDefaultDateFormat( ++p );
+ else{
+ std::cout << "Invalid paramater " << *p << std::endl;
+ Usage();
+ return 1;
+ }
+ }
+
+/* if missing params, display a usage message and exit */
+
+ if( !dbfname ){
+ Usage();
+ return 1;
+ }
+
+/* open the database file */
+
+ if(( rc = d.Open( dbfname )) != XB_NO_ERROR )
+ {
+ std::cout << "\nCould not open file " << dbfname << " rc = " << rc
+ << "\n";
+ return 2;
+ }
+
+/* if an index was specified, open the index file */
+
+ if( ixname ){
+
+#ifdef XB_INDEX_NTX
+ if( strstr( ixname, "NTX" ))
+ ix = new xbNtx( &d );
+#endif
+
+#ifdef XB_INDEX_NDX
+ if( strstr( ixname, "NDX" ))
+ ix = new xbNdx( &d );
+#endif
+ if( !ix ){
+ std::cout << "Unknown index type. .NTX and .NDX index file support only\n";
+ return 3;
+ }
+ if(( rc = ix->OpenIndex( ixname )) != XB_NO_ERROR )
+ {
+ std::cout << "\nCould not open index " << ixname << " rc = " << rc
+ << "\n";
+ return 4;
+ }
+ }
+
+
+/* if -f or -F paramater, dump the header information */
+ if( FieldOption ){
+ for( xbLong l = 0; l < d.FieldCount(); l++ ){
+ if( l ) std::cout << ",";
+ std::cout << d.GetFieldName(l);
+ if( FieldOption == 2 ){
+ std::cout << "|" << d.GetFieldType(l) << "|" << d.GetFieldLen(l);
+ std::cout << "|" << d.GetFieldDecimal(l);
+ }
+ }
+ std::cout << std::endl;
+ }
+
+/* if an index used, then loop thru each record, based on index, else
+ dump in dbf sort order */
+ if( ixname )
+ rc = ix->GetFirstKey();
+ else
+ rc = d.GetFirstRecord();
+
+ while( rc == XB_NO_ERROR ){
+ for( xbLong l = 0; l < d.FieldCount(); l++ ){
+ if( l ) std::cout << ",";
+ strcpy( buf, exp.LTRIM( d.GetStringField( l )));
+ if( d.GetFieldType( l ) == 'D' )
+ std::cout << exp.DTOC( buf );
+ else
+ std::cout << exp.TRIM( buf );
+ }
+ if( ixname )
+ rc = ix->GetNextKey();
+ else
+ rc = d.GetNextRecord();
+ std::cout << std::endl;
+ }
+
+ d.Close();
+ return 0;
+}
diff --git a/src/utils/preamble.txt b/src/utils/preamble.txt
new file mode 100755
index 0000000..e2aeda8
--- /dev/null
+++ b/src/utils/preamble.txt
@@ -0,0 +1,19 @@
+/* xbXXXXX.XXX
+
+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
+
+*/
+
+
+namespace xb{
+
diff --git a/src/utils/reindex.cpp b/src/utils/reindex.cpp
new file mode 100755
index 0000000..3013167
--- /dev/null
+++ b/src/utils/reindex.cpp
@@ -0,0 +1,83 @@
+/*
+ Xbase64 project source code
+
+ This sample program packs an Xbase DBF file
+
+ Copyright (C) 1997,2003 Gary A. Kunkel
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+ Contact:
+
+ Email:
+
+ xbase64-devel@lists.sourceforge.net
+ xbase64-users@lists.sourceforge.net
+*/
+
+
+// FIXME - program needs to be updated
+
+#include <xbase64/xbase64.h>
+
+static void
+showStatus(xbLong itemNum, xbLong numItems)
+{
+ printf("indexing record %ld of %ld\r", itemNum, numItems);
+ fflush(stdout);
+}
+
+int main(int ac,char** av)
+{
+ if (3 != ac) {
+ std::cout <<
+ "\nUsage: reindex dbf_file ndx_file\n"
+ ;
+ return 1;
+ }
+
+ char* filename = av[1];
+ char* filename2 = av[2];
+
+ xbXBase x;
+ xbDbf MyFile( &x );
+ xbNdx MyIndex( &MyFile );
+
+ if( MyFile.Open( filename )) {
+ std::cout << "Could not open file " << filename << "\n";
+ return 0;
+ }
+ if( MyIndex.OpenIndex( filename2 )) {
+ std::cout << "Could not open index file " << filename2 << "\n";
+ return 0;
+ }
+
+ xbInt16 rc = MyIndex.ReIndex(showStatus);
+ printf("\n");
+ if( rc != XB_NO_ERROR ) {
+ std::cout << "\nError reindexing index ==> " << filename2;
+ std::cout << " Return Code = " << rc;
+ }
+
+ /* or
+ if(( rc = MyFile.RebuildAllIndicis()) != XB_NO_ERROR )
+ {
+ std::cout << "\nError reindexing...";
+ std::cout << "\nReturn Code = " << rc;
+ }
+ */
+ MyFile.Close();
+ return 0;
+}
diff --git a/src/utils/xb_cfg_check.cpp b/src/utils/xb_cfg_check.cpp
new file mode 100755
index 0000000..25ca46c
--- /dev/null
+++ b/src/utils/xb_cfg_check.cpp
@@ -0,0 +1,370 @@
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "xbase.h"
+
+using namespace xb;
+
+
+int main()
+{
+
+ fprintf( stdout, "\n%s version %d.%d.%d build options\n", CMAKE_PROJECT_NAME, xbase_VERSION_MAJOR,
+ xbase_VERSION_MINOR, xbase_VERSION_PATCH );
+ // fprintf( stdout, "Usage: xb_cfg_check\n\n" );
+ fprintf( stdout, "These options were in effect at library build time:\n" );
+
+ fprintf( stdout, "\nGeneral system variables:\n" );
+ fprintf( stdout, "SYSTEM_NAME = [%s]\n", CMAKE_SYSTEM_NAME );
+ fprintf( stdout, "SYSTEM_PROCESSOR = [%s]\n", CMAKE_SYSTEM_PROCESSOR );
+ fprintf( stdout, "SYSTEM_VERSION = [%s]\n", CMAKE_SYSTEM_VERSION );
+ fprintf( stdout, "PLATFORM = [%s]\n", XB_PLATFORM );
+ fprintf( stdout, "BUILD TYPE = [%s]\n", CMAKE_BUILD_TYPE );
+ 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" );
+ #endif
+ #ifdef XB_PLATFORM_64
+ fprintf( stdout, "XB_PLATFORM_64 = [TRUE]\n" );
+ #endif
+ fprintf( stdout, "COMPILER = [%s]\n", CMAKE_COMPILER );
+ #ifdef WIN32
+ fprintf( stdout, "WIN32 = [ON]\n" );
+ #else
+ fprintf( stdout, "WIN32 = [OFF]\n" );
+ #endif
+
+ /*
+ #ifdef XBDLLEXPORT
+ fprintf( stdout, "XBDLLEXPORT = [%s]\n", XBDLLEXPORT );
+ #endif
+ */
+ printf( "\n" );
+
+
+ #ifdef CMAKE_COMPILER_IS_GNUCC
+ fprintf( stdout, "CMAKE_COMPILER_IS_GNUCC = [ON]\n" );
+ #else
+ fprintf( stdout, "CMAKE_COMPILER_IS_GNUCC = [OFF]\n" );
+ #endif
+
+ #ifdef _FILE_OFFSET_BITS
+ fprintf( stdout, "_FILE_OFFSET_BITS = [DEFINED]\n" );
+ #endif
+
+ fprintf( stdout, "User controlled build options:\n" );
+
+
+ #ifdef XB_DEBUG_SUPPORT
+ fprintf( stdout, "XB_DEBUG_SUPPORT = [ON]\n" );
+ #else
+ fprintf( stdout, "XB_DEBUG_SUPPORT = [OFF]\n" );
+ #endif
+
+ #ifdef XB_LOGGING_SUPPORT
+ fprintf( stdout, "XB_LOGGING_SUPPORT = [ON]\n" );
+ #else
+ fprintf( stdout, "XB_LOGGING_SUPPORT = [OFF]\n" );
+ #endif
+
+ #ifdef XB_MEMO_SUPPORT
+ fprintf( stdout, "XB_MEMO_SUPPORT = [ON]\n" );
+ #else
+ fprintf( stdout, "XB_MEMO_SUPPORT = [OFF]\n" );
+ #endif
+
+ #ifdef XB_DBF3_SUPPORT
+ fprintf( stdout, "XB_DBF3_SUPPORT = [ON]\n" );
+ #else
+ fprintf( stdout, "XB_DBF3_SUPPORT = [OFF]\n" );
+ #endif
+
+ #ifdef XB_DBF4_SUPPORT
+ fprintf( stdout, "XB_DBF4_SUPPORT = [ON]\n" );
+ #else
+ fprintf( stdout, "XB_DBF4_SUPPORT = [OFF]\n" );
+ #endif
+
+ #ifdef XB_LINKLIST_SUPPORT
+ fprintf( stdout, "XB_LINKLIST_SUPPORT = [ON]\n" );
+ #else
+ fprintf( stdout, "XB_LINKLIST_SUPPORT = [OFF]\n" );
+ #endif
+
+ #ifdef XB_LOCKING_SUPPORT
+ fprintf( stdout, "XB_LOCKING_SUPPORT = [ON]\n" );
+ #else
+ fprintf( stdout, "XB_LOCKING_SUPPORT = [OFF]\n" );
+ #endif
+
+ #ifdef XB_EXPRESSION_SUPPORT
+ fprintf( stdout, "XB_EXPRESSION_SUPPORT = [ON]\n" );
+ #else
+ fprintf( stdout, "XB_EXPRESSION_SUPPORT = [OFF]\n" );
+ #endif
+
+ #ifdef XB_LOCKING_SUPPORT
+ fprintf( stdout, "XB_EXAMPLES_SUPPORT = [ON]\n" );
+ #else
+ fprintf( stdout, "XB_EXAMPLES_SUPPORT = [OFF]\n" );
+ #endif
+ #ifdef XB_LOCKING_SUPPORT
+ fprintf( stdout, "XB_UTILS_SUPPORT = [ON]\n" );
+ #else
+ fprintf( stdout, "XB_UTILS_SUPPORT = [OFF]\n" );
+ #endif
+
+ #ifdef XB_INDEX_SUPPORT
+ fprintf( stdout, "XB_INDEX_SUPPORT = [ON]\n" );
+ #else
+ fprintf( stdout, "XB_INDEX_SUPPORT = [OFF]\n" );
+ #endif
+
+ #ifdef XB_INDEX_SUPPORT
+ fprintf( stdout, "XB_NDX_SUPPORT = [ON]\n" );
+ #else
+ fprintf( stdout, "XB_NDX_SUPPORT = [OFF]\n" );
+ #endif
+
+ #ifdef XB_INDEX_SUPPORT
+ fprintf( stdout, "XB_MDX_SUPPORT = [ON]\n" );
+ #else
+ fprintf( stdout, "XB_MDX_SUPPORT = [OFF]\n" );
+ #endif
+
+ #ifdef XB_SQL_SUPPORT
+ fprintf( stdout, "XB_SQL_SUPPORT = [ON]\n" );
+ #else
+ fprintf( stdout, "XB_SQL_SUPPORT = [OFF]\n" );
+ #endif
+
+
+ fprintf( stdout, "\nDirectories:\n" );
+ fprintf( stdout, "HOME_DIRECTORY = [%s]\n", CMAKE_HOME_DIRECTORY );
+ fprintf( stdout, "PROJECT_PARENT_DIR = [%s]\n", PROJECT_PARENT_DIR );
+ fprintf( stdout, "PROJECT_BINARY_DIR = [%s]\n", PROJECT_BINARY_DIR );
+ fprintf( stdout, "PROJECT_DATA_DIR = [%s]\n", PROJECT_DATA_DIR );
+ fprintf( stdout, "PROJECT_LOG_DIR = [%s]\n", PROJECT_LOG_DIR );
+ fprintf( stdout, "PROJECT_DFLT_LOGFILE = [%s]\n", PROJECT_DFLT_LOGFILE );
+ fprintf( stdout, "PROJECT_SOURCE_DIR = [%s]\n", PROJECT_SOURCE_DIR );
+ fprintf( stdout, "CMAKE_RUNTIME_OUTPUT_DIRECTORY = [%s]\n\n", CMAKE_RUNTIME_OUTPUT_DIRECTORY );
+
+ fprintf( stdout, "Libraries:\n" );
+ fprintf( stdout, "BUILD_SHARED_LIBS = [%s]\n", BUILD_SHARED_LIBS );
+ fprintf( stdout, "EXTRA_LIBS = [%s]\n\n", EXTRA_LIBS );
+
+ 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 ));
+ #ifdef HAVE_WCHAR_H
+ fprintf( stdout, "sizeof(wchar_t) = [%ld]\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, "\nHeader files:\n" );
+ #ifdef HAVE_CTYPE_H
+ fprintf( stdout, "HAVE_CTYPE_H = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_CTYPE_H = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_DIRENT_H
+ fprintf( stdout, "HAVE_DIRENT_H = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_DIRENT_H = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_FCNTL_H
+ fprintf( stdout, "HAVE_FCNTL_H = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_FCNTL_H = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_INTTYPES_H
+ fprintf( stdout, "HAVE_INTTYPES_H = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_INTTYPES_H = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_STDARG_H
+ fprintf( stdout, "HAVE_STDARG_H = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_STDARG_H = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_STRING_H
+ fprintf( stdout, "HAVE_STRING_H = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_STRING_H = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_STRINGS_H
+ fprintf( stdout, "HAVE_STRINGS_H = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_STRINGS_H = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_STAT_H
+ fprintf( stdout, "HAVE_STAT_H = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_STAT_H = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_UNISTD_H
+ fprintf( stdout, "HAVE_UNISTD_H = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_UNISTD_H = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_WINDOWS_H
+ fprintf( stdout, "HAVE_WINDOWS_H = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_WINDOWS_H = [NO]\n" );
+ #endif
+
+
+ fprintf( stdout, "\nC Library functions:\n" );
+
+ #ifdef HAVE__CLOSE_F
+ fprintf( stdout, "HAVE__CLOSE_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE__CLOSE_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_CREATEPROCESSW_F
+ fprintf( stdout, "HAVE_CREATEPROCESSW_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_CREATEPROCESSW_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_FCNTL_F
+ fprintf( stdout, "HAVE_FCNTL_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_FCNTL_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE__FDOPEN_F
+ fprintf( stdout, "HAVE__FDOPEN_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE__FDOPEN_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_FOPEN_S_F
+ fprintf( stdout, "HAVE_FOPEN_S_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_FOPEN_S_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE__FSOPEN_F
+ fprintf( stdout, "HAVE__FSOPEN_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE__FSOPEN_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE__FILENO_F
+ fprintf( stdout, "HAVE__FILENO_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE__FILENO_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_FORK_F
+ fprintf( stdout, "HAVE_FORK_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_FORK_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE__FSEEKI64_F
+ fprintf( stdout, "HAVE__FSEEKI64_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE__FSEEKI64_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_FSEEKO_F
+ fprintf( stdout, "HAVE_FSEEKO_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_FSEEKO_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_FTRUNCATE_F
+ fprintf( stdout, "HAVE_FTRUNCATE_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_FTRUNCATE_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE__LOCALTIME_S_F
+ fprintf( stdout, "HAVE__LOCALTIME_S_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE__LOCALTIME_S_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_LOCKFILE_F
+ fprintf( stdout, "HAVE_LOCKFILE_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_LOCKFILE_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_LOCKING_F
+ fprintf( stdout, "HAVE_LOCKING_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_LOCKING_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE__LOCKING_F
+ fprintf( stdout, "HAVE__LOCKING_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE__LOCKING_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE__OPEN_F
+ fprintf( stdout, "HAVE__OPEN_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE__OPEN_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_SETENDOFFILE_F
+ fprintf( stdout, "HAVE_SETENDOFFILE_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_SETENDOFFILE_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_VSNPRINTF_F
+ fprintf( stdout, "HAVE_VSNPRINTF_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_VSNPRINTF_F = [NO]\n" );
+ #endif
+
+ #ifdef HAVE_VSNPRINTF_S_F
+ fprintf( stdout, "HAVE_VSNPRINTF_S_F = [YES]\n" );
+ #else
+ fprintf( stdout, "HAVE_VSNPRINTF_S_F = [NO]\n" );
+ #endif
+
+ return 0;
+}
+
diff --git a/src/utils/xb_copydbf.cpp b/src/utils/xb_copydbf.cpp
new file mode 100755
index 0000000..1f88eb9
--- /dev/null
+++ b/src/utils/xb_copydbf.cpp
@@ -0,0 +1,62 @@
+/* xb_copydbf.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2019 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 (3 != ac) {
+ std::cout <<
+ "\nUsage: xb_copydbf filename1 filename2\n"
+ "This program copies the structure of one dbf file to another\n";
+ return 1;
+ }
+
+ char* sFileName = av[1];
+ char* tFileName = av[2];
+
+ xbXBase x;
+ xbInt16 iRc;
+ xbDbf *MyFile = NULL;
+ xbDbf *MyNewFile = NULL;
+
+ #ifdef XB_LOGGING_SUPPORT
+ x.EnableMsgLogging();
+ xbString sMsg;
+ sMsg.Sprintf( "Program [%s] initializing...", av[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;
+ x.DisplayError( iRc );
+ return 0;
+ }
+
+ 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;
+ }
+
+ MyFile->Close();
+ return 0;
+}
+
+
+
+
+
diff --git a/src/utils/xb_dbfutil.cpp b/src/utils/xb_dbfutil.cpp
new file mode 100755
index 0000000..e008155
--- /dev/null
+++ b/src/utils/xb_dbfutil.cpp
@@ -0,0 +1,3719 @@
+/* xb_dbfutil.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2021 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"
+
+#ifdef HAVE_DIRENT_H
+#include <dirent.h>
+#endif
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+using namespace xb;
+
+///@cond DOXYOFF
+class xbUtil{
+ public:
+ xbUtil();
+ ~xbUtil();
+ xbDbf *GetTablePtr( const char * cTitle );
+ void DisplayActiveTable() const;
+
+ // menus
+ xbInt16 GetOption();
+ xbInt32 GetLong();
+ void ProcessOption( const xbString & sOption );
+ void MainMenu();
+ void SystemMenu();
+ void FileMenu();
+ void RecordMenu();
+ void FieldMenu();
+ void IndexMenu();
+ void LockingMenu();
+ void ExpressionMenu();
+ void DebugMenu();
+ void FilterMenu();
+
+ #ifdef XB_SQL_SUPPORT
+ void SqlMenu();
+ #endif // XB_SQL_MENU
+
+ #ifdef XB_NDXINF_SUPPORT
+ void InfFileMenu();
+ #endif // XB_NDXINF_SUPPORT
+
+ // 2 - SystemMenu options
+ void ListSystemSettings();
+ void UpdateDataDirectory();
+ void ToggleDefaultAutoCommit();
+ #ifdef XB_MEMO_SUPPORT
+ void UpdateDefaultMemoBlockSize();
+ #endif
+ void UpdateLogDirectory();
+ void UpdateLogFileName();
+ void ToggleLoggingStatus();
+ void WriteLogMessage();
+ #ifdef XB_LOCKING_SUPPORT
+ void UpdateDefaultLockRetries();
+ void ToggleDefaultAutoLock();
+ void UpdateDefaultLockFlavor();
+ void UpdateDefaultLockWait();
+ void ToggleMultiUserMode();
+ #endif
+
+ // 3 - FileMenu options
+ void ListFilesInDataDirectory();
+ void Open();
+ void Close();
+ void CloseAllTables();
+ void DisplayTableStats();
+ void Pack();
+ void ZapTable();
+ void CopyDbfStructure();
+ void UpdateTableAutoCommit();
+ void DisplayTableInfo();
+
+ // 4 - RecordMenu options
+ void GetRecord();
+ void BlankRecord();
+ void AppendRecord();
+ void PutRecord();
+ void DeleteRecord();
+ void UndeleteRecord();
+ void SelectActiveTable();
+ void GetFirstRecord();
+ void GetNextRecord();
+ void GetPrevRecord();
+ void GetLastRecord();
+ void DumpRecord();
+ void AbortRecord();
+ void CommitRecord();
+
+ #ifdef XB_FILTER_SUPPORT
+ void SetFilter();
+ void GetFirstFilterRec();
+ void GetNextFilterRec();
+ void GetPrevFilterRec();
+ void GetLastFilterRec();
+ #endif // XB_FILTER_SUPPORT
+
+ // 5 - FieldMenu options
+ void ListFieldInfo();
+ void UpdateFieldData();
+ #ifdef XB_MEMO_SUPPORT
+ void ShowMemoFieldData();
+ void UpdateMemoFieldData();
+ void DeleteMemoField();
+ #endif
+
+ // 6 - LockMenu options
+ #ifdef XB_LOCKING_SUPPORT
+ void DisplayFileLockSettings();
+ void UpdateFileLockRetryCount();
+ void UpdateFileLockFlavor();
+ void UpdateFileAutoLock();
+ void LockDbf();
+ void UnlockDbf();
+ void LockRecord();
+ void UnlockRecord();
+ void LockAppend();
+ void UnlockAppend();
+ #ifdef XB_INDEX_SUPPORT
+ void LockIndices();
+ void UnlockIndices();
+ #endif // XB_INDEX_SUPPORT
+
+ #ifdef XB_MEMO_SUPPORT
+ void LockMemo();
+ void UnlockMemo();
+ #endif
+
+ void LockHeader();
+ void UnlockHeader();
+ void xbFileLock();
+ void xbFileUnlock();
+ #endif
+
+ // 7 - Expression Menu options
+ #ifdef XB_EXPRESSION_SUPPORT
+ void ParseExpression( xbInt16 iOption );
+ void ProcessParsedExpression( xbInt16 iOption );
+ void ParseAndProcessExpression();
+ void JulToDate8();
+ void Date8ToJul();
+ void IsLeapYear();
+ #ifdef XB_DEBUG_SUPPORT
+ void DumpExpressionTree();
+ #endif
+ #endif
+
+ // 8 - Index Menu Options
+ #ifdef XB_INDEX_SUPPORT
+ void DisplayOpenIndexFiles();
+ void DisplaySupportedIndexTypes();
+ void SelectTag();
+ void OpenIndex();
+ void CloseIndexFile();
+ void CreateIndexTag();
+
+ void GetFirstKey();
+ void GetNextKey();
+ void GetPrevKey();
+ void GetLastKey();
+ void FindKey();
+
+ void CheckIntegrity();
+ void Reindex();
+ void DeleteTag();
+ void AssociateNonProdIx();
+
+ void DumpIxHeader();
+ void DumpIxNode();
+ void DumpIxNodeChain();
+ void DumpRecsByIx( xbInt16 iOpt );
+ void DumpFreeBlocks();
+
+ #endif // XB_INDEX_SUPPORT
+
+
+ // 9 - SQL Menu Options
+ #ifdef XB_SQL_SUPPORT
+ void ExecSqlNonQuery();
+ void ExecSqlQuery();
+ #endif // XB_SQL_SUPPORT
+
+
+ // 10 - DebugMenu options
+ #ifdef XB_MEMO_SUPPORT
+ void DumpDbtHeader();
+ void DumpMemoFreeChain();
+ #endif
+
+ // 11 - InfFileMenu options
+ #ifdef XB_NDXINF_SUPPORT
+ void ListInfFileData();
+ void AddInfFileData();
+ void DeleteInfFileData();
+ void InfFileHelp();
+ #endif
+
+
+ private:
+ xbXBase x;
+ xbDbf * dActiveTable;
+
+ #ifdef XB_EXPRESSION_SUPPORT
+ xbExp *exp;
+ #endif // XB_EXPRESSION_SUPPORT
+
+ #ifdef XB_SQL_SUPPORT
+ xbSql *sql;
+ #endif // XB_SQL_SUPPORT
+
+ #ifdef XB_FILTER_SUPPORT
+ xbFilter *filt;
+ #endif // XB_FILTER_SUPPORT
+
+};
+
+/*************************************************************************************/
+xbUtil::xbUtil()
+{
+ dActiveTable = NULL;
+ x.EnableMsgLogging();
+ x.SetLogSize( 10000000L );
+
+ #ifdef XB_EXPRESSION_SUPPORT
+ exp = NULL;
+ #endif
+
+ #ifdef XB_SQL_SUPPORT
+ sql = new xbSql( &x );
+ #endif // XB_SQL_SUPPORT
+
+ #ifdef XB_FILTER_SUPPORT
+ filt = NULL;
+ #endif // XB_FILTER_SUPPORT
+}
+
+
+/*************************************************************************************/
+xbUtil::~xbUtil(){
+
+ x.CloseAllTables();
+
+ if( dActiveTable )
+ delete dActiveTable;
+
+ #ifdef XB_SQL_SUPPORT
+ if( sql )
+ delete sql;
+ #endif // XB_SQL_SUPPORT
+
+ #ifdef XB_FILTER_SUPPORT
+ if( filt )
+ delete filt;
+ #endif // XB_FILTER_SUPPORT
+}
+
+/*************************************************************************************/
+#ifdef XB_NDXINF_SUPPORT
+
+void xbUtil::ListInfFileData()
+{
+ xbLinkListNode<xbString> *llN = dActiveTable->GetNdxInfList();
+
+ xbString s;
+ while( llN ){
+ s = llN->GetKey();
+ std::cout << s.Str() << std::endl;
+ llN = llN->GetNextNode();
+ }
+
+}
+
+void xbUtil::AddInfFileData()
+{
+ char cBuf[128];
+ 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 );
+}
+
+void xbUtil::DeleteInfFileData()
+{
+ char cBuf[128];
+ 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 );
+}
+
+void xbUtil::InfFileHelp()
+{
+ std::cout << std::endl;
+ std::cout << "Xbase64 uses an .INF file to link non production (NDX) index files to their associated DBF data file" << std::endl;
+}
+#endif // XB_NDXINF_SUPPORT
+
+
+/*************************************************************************************/
+#ifdef XB_INDEX_SUPPORT
+#ifdef XB_LOCKING_SUPPORT
+
+void xbUtil::LockIndices(){
+
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ xbInt16 iRc = dActiveTable->LockIndices( XB_LOCK );
+ x.DisplayError( iRc );
+}
+
+void xbUtil::UnlockIndices(){
+
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ xbInt16 iRc = dActiveTable->LockIndices( XB_UNLOCK );
+ x.DisplayError( iRc );
+}
+
+#endif // XB_LOCKING_SUPPORT
+
+
+/*************************************************************************************/
+void xbUtil::ParseExpression( xbInt16 iOption ){
+
+ if( iOption == 0 )
+ std::cout << "ParseExpression()\n";
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ xbInt16 iRc;
+ char sExpression[256];
+ memset( sExpression, 0x00, 256 );
+
+ std::cout << "Enter expresion:\n";
+ std::cin.getline( sExpression, 255 );
+
+ if( strlen( sExpression ) == 0 ){
+ std::cout << "Invalid expression" << std::endl;
+ return;
+ }
+
+ if( exp ){
+ delete exp;
+ exp = NULL;
+ }
+
+ exp = new xbExp( &x, dActiveTable );
+ iRc = exp->ParseExpression( sExpression );
+
+ if( iOption == 0 )
+ x.DisplayError( iRc );
+}
+
+/*************************************************************************************/
+void xbUtil::ProcessParsedExpression( xbInt16 iOption ){
+
+ if( iOption == 0 )
+ std::cout << "ProcessParsedExpression()\n";
+ if( !exp )
+ ParseExpression( iOption );
+ if( !exp )
+ return;
+
+ std::cout << "Dump from w/i dbfutil before processing expression\n";
+ exp->DumpTree( xbTrue );
+ std::cout << "-- end of dumptree in dbfutil before processExpression\n";
+
+ xbInt16 iRc = exp->ProcessExpression();
+ if( iRc != XB_NO_ERROR ){
+ x.DisplayError( iRc );
+ return;
+ }
+
+ std::cout << "Dump from w/i dbfutil after processing expression\n";
+ exp->DumpTree( xbTrue );
+ std::cout << "-- end of dumptree in dbfutil\n";
+
+ xbString sResult;
+ xbDouble dResult;
+ xbDate dtResult;
+ xbBool bResult;
+
+ switch ( exp->GetReturnType()){
+ case XB_EXP_CHAR:
+ exp->GetStringResult( sResult );
+ std::cout << sResult.Str() << "\n";
+ break;
+ case XB_EXP_DATE:
+ exp->GetDateResult( dtResult );
+ std::cout << dtResult.Str() << "\n";
+ break;
+ case XB_EXP_LOGICAL:
+ exp->GetBoolResult( bResult );
+ std::cout << bResult << "\n";
+ break;
+ case XB_EXP_NUMERIC:
+ exp->GetNumericResult( dResult );
+ std::cout << dResult << "\n";
+ break;
+ default:
+ std::cout << "Unknown result type [" << exp->GetReturnType() << std::endl;
+ break;
+ }
+ return;
+}
+
+/*************************************************************************************/
+void xbUtil::ParseAndProcessExpression(){
+ ParseExpression( 1 );
+ if( exp )
+ ProcessParsedExpression( 1 );
+}
+/*************************************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+void xbUtil::DumpExpressionTree(){
+
+ if( exp )
+ exp->DumpTree( xbTrue );
+ else
+ std::cout << "No expression defined\n";
+}
+#endif // XB_DEBUG_SUPPORT
+
+
+void xbUtil::JulToDate8(){
+ std::cout << "Convert Julian Date to Date8 (CCYYMMDD) format" << std::endl;
+ std::cout << "Enter Julian Value" << std::endl;
+ xbInt32 l = GetLong();
+ xbDate d( l );
+ std::cout << "Date8 value = [" << d.Str() << "]" << std::endl;
+}
+
+void xbUtil::Date8ToJul(){
+ char cLine[12];
+ std::cout << "Convert Date8 (CCYYMMDD) format to Julian Date value" << std::endl;
+ std::cout << "Enter Date8 value:" << std::endl;
+ memset( cLine, 0x00, 12 );
+ std::cin.getline( cLine, 9 );
+
+ if( strlen( cLine ) == 8 ){
+ xbDate d( cLine );
+ std::cout << "Julian Value = [" << d.JulianDays() << "]" << std::endl;
+ } else {
+ std::cout << "Invalid length, expecting 8 characters" << std::endl;
+ }
+}
+
+void xbUtil::IsLeapYear(){
+ std::cout << "Check leap year status for a given year" << std::endl;
+ std::cout << "Enter a four digit year" << std::endl;
+ xbInt32 l = GetLong();
+ xbDate d( l );
+ if( d.IsLeapYear( (xbInt16) l ))
+ std::cout << l << " is a leap year" << std::endl;
+ else
+ std::cout << l << " is not a leap year" << std::endl;
+}
+#endif // XB_EXPRESSION_SUPPORT
+/*************************************************************************************/
+#ifdef XB_SQL_SUPPORT
+void xbUtil::ExecSqlNonQuery(){
+
+ xbSql sql( &x );
+ std::cout << "ExecSqlNonQuery\n";
+
+ char sSql[2048];
+ std::cout << "Enter an SQL command (2K max byte max)" << std::endl;
+ std::cin.getline( sSql, 2048 );
+
+ xbInt16 iRc = sql.ExecuteNonQuery( sSql );
+ x.DisplayError( iRc );
+}
+
+void xbUtil::ExecSqlQuery(){
+ std::cout << "ExecSqlQuery\n";
+}
+#endif // XB_SQL_SUPPORT
+
+/*************************************************************************************/
+#ifdef XB_LOCKING_SUPPORT
+void xbUtil::DisplayFileLockSettings(){
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ std::cout << "File Lock Retry Count = [" << dActiveTable->GetLockRetryCount() << "]" << std::endl;
+ std::cout << "File Lock Flavor = [";
+ switch (dActiveTable->GetLockFlavor()){
+ case 1:
+ std::cout << "Dbase]" << std::endl;
+ break;
+ case 2:
+ std::cout << "Clipper]" << std::endl;
+ break;
+ case 3:
+ std::cout << "Fox]" << std::endl;
+ break;
+ case 9:
+ std::cout << "Xbase64]" << std::endl;
+ break;
+ default:
+ std::cout << "Unknown]" << std::endl;
+ break;
+ }
+ std::cout << "File Auto Lock = [";
+
+ if( dActiveTable->GetAutoLock())
+ std::cout << "ON]" << std::endl;
+ else
+ std::cout << "OFF]" << std::endl;
+ if( dActiveTable->GetHeaderLocked())
+ std::cout << "Header Locked = [TRUE]\n";
+ else
+ std::cout << "Header Locked = [FALSE]\n";
+
+ if( dActiveTable->GetTableLocked())
+ std::cout << "Table Locked = [TRUE]\n";
+ else
+ std::cout << "Table Locked = [FALSE]\n";
+
+ if( dActiveTable->GetAppendLocked() > 0 )
+ std::cout << "Append Locked = [" << dActiveTable->GetAppendLocked() << "]\n";
+ else
+ std::cout << "Append Locked = [FALSE]\n";
+
+ #ifdef XB_MEMO_SUPPORT
+ if( dActiveTable->GetMemoLocked())
+ std::cout << "Memo Locked = [TRUE]\n";
+ else
+ std::cout << "Memo Locked = [FALSE]\n";
+ #endif
+
+ xbLinkListNode<xbUInt32> * llN = dActiveTable->GetFirstRecLock();
+ if( llN ){
+ while( llN ){
+ std::cout << "Record Locked = [" << llN->GetKey() << "]\n";
+ llN = llN->GetNextNode();
+ }
+ } else {
+ std::cout << "Record Locked = [None]\n";
+ }
+}
+
+void xbUtil::UpdateFileLockRetryCount(){
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+
+ char cBuf[15];
+ std::cout << std::endl << "Enter new File Lock Retry Count: " << std::endl;
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "File Lock Retry Count not updated" << std::endl;
+ return;
+ } else {
+ dActiveTable->SetLockRetryCount( atoi( cBuf ));
+ std::cout << "File Lock Retry Count updated to ["
+ << dActiveTable->GetLockRetryCount() << "]" << std::endl;
+ }
+}
+
+void xbUtil::UpdateFileLockFlavor(){
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+
+ std::cout << std::endl;
+ std::cout << "Enter new File Lock Flavor: " << std::endl;
+ std::cout << "1 = DBase" << std::endl;
+ std::cout << "2 = Clipper (not implemented yet)" << std::endl;
+ std::cout << "3 = Fox (not implemented yet)" << std::endl;
+ std::cout << "9 = XBase64 (not implemented yet)" << std::endl;
+
+ char cBuf[15];
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "File Lock Flavor not updated" << std::endl;
+ return;
+ } else {
+ dActiveTable->SetLockFlavor( atoi( cBuf ));
+ std::cout << "File Lock Flavor updated to ["
+ << dActiveTable->GetLockFlavor() << "]" << std::endl;
+ }
+}
+
+void xbUtil::UpdateFileAutoLock(){
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+
+ std::cout << "Enter new File Auto Lock: " << std::endl;
+ std::cout << "-1 = Use System Default" << std::endl;
+ std::cout << " 0 = Disable Auto Lock for this DBF file" << std::endl;
+ std::cout << " 1 = Enable Auto Lock for this DBF file" << std::endl;
+
+ char cBuf[15];
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "File Auto Lock Flavor not updated" << std::endl;
+ return;
+ }
+ xbInt16 iOption = atoi( cBuf );
+ if( iOption < -1 || iOption > 1 ){
+ std::cout << "Must be one of:" << std::endl;
+ std::cout << " -1 = Use Default Auto Lock" << std::endl;
+ std::cout << " 0 = File Auto Lock Off" << std::endl;
+ std::cout << " 1 = File Auto Lock On" << std::endl;
+ std::cout << "File Auto Lock Flavor not updated" << std::endl;
+ return;
+ } else {
+ dActiveTable->SetAutoLock( iOption );
+ std::cout << "File Auto Lock updated to ["
+ << dActiveTable->GetAutoLock() << "]" << std::endl;
+ }
+}
+
+void xbUtil::LockDbf(){
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ xbInt16 iRc;
+ std::cout << std::endl << "Lock Table" << std::endl;
+ iRc = dActiveTable->LockTable( XB_LOCK );
+ x.DisplayError( iRc );
+}
+
+void xbUtil::LockAppend(){
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ xbInt16 iRc;
+ std::cout << std::endl << "Lock Append" << std::endl;
+ iRc = dActiveTable->LockAppend( XB_LOCK );
+ x.DisplayError( iRc );
+}
+
+void xbUtil::UnlockAppend(){
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ xbInt16 iRc;
+ std::cout << std::endl << "Unlock Append" << std::endl;
+ iRc = dActiveTable->LockAppend( XB_UNLOCK );
+ x.DisplayError( iRc );
+}
+#ifdef XB_MEMO_SUPPORT
+void xbUtil::LockMemo(){
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ xbInt16 iRc;
+ std::cout << std::endl << "Lock Memo" << std::endl;
+ iRc = dActiveTable->LockMemo( XB_LOCK );
+ x.DisplayError( iRc );
+}
+
+void xbUtil::UnlockMemo(){
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ xbInt16 iRc;
+ std::cout << std::endl << "Unlock Memo" << std::endl;
+ iRc = dActiveTable->LockMemo( XB_UNLOCK );
+ x.DisplayError( iRc );
+}
+#endif
+
+void xbUtil::LockRecord(){
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+
+ xbInt16 iRc;
+ std::cout << std::endl << "Lock Record" << std::endl;
+ std::cout << "Enter record number to lock specific record" << std::endl;
+
+ char cBuf[15];
+ std::cin.getline( cBuf, 15 );
+ iRc = dActiveTable->LockRecord( XB_LOCK, atol( cBuf ));
+ x.DisplayError( iRc );
+}
+
+void xbUtil::UnlockRecord(){
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+
+ xbInt16 iRc;
+ std::cout << std::endl << "Unlock Record" << std::endl;
+ std::cout << "Enter record number to unlock specific record" << std::endl;
+
+ char cBuf[15];
+ std::cin.getline( cBuf, 15 );
+ iRc = dActiveTable->LockRecord( XB_UNLOCK, atol( cBuf ));
+ x.DisplayError( iRc );
+}
+
+void xbUtil::UnlockDbf(){
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+
+ xbInt16 iRc;
+ std::cout << std::endl << "Unlock Table" << std::endl;
+ iRc = dActiveTable->LockTable( XB_UNLOCK );
+ x.DisplayError( iRc );
+}
+
+void xbUtil::UnlockHeader(){
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+
+ xbInt16 iRc;
+ std::cout << std::endl << "Unlock Table Header" << std::endl;
+ iRc = dActiveTable->LockHeader( XB_UNLOCK );
+ x.DisplayError( iRc );
+}
+
+void xbUtil::LockHeader(){
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+
+ xbInt16 iRc;
+ std::cout << std::endl << "Lock Table Header" << std::endl;
+ iRc = dActiveTable->LockHeader( XB_LOCK );
+ x.DisplayError( iRc );
+}
+
+#ifdef XB_DEBUG_SUPPORT
+
+void xbUtil::xbFileLock(){
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+
+ char cBufOffset[30];
+ char cBufLen[30];
+
+ std::cout << std::endl << "Enter new File Lock Offset (in bytes from BOF): " << std::endl;
+ std::cin.getline( cBufOffset, 30 );
+ std::cout << std::endl << "Enter new File Lock Len (in Bytes): " << std::endl;
+ std::cin.getline( cBufLen, 30 );
+
+ if( strlen( cBufOffset ) == 0 || strlen( cBufLen ) == 0 ){
+ std::cout << "Offset and length required." << std::endl;
+ return;
+ }
+
+ xbInt64 llSpos;
+ xbInt64 llLen;
+ xbString s1 = cBufOffset;
+ s1.CvtLongLong( llSpos );
+ s1 = cBufLen;
+ s1.CvtLongLong( llLen );
+ xbInt16 iRc = dActiveTable->xbLock( XB_LOCK, llSpos, (size_t) llLen );
+ x.DisplayError( iRc );
+}
+
+void xbUtil::xbFileUnlock(){
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ char cBufOffset[30];
+ char cBufLen[30];
+ std::cout << std::endl << "Enter new File Lock Offset (in bytes from BOF): " << std::endl;
+ std::cin.getline( cBufOffset, 30 );
+ std::cout << std::endl << "Enter new File Lock Len (in Bytes): " << std::endl;
+ std::cin.getline( cBufLen, 30 );
+ if( strlen( cBufOffset ) == 0 || strlen( cBufLen ) == 0 ){
+ std::cout << "Offset and length required." << std::endl;
+ return;
+ }
+ xbInt16 iRc;
+ iRc = dActiveTable->xbLock( XB_UNLOCK, atol( cBufOffset ), (size_t) atol( cBufLen ));
+ x.DisplayError( iRc );
+}
+
+#endif
+#endif
+/*************************************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+#ifdef XB_MEMO_SUPPORT
+
+void xbUtil::DumpDbtHeader(){
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+
+ if( !dActiveTable->MemoFieldsExist()){
+ std::cout << "Table has no memo fields" << std::endl;
+ return;
+ }
+
+ xbMemo * mPtr;
+ mPtr = dActiveTable->GetMemoPtr();
+ mPtr->DumpMemoHeader();
+
+}
+#endif
+#endif
+
+/*************************************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+#ifdef XB_MEMO_SUPPORT
+
+void xbUtil::DumpMemoFreeChain(){
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ if( !dActiveTable->MemoFieldsExist()){
+ std::cout << "Table has no memo fields" << std::endl;
+ return;
+ }
+ xbMemo * mPtr;
+ mPtr = dActiveTable->GetMemoPtr();
+ mPtr->DumpMemoFreeChain();
+}
+#endif
+#endif
+
+/*************************************************************************************/
+void xbUtil::ListFieldInfo(){
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ DisplayActiveTable();
+ dActiveTable->DumpHeader( 2 );
+}
+/*************************************************************************************/
+void xbUtil::UpdateFieldData(){
+ xbInt16 rc;
+ char cFldName[40];
+ char cFldData[256];
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ std::cout << "Enter Field Name " << std::endl;
+ std::cin.getline( cFldName, 40 );
+
+ std::cout << "Enter Field Data " << std::endl;
+ std::cin.getline( cFldData, 256 );
+
+ if(( rc = dActiveTable->PutField( cFldName, cFldData )) != XB_NO_ERROR ){
+ x.DisplayError( rc );
+ return;
+ }
+ std::cout << "Success" << std::endl;
+}
+/*************************************************************************************/
+#ifdef XB_MEMO_SUPPORT
+void xbUtil::ShowMemoFieldData(){
+ xbInt16 rc;
+ char cFldName[40];
+ char cBuf[15];
+ xbString sMemoData;
+ xbUInt32 ulRecNo;
+ xbUInt32 ulFldLen;
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ if( !dActiveTable->MemoFieldsExist()){
+ std::cout << "Table has no memo fields" << std::endl;
+ return;
+ }
+ if( dActiveTable->GetCurRecNo() == 0 ){
+ std::cout << "Enter Record number" << std::endl;
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "Record number not entered" << std::endl;
+ return;
+ }
+ ulRecNo = atol( cBuf );
+ if(( rc = dActiveTable->GetRecord( ulRecNo )) != XB_NO_ERROR ){
+ x.DisplayError( rc );
+ return;
+ }
+ }
+ std::cout << "Enter Memo Field Name " << std::endl;
+ std::cin.getline( cFldName, 40 );
+ if(( rc = dActiveTable->GetMemoField( cFldName, sMemoData )) != XB_NO_ERROR ){
+ std::cout << "rc = " << rc << std::endl;
+ x.DisplayError( rc );
+ return;
+ }
+ if(( rc = dActiveTable->GetMemoFieldLen( cFldName, ulFldLen )) != XB_NO_ERROR ){
+ std::cout << "rc = " << rc << std::endl;
+ x.DisplayError( rc );
+ return;
+ }
+ std::cout << sMemoData.Str() << std::endl;
+ std::cout << "Data length = [" << ulFldLen << "]" << std::endl;
+}
+#endif
+/*************************************************************************************/
+#ifdef XB_MEMO_SUPPORT
+void xbUtil::UpdateMemoFieldData(){
+
+ xbInt16 rc;
+ char cFldName[40];
+ char cBuf[15];
+ char cMemoData[2048];
+ xbUInt32 ulRecNo;
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ if( !dActiveTable->MemoFieldsExist()){
+ std::cout << "Table has no memo fields" << std::endl;
+ return;
+ }
+ if( dActiveTable->GetCurRecNo() == 0 ){
+ std::cout << "Enter Record number" << std::endl;
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "Record number not entered" << std::endl;
+ return;
+ }
+ ulRecNo = atol( cBuf );
+ if(( rc = dActiveTable->GetRecord( ulRecNo )) != XB_NO_ERROR ){
+ x.DisplayError( rc );
+ return;
+ }
+ }
+ std::cout << "Enter Memo Field Name " << std::endl;
+ std::cin.getline( cFldName, 40 );
+ std::cout << "Enter Memo Data (2048 bytes max) " << std::endl;
+ std::cin.getline( cMemoData, 2048 );
+ if(( rc = dActiveTable->UpdateMemoField( cFldName, cMemoData )) != XB_NO_ERROR ){
+ std::cout << "rc = " << rc << std::endl;
+ x.DisplayError( rc );
+ return;
+ }
+
+ if(( rc = dActiveTable->PutRecord( dActiveTable->GetCurRecNo())) != XB_NO_ERROR ){
+ std::cout << "rc = " << rc << std::endl;
+ x.DisplayError( rc );
+ return;
+ }
+}
+#endif
+
+/*************************************************************************************/
+#ifdef XB_MEMO_SUPPORT
+void xbUtil::DeleteMemoField(){
+
+ xbInt16 rc;
+ char cFldName[40];
+ char cBuf[15];
+ xbUInt32 ulRecNo;
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+
+ if( !dActiveTable->MemoFieldsExist()){
+ std::cout << "Table has no memo fields" << std::endl;
+ return;
+ }
+
+ if( dActiveTable->GetCurRecNo() == 0 ){
+ std::cout << "Enter Record number" << std::endl;
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "Record number not entered" << std::endl;
+ return;
+ }
+ ulRecNo = atol( cBuf );
+ if(( rc = dActiveTable->GetRecord( ulRecNo )) != XB_NO_ERROR ){
+ x.DisplayError( rc );
+ return;
+ }
+ }
+ std::cout << "Enter Memo Field Name " << std::endl;
+ std::cin.getline( cFldName, 40 );
+ if(( rc = dActiveTable->UpdateMemoField( cFldName, "" )) != XB_NO_ERROR ){
+ std::cout << "rc = " << rc << std::endl;
+ x.DisplayError( rc );
+ return;
+ }
+ if(( rc = dActiveTable->PutRecord( dActiveTable->GetCurRecNo())) != XB_NO_ERROR ){
+ std::cout << "rc = " << rc << std::endl;
+ x.DisplayError( rc );
+ return;
+ }
+}
+#endif
+/*************************************************************************************/
+void xbUtil::SelectActiveTable(){
+
+ char cBuf[15];
+ xbInt16 iLineNo;
+ 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();
+ std::cout << std::endl << "Enter line number:" << std::endl;
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+ iLineNo = atoi( cBuf );
+ dActiveTable = x.GetDbfPtr( iLineNo );
+}
+
+/*************************************************************************************/
+void xbUtil::CommitRecord(){
+
+ xbInt16 rc = XB_NO_ERROR;
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+
+ DisplayActiveTable();
+
+ if(( rc = dActiveTable->Commit()) == XB_NO_ERROR )
+ std::cout << "Success" << std::endl;
+ else
+ x.DisplayError( rc );
+}
+/*************************************************************************************/
+void xbUtil::AbortRecord(){
+
+ xbInt16 rc = XB_NO_ERROR;
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ DisplayActiveTable();
+
+
+ if(( rc = dActiveTable->Abort()) == XB_NO_ERROR )
+ std::cout << "Success" << std::endl;
+ else
+ x.DisplayError( rc );
+}
+/*************************************************************************************/
+void xbUtil::DumpRecord(){
+
+ char cBuf[15];
+ xbInt16 rc;
+ xbUInt32 lRecNo;
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ DisplayActiveTable();
+
+ if( dActiveTable->GetCurRecNo() == 0 ){
+ std::cout << "Enter Record number" << std::endl;
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "Record number not entered" << std::endl;
+ return;
+ }
+ lRecNo = atol( cBuf );
+ if(( rc = dActiveTable->GetRecord( lRecNo )) != XB_NO_ERROR ){
+ x.DisplayError( rc );
+ return;
+ }
+ }
+
+ if(( rc = dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2 )) == XB_NO_ERROR )
+ std::cout << "Success" << std::endl;
+ else
+ x.DisplayError( rc );
+}
+/*************************************************************************************/
+void xbUtil::GetFirstRecord(){
+
+ xbInt16 iRc;
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+
+ if(( iRc = dActiveTable->GetFirstRecord()) == XB_NO_ERROR )
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
+ else
+ x.DisplayError( iRc );
+}
+/*************************************************************************************/
+void xbUtil::GetNextRecord(){
+
+ xbInt16 iRc;
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ if(( iRc = dActiveTable->GetNextRecord()) == XB_NO_ERROR )
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
+ else
+ x.DisplayError( iRc );
+}
+/*************************************************************************************/
+void xbUtil::GetPrevRecord(){
+
+ xbInt16 iRc;
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ if(( iRc = dActiveTable->GetPrevRecord()) == XB_NO_ERROR )
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
+ else
+ x.DisplayError( iRc );
+}
+/*************************************************************************************/
+void xbUtil::GetLastRecord(){
+
+ xbInt16 iRc;
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ if(( iRc = dActiveTable->GetLastRecord()) == XB_NO_ERROR )
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(),2);
+ else
+ x.DisplayError( iRc );
+}
+
+/*************************************************************************************/
+void xbUtil::UndeleteRecord(){
+
+ char cBuf[15];
+ xbInt16 rc;
+ xbUInt32 lRecNo;
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ DisplayActiveTable();
+
+ if( dActiveTable->GetCurRecNo() == 0 ){
+ std::cout << "Enter Record number" << std::endl;
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "Record number not entered" << std::endl;
+ return;
+ }
+ lRecNo = atol( cBuf );
+ if(( rc = dActiveTable->GetRecord( lRecNo )) != 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 );
+ }
+}
+
+/*************************************************************************************/
+void xbUtil::DeleteRecord(){
+
+ char cBuf[15];
+ xbInt16 rc;
+ xbUInt32 lRecNo;
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ DisplayActiveTable();
+ if( dActiveTable->GetCurRecNo() == 0 ){
+ std::cout << "Enter Record number" << std::endl;
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "Record number not entered" << std::endl;
+ return;
+ }
+ lRecNo = atol( cBuf );
+ if(( rc = dActiveTable->GetRecord( lRecNo )) != XB_NO_ERROR ){
+ x.DisplayError( rc );
+ return;
+ }
+ }
+
+ if(( dActiveTable->RecordDeleted()) == xbTrue )
+ std::cout << "Record is already flagged for deletion" << std::endl;
+ else{
+ if(( rc = dActiveTable->DeleteRecord()) == XB_NO_ERROR )
+ std::cout << "Success" << std::endl;
+ else
+ x.DisplayError( rc );
+ }
+}
+
+/*************************************************************************************/
+void xbUtil::PutRecord(){
+
+ char cBuf[15];
+ xbInt16 rc;
+ xbUInt32 lRecNo;
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ DisplayActiveTable();
+
+ std::cout << "Enter Record number" << std::endl;
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "Record number not entered" << std::endl;
+ return;
+ }
+ lRecNo = atol( cBuf );
+ if(( rc = dActiveTable->PutRecord( lRecNo )) == XB_NO_ERROR )
+ std::cout << "Success" << std::endl;
+ else
+ x.DisplayError( rc );
+}
+
+/*************************************************************************************/
+void xbUtil::AppendRecord(){
+
+ xbInt16 rc;
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ if(( rc = dActiveTable->AppendRecord()) == XB_NO_ERROR )
+ std::cout << "Success" << std::endl;
+ else
+ x.DisplayError( rc );
+}
+
+/*************************************************************************************/
+void xbUtil::BlankRecord(){
+
+ xbInt16 rc;
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ if(( rc = dActiveTable->BlankRecord()) == XB_NO_ERROR )
+ std::cout << "Success" << std::endl;
+ else
+ x.DisplayError( rc );
+}
+
+/*************************************************************************************/
+void xbUtil::DisplayTableInfo(){
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ dActiveTable->DumpHeader( 1 );
+}
+
+/*************************************************************************************/
+void xbUtil::GetRecord(){
+
+ char cBuf[15];
+ xbInt16 iRc;
+ xbUInt32 lRecNo;
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+
+ DisplayActiveTable();
+
+ std::cout << "Enter Record number" << std::endl;
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "Record number not entered" << std::endl;
+ return;
+ }
+ lRecNo = atol( cBuf );
+ if(( iRc = dActiveTable->GetRecord( lRecNo )) == XB_NO_ERROR )
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
+ else
+ x.DisplayError( iRc );
+}
+/*************************************************************************************/
+void xbUtil::DisplayActiveTable() const{
+ if( dActiveTable ){
+ std::cout << "Active Table = [" << dActiveTable->GetTblAlias().Str() << "] ";
+ xbUInt32 ulRecCnt = 0;
+ dActiveTable->ReadHeader( 0, 1 );
+ dActiveTable->GetRecordCnt( ulRecCnt );
+ std::cout << "Total Records = [" << ulRecCnt << "] ";
+ std::cout << "Current Record = [" << dActiveTable->GetCurRecNo() << "] ";
+
+ if( dActiveTable->GetAutoCommit())
+ std::cout << " Auto Commit = [Enabled]";
+ else
+ std::cout << " Auto Commit = [Disabled]";
+
+ std::cout << std::endl;
+ #ifdef XB_INDEX_SUPPORT
+ xbIx *pIx = dActiveTable->GetCurIx();
+ if( pIx ){
+ void *vpTag = dActiveTable->GetCurTag();
+ std::cout << "Active Tag = [" << pIx->GetTagName( vpTag ).Str() << "] Type = [" << dActiveTable->GetCurIxType().Str() <<
+ "] \tFile Name = [" << pIx->GetFileName().Str() << "] Key = [" << pIx->GetKeyExpression( vpTag ).Str() << "]" << std::endl;
+ }
+ #endif // XB_INDEX_SUPPORT
+ std::cout << std::endl;
+ }
+}
+/*************************************************************************************/
+xbDbf * xbUtil::GetTablePtr( const char * cTitle ){
+
+ xbDbf *d;
+ xbInt16 iOpenTableCnt = x.GetOpenTableCount();
+ char cBuf[15];
+ xbInt16 iLineNo;
+
+ if( iOpenTableCnt == 0 ){
+ std::cout << "No open tables" << std::endl;
+ return NULL;
+ } else if( iOpenTableCnt == 1 ){
+ d = x.GetDbfPtr( 1 );
+ } else {
+ std::cout << "Select file/table " << cTitle << std::endl;
+ x.DisplayTableList();
+ std::cout << std::endl << "Enter line number:" << std::endl;
+ memset( cBuf, 0x00, 15 );
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "Table not selected" << std::endl;
+ return NULL;
+ }
+ iLineNo = atoi( cBuf );
+ if( iLineNo < 1 || iLineNo > iOpenTableCnt ){
+ std::cout << "Invalid selection. Valid line numbers are 1 through " << iOpenTableCnt << std::endl;
+ return NULL;
+ }
+ d = x.GetDbfPtr( iLineNo );
+ }
+ return d;
+}
+/*************************************************************************************/
+void xbUtil::UpdateTableAutoCommit(){
+ xbDbf *d;
+ d = GetTablePtr( "" );
+ if( d ){
+ std::cout << "Xbase64 AutoCommit is functionality to determine if table updates should be posted" << std::endl;
+ std::cout << " to the table automatically, even if no xbDbf::PutRecord explicitly executed" << std::endl;
+ 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() )
+ std::cout << "ON]" << std::endl;
+ else
+ std::cout << "OFF]" << std::endl;
+ std::cout << " 0 ==> Disable Auto Commit for table" << std::endl;
+ std::cout << " 1 ==> Enable Auto Commit for table" << std::endl;
+ std::cout << "Current setting is [" << d->GetAutoCommit() << "]" << std::endl;
+ char cBuf[15];
+ xbInt16 iAuto;
+ std::cout << "Enter new Table Auto Commit: " << std::endl;
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ) {
+ std::cout << "Not updated" << std::endl;
+ return;
+ }
+ iAuto = atoi( cBuf );
+ if( iAuto < -1 || iAuto > 1 ){
+ std::cout << "Invalid value. Must be one of -1, 0 or 1" << std::endl;
+ return;
+ }
+ d->SetAutoCommit( iAuto );
+ std::cout << "Auto Commit set to [" << d->GetAutoCommit(0) << "]" << std::endl;
+ if( d->GetAutoCommit() )
+ std::cout << "Auto Commit enabled for table" << std::endl;
+ else
+ std::cout << "Auto Commit disabled for table" << std::endl;
+ }
+}
+/*************************************************************************************/
+void xbUtil::CopyDbfStructure(){
+ xbDbf *d;
+ xbInt16 rc;
+ char filename[128];
+ xbFile f( &x );
+ xbDbf *dNewTable;
+ d = GetTablePtr( "" );
+
+ if( d ){
+
+ if( d->GetVersion() == 3 ){
+ #ifdef XB_DBF3_SUPPORT
+ 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 );
+ #else
+ std::cout << "Dbase IV file support not build into library. See XB_DBF4_SUPPORT" << std::endl;
+ return;
+ #endif
+ } else {
+ std::cout << "Unsupported file type file = " << d->GetVersion() << std::endl;
+ return;
+ }
+ std::cout << "Copy Table" << std::endl;
+ std::cout << "Enter new DBF file name (ie; myfile.dbf or MYFILE.DBF): ";
+ std::cin.getline( filename, 128 );
+ f.SetFileName( filename );
+ if( strlen( filename ) == 0 ){
+ std::cout << "No file name entered" << std::endl;
+ return;
+ }
+ if(( rc = f.FileExists( f.GetFqFileName() )) == xbTrue ){
+ std::cout << "File [" << f.GetFqFileName().Str() << "] already exists " << std::endl;
+ return;
+ }
+ 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 );
+ 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 );
+ return;
+ }
+ }
+}
+/*************************************************************************************/
+void xbUtil::ZapTable(){
+
+ xbInt16 iRc;
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ DisplayActiveTable();
+
+ iRc = dActiveTable->Zap();
+ if( iRc == XB_NO_ERROR )
+ std::cout << "Table Zapped (all rows deleted)" << std::endl;
+ else
+ x.DisplayError( iRc );
+}
+/*************************************************************************************/
+void xbUtil::Pack(){
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+ DisplayActiveTable();
+ xbInt16 iRc;
+ iRc = dActiveTable->Pack();
+ if( iRc == XB_NO_ERROR )
+ std::cout << "Table Packed" << std::endl;
+ else
+ x.DisplayError( iRc );
+}
+/*************************************************************************************/
+void xbUtil::DisplayTableStats(){
+
+ xbDbf *d;
+ char cBuf[15];
+ xbInt16 iOptionNo;
+ d = GetTablePtr( "" );
+ if( d ){
+ std::cout << "Enter option" << std::endl;
+ std::cout << "1 - Header data only" << std::endl;
+ std::cout << "2 - Field data only" << std::endl;
+ std::cout << "3 - Header and Field data" << std::endl;
+ std::cout << "4 - Header, Field and Memo Header if applicable" << std::endl;
+ std::cout << "5 - DBMS Settings (not stored in the file)" << std::endl << std::endl;
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "Option not entered" << std::endl;
+ return;
+ }
+ iOptionNo = atoi( cBuf );
+ if( iOptionNo < 1 || iOptionNo > 5 ){
+ std::cout << "Invalid option [" << cBuf << "] entered. Defaulting to 1" << std::endl;
+ iOptionNo = 1;
+ }
+ if( iOptionNo < 5 ) {
+ d->ReadHeader( xbTrue, 0 );
+ d->DumpHeader( iOptionNo );
+ } else {
+ // DBMS settings
+ if( d->GetAutoCommit( 0 ) == -1 ){
+ std::cout << "Table Auto Commit = [Use DBMS Setting]" << std::endl;
+ if( x.GetDefaultAutoCommit() )
+ std::cout << "DBMS Auto Commit = [ON]" << std::endl;
+ else
+ std::cout << "DBMS Auto Commit = [OFF]" << std::endl;
+ }
+ else if( d->GetAutoCommit( 0 ) == 0 )
+ std::cout << "Table Auto Commit = [OFF]" << std::endl;
+ else
+ std::cout << "Table Auto Commit = [ON]" << std::endl;
+ }
+ }
+}
+/*************************************************************************************/
+void xbUtil::CloseAllTables(){
+
+ xbInt16 sOpenTableCnt = x.GetOpenTableCount();
+ xbInt16 rc;
+ if( sOpenTableCnt == 0 ){
+ std::cout << "No open tables" << std::endl;
+ return;
+ }
+ rc = x.CloseAllTables();
+ if( rc == XB_NO_ERROR )
+ std::cout << "All open tables closed" << std::endl;
+ else
+ x.DisplayError( rc );
+ dActiveTable = NULL;
+}
+
+/*************************************************************************************/
+void xbUtil::Close(){
+ xbDbf *d;
+// xbInt16 sOpenTableCnt = x.GetOpenTableCount();
+
+ d = GetTablePtr( "to close" );
+ if( d ){
+ d->Close();
+ std::cout << "Table closed" << std::endl;
+ if( d == dActiveTable )
+ dActiveTable = NULL;
+ }
+ else
+ printf( "Can't identify table\n");
+}
+/*************************************************************************************/
+void xbUtil::Open(){
+ xbInt16 rc;
+ xbFile f( &x );
+ xbDbf *dTable;
+ char filename[128];
+ unsigned char cFileTypeByte;
+
+ std::cout << "Open Table" << std::endl;
+ std::cout << "Enter DBF file name (.dbf or .DBF): ";
+ std::cin.getline( filename, 128 );
+ f.SetFileName( filename );
+
+ if( strlen( filename ) == 0 ){
+ std::cout << "No file name entered" << std::endl;
+ return;
+ }
+ if(( rc = f.FileExists( f.GetFqFileName() )) != xbTrue ){
+ std::cout << "File [" << f.GetFqFileName().Str() << "] does not exist " << std::endl;
+ return;
+ }
+ 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 );
+ return;
+ }
+ std:: cout << "File Type Byte ";
+ 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 );
+ #else
+ std::cout << "Dbase IV file support not build into library. See XB_DBF4_SUPPORT" << std::endl;
+ return;
+ #endif
+
+ } else if( f.DetermineXbaseTableVersion( cFileTypeByte ) == 3 ){
+ #ifdef XB_DBF3_SUPPORT
+ 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 );
+ 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 );
+ return;
+ }
+
+ dActiveTable = dTable;
+ dActiveTable->GetFirstRecord();
+
+ if( dActiveTable )
+ std::cout << dActiveTable->GetTblAlias().Str() << " opened" << std::endl;
+ else
+ std::cout << "dActiveTable not set" << std::endl;
+}
+/*************************************************************************************/
+#ifdef XB_LOCKING_SUPPORT
+void xbUtil::UpdateDefaultLockRetries(){
+ char cBuf[15];
+ std::cout << std::endl << "Enter new Default Lock Retry Count: " << std::endl;
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "Default Lock Retry Count not updated" << std::endl;
+ return;
+ } else {
+ x.SetDefaultLockRetries( atoi( cBuf ));
+ std::cout << "Default Lock Retry Count updated to ["
+ << x.GetDefaultLockRetries() << "]" << std::endl;
+ }
+}
+
+void xbUtil::UpdateDefaultLockWait(){
+ char cBuf[15];
+ std::cout << std::endl << "Enter new Default Lock Wait Time (in millisecs 1000=1 second): " << std::endl;
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "Default Lock Wait Time not updated" << std::endl;
+ return;
+ } else {
+ x.SetDefaultLockWait( atoi( cBuf ));
+ std::cout << "Default Lock Wait Time updated to ["
+ << x.GetDefaultLockWait() << "]" << std::endl;
+ }
+}
+
+void xbUtil::UpdateDefaultLockFlavor(){
+ char cBuf[15];
+ std::cout << std::endl;
+ std::cout << "Enter new Default Lock Flavor: " << std::endl;
+ std::cout << "1 = DBase" << std::endl;
+ std::cout << "2 = Clipper (not implemented yet)" << std::endl;
+ std::cout << "3 = Fox (not implemented yet)" << std::endl;
+ std::cout << "9 = XBase64 (not implemented yet)" << std::endl;
+ std::cin.getline( cBuf, 15 );
+ if( strlen( cBuf ) == 0 ){
+ std::cout << "Default Lock Flavor not updated" << std::endl;
+ return;
+ } else {
+ x.SetDefaultLockFlavor( atoi( cBuf ));
+ std::cout << "Default Lock Flavor updated to ["
+ << x.GetDefaultLockFlavor() << "]" << std::endl;
+ }
+}
+void xbUtil::ToggleDefaultAutoLock(){
+ 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" );
+ 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" );
+ std::cout << "Multi user mode disabled" << std::endl;
+ } else {
+ 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;
+ xbString s1;
+ xbInt16 iCnt = 0;
+
+#ifdef WIN32
+
+ WIN32_FIND_DATA fData;
+ HANDLE hFile;
+
+ xbString sSearchPath = x.GetDataDirectory();
+ xbUInt32 l = sSearchPath.Len();
+ char cPathSeperator = sSearchPath.GetPathSeparator();
+ char cLastChar = sSearchPath.GetCharacter( l );
+
+ if( cLastChar == cPathSeperator )
+ sSearchPath += "*.*";
+ else if( cPathSeperator ){
+ sSearchPath += cPathSeperator;
+ sSearchPath += "*.*";
+ }
+ else
+ sSearchPath += "\\*.*";
+
+ hFile = FindFirstFile( sSearchPath.Str(), &fData );
+ if( hFile == INVALID_HANDLE_VALUE ){
+ std::cout << "Could not open directory" << std::endl;
+ return;
+ }
+
+ do{
+ s1 = fData.cFileName;
+ if( s1 != "." && s1 != ".." ){
+ std::cout << fData.cFileName << std::endl;
+ iCnt++;
+ }
+ } while( FindNextFile( hFile, &fData ));
+ std::cout << std::endl << iCnt << " entries" << std::endl;
+#else
+ DIR *dir;
+ struct dirent *ent;
+
+ if(( dir = opendir( x.GetDataDirectory() )) != NULL ){
+ while(( ent = readdir( dir )) != NULL ){
+ s1 = ent->d_name;
+ if( s1 != "." && s1 != ".." ){
+ std::cout << ent->d_name << std::endl;
+ iCnt++;
+ }
+ }
+ std::cout << std::endl << iCnt << " entries" << std::endl;
+ closedir( dir );
+ }
+ else
+ std::cout << "Could not open directory" << std::endl;
+#endif
+}
+/*************************************************************************************/
+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 << "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 new log directory. Enter for no updates." << std::endl;
+ std::cin.getline( cNewDir, 256 );
+ if( strlen( cNewDir ) > 0 ){
+ if( cNewDir[0] == '1' )
+ x.SetLogDirectory( "" );
+ else if( cNewDir[0] == '2' )
+ x.SetLogDirectory( x.GetDefaultLogDirectory());
+ else
+ x.SetLogDirectory( cNewDir );
+
+ std::cout << "Log File Directory is [" << x.GetLogDirectory().Str() << "]" << std::endl;
+ }
+ else
+ std::cout << "Log Directory not updated" << std::endl;
+}
+/*************************************************************************************/
+void xbUtil::UpdateLogFileName(){
+ char cNewFile[256];
+ 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 << "Enter new Log File Name" << std::endl;
+ std::cin.getline( cNewFile, 256 );
+ if( strlen( cNewFile ) > 0 ){
+ if( cNewFile[0] == '1' )
+ x.SetLogFileName( x.GetDefaultLogFileName());
+ else
+ x.SetLogFileName( cNewFile );
+
+ 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()) {
+ 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 );
+ } else
+ std::cout << "Logging disabled" << std::endl;
+}
+/*************************************************************************************/
+void xbUtil::ToggleLoggingStatus(){
+ 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" );
+ std::cout << "Logging enabled" << std::endl;
+ }
+}
+/*************************************************************************************/
+void xbUtil::ToggleDefaultAutoCommit(){
+ 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" );
+ std::cout << "Default Auto Commit enabled" << std::endl;
+ }
+}
+/*************************************************************************************/
+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 << "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( "" );
+ else if( cNewDir[0] == '2' )
+ x.SetDataDirectory( PROJECT_DATA_DIR );
+ else
+ x.SetDataDirectory( cNewDir );
+ std::cout << "Default Data Directory is [" << x.GetDataDirectory().Str() << "]" << std::endl;
+ }
+ else
+ std::cout << "Default Data Directory not updated" << std::endl;
+}
+/*************************************************************************************/
+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;
+ #ifdef XB_LOCKING_SUPPORT
+ std::cout << "Default Auto Locking = [";
+ 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 Flavor = [";
+ switch (x.GetDefaultLockFlavor()){
+ case 1:
+ std::cout << "Dbase]" << std::endl;
+ break;
+ case 2:
+ std::cout << "Clipper]" << std::endl;
+ break;
+ case 3:
+ std::cout << "Fox]" << std::endl;
+ break;
+ case 9:
+ std::cout << "Xbase64]" << std::endl;
+ break;
+ default:
+ std::cout << "Unknown]" << std::endl;
+ break;
+ }
+ #endif
+ std::cout << "Default Log Directory = [" << x.GetDefaultLogDirectory().Str() << "]" << std::endl;
+ std::cout << "Default Logfile Name = [" << x.GetDefaultLogFileName().Str() << "]" << std::endl;
+ std::cout << "Default Auto Commit = [";
+ if( x.GetDefaultAutoCommit())
+ std::cout << "ON]" << std::endl;
+ else
+ std::cout << "OFF]" << std::endl;
+
+ std::cout << "Logging Status = [";
+ if( x.GetLogStatus())
+ std::cout << "ON]" << std::endl;
+ else
+ std::cout << "OFF]" << std::endl;
+ std::cout << "Endian Type = [";
+ if( x.GetEndianType() == 'L' )
+ std::cout << "Little Endian]" << std::endl;
+ else
+ std::cout << "Big Endian]" << std::endl;
+
+ if( x.GetMultiUser())
+ std::cout << "Multi User Mode = [ON]";
+ else
+ std::cout << "Multi User Mode = [OFF]";
+}
+/*************************************************************************************/
+/* This method handles all the complex menu option commands */
+void xbUtil::ProcessOption( const xbString &sOption ){
+
+ if( sOption[1] == '=' ){
+ if( sOption == "=0" )
+ MainMenu();
+ else if( sOption == "=0.99" )
+ // exit right now, now cleanup or termination of anything
+ exit(0);
+ else if( sOption == "=2" )
+ SystemMenu();
+ else if( sOption == "=2.1" )
+ ListSystemSettings();
+ else if( sOption == "=2.2" )
+ UpdateDataDirectory();
+ else if( sOption == "=2.3" )
+ ToggleDefaultAutoCommit();
+ else if( sOption == "=2.4" )
+ UpdateLogDirectory();
+ else if( sOption == "=2.5" )
+ UpdateLogFileName();
+ else if( sOption == "=2.6" )
+ ToggleLoggingStatus();
+ else if( sOption == "=2.7" )
+ WriteLogMessage();
+ #ifdef XB_LOCKING_SUPPORT
+ else if( sOption == "=2.8" )
+ UpdateDefaultLockRetries();
+ else if( sOption == "=2.9" )
+ ToggleDefaultAutoLock();
+ else if( sOption == "=2.10" )
+ UpdateDefaultLockFlavor();
+ else if( sOption == "=2.11" )
+ UpdateDefaultLockWait();
+ else if( sOption == "=2.12" )
+ ToggleMultiUserMode();
+ #endif
+ else if( sOption == "=3" )
+ FileMenu();
+ else if( sOption == "=3.1" )
+ ListFilesInDataDirectory();
+ else if( sOption == "=3.2" )
+ UpdateDataDirectory();
+ else if( sOption == "=3.3" )
+ x.DisplayTableList();
+ else if( sOption == "=3.4" )
+ Open();
+ else if( sOption == "=3.5" )
+ Close();
+ else if( sOption == "=3.6" )
+ CloseAllTables();
+ else if( sOption == "=3.7" )
+ SelectActiveTable();
+ else if( sOption == "=3.8" )
+ DisplayTableStats();
+ else if( sOption == "=3.10" )
+ Pack();
+ else if( sOption == "=3.11" )
+ ZapTable();
+ else if( sOption == "=3.12" )
+ CopyDbfStructure();
+ else if( sOption == "=3.13" )
+ UpdateTableAutoCommit();
+ else if( sOption == "=3.14" )
+ DisplayTableInfo();
+ else if( sOption == "=4" )
+ RecordMenu();
+ else if( sOption == "=4.1" )
+ SelectActiveTable();
+ else if( sOption == "=4.2" )
+ GetRecord();
+ else if( sOption == "=4.3" )
+ BlankRecord();
+ else if( sOption == "=4.4" )
+ AppendRecord();
+ else if( sOption == "=4.5" )
+ PutRecord();
+ else if( sOption == "=4.6" )
+ DeleteRecord();
+ else if( sOption == "=4.7" )
+ UndeleteRecord();
+ else if( sOption == "=4.8" )
+ GetFirstRecord();
+ else if( sOption == "=4.9" )
+ GetNextRecord();
+ else if( sOption == "=4.10" )
+ GetPrevRecord();
+ else if( sOption == "=4.11" )
+ GetLastRecord();
+ else if( sOption == "=4.12" )
+ DumpRecord();
+ else if( sOption == "=4.13" )
+ AbortRecord();
+ else if( sOption == "=4.14" )
+ CommitRecord();
+ #ifdef XB_FILTER_SUPPORT
+ else if( sOption == "=4.20" )
+ SetFilter();
+ else if( sOption == "=4.21" )
+ GetFirstFilterRec();
+ else if( sOption == "=4.22" )
+ GetNextFilterRec();
+ else if( sOption == "=4.23" )
+ GetPrevFilterRec();
+ else if( sOption == "=4.24" )
+ GetLastFilterRec();
+ #endif // XB_FILTER_SUPPORT
+ else if( sOption == "=5" )
+ FieldMenu();
+ else if( sOption == "=5.1" )
+ SelectActiveTable();
+ else if( sOption == "=5.2" )
+ ListFieldInfo();
+ else if( sOption == "=5.3" )
+ DumpRecord();
+ else if( sOption == "=5.4" )
+ UpdateFieldData();
+ #ifdef XB_MEMO_SUPPORT
+ else if( sOption == "=5.5" )
+ ShowMemoFieldData();
+ else if( sOption == "=5.6" )
+ UpdateMemoFieldData();
+ else if( sOption == "=5.7" )
+ DeleteMemoField();
+ #endif
+
+ #ifdef XB_LOCKING_SUPPORT
+ else if( sOption == "=6" )
+ LockingMenu();
+ else if( sOption == "=6.1" )
+ DisplayFileLockSettings();
+ else if( sOption == "=6.2" )
+ UpdateFileLockRetryCount();
+ else if( sOption == "=6.3" )
+ UpdateFileLockFlavor();
+ else if( sOption == "=6.4" )
+ UpdateFileAutoLock();
+ else if( sOption == "=6.5" )
+ LockDbf();
+ else if( sOption == "=6.6" )
+ UnlockDbf();
+ else if( sOption == "=6.7" )
+ LockRecord();
+ else if( sOption == "=6.8" )
+ UnlockRecord();
+ else if( sOption == "=6.9" )
+ LockAppend();
+ else if( sOption == "=6.10" )
+ UnlockAppend();
+ else if( sOption == "=6.11" )
+ LockHeader();
+ else if( sOption == "=6.12" )
+ UnlockHeader();
+ #ifdef XB_MEMO_SUPPORT
+ else if( sOption == "=6.13" )
+ LockMemo();
+ else if( sOption == "=6.14" )
+ UnlockMemo();
+ #endif
+
+ #ifdef XB_DEBUG_SUPPORT
+ else if( sOption == "=6.20" )
+ xbFileLock();
+ else if( sOption == "=6.21" )
+ xbFileUnlock();
+ #endif
+ #endif
+
+ #ifdef XB_EXPRESSION_SUPPORT
+ else if( sOption == "=7" )
+ ExpressionMenu();
+ else if( sOption == "=7.1" )
+ ParseExpression( 0 );
+ else if( sOption == "=7.2" )
+ ProcessParsedExpression( 0 );
+ else if( sOption == "=7.3" )
+ ParseAndProcessExpression();
+ #ifdef XB_DEBUG_SUPPORT
+ else if (sOption == "=7.4" )
+ DumpExpressionTree();
+ #endif // XB_DEBUG_SUPPORT
+ else if (sOption == "=7.10" )
+ Date8ToJul();
+ else if (sOption == "=7.11" )
+ JulToDate8();
+ else if (sOption == "=7.12" )
+ IsLeapYear();
+ #endif // XB_EXPRESSION_SUPPORT
+
+ #ifdef XB_INDEX_SUPPORT
+
+ else if( sOption == "=8" )
+ IndexMenu();
+ else if( sOption == "=8.1" )
+ SelectActiveTable();
+ else if( sOption == "=8.2" )
+ DisplayOpenIndexFiles();
+ else if( sOption == "=8.3" )
+ DisplaySupportedIndexTypes();
+ else if( sOption == "=8.4" )
+ SelectTag();
+ else if( sOption == "=8.5" )
+ OpenIndex();
+ else if( sOption == "=8.6" )
+ CloseIndexFile();
+ else if( sOption == "=8.7" )
+ CreateIndexTag();
+ else if( sOption == "=8.8" )
+ GetFirstKey();
+ else if( sOption == "=8.9" )
+ GetPrevKey();
+ else if( sOption == "=8.10" )
+ GetNextKey();
+ else if( sOption == "=8.11" )
+ GetLastKey();
+ else if( sOption == "=8.12" )
+ FindKey();
+
+ else if( sOption == "=8.13" )
+ CheckIntegrity();
+ else if( sOption == "=8.14" )
+ Reindex();
+ else if( sOption == "=8.15" )
+ DeleteTag();
+ else if( sOption == "=8.16" )
+ AssociateNonProdIx();
+
+ #ifdef XB_DEBUG_SUPPORT
+ else if( sOption == "=8.20" )
+ DumpIxHeader();
+ else if( sOption == "=8.21" )
+ DumpIxNode();
+ else if( sOption == "=8.22" )
+ DumpIxNodeChain();
+ else if( sOption == "=8.23" )
+ DumpRecsByIx(0);
+ else if( sOption == "=8.24" )
+ DumpRecsByIx(1);
+ else if( sOption == "=8.25" )
+ DumpFreeBlocks();
+ #endif // XB_DEBUG_SUPPORT
+ #endif // XB_INDEX_SUPPORT
+
+ #ifdef XB_SQL_SUPPORT
+ else if( sOption == "=10" )
+ SqlMenu();
+ else if( sOption == "=10.1" )
+ ExecSqlNonQuery();
+ else if( sOption == "=10.2" )
+ ExecSqlQuery();
+ #endif // XB_SQL_SUPPORT
+
+ #ifdef XB_NDXINF_SUPPORT
+ else if( sOption == "=11" )
+ InfFileMenu();
+ else if( sOption == "=11.1" )
+ ListInfFileData();
+ else if( sOption == "=11.2" )
+ AddInfFileData();
+ else if( sOption == "=11.3" )
+ DeleteInfFileData();
+ else if( sOption == "=11.10" )
+ InfFileHelp();
+ #endif // XB_NDXINF_SUPPORT
+
+ #ifdef XB_DEBUG_SUPPORT
+ else if( sOption == "=20" )
+ DebugMenu();
+ else if( sOption == "=20.1" )
+ SelectActiveTable();
+/*
+ #ifdef XB_MEMO_SUPPORT
+ else if( sOption == "=10.2" )
+ DumpDbtHeader();
+ else if( sOption == "=10.3" )
+ DumpMemoFreeChain();
+ #endif
+*/
+
+ #endif
+ else
+ return;
+ }
+}
+
+/*************************************************************************************/
+xbInt32 xbUtil::GetLong(){
+ char cLine[256];
+ xbString sLine;
+ memset( cLine, 0x00, 256 );
+ std::cin.getline( cLine, 256 );
+ sLine = cLine;
+ sLine.Trim();
+ return atol( cLine );
+}
+/*************************************************************************************/
+xbInt16 xbUtil::GetOption(){
+ char cLine[256];
+ xbString sLine;
+ memset( cLine, 0x00, 256 );
+ std::cin.getline( cLine, 256 );
+ sLine = cLine;
+ sLine.Trim();
+
+ if( sLine[1] == '=' || sLine.Pos(".") != 0 ){
+ ProcessOption( sLine );
+ return 0;
+ }
+ else
+ return atoi( cLine );
+}
+/************************************************************************/
+#ifdef XB_INDEX_SUPPORT
+void xbUtil::IndexMenu()
+{
+ int option = 0;
+
+ while( option != 99 ) {
+
+ std::cout << std::endl << std::endl << " 8 - Index Menu" << std::endl;
+ std::cout << "---------------------" << std::endl;
+ DisplayActiveTable();
+
+ std::cout << " 1 - Select Active Table" << std::endl;
+ std::cout << " 2 - Display Open Index Files" << std::endl;
+ std::cout << " 3 - Display Supported Index Types" << std::endl;
+ std::cout << " 4 - Select Active Tag" << std::endl;
+ std::cout << " 5 - Open Index File" << std::endl;
+ std::cout << " 6 - Close Index File" << std::endl;
+ std::cout << " 7 - Create Index Tag" << std::endl;
+ std::cout << " 8 - Get First Key" << std::endl;
+ std::cout << " 9 - Get Next Key" << std::endl;
+ std::cout << " 10 - Get Prev Key" << std::endl;
+ std::cout << " 11 - Get Last Key" << std::endl;
+ std::cout << " 12 - Find Key" << std::endl;
+ std::cout << " 13 - Check Index Integrity" << std::endl;
+ std::cout << " 14 - Reindex" << std::endl;
+ std::cout << " 15 - Delete Tag" << std::endl;
+ std::cout << " 16 - Associate NDX file" << std::endl;
+
+ #ifdef XB_DEBUG_SUPPORT
+ std::cout << std::endl;
+ std::cout << " 20 - Dump Header" << std::endl;
+ std::cout << " 21 - Dump Node(s)" << std::endl;
+ std::cout << " 22 - Dump Node Chain" << std::endl;
+ std::cout << " 23 - Dump Recs by Tag Fwd" << std::endl;
+ std::cout << " 24 - Dump Recs by Tag Bwd" << std::endl;
+ std::cout << " 25 - Dump Free Blocks / MDX ulBlock2" << std::endl;
+ #endif // XB_DEBUG_SUPPORT
+
+ std::cout << std::endl;
+ std::cout << std::endl;
+
+ std::cout << " 99 - Exit Menu" << std::endl;
+ option = GetOption();
+
+ switch( option ){
+ case 0: break;
+ case 1: SelectActiveTable(); break;
+ case 2: DisplayOpenIndexFiles(); break;
+ case 3: DisplaySupportedIndexTypes(); break;
+ case 4: SelectTag(); break;
+ case 5: OpenIndex(); break;
+ case 6: CloseIndexFile(); break;
+ case 7: CreateIndexTag(); break;
+
+ case 8: GetFirstKey(); break;
+ case 9: GetNextKey(); break;
+ case 10: GetPrevKey(); break;
+ case 11: GetLastKey(); break;
+
+ case 12: FindKey(); break;
+ case 13: CheckIntegrity(); break;
+ case 14: Reindex(); break;
+ case 15: DeleteTag(); break;
+ case 16: AssociateNonProdIx(); break;
+
+ #ifdef XB_DEBUG_SUPPORT
+ case 20: DumpIxHeader(); break;
+ case 21: DumpIxNode(); break;
+ case 22: DumpIxNodeChain(); break;
+ case 23: DumpRecsByIx(0); break;
+ case 24: DumpRecsByIx(1); break;
+ case 25: DumpFreeBlocks(); break;
+ #endif
+
+ case 99: break;
+ default: std::cout << "Invalid option" << std::endl; break;
+ }
+ }
+}
+#endif
+/************************************************************************/
+#ifdef XB_EXPRESSION_SUPPORT
+void xbUtil::ExpressionMenu()
+{
+ int option = 0;
+
+ while( option != 99 ) {
+ std::cout << std::endl << std::endl << " 7 - Expression Menu" << std::endl;
+ std::cout << " --------------" << std::endl;
+ DisplayActiveTable();
+ std::cout << " 1 - Parse Expression" << std::endl;
+ std::cout << " 2 - Process Parsed Expression" << std::endl;
+ std::cout << " 3 - Parse and Process Expression" << std::endl;
+ #ifdef XB_DEBUG_SUPPORT
+ std::cout << " 4 - Dump Expression Internals" << std::endl;
+ #endif
+ std::cout << " 10 - Date8 To Julian Date" << std::endl;
+ std::cout << " 11 - Julian Date to Date8" << std::endl;
+ std::cout << " 12 - Check Leap Year" << std::endl;
+ std::cout << " 99 - Exit Menu" << std::endl;
+ option = GetOption();
+ switch( option ){
+ case 0: break;
+ case 1: ParseExpression( 0 ); break;
+ case 2: ProcessParsedExpression( 0 ); break;
+ case 3: ParseAndProcessExpression(); break;
+ #ifdef XB_DEBUG_SUPPORT
+ case 4: DumpExpressionTree(); break;
+ #endif
+ case 10: Date8ToJul(); break;
+ case 11: JulToDate8(); break;
+ case 12: IsLeapYear(); break;
+ case 99: break;
+ default: std::cout << "Invalid option" << std::endl; break;
+ }
+ }
+}
+#endif
+/************************************************************************/
+#ifdef XB_LOCKING_SUPPORT
+void xbUtil::LockingMenu()
+{
+ int option = 0;
+
+ while( option != 99 ) {
+ std::cout << std::endl << std::endl << " 6 - Locking Menu" << std::endl;
+ std::cout << "-------------" << std::endl;
+ DisplayActiveTable();
+
+ std::cout << " 1 - Display File Specific Settings" << std::endl;
+ std::cout << " 2 - Update File Retry Count" << std::endl;
+ std::cout << " 3 - Update Locking Flavor" << std::endl;
+ std::cout << " 4 - Update Auto Lock" << std::endl;
+ std::cout << " 5 - Lock table (dbf file)" << std::endl;
+ std::cout << " 6 - Unlock table (dbf file)" << std::endl;
+ std::cout << " 7 - Lock Record" << std::endl;
+ std::cout << " 8 - Unlock Record" << std::endl;
+ std::cout << " 9 - Lock Append" << std::endl;
+ std::cout << " 10 - Unlock Append" << std::endl;
+ std::cout << " 11 - Lock Header" << std::endl;
+ std::cout << " 12 - Unlock Header" << std::endl;
+
+
+ #ifdef XB_MEMO_SUPPORT
+ std::cout << " 13 - Lock Memo File" << std::endl;
+ std::cout << " 14 - Unlock Memo File" << std::endl;
+ #endif // XB_MEMO_SUPPORT
+
+ #ifdef XB_INDEX_SUPPORT
+ std::cout << " 15 - Lock Index File(s)" << std::endl;
+ std::cout << " 16 - Unlock Index File(s)" << std::endl;
+ #endif // XB_INDEX_SUPPORT
+
+ #ifdef XB_DEBUG_SUPPORT
+ std::cout << " 20 - Native xbFile - Lock Bytes" << std::endl;
+ std::cout << " 21 - Native xbFile - Unlock Bytes" << std::endl;
+ #endif // XB_DEBUG_SUPPORT
+
+ std::cout << " 99 - Exit Menu" << std::endl;
+ option = GetOption();
+
+ switch( option ) {
+ case 0: break;
+ case 1: DisplayFileLockSettings(); break;
+ case 2: UpdateFileLockRetryCount(); break;
+ case 3: UpdateFileLockFlavor(); break;
+ case 4: UpdateFileAutoLock(); break;
+ case 5: LockDbf(); break;
+ case 6: UnlockDbf(); break;
+ case 7: LockRecord(); break;
+ case 8: UnlockRecord(); break;
+ case 9: LockAppend(); break;
+ case 10: UnlockAppend(); break;
+ case 11: LockHeader(); break;
+ case 12: UnlockHeader(); break;
+
+ #ifdef XB_MEMO_SUPPORT
+ case 13: LockMemo(); break;
+ case 14: UnlockMemo(); break;
+ #endif // XB_MEMO_SUPPORT
+
+ #ifdef XB_INDEX_SUPPORT
+ case 15: LockIndices(); break;
+ case 16: UnlockIndices(); break;
+ #endif // XB_INDEX_SUPPORT
+
+ #ifdef XB_DEBUG_SUPPORT
+ case 20: xbFileLock(); break;
+ case 21: xbFileUnlock(); break;
+ #endif // XB_DEBUG_SUPPORT
+
+ case 99: break;
+ default: std::cout << "Invalid Option" << std::endl;
+ }
+ }
+}
+#endif
+
+/************************************************************************/
+#ifdef XB_SQL_SUPPORT
+void xbUtil::SqlMenu()
+{
+ int option = 0;
+
+ while( option != 99 ) {
+ std::cout << std::endl << std::endl << "9 - Sql Menu" << std::endl;
+ std::cout << "-------------" << std::endl;
+ DisplayActiveTable();
+
+ std::cout << " 1 - Execute SQL Non Query" << std::endl;
+ std::cout << " 2 - Execute SQL Query" << std::endl;
+ std::cout << "99 - Exit Menu" << std::endl;
+
+ option = GetOption();
+ switch( option ){
+ case 0: break;
+ case 1: ExecSqlNonQuery(); break;
+ case 2: ExecSqlQuery(); break;
+ case 99: break;
+ default: std::cout << "Invalid option" << std::endl; break;
+ }
+ }
+}
+#endif // XB_SQL_SUPPORT
+
+/************************************************************************/
+#ifdef XB_DEBUG_SUPPORT
+void xbUtil::DebugMenu()
+{
+ int option = 0;
+
+ while( option != 99 ) {
+ std::cout << std::endl << std::endl << "10 - Debug Menu" << std::endl;
+ std::cout << "-------------" << std::endl;
+ DisplayActiveTable();
+
+ std::cout << " 1 - Select Active Table" << std::endl;
+ #ifdef XB_MEMO_SUPPORT
+ std::cout << " 2 - Dislay Memo Header Info" << std::endl;
+ std::cout << " 3 - Dump Memo Free Chain" << std::endl;
+ #endif
+
+// //std::cout << "4 - Dump index node chains to file xbase.dmp" << std::endl;
+// //std::cout << "5 - Dump index node chain" << std::endl;
+ std::cout << "99 - Exit Menu" << std::endl;
+ option = GetOption();
+ switch( option ){
+ case 0: break;
+ case 1: SelectActiveTable(); break;
+ #ifdef XB_MEMO_SUPPORT
+ case 2: DumpDbtHeader(); break;
+ case 3: DumpMemoFreeChain(); break;
+ #endif
+ case 99: break;
+ default: std::cout << "Invalid option" << std::endl; break;
+ }
+ }
+}
+#endif // XBASE_DEBUG
+/************************************************************************/
+void xbUtil::FieldMenu()
+{
+ int option = 0;
+
+ while( option != 99 ) {
+ std::cout << std::endl << std::endl << " 5 - Field Menu" << std::endl;
+ std::cout << " --------------" << std::endl;
+ DisplayActiveTable();
+ std::cout << " 1 - Select Active Table" << std::endl;
+ std::cout << " 2 - List Field Info" << std::endl;
+ std::cout << " 3 - Show Field Data (non memo field)" << std::endl;
+ std::cout << " 4 - Update Field Data" << std::endl;
+ #ifdef XB_MEMO_SUPPORT
+ std::cout << " 5 - Show Memo Field Data" << std::endl;
+ std::cout << " 6 - Update Memo Field" << std::endl;
+ std::cout << " 7 - Delete Memo Field" << std::endl;
+ #endif
+
+ std::cout << "99 - Exit Menu" << std::endl;
+ option = GetOption();
+ switch( option ){
+ case 0: break;
+ case 1: SelectActiveTable(); break;
+ case 2: ListFieldInfo(); break;
+ case 3: DumpRecord(); break;
+ case 4: UpdateFieldData(); break;
+ #ifdef XB_MEMO_SUPPORT
+ case 5: ShowMemoFieldData(); break;
+ case 6: UpdateMemoFieldData(); break;
+ case 7: DeleteMemoField(); break;
+ #endif
+ case 99: break;
+ default: std::cout << "Invalid option" << std::endl; break;
+ }
+ }
+}
+/************************************************************************/
+void xbUtil::RecordMenu()
+{
+ int option = 0;
+ while( option != 99 ) {
+ std::cout << std::endl << std::endl << " 4 - Record Menu" << std::endl;
+ std::cout << " ---------------" << std::endl;
+ DisplayActiveTable();
+ std::cout << " 1 - Select Active Table" << std::endl;
+ std::cout << " 2 - Get Record" << std::endl;
+ std::cout << " 3 - Blank Record" << std::endl;
+ std::cout << " 4 - Append Record" << std::endl;
+ std::cout << " 5 - Put Record" << std::endl;
+ std::cout << " 6 - Delete Record" << std::endl;
+ std::cout << " 7 - Undelete Record" << std::endl;
+ std::cout << " 8 - First Record" << std::endl;
+ std::cout << " 9 - Next Record" << std::endl;
+ std::cout << "10 - Prev Record" << std::endl;
+ std::cout << "11 - Last Record" << std::endl;
+ std::cout << "12 - Dump Record" << std::endl;
+ std::cout << "13 - Abort Record Updates" << std::endl;
+ std::cout << "14 - Commit Record Updates" << std::endl;
+
+ #ifdef XB_FILTER_SUPPORT
+ std::cout << "20 - Set Filter" << std::endl;
+ std::cout << "21 - Get First Filter Rec" << std::endl;
+ std::cout << "22 - Get Next Filter Rec" << std::endl;
+ std::cout << "23 - Get Prev Filter Rec" << std::endl;
+ std::cout << "24 - Get Last Filter Rec" << std::endl;
+ #endif // XB_FILTER_SUPPORT
+
+ std::cout << "99 - Exit Menu" << std::endl;
+ option = GetOption();
+
+ switch( option ){
+ case 0: break;
+ case 1: SelectActiveTable(); break;
+ case 2: GetRecord(); break;
+ case 3: BlankRecord(); break;
+ case 4: AppendRecord(); break;
+ case 5: PutRecord(); break;
+ case 6: DeleteRecord(); break;
+ case 7: UndeleteRecord(); break;
+ case 8: GetFirstRecord(); break;
+ case 9: GetNextRecord(); break;
+ case 10: GetPrevRecord(); break;
+ case 11: GetLastRecord(); break;
+ case 12: DumpRecord(); break;
+ case 13: AbortRecord(); break;
+ case 14: CommitRecord(); break;
+
+ #ifdef XB_FILTER_SUPPORT
+ case 20: SetFilter(); break;
+ case 21: GetFirstFilterRec(); break;
+ case 22: GetNextFilterRec(); break;
+ case 23: GetPrevFilterRec(); break;
+ case 24: GetLastFilterRec(); break;
+ #endif // XB_FILTER_SUPPORT
+
+ case 99: break;
+ default: std::cout << "Invalid option" << std::endl; break;
+ }
+ }
+}
+
+/************************************************************************/
+void xbUtil::FileMenu()
+{
+ int option = 0;
+
+ while( option != 99 ) {
+ std::cout << std::endl << std::endl << " 3 - File / Table Menu" << std::endl;
+ std::cout << " ---------------------" << std::endl;
+ DisplayActiveTable();
+ std::cout << " 1 - List files in Default Data Directory" << std::endl;
+ std::cout << " 2 - Update Default Data Directory" << std::endl;
+ std::cout << " 3 - List Open Tables/Files" << std::endl;
+ std::cout << " 4 - Open Table/File" << std::endl;
+ std::cout << " 5 - Close Table/File" << std::endl;
+ std::cout << " 6 - Close All Tables/Files" << std::endl;
+ std::cout << " 7 - Select Active Table" << std::endl;
+ std::cout << " 8 - Table/File Information" << std::endl;
+ std::cout << "10 - Pack" << std::endl;
+ std::cout << "11 - Zap Database" << std::endl;
+ std::cout << "12 - Copy Dbf Structure" << std::endl;
+ std::cout << "13 - Update Table Auto Commit Setting" << std::endl;
+ std::cout << "14 - Display Table Info" << std::endl;
+
+ std::cout << "99 - Exit Menu" << std::endl;
+ option = GetOption();
+
+ switch( option ){
+ case 0: break;
+ case 1: ListFilesInDataDirectory(); break;
+ case 2: UpdateDataDirectory(); break;
+ case 3: x.DisplayTableList(); break;
+ case 4: Open(); break;
+ case 5: Close(); break;
+ case 6: CloseAllTables(); break;
+ case 7: SelectActiveTable(); break;
+ case 8: DisplayTableStats(); break;
+ case 10: Pack(); break;
+ case 11: ZapTable(); break;
+ case 12: CopyDbfStructure(); break;
+ case 13: UpdateTableAutoCommit(); break;
+ case 14: DisplayTableInfo(); break;
+ case 99: break;
+
+ default: std::cout << "Invalid Option" << std::endl;
+ }
+ }
+}
+
+/************************************************************************/
+#ifdef XB_NDXINF_SUPPORT
+void xbUtil::InfFileMenu()
+{
+
+
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "No table selected" << std::endl;
+ return;
+ }
+
+ int option = 0;
+ while( option != 99 ) {
+ std::cout << std::endl << std::endl << " 11 - InfFileData Menu" << std::endl;
+ std::cout << " ---------------------" << std::endl;
+ DisplayActiveTable();
+ std::cout << " 1 - List Inf Contents" << std::endl;
+ std::cout << " 2 - Add NDX File association to [" << dActiveTable->GetTblAlias().Str() << "]" << std::endl;
+ std::cout << " 3 - Delete NDX File association from [" << dActiveTable->GetTblAlias().Str() << "]" << std::endl;
+ std::cout << "10 - Inf File Help" << std::endl;
+ std::cout << "99 - Exit Menu" << std::endl;
+ option = GetOption();
+
+ switch( option ){
+ case 0: break;
+ case 1: ListInfFileData(); break;
+ case 2: AddInfFileData(); break;
+ case 3: DeleteInfFileData(); break;
+ case 10: InfFileHelp(); break;
+ case 99: break;
+ default: std::cout << "Invalid Option" << std::endl;
+ }
+ }
+}
+#endif // XB_NDXINF_SUPPORT
+
+/************************************************************************************/
+void xbUtil::SystemMenu()
+{
+ int option = 0;
+ while( option != 99 ) {
+ std::cout << std::endl << std::endl << " 2 - System Menu" << std::endl;
+ std::cout << " ---------------" << std::endl;
+ DisplayActiveTable();
+ std::cout << " 1 - Display System Settings" << std::endl;
+ std::cout << " 2 - Update Default Data Directory" << std::endl;
+
+ std::cout << " 3 - Toggle Default Auto Commit" << std::endl;
+ std::cout << " 4 - Update Default Log Directory" << std::endl;
+ std::cout << " 5 - Update Default Log File Name" << std::endl;
+ std::cout << " 6 - Toggle Logging Status" << std::endl;
+ std::cout << " 7 - Write Test Log Message" << std::endl;
+ #ifdef XB_LOCKING_SUPPORT
+ std::cout << " 8 - Update Default Lock Retries" << std::endl;
+ std::cout << " 9 - Toggle Default Auto Lock" << std::endl;
+ //std::cout << "10 - Update Lock Flavor" << std::endl; 3/20/17, only one flavor working
+ std::cout << "11 - Update Default Lock Wait Time" << std::endl;
+ std::cout << "12 - Toggle Multi User Mode" << std::endl;
+ #endif
+
+ std::cout << "99 - Exit Menu" << std::endl;
+ option = GetOption();
+
+ switch( option ) {
+ case 0: break;
+ case 1: ListSystemSettings(); break;
+ case 2: UpdateDataDirectory(); break;
+ case 3: ToggleDefaultAutoCommit(); break;
+ case 4: UpdateLogDirectory(); break;
+ case 5: UpdateLogFileName(); break;
+ case 6: ToggleLoggingStatus(); break;
+ case 7: WriteLogMessage(); break;
+ #ifdef XB_LOCKING_SUPPORT
+ case 8: UpdateDefaultLockRetries(); break;
+ case 9: ToggleDefaultAutoLock(); break;
+ case 10: UpdateDefaultLockFlavor(); break;
+ case 11: UpdateDefaultLockWait(); break;
+ case 12: ToggleMultiUserMode(); break;
+ #endif
+
+ case 99: break;
+ default: std::cout << "Invalid Option" << std::endl;
+ }
+ }
+}
+/************************************************************************************/
+void xbUtil::MainMenu()
+{
+ int option = 0;
+ std::cout << std::endl<< std::endl << "XBase64 Utility Program";
+ DisplayActiveTable();
+ while( option != 99 ) {
+ std::cout << std::endl << std::endl << " 0 - Main Menu" << std::endl;
+ std::cout << " -------------" << std::endl;
+ std::cout << " 1 - Help" << std::endl;
+ std::cout << " 2 - System Menu" << std::endl;
+ std::cout << " 3 - File / Table Menu" << std::endl;
+ std::cout << " 4 - Record Menu" << std::endl;
+ std::cout << " 5 - Field Menu" << std::endl;
+ //std::cout << " 6 - Index Menu" << std::endl;
+ #ifdef XB_LOCKING_SUPPORT
+ std::cout << " 6 - Locking Menu" << std::endl;
+ #endif
+ #ifdef XB_EXPRESSION_SUPPORT
+ std::cout << " 7 - Expression Menu" << std::endl;
+ #endif
+ #ifdef XB_INDEX_SUPPORT
+ std::cout << " 8 - Index Menu" << std::endl;
+ #endif
+
+ #ifdef XB_FILTERS
+ std::cout << " 9 - Filter Menu" << std::endl;
+ #endif
+
+ #ifdef XB_SQL_SUPPORT
+ std::cout << "10 - SQL Menu" << std::endl;
+ #endif // XB_SQL_SUPPORT
+
+ #ifdef XB_NDXINF_SUPPORT
+ std::cout << "11 - INF File Menu" << std::endl;
+ #endif // XB_NDXINF_SUPPORT
+
+ #ifdef XB_DEBUG_SUPPORT
+ std::cout << "20 - Debug Menu" << std::endl;
+ #endif
+
+ std::cout << "99 - Exit" << std::endl;
+ option = GetOption();
+ switch( option ){
+ case 0: break;
+ case 2: SystemMenu(); break;
+ case 3: FileMenu(); break;
+ case 4: RecordMenu(); break;
+ case 5: FieldMenu(); break;
+
+ #ifdef XB_LOCKING_SUPPORT
+ case 6: LockingMenu(); break;
+ #endif
+
+ #ifdef XB_EXPRESSION_SUPPORT
+ case 7: ExpressionMenu(); break;
+ #endif
+
+ #ifdef XB_INDEX_SUPPORT
+ case 8: IndexMenu(); break;
+ #endif
+
+ #ifdef XB_FILTERS
+ case 9: FilterMenu(); break;
+ #endif
+
+ #ifdef XB_SQL_SUPPORT
+ case 10: SqlMenu(); break;
+ #endif
+
+ #ifdef XB_NDXINF_SUPPORT
+ case 11: InfFileMenu(); break;
+ #endif
+
+ #ifdef XB_DEBUG_SUPPORT
+ case 20: DebugMenu(); break;
+ #endif
+
+ case 99: std::cout << "Bye!! - Thanks for using XBase64" << std::endl; break;
+ default:
+ std::cout << option << " - Invalid function" << std::endl;
+ break;
+ }
+ }
+}
+/*************************************************************************************/
+#ifdef XB_INDEX_SUPPORT
+void xbUtil::DisplayOpenIndexFiles(){
+
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+ // if not active indices, display no open NDX indices
+ xbInt32 lIxCnt = dActiveTable->GetPhysicalIxCnt();
+ if( lIxCnt == 0 ){
+ std::cout << "No open index files for table" << std::endl;
+ return;
+ } else {
+ std::cout << " Open Index Files = [" << lIxCnt << "]" << std::endl;
+ std::cout << " FileName\tFile Type\n";
+ std::cout << " ========\t=========\n";
+ }
+ // For each active index
+ // display File Name, Type, Key
+ xbIxList *p = dActiveTable->GetIxList();
+ xbIx *ixp;
+ while( p ){
+ ixp = p->ix;
+ std::cout << " " << ixp->GetFileName().Str() << "\t" << p->sFmt->Str() << std::endl;
+ p = p->next;
+ }
+}
+
+void xbUtil::DisplaySupportedIndexTypes(){
+
+ std::cout << "Supported Index Type" << std::endl;
+ std::cout << "Type MaxTags Asc/Dsc Filters Description" << std::endl;
+ std::cout << "---- ------- -------- ------- --------------------------------" << std::endl;
+ #ifdef XB_NDX_SUPPORT
+ std::cout << "NDX 1 ASC No Dbase III single tag index file" << std::endl;
+ #endif
+ #ifdef XB_MDX_SUPPORT
+ std::cout << "MDX 47 ASC/DSC Yes Dbase IV multiple tag index file" << std::endl;
+ #endif
+}
+
+void xbUtil::SelectTag(){
+ std::cout << "SelectTag" << std::endl;
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+
+ xbLinkListNode<xbTag *> *llN = dActiveTable->GetTagList();
+ xbTag *pTag;
+ xbInt16 i = 1;
+ std::cout << "Line\tType\tUnique\tSort\tName\t\tKey Expression\t\tFilter" << std::endl;
+
+ char cUnique;
+ char cSort;
+ xbString s;
+ while( llN ){
+ pTag = llN->GetKey();
+ pTag->GetUnique() ? cUnique = 'Y' : cUnique = 'N';
+ pTag->GetSort() ? cSort = 'D' : cSort = 'A';
+ s.Sprintf( "%d\t%s\t%c\t%c\t%-12s\t%-20s\t%s \n", i++, pTag->GetType().Str(), cUnique, cSort, pTag->GetTagName().Str(), pTag->GetExpression().Str(), pTag->GetFilter().Str() );
+ std::cout << s.Str();
+// std::cout << i++ << "\t" << pTag->GetType() << "\t " << cUnique << "\t " << cSort << "\t" << pTag->GetTagName() << "\t" << pTag->GetExpression() << "\t" << pTag->GetFilter() << std::endl;
+ llN = llN->GetNextNode();
+ }
+ char cBuf[128];
+ std::cout << std::endl << "Enter Line No:" << std::endl;
+ std::cin.getline( cBuf, 128 );
+
+ xbInt32 iSelection = atol( cBuf );
+ if( iSelection < 1 || iSelection > i ){
+ std::cout << "Invalid selection [" << iSelection << "]" << std::endl;
+ } else {
+ llN = dActiveTable->GetTagList();
+ i = 1;
+ for( i = 1; i < iSelection; i++ )
+ llN = llN->GetNextNode();
+ pTag = llN->GetKey();
+ dActiveTable->SetCurTag( pTag->GetType(), pTag->GetIx(), pTag->GetVpTag() );
+ }
+}
+
+void xbUtil::OpenIndex(){
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+ xbInt16 iRc;
+
+ char cBuf[128];
+ std::cout << "Enter index type (NDX or MDX)" << std::endl;
+ std::cin.getline( cBuf, 128 );
+ xbString sIxType = cBuf;
+
+ std::cout << "Enter File Name" << std::endl;
+ std::cin.getline( cBuf, 128 );
+ xbString sIxFileName = cBuf;
+
+ iRc = dActiveTable->OpenIndex( sIxType, sIxFileName );
+ x.DisplayError( iRc );
+}
+
+void xbUtil::CloseIndexFile(){
+
+ std::cout << "CloseIndex\n";
+
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+
+ xbIx *pIx = dActiveTable->GetCurIx();
+ if( !pIx )
+ SelectTag();
+
+ pIx = dActiveTable->GetCurIx();
+ if( !pIx ){
+ std::cout << "Tag not selected" << std::endl;
+ return;
+ }
+
+ xbInt16 iRc = dActiveTable->CloseIndexFile( pIx );
+ x.DisplayError( iRc );
+}
+
+void xbUtil::CreateIndexTag(){
+
+ std::cout << "CreateIndexTag\n";
+
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+
+ char cBuf[512];
+ xbString sPrompt = "Enter Index Type (";
+ #ifdef XB_NDX_SUPPORT
+ sPrompt += "NDX";
+ #endif // XB_NDX_SUPPORT
+ #ifdef XB_MDX_SUPPORT
+ sPrompt += " MDX";
+ #endif // XB_MDX_SUPPORT
+ sPrompt += "):";
+ std::cout << sPrompt.Str() << std::endl;
+
+ std::cin.getline( cBuf, 128 );
+ xbString sIxType = cBuf;
+
+ if( sIxType == "NDX" )
+ std::cout << "Enter File Name" << std::endl;
+ else if( sIxType == "MDX" )
+ std::cout << "Enter Tag Name" << std::endl;
+
+ std::cin.getline( cBuf, 128 );
+ xbString sIxName = cBuf;
+
+ if( sIxType != "NDX" && sIxType != "MDX" ){
+ std::cout << "Invalid tag type" << std::endl;
+ return;
+ }
+
+ xbString s;
+ if( sIxType == "NDX" ){
+ s = sIxName;
+ s.ToUpperCase();
+ xbUInt32 lPos = s.Pos( ".NDX" );
+ if( lPos == 0 )
+ sIxName += ".NDX";
+ }
+ if( sIxType == "MDX" ){
+ if( sIxName.Len() > 12 ){
+ std::cout << "Tag name [" << sIxName.Str() << "] to long. Must be 12 bytes or less" << std::endl;
+ return;
+ }
+ }
+
+ xbInt16 iDescending = 0;
+ xbInt16 iUnique = 0;
+
+ std::cout << "Enter Key Expression:" << std::endl;
+ std::cin.getline( cBuf, 512 );
+ xbString sKeyExpression = cBuf;
+
+ xbString sFilter;
+ if( sIxType == "MDX" ){
+ std::cout << "Enter Filter (or enter for none):" << std::endl;
+ std::cin.getline( cBuf, 512 );
+ sFilter = cBuf;
+
+ std::cout << "Descending? (Enter Y for yes):" << std::endl;
+ std::cin.getline( cBuf, 12 );
+ if( cBuf[0] == 'Y' )
+ iDescending = 1;
+ }
+
+ std::cout << "Unique Keys? (Enter Y for yes):" << std::endl;
+ std::cin.getline( cBuf, 12 );
+ if( cBuf[0] == 'Y' )
+ iUnique = 1;
+
+ xbIx *pIx;
+ void *vpTag;
+
+ xbInt16 iRc = dActiveTable->CreateTag( sIxType, sIxName, sKeyExpression, sFilter, iDescending, iUnique, 0, &pIx, &vpTag );
+ x.DisplayError( iRc );
+}
+
+void xbUtil::GetFirstKey(){
+ std::cout << "GetFirstKey\n";
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+ xbIx *pIx = dActiveTable->GetCurIx();
+ if( !pIx )
+ SelectTag();
+ pIx = dActiveTable->GetCurIx();
+ if( !pIx ){
+ std::cout << "Tag not selected" << std::endl;
+ return;
+ }
+ void *vpCurTag = dActiveTable->GetCurTag();
+ xbInt16 iRc = pIx->GetFirstKey( vpCurTag, 1 );
+ if( iRc == XB_NO_ERROR )
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
+ else
+ x.DisplayError( iRc );
+}
+
+void xbUtil::GetNextKey(){
+ std::cout << "GetNextKey\n";
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+ xbIx *pIx = dActiveTable->GetCurIx();
+ if( !pIx )
+ SelectTag();
+ pIx = dActiveTable->GetCurIx();
+ if( !pIx ){
+ std::cout << "Tag not selected" << std::endl;
+ return;
+ }
+ void *vpCurTag = dActiveTable->GetCurTag();
+ xbInt16 iRc = pIx->GetNextKey( vpCurTag, 1 );
+ if( iRc == XB_NO_ERROR )
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
+ else
+ x.DisplayError( iRc );
+}
+
+void xbUtil::GetPrevKey(){
+ std::cout << "GetPrevKey\n";
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+ xbIx *pIx = dActiveTable->GetCurIx();
+ if( !pIx )
+ SelectTag();
+ pIx = dActiveTable->GetCurIx();
+ if( !pIx ){
+ std::cout << "Tag not selected" << std::endl;
+ return;
+ }
+ void *vpCurTag = dActiveTable->GetCurTag();
+ xbInt16 iRc = pIx->GetPrevKey( vpCurTag, 1 );
+ if( iRc == XB_NO_ERROR )
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
+ else
+ x.DisplayError( iRc );
+}
+
+void xbUtil::GetLastKey(){
+ std::cout << "GetLastKey\n";
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "Table selected" << std::endl;
+ return;
+ }
+ xbIx *pIx = dActiveTable->GetCurIx();
+ if( !pIx )
+ SelectTag();
+ pIx = dActiveTable->GetCurIx();
+ if( !pIx ){
+ std::cout << "Tag not selected" << std::endl;
+ return;
+ }
+ void *vpCurTag = dActiveTable->GetCurTag();
+ xbInt16 iRc = pIx->GetLastKey( vpCurTag, 1 );
+ if( iRc == XB_NO_ERROR )
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
+ else
+ x.DisplayError( iRc );
+}
+
+void xbUtil::FindKey(){
+ std::cout << "FindKey\n";
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+ xbIx *pIx = dActiveTable->GetCurIx();
+ if( !pIx )
+ SelectTag();
+ pIx = dActiveTable->GetCurIx();
+ if( !pIx ){
+ std::cout << "Tag not selected" << std::endl;
+ return;
+ }
+ void *vpCurTag = dActiveTable->GetCurTag();
+ char cKeyType = pIx->GetKeyType( vpCurTag );
+
+ switch( cKeyType ){
+ case 'C':
+ std::cout << "Enter character key value:";
+ break;
+ case 'F':
+ case 'N':
+ std::cout << "Enter numeric key value:";
+ break;
+ case 'D':
+ std::cout << "Enter date (YYYYMMDD) key value:";
+ break;
+ default:
+ std::cout << "Unknown key type [" << cKeyType << "]" << std::endl;
+ return;
+ break;
+ }
+
+ char cBuf[128];
+ std::cin.getline( cBuf, 128 );
+ xbInt16 iRc = 0;
+
+ if( cKeyType == 'C' ){
+ iRc = pIx->FindKey( vpCurTag, cBuf, (xbInt32) strlen( cBuf ), 1 );
+
+ } else if( cKeyType == 'F' || cKeyType == 'N' ){
+ xbDouble d = atof( cBuf );
+ iRc = pIx->FindKey( vpCurTag, d, 1 );
+
+ } else if( cKeyType == 'D' ){
+ xbDate dt( cBuf );
+ iRc = pIx->FindKey( vpCurTag, dt, 1 );
+ }
+
+ if( iRc == XB_NO_ERROR )
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
+ else
+ x.DisplayError( iRc );
+}
+
+void xbUtil::CheckIntegrity(){
+ std::cout << "CheckIntegrity\n";
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+ xbIx *pIx = dActiveTable->GetCurIx();
+ if( !pIx )
+ SelectTag();
+ pIx = dActiveTable->GetCurIx();
+ if( !pIx ){
+ std::cout << "Tag not selected" << std::endl;
+ return;
+ }
+ void *vpCurTag = dActiveTable->GetCurTag();
+
+ xbInt16 iRc = pIx->CheckTagIntegrity( vpCurTag, 2 );
+ x.DisplayError( iRc );
+}
+
+void xbUtil::Reindex(){
+ std::cout << "Reindex\n";
+
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+ xbIx *pIx = dActiveTable->GetCurIx();
+ if( !pIx )
+ SelectTag();
+ pIx = dActiveTable->GetCurIx();
+ if( !pIx ){
+ std::cout << "Tag not selected" << std::endl;
+ return;
+ }
+ void *vpCurTag = dActiveTable->GetCurTag();
+ xbInt16 iRc = pIx->Reindex( &vpCurTag );
+ x.DisplayError( iRc );
+}
+
+void xbUtil::DeleteTag(){
+ std::cout << "DeleteTag\n";
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+ xbIx *pIx = dActiveTable->GetCurIx();
+ if( !pIx )
+ SelectTag();
+ pIx = dActiveTable->GetCurIx();
+ if( !pIx ){
+ std::cout << "Tag not selected" << std::endl;
+ return;
+ }
+ void *vpCurTag = dActiveTable->GetCurTag();
+ xbInt16 iRc = dActiveTable->DeleteTag( dActiveTable->GetCurIxType(), pIx->GetTagName( vpCurTag ));
+ x.DisplayError( iRc );
+}
+
+void xbUtil::AssociateNonProdIx(){
+ std::cout << "See InfFile menu option, option 11 from the main menu or =11 from here\n";
+}
+
+#ifdef XB_DEBUG_SUPPORT
+
+void xbUtil::DumpRecsByIx( xbInt16 iOpt ){
+ // iDirection = 0 - Forward - MDX
+ // = 1 - Reverse - MDX
+
+ std::cout << "DumpRecsByIx\n";
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+ xbIx *pIx = dActiveTable->GetCurIx();
+ if( !pIx )
+ SelectTag();
+ pIx = dActiveTable->GetCurIx();
+ if( !pIx ){
+ std::cout << "Tag not selected" << std::endl;
+ return;
+ }
+ std::cout << "Select destination:" << std::endl;
+ std::cout << "0 - Logfile" << std::endl;
+ std::cout << "1 - Screen" << std::endl;
+ std::cout << "2 - Both" << std::endl;
+ xbInt16 iDispOpt = GetOption();
+ std::cout << "Select format:" << std::endl;
+ std::cout << "0 - With Field Names" << std::endl;
+ std::cout << "1 - 1 line per record" << std::endl;
+ xbInt16 iDispFmt = GetOption();
+
+ x.WriteLogMessage( "--------- Dump Recs By Index -------------", iDispOpt );
+ void *vpCurTag = dActiveTable->GetCurTag();
+ xbUInt32 lRecCnt = 0;
+ xbInt16 iRc = 0;
+
+ if( iOpt == 0 ){
+ iRc = pIx->GetFirstKey( vpCurTag, 1 );
+ if( iRc == XB_NO_ERROR ){
+ lRecCnt++;
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), iDispOpt, iDispFmt );
+ while(( iRc = pIx->GetNextKey( vpCurTag, 1 )) == XB_NO_ERROR ){
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), iDispOpt, iDispFmt );
+ lRecCnt++;
+ }
+ } else {
+ x.DisplayError( iRc );
+ }
+ } else if( iOpt == 1 ) {
+ iRc = pIx->GetLastKey( vpCurTag, 1 );
+ if( iRc == XB_NO_ERROR ){
+ lRecCnt++;
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), iDispOpt, iDispFmt );
+ while(( iRc = pIx->GetPrevKey( vpCurTag, 1 )) == XB_NO_ERROR ){
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), iDispOpt, iDispFmt );
+ lRecCnt++;
+ }
+ }
+ } else {
+ std::cout << "Invalid option " << iOpt << std::endl;
+ return;
+ }
+ std::cout << lRecCnt << " record(s) dumped" << std::endl;
+}
+
+void xbUtil::DumpIxHeader(){
+ std::cout << "DumpIxHeader\n";
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+ xbIx *pIx = dActiveTable->GetCurIx();
+ if( !pIx )
+ SelectTag();
+ pIx = dActiveTable->GetCurIx();
+ if( !pIx ){
+ std::cout << "Tag not selected" << std::endl;
+ return;
+ }
+ std::cout << "0 - Logfile" << std::endl;
+ std::cout << "1 - Screen" << std::endl;
+ std::cout << "2 - Both" << std::endl;
+ xbInt16 iDispOpt = GetOption();
+ pIx->DumpHeader( iDispOpt, 3 );
+
+}
+
+void xbUtil::DumpIxNode(){
+ std::cout << "DumpIxNode\n";
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+
+ xbIx *pIx = dActiveTable->GetCurIx();
+ if( !pIx )
+ SelectTag();
+
+ pIx = dActiveTable->GetCurIx();
+ if( !pIx ){
+ std::cout << "Tag not selected" << std::endl;
+ return;
+ }
+ std::cout << "0 - Logfile" << std::endl;
+ std::cout << "1 - Screen" << std::endl;
+ std::cout << "2 - Both" << std::endl;
+ xbInt16 iDispOpt = GetOption();
+// std::cout << std::endl << "0 - All Blocks" << std::endl;
+// std::cout << "NNN - Specific block number, 0=All" << std::endl;
+// xbUInt32 iBlockOpt = (xbUInt32) GetOption();
+// if( iBlockOpt == 0 ) // dump the header if dumping all blocks
+ // pIx->DumpHeader( iDispOpt );
+ pIx->DumpTagBlocks( iDispOpt, dActiveTable->GetCurTag() );
+}
+
+void xbUtil::DumpIxNodeChain(){
+
+ std::cout << "DumpIxNodeChain\n";
+
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+
+ xbIx *pIx = dActiveTable->GetCurIx();
+ if( !pIx )
+ SelectTag();
+
+ pIx = dActiveTable->GetCurIx();
+ if( !pIx ){
+ std::cout << "Tag not selected" << std::endl;
+ return;
+ }
+
+ std::cout << "0 - Logfile" << std::endl;
+ std::cout << "1 - Screen" << std::endl;
+ std::cout << "2 - Both" << std::endl;
+ xbInt16 iDispOpt = GetOption();
+
+ void *vpCurTag = dActiveTable->GetCurTag();
+ pIx->DumpIxNodeChain( vpCurTag, iDispOpt );
+}
+
+
+void xbUtil::DumpFreeBlocks(){
+ std::cout << "Dump ulBlock2 - (Free Block or Split From Page) for MDX Index file\n";
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+ xbIx *pIx = dActiveTable->GetCurIx();
+ if( !pIx )
+ SelectTag();
+ pIx = dActiveTable->GetCurIx();
+ if( !pIx ){
+ std::cout << "Tag not selected" << std::endl;
+ return;
+ }
+ std::cout << "0 - Logfile" << std::endl;
+ std::cout << "1 - Screen" << std::endl;
+ std::cout << "2 - Both" << std::endl;
+ xbInt16 iDispOpt = GetOption();
+ pIx->DumpFreeBlocks( iDispOpt );
+
+}
+
+
+
+#endif // XB_DEBUG_SUPPORT
+#endif // XB_INDEX_SUPPORT
+
+#ifdef XB_FILTER_SUPPORT
+void xbUtil::SetFilter()
+{
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+
+ char cBuf[128];
+ std::cout << "Enter filter expression:" << std::endl;
+ std::cin.getline( cBuf, 128 );
+ xbString s( cBuf );
+
+ if( filt )
+ delete filt;
+
+ filt = new xbFilter( &x, dActiveTable );
+ xbInt16 iRc = filt->Set( s );
+
+ x.DisplayError( iRc );
+}
+
+void xbUtil::GetFirstFilterRec()
+{
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+
+ xbInt16 iRc;
+ if(( iRc = filt->GetFirstRecord()) == XB_NO_ERROR )
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
+ else
+ x.DisplayError( iRc );
+}
+
+void xbUtil::GetNextFilterRec()
+{
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+ xbInt16 iRc;
+ if(( iRc = filt->GetNextRecord()) == XB_NO_ERROR )
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
+ else
+ x.DisplayError( iRc );
+}
+
+void xbUtil::GetPrevFilterRec()
+{
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+ xbInt16 iRc;
+ if(( iRc = filt->GetPrevRecord()) == XB_NO_ERROR )
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
+ else
+ x.DisplayError( iRc );
+}
+
+void xbUtil::GetLastFilterRec()
+{
+ // verify active table selected, if not, select one
+ if( !dActiveTable )
+ dActiveTable = GetTablePtr( " - select table" );
+
+ if( !dActiveTable ){
+ std::cout << "Table not selected" << std::endl;
+ return;
+ }
+ xbInt16 iRc;
+ if(( iRc = filt->GetLastRecord()) == XB_NO_ERROR )
+ dActiveTable->DumpRecord( dActiveTable->GetCurRecNo(), 2);
+ else
+ x.DisplayError( iRc );
+}
+#endif // XB_FILTER_SUPPORT
+
+///@endcond DOXYOFF
+
+/*************************************************************************************/
+int main(int, char**)
+{
+ std::cout << "xb_dbfutil initializing" << std::endl;
+ xbUtil u;
+ u.MainMenu();
+ return 0;
+}
diff --git a/src/utils/xb_deletall.cpp b/src/utils/xb_deletall.cpp
new file mode 100755
index 0000000..720710f
--- /dev/null
+++ b/src/utils/xb_deletall.cpp
@@ -0,0 +1,55 @@
+/* xb_deletall.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2017,2019 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 sets the delete flag on all records in a dbf file
+
+*/
+
+
+#include <xbase.h>
+
+
+using namespace xb;
+
+int main(int ac,char** av)
+{
+ xbXBase x;
+ xbDbf *MyFile = NULL;
+ xbFile f( &x );
+ xbInt16 iRc = 0;
+
+ if (ac <= 1) {
+ std::cout << "\nUsage: xb_deletall 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;
+ }
+
+ iRc = MyFile->DeleteAllRecords();
+ if( iRc != XB_NO_ERROR ) {
+ std::cout << "Error Deleting all records - database ==> " << av[1] << "\n";
+ std::cout << " Return Code = " << iRc;
+ }
+ MyFile->Close();
+ std::cout << "\nDone...\n\n";
+
+ return 0;
+
+} \ No newline at end of file
diff --git a/src/utils/xb_dumpdbt.cpp b/src/utils/xb_dumpdbt.cpp
new file mode 100755
index 0000000..bc95ab7
--- /dev/null
+++ b/src/utils/xb_dumpdbt.cpp
@@ -0,0 +1,87 @@
+/* xb_dumpdbt.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 )
+{
+
+
+#ifdef XB_MEMO_SUPPORT
+ xbXBase x;
+
+ xbInt16 iRc;
+ char cFieldType;
+ xbDbf *MyFile = NULL;
+ xbUInt32 ulMemoFieldLen;
+ xbString sFldName;
+ xbInt32 lBlockPtr;
+ xbString sMemoFldData;
+
+ if( ac <= 1 ){
+ std::cout << "\nUsage: dumpdbt 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;
+ }
+
+ if( MyFile->GetMemoFieldCnt() == 0 ) {
+ std::cout << "No memo fields exist in " << av[1] << std::endl;
+ } else {
+
+ xbUInt32 ulRecCnt = 0;
+ iRc = MyFile->GetRecordCnt( ulRecCnt );
+
+ for( xbUInt32 ul = 1; ul <= ulRecCnt; ul++ ){
+ MyFile->GetRecord( ul );
+ std::cout << "\nRecord # " << MyFile->GetCurRecNo();
+ if( MyFile->RecordDeleted())
+ std::cout << " (deleted) ";
+
+ for( int j = 0; j < MyFile->GetFieldCnt(); j++ ) {
+ MyFile->GetFieldType( j, cFieldType );
+
+ if( cFieldType == 'M' ) {
+ MyFile->GetMemoFieldLen( j, ulMemoFieldLen );
+ MyFile->GetFieldName( j, sFldName );
+ MyFile->GetLongField( j, lBlockPtr );
+ std::cout << "\nMemo field [" << sFldName.Str()
+ << "] length = [" << ulMemoFieldLen;
+ std::cout << "] Head Block = [" << lBlockPtr << "]\n";
+
+ MyFile->GetMemoField( j, sMemoFldData );
+ std::cout << sMemoFldData.Str() << "\n";
+ }
+ }
+ }
+ std::cout << "\n";
+ MyFile->Close();
+ delete MyFile;
+ }
+
+#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
new file mode 100755
index 0000000..267f4c5
--- /dev/null
+++ b/src/utils/xb_dumphdr.cpp
@@ -0,0 +1,45 @@
+/* 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
new file mode 100755
index 0000000..afd8764
--- /dev/null
+++ b/src/utils/xb_dumpix.cpp
@@ -0,0 +1,56 @@
+/* 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
new file mode 100755
index 0000000..0a85f45
--- /dev/null
+++ b/src/utils/xb_dumprecs.cpp
@@ -0,0 +1,62 @@
+/* xb_dumprecs.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2019 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)
+{
+ xbXBase x;
+ xbInt16 iRc;
+ x.EnableMsgLogging();
+ x.SetLogSize( 1000000L );
+// xbUInt32 ulRecCnt = 0;
+
+ if (ac <= 1) {
+ std::cout << "Usage: xb_dumprecs filename..." << std::endl;
+ 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;
+ x.DisplayError( iRc );
+ return 0;
+ }
+
+// std::cout << "Processing file sequentially from beginning..." << std::endl;
+
+ xbUInt32 j = 0;
+ xbUInt32 ulRecCnt = 0;
+
+ iRc = MyFile->GetRecordCnt( ulRecCnt );
+
+ if( iRc < XB_NO_ERROR )
+ return iRc;
+ while( j < ulRecCnt ){
+ if( j == 0 )
+ iRc = MyFile->DumpRecord(++j, 2, 2 );
+ else
+ iRc = MyFile->DumpRecord(++j, 2, 1 );
+ if( iRc != XB_NO_ERROR ){
+ x.DisplayError( iRc );
+ return 1;
+ }
+ }
+// std::cout << j << " Records written to logile" << std::endl;
+ MyFile->Close();
+ return 0;
+}
diff --git a/src/utils/xb_execsql.cpp b/src/utils/xb_execsql.cpp
new file mode 100755
index 0000000..d474593
--- /dev/null
+++ b/src/utils/xb_execsql.cpp
@@ -0,0 +1,95 @@
+/* xb_execsql.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;
+
+xbInt16 GetNextSqlCmd( xbFile &f, xbString &sCmd );
+xbInt16 GetNextSqlCmd( xbFile &f, xbString &sCmd )
+{
+ sCmd = "";
+ xbString sLine;
+ xbInt16 iRc = XB_NO_ERROR;
+ xbUInt32 lPos = 0;
+ xbBool bDone = xbFalse;
+ while( !bDone ){
+ if(( iRc = f.xbFgets( 256, sLine )) != XB_NO_ERROR ){
+ bDone = xbTrue;
+ } else {
+
+ // don't need CR/LF chars
+ sLine.ZapChar( 0x0a );
+ sLine.ZapChar( 0x0d );
+
+ // if comment, zap out everything to the right of the hash
+ lPos = sLine.Pos( '#' );
+ if( lPos > 0 )
+ sLine.Left( lPos - 1);
+
+ if( sLine.Pos( ';' ) > 0 ){
+ bDone = xbTrue;
+ sLine.ZapChar( ';' );
+ }
+ }
+ sCmd += sLine;
+ }
+ return iRc;
+}
+
+int main(int ac,char** av)
+{
+
+ if (ac <= 1) {
+ std::cout << "Usage: xb_execsql filename..." << std::endl;
+ return 1;
+ }
+
+ xbXBase x;
+ x.EnableMsgLogging();
+ xbSql sql( &x );
+ xbFile f( sql.GetXbasePtr() );
+ xbInt16 iRc = XB_NO_ERROR;
+ xbString sFileName;
+ xbString sSqlLine;
+
+ sFileName = av[1];
+
+ if(( iRc = f.xbFopen( "r", sFileName, XB_SINGLE_USER )) != XB_NO_ERROR ){
+ xbString sMsg;
+ sMsg.Sprintf( "Error opening [%s]\n", sFileName.Str() );
+ std::cout << sMsg.Str();
+ sql.GetXbasePtr()->DisplayError( iRc );
+ return 1;
+ }
+
+ while( iRc == XB_NO_ERROR ){
+ iRc = GetNextSqlCmd( f, sSqlLine );
+
+ if( iRc == XB_NO_ERROR ){
+
+ sSqlLine.Trim();
+ std::cout << "Processing line [" << sSqlLine.Str() << "]\n";
+ iRc = sql.ExecuteNonQuery( sSqlLine );
+ if( iRc != XB_NO_ERROR )
+ x.DisplayError( iRc );
+ }
+ }
+
+ f.xbFclose();
+ return 0;
+}
+
diff --git a/src/utils/xb_pack.cpp b/src/utils/xb_pack.cpp
new file mode 100755
index 0000000..ba61837
--- /dev/null
+++ b/src/utils/xb_pack.cpp
@@ -0,0 +1,55 @@
+/* xb_pack.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: xb_pack filename...\n"
+ "\nThis program does not automatically reindex any NDX indexes."
+ "\nUse the reindex program to reindex any indexes associated"
+ "\nwith the database, or build your own program which executes "
+ "\nthe Pack() 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 iRc = " << iRc << " file = " << av[1] << std::endl;
+ x.DisplayError( iRc );
+ return 0;
+ }
+
+ if(( iRc = MyFile->Pack()) != 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 << "\nPack Database complete...\n\n";
+ return 0;
+}
+
+
+
diff --git a/src/utils/xb_tblinfo.cpp b/src/utils/xb_tblinfo.cpp
new file mode 100755
index 0000000..884ce5e
--- /dev/null
+++ b/src/utils/xb_tblinfo.cpp
@@ -0,0 +1,91 @@
+/* xb_dumpmdx.cpp
+
+XBase64 Software Library
+
+Copyright (c) 1997,2003,2014,2021 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 ){
+
+ xbXBase x;
+ xbBool bHdr = xbFalse;
+ xbBool bMdxFound = xbFalse;
+ xbInt16 iRc;
+ xbString sTagName;
+ xbDbf *MyFile = NULL;
+
+ 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";
+ 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( bHdr == xbFalse && sTagName == "" )
+ bHdr = xbTrue;
+
+
+ // std::cout << "Hdr = " << bHdr << std::endl;
+ if( sTagName != "" )
+ std::cout << "Tag = " << sTagName.Str() << std::endl;
+
+ 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 );
+
+ // for each mdx file, dump the header
+ xbIxList *ixl = MyFile->GetIxList();
+ xbIx *ixp;
+ xbString sFileType;
+ while( ixl ){
+ ixp = ixl->ix;
+ ixp->GetFileType( sFileType );
+
+ if( sFileType == "MDX" ){
+ bMdxFound = xbTrue;
+ if( bHdr ){
+ // std::cout << "MDX header\n";
+ ixp->DumpHeader( 1, 3 );
+ }
+ }
+ ixl = ixl->next;
+ }
+
+ if( !bMdxFound )
+ std::cout << "No MDX index for file." << std::endl;
+
+ MyFile->Close();
+ delete MyFile;
+
+ return 0;
+}
diff --git a/src/utils/xb_undelall.cpp b/src/utils/xb_undelall.cpp
new file mode 100755
index 0000000..4f1af12
--- /dev/null
+++ b/src/utils/xb_undelall.cpp
@@ -0,0 +1,55 @@
+/* xb_deletall.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
+
+
+
+This program sets the delete flag on all records in a dbf file
+
+*/
+
+
+#include <xbase.h>
+
+
+using namespace xb;
+
+int main(int ac,char** av)
+{
+
+ xbXBase x;
+ xbDbf *MyFile = NULL;
+ xbInt16 iRc = 0;
+
+ if (ac <= 1) {
+ std::cout << "\nUsage: xb_deletall 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;
+ }
+
+ iRc = MyFile->UndeleteAllRecords();
+ if( iRc != XB_NO_ERROR ) {
+ std::cout << "Error Undeleting all records - database ==> " << av[1] << "\n";
+ std::cout << " Return Code = " << iRc;
+ }
+ 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
new file mode 100755
index 0000000..4660cd8
--- /dev/null
+++ b/src/utils/xb_zap.cpp
@@ -0,0 +1,52 @@
+/* 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;
+}