diff --git a/harbour/ChangeLog b/harbour/ChangeLog
index 24fbd2141b..957f5b65c1 100644
--- a/harbour/ChangeLog
+++ b/harbour/ChangeLog
@@ -17,6 +17,47 @@
    past entries belonging to author(s): Viktor Szakats.
 */
 
+2010-01-15 00:45 UTC+0100 Viktor Szakats (harbour.01 syenar.hu)
+  * contrib/hbbmcdx/bmdbfcdx.c
+  * contrib/hbbmcdx/hbbmcdx.h
+  * include/hbapirdd.h
+  * include/hbdbsort.h
+  * include/hbrddcdx.h
+  * include/hbrdddbf.h
+  * include/hbrdddel.h
+  * include/hbrddfpt.h
+  * include/hbrddnsx.h
+  * include/hbrddntx.h
+  * include/hbrddsdf.h
+  * src/rdd/dbcmd.c
+  * src/rdd/dbcmd53.c
+  * src/rdd/dbdetach.c
+  * src/rdd/dbf1.c
+  * src/rdd/dbfcdx/dbfcdx1.c
+  * src/rdd/dbffpt/dbffpt1.c
+  * src/rdd/dbfnsx/dbfnsx1.c
+  * src/rdd/dbfntx/dbfntx1.c
+  * src/rdd/dbsql.c
+  * src/rdd/delim1.c
+  * src/rdd/hbdbsort.c
+  * src/rdd/hbsix/sxcompr.c
+  * src/rdd/hbsix/sxcrypt.c
+  * src/rdd/hbsix/sxfname.c
+  * src/rdd/hbsix/sxord.c
+  * src/rdd/hbsix/sxsem.c
+  * src/rdd/hbsix/sxtable.c
+  * src/rdd/hbsix/sxutil.c
+  * src/rdd/hsx/hsx.c
+  * src/rdd/nulsys/nulsys.c
+  * src/rdd/sdf1.c
+  * src/rdd/usrrdd/usrrdd.c
+  * src/rdd/wacore.c
+  * src/rdd/wafunc.c
+  * src/rdd/workarea.c
+    * BOOL  -> HB_BOOL
+    * TRUE  -> HB_TRUE
+    * FALSE -> HB_FALSE
+
 2010-01-14 23:46 UTC+0100 Viktor Szakats (harbour.01 syenar.hu)
   * contrib/rddsql/sddmy/mysqldd.c
   * contrib/rddsql/sddpg/pgsqldd.c
diff --git a/harbour/contrib/hbbmcdx/bmdbfcdx.c b/harbour/contrib/hbbmcdx/bmdbfcdx.c
index 61dab9177f..92ae267e18 100644
--- a/harbour/contrib/hbbmcdx/bmdbfcdx.c
+++ b/harbour/contrib/hbbmcdx/bmdbfcdx.c
@@ -107,7 +107,7 @@
  */
 
 /* create a new Tag (make index) */
-static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex );
+static void hb_cdxTagDoIndex( LPCDXTAG pTag, HB_BOOL fReindex );
 
 /* Close Tag */
 static void hb_cdxTagClose( LPCDXTAG pTag );
@@ -136,15 +136,15 @@ static int hb_cdxPageRootSplit( LPCDXPAGE pPage );
 /* free create index structur */
 static void hb_cdxSortFree( LPCDXSORTINFO pSort );
 
-static BOOL hb_cdxPageReadTopKey( LPCDXPAGE pPage );
+static HB_BOOL hb_cdxPageReadTopKey( LPCDXPAGE pPage );
 
-static BOOL hb_cdxPageReadNextKey( LPCDXPAGE pPage );
+static HB_BOOL hb_cdxPageReadNextKey( LPCDXPAGE pPage );
 
 static LPCDXTAG hb_cdxGetActiveTag( CDXAREAP pArea );
 
 static void hb_cdxClearLogPosInfo( CDXAREAP pArea );
 
-static BOOL     bTurbo = FALSE;
+static HB_BOOL  bTurbo = HB_FALSE;
 static RDDFUNCS cdxSuper;
 static const RDDFUNCS cdxTable =
 {
@@ -650,7 +650,7 @@ static BYTE hb_cdxItemTypeCmp( BYTE bType )
  * store Item in index key
  * TODO: uiType check and generate RT error if necessary
  */
-static LPCDXKEY hb_cdxKeyPutItem( LPCDXKEY pKey, PHB_ITEM pItem, ULONG ulRec, LPCDXTAG pTag, BOOL fTrans, int iMode )
+static LPCDXKEY hb_cdxKeyPutItem( LPCDXKEY pKey, PHB_ITEM pItem, ULONG ulRec, LPCDXTAG pTag, HB_BOOL fTrans, int iMode )
 {
    BYTE buf[CDX_MAXKEY], *ptr;
    ULONG ulLen = 0;
@@ -728,7 +728,7 @@ static LPCDXKEY hb_cdxKeyPutItem( LPCDXKEY pKey, PHB_ITEM pItem, ULONG ulRec, LP
 /*
  * get Item from index key
  */
-static PHB_ITEM hb_cdxKeyGetItem( LPCDXKEY pKey, PHB_ITEM pItem, LPCDXTAG pTag, BOOL fTrans )
+static PHB_ITEM hb_cdxKeyGetItem( LPCDXKEY pKey, PHB_ITEM pItem, LPCDXTAG pTag, HB_BOOL fTrans )
 {
    double d;
 
@@ -801,7 +801,7 @@ static LPCDXKEY hb_cdxKeyEval( LPCDXKEY pKey, LPCDXTAG pTag )
    {
       pItem = hb_itemNew( NULL );
       SELF_GETVALUE( ( AREAP ) pArea, pTag->nField, pItem );
-      pKey = hb_cdxKeyPutItem( pKey, pItem, pArea->dbfarea.ulRecNo, pTag, FALSE, CDX_CMP_EXACT );
+      pKey = hb_cdxKeyPutItem( pKey, pItem, pArea->dbfarea.ulRecNo, pTag, HB_FALSE, CDX_CMP_EXACT );
       hb_itemRelease( pItem );
    }
    else
@@ -814,7 +814,7 @@ static LPCDXKEY hb_cdxKeyEval( LPCDXKEY pKey, LPCDXTAG pTag )
          iCurrArea = 0;
 
       pItem = hb_vmEvalBlockOrMacro( pTag->pKeyItem );
-      pKey = hb_cdxKeyPutItem( pKey, pItem, pArea->dbfarea.ulRecNo, pTag, FALSE, CDX_CMP_EXACT );
+      pKey = hb_cdxKeyPutItem( pKey, pItem, pArea->dbfarea.ulRecNo, pTag, HB_FALSE, CDX_CMP_EXACT );
 
       if( iCurrArea )
          hb_rddSelectWorkAreaNumber( iCurrArea );
@@ -828,10 +828,10 @@ static LPCDXKEY hb_cdxKeyEval( LPCDXKEY pKey, LPCDXTAG pTag )
 /*
  * evaluate conditional expression and return the result
  */
-static BOOL hb_cdxEvalCond( CDXAREAP pArea, PHB_ITEM pCondItem, BOOL fSetWA )
+static HB_BOOL hb_cdxEvalCond( CDXAREAP pArea, PHB_ITEM pCondItem, HB_BOOL fSetWA )
 {
    int iCurrArea = 0;
-   BOOL fRet;
+   HB_BOOL fRet;
 
    if( fSetWA )
    {
@@ -853,12 +853,12 @@ static BOOL hb_cdxEvalCond( CDXAREAP pArea, PHB_ITEM pCondItem, BOOL fSetWA )
 /*
  * evaluate seek/skip block: {|key, rec| ... }
  */
-static BOOL hb_cdxEvalSeekCond( LPCDXTAG pTag, PHB_ITEM pCondItem )
+static HB_BOOL hb_cdxEvalSeekCond( LPCDXTAG pTag, PHB_ITEM pCondItem )
 {
-   BOOL fRet;
+   HB_BOOL fRet;
    PHB_ITEM pKeyVal, pKeyRec;
 
-   pKeyVal = hb_cdxKeyGetItem( pTag->CurKey, NULL, pTag, TRUE );
+   pKeyVal = hb_cdxKeyGetItem( pTag->CurKey, NULL, pTag, HB_TRUE );
    pKeyRec = hb_itemPutNInt( NULL, pTag->CurKey->rec );
 
    fRet = hb_itemGetL( hb_vmEvalBlockV( pCondItem, 2, pKeyVal, pKeyRec ) );
@@ -872,7 +872,7 @@ static BOOL hb_cdxEvalSeekCond( LPCDXTAG pTag, PHB_ITEM pCondItem )
 /*
  * check if Key is in top scope
  */
-static BOOL hb_cdxTopScope( LPCDXTAG pTag )
+static HB_BOOL hb_cdxTopScope( LPCDXTAG pTag )
 {
    LPCDXKEY pKey;
 
@@ -897,7 +897,7 @@ static BOOL hb_cdxTopScope( LPCDXTAG pTag )
 /*
  * check if Key is in bottom scope
  */
-static BOOL hb_cdxBottomScope( LPCDXTAG pTag )
+static HB_BOOL hb_cdxBottomScope( LPCDXTAG pTag )
 {
    LPCDXKEY pKey;
 
@@ -996,7 +996,7 @@ static void hb_cdxTagSetScope( LPCDXTAG pTag, USHORT nScope, PHB_ITEM pItem )
       if( *pScope == NULL )
          *pScope = hb_itemNew( NULL );
       hb_itemCopy( *pScope, pItem );
-      *pScopeKey = hb_cdxKeyPutItem( *pScopeKey, pScopeVal, ulRec, pTag, TRUE, CDX_CMP_PREFIX );
+      *pScopeKey = hb_cdxKeyPutItem( *pScopeKey, pScopeVal, ulRec, pTag, HB_TRUE, CDX_CMP_PREFIX );
       pTag->curKeyState &= ~( CDX_CURKEY_RAWCNT | CDX_CURKEY_LOGCNT );
       if( nScope == 0 )
          pTag->curKeyState &= ~( CDX_CURKEY_RAWPOS | CDX_CURKEY_LOGPOS );
@@ -1043,14 +1043,14 @@ static void hb_cdxTagRefreshScope( LPCDXTAG pTag )
       pItem = hb_vmEvalBlock( pTag->topScope );
       pTag->topScopeKey = hb_cdxKeyPutItem( pTag->topScopeKey, pItem,
                                             pTag->topScopeKey->rec, pTag,
-                                            TRUE, CDX_CMP_PREFIX );
+                                            HB_TRUE, CDX_CMP_PREFIX );
    }
    if( hb_itemType( pTag->bottomScope ) == HB_IT_BLOCK )
    {
       pItem = hb_vmEvalBlock( pTag->bottomScope );
       pTag->bottomScopeKey = hb_cdxKeyPutItem( pTag->bottomScopeKey, pItem,
                                                pTag->bottomScopeKey->rec, pTag,
-                                               TRUE, CDX_CMP_PREFIX );
+                                               HB_TRUE, CDX_CMP_PREFIX );
    }
 }
 
@@ -1078,11 +1078,11 @@ static void hb_cdxTagPoolCheck( LPCDXTAG pTag )
  */
 static void hb_cdxTagCheckBuffers( LPCDXTAG pTag )
 {
-   BOOL fChanged = FALSE;
+   HB_BOOL fChanged = HB_FALSE;
 
    hb_cdxTagPoolCheck( pTag );
    if( pTag->TagChanged )
-      fChanged = TRUE;
+      fChanged = HB_TRUE;
    else
    {
       LPCDXPAGE pPage = pTag->pagePool;
@@ -1120,7 +1120,7 @@ static void hb_cdxIndexCheckBuffers( LPCDXINDEX pIndex )
 /*
  * get free index page
  */
-static ULONG hb_cdxIndexGetAvailPage( LPCDXINDEX pIndex, BOOL bHeader )
+static ULONG hb_cdxIndexGetAvailPage( LPCDXINDEX pIndex, HB_BOOL bHeader )
 {
    PHB_FILE pFile = pIndex->pFile;
    BYTE byBuf[4];
@@ -1178,7 +1178,7 @@ static ULONG hb_cdxIndexGetAvailPage( LPCDXINDEX pIndex, BOOL bHeader )
             fOffset += CDX_PAGELEN;
          }
          while( --iCnt );
-         pIndex->fChanged = TRUE;
+         pIndex->fChanged = HB_TRUE;
       }
    }
    return ulPos;
@@ -1187,7 +1187,7 @@ static ULONG hb_cdxIndexGetAvailPage( LPCDXINDEX pIndex, BOOL bHeader )
 /*
  * free index page
  */
-static void hb_cdxIndexPutAvailPage( LPCDXINDEX pIndex, ULONG ulPos, BOOL bHeader )
+static void hb_cdxIndexPutAvailPage( LPCDXINDEX pIndex, ULONG ulPos, HB_BOOL bHeader )
 {
    if( ulPos != 0 && ulPos != CDX_DUMMYNODE )
    {
@@ -1204,7 +1204,7 @@ static void hb_cdxIndexPutAvailPage( LPCDXINDEX pIndex, ULONG ulPos, BOOL bHeade
          pLst = (LPCDXLIST) hb_xgrab( sizeof( CDXLIST ) );
          pLst->ulAddr = pIndex->freePage;
          pIndex->freePage = ulPos;
-         pLst->fStat = TRUE;
+         pLst->fStat = HB_TRUE;
          pLst->pNext = pIndex->freeLst;
          pIndex->freeLst = pLst;
          ulPos += CDX_PAGELEN;
@@ -1220,7 +1220,7 @@ static void hb_cdxIndexFlushAvailPage( LPCDXINDEX pIndex )
    LPCDXLIST pLst = pIndex->freeLst;
    BYTE byPageBuf[CDX_PAGELEN];
    ULONG ulPos;
-   BOOL fClean = TRUE;
+   HB_BOOL fClean = HB_TRUE;
 
    if( pIndex->fReadonly )
       hb_errInternal( 9101, "hb_cdxIndexPutAvailPage on readonly database.", NULL, NULL );
@@ -1233,16 +1233,16 @@ static void hb_cdxIndexFlushAvailPage( LPCDXINDEX pIndex )
       if( fClean )
       {
          memset( byPageBuf, 0, CDX_PAGELEN );
-         fClean = FALSE;
+         fClean = HB_FALSE;
       }
       HB_PUT_LE_UINT32( byPageBuf, pLst->ulAddr );
       if( hb_fileWriteAt( pIndex->pFile, byPageBuf, CDX_PAGELEN, ulPos ) != CDX_PAGELEN )
       {
          hb_errInternal( EDBF_WRITE, "Write in index page failed.", NULL, NULL );
       }
-      pIndex->fChanged = TRUE;
+      pIndex->fChanged = HB_TRUE;
       ulPos = pLst->ulAddr;
-      pLst->fStat = FALSE;
+      pLst->fStat = HB_FALSE;
       pLst = pLst->pNext;
 #ifdef HB_CDX_DBGUPDT
       cdxWriteNO++;
@@ -1278,7 +1278,7 @@ static void hb_cdxIndexPageWrite( LPCDXINDEX pIndex, ULONG ulPos, BYTE * pBuffer
 
    if( hb_fileWriteAt( pIndex->pFile, pBuffer, uiSize, ulPos ) != ( ULONG ) uiSize )
       hb_errInternal( EDBF_WRITE, "Write in index page failed.", NULL, NULL );
-   pIndex->fChanged = TRUE;
+   pIndex->fChanged = HB_TRUE;
 #ifdef HB_CDX_DBGUPDT
    cdxWriteNO++;
 #endif
@@ -1336,16 +1336,16 @@ static void hb_cdxIndexCheckVersion( LPCDXINDEX pIndex )
 /*
  * lock index for reading (shared lock)
  */
-static BOOL hb_cdxIndexLockRead( LPCDXINDEX pIndex )
+static HB_BOOL hb_cdxIndexLockRead( LPCDXINDEX pIndex )
 {
-   BOOL ret;
+   HB_BOOL ret;
 
    if( pIndex->lockRead > 0 || pIndex->lockWrite > 0 ||
         !pIndex->pArea->dbfarea.fShared || !pIndex->fShared ||
         HB_DIRTYREAD( &pIndex->pArea->dbfarea ) )
    {
       pIndex->lockRead++;
-      return TRUE;
+      return HB_TRUE;
    }
 #ifdef HB_CDX_DBGCODE
    if( pIndex->lockRead != 0 )
@@ -1353,14 +1353,14 @@ static BOOL hb_cdxIndexLockRead( LPCDXINDEX pIndex )
 
    if( pIndex->WrLck || pIndex->RdLck )
       hb_errInternal( 9107, "hb_cdxIndexLockRead: lock failure (*)", NULL, NULL );
-   pIndex->RdLck = TRUE;
+   pIndex->RdLck = HB_TRUE;
 #endif
 
   if( bTurbo )
   {
    pIndex->lockRead++;
    hb_cdxIndexCheckVersion( pIndex );
-   return TRUE;
+   return HB_TRUE;
   }
   else
   {
@@ -1382,9 +1382,9 @@ static BOOL hb_cdxIndexLockRead( LPCDXINDEX pIndex )
 /*
  * lock index for writing (exclusive lock)
  */
-static BOOL hb_cdxIndexLockWrite( LPCDXINDEX pIndex )
+static HB_BOOL hb_cdxIndexLockWrite( LPCDXINDEX pIndex )
 {
-   BOOL ret;
+   HB_BOOL ret;
 
    if( pIndex->fReadonly )
       hb_errInternal( 9101, "hb_cdxIndexLockWrite: readonly index.", NULL, NULL );
@@ -1393,19 +1393,19 @@ static BOOL hb_cdxIndexLockWrite( LPCDXINDEX pIndex )
    if( pIndex->lockWrite > 0 )
    {
       pIndex->lockWrite++;
-      return TRUE;
+      return HB_TRUE;
    }
    if( pIndex->lockWrite != 0 )
       hb_errInternal( 9105, "hb_cdxIndexLockWrite: bad count of locks.", NULL, NULL );
 
    if( !pIndex->pArea->dbfarea.fShared || !pIndex->fShared )
-      ret = TRUE;
+      ret = HB_TRUE;
    else
    {
 #ifdef HB_CDX_DBGCODE
       if( pIndex->WrLck || pIndex->RdLck )
          hb_errInternal( 9107, "hb_cdxIndexLockWrite: lock failure (*)", NULL, NULL );
-      pIndex->WrLck = TRUE;
+      pIndex->WrLck = HB_TRUE;
 #endif
       ret = hb_dbfLockIdxFile( pIndex->pFile, pIndex->pArea->dbfarea.bLockType,
                                FL_LOCK | FLX_EXCLUSIVE | FLX_WAIT, &pIndex->ulLockPos );
@@ -1425,7 +1425,7 @@ static BOOL hb_cdxIndexLockWrite( LPCDXINDEX pIndex )
 /*
  * remove index read lock (shared lock)
  */
-static BOOL hb_cdxIndexUnLockRead( LPCDXINDEX pIndex )
+static HB_BOOL hb_cdxIndexUnLockRead( LPCDXINDEX pIndex )
 {
    pIndex->lockRead--;
    if( pIndex->lockRead < 0 )
@@ -1434,7 +1434,7 @@ static BOOL hb_cdxIndexUnLockRead( LPCDXINDEX pIndex )
    }
    if( pIndex->lockRead || pIndex->lockWrite )
    {
-      return TRUE;
+      return HB_TRUE;
    }
 #ifdef HB_CDX_DBGCODE_EXT
    hb_cdxIndexCheckBuffers( pIndex );
@@ -1447,7 +1447,7 @@ static BOOL hb_cdxIndexUnLockRead( LPCDXINDEX pIndex )
 #ifdef HB_CDX_DBGCODE
    if( pIndex->pArea->dbfarea.fShared && pIndex->fShared &&
         ! HB_DIRTYREAD( &pIndex->pArea->dbfarea ) )
-      pIndex->RdLck = FALSE;
+      pIndex->RdLck = HB_FALSE;
 #endif
  }
  else
@@ -1458,7 +1458,7 @@ static BOOL hb_cdxIndexUnLockRead( LPCDXINDEX pIndex )
 #ifdef HB_CDX_DBGCODE
       if( pIndex->WrLck || ! pIndex->RdLck )
          hb_errInternal( 9108, "hb_cdxIndexUnLockRead: unlock error (*)", NULL, NULL );
-      pIndex->RdLck = FALSE;
+      pIndex->RdLck = HB_FALSE;
 #endif
       if( !hb_dbfLockIdxFile( pIndex->pFile, pIndex->pArea->dbfarea.bLockType, FL_UNLOCK, &pIndex->ulLockPos ) )
       {
@@ -1466,18 +1466,18 @@ static BOOL hb_cdxIndexUnLockRead( LPCDXINDEX pIndex )
       }
    }
  }
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * remove index write lock (exclusive lock)
  */
-static BOOL hb_cdxIndexUnLockWrite( LPCDXINDEX pIndex )
+static HB_BOOL hb_cdxIndexUnLockWrite( LPCDXINDEX pIndex )
 {
    if( pIndex->lockWrite > 1 )
    {
       pIndex->lockWrite--;
-      return TRUE;
+      return HB_TRUE;
    }
 
    if( pIndex->lockWrite < 1 )
@@ -1505,13 +1505,13 @@ static BOOL hb_cdxIndexUnLockWrite( LPCDXINDEX pIndex )
          {
             hb_errInternal( EDBF_WRITE, "Write in index page failed (ver)", NULL, NULL );
          }
-         pIndex->fFlush = TRUE;
-         pIndex->fChanged = FALSE;
+         pIndex->fFlush = HB_TRUE;
+         pIndex->fChanged = HB_FALSE;
       }
 #ifdef HB_CDX_DBGCODE
       if( ! pIndex->WrLck || pIndex->RdLck )
          hb_errInternal( 9108, "hb_cdxIndexUnLockWrite: unlock error (*)", NULL, NULL );
-      pIndex->WrLck = FALSE;
+      pIndex->WrLck = HB_FALSE;
 #endif
       if( !hb_dbfLockIdxFile( pIndex->pFile, pIndex->pArea->dbfarea.bLockType, FL_UNLOCK, &pIndex->ulLockPos ) )
       {
@@ -1529,18 +1529,18 @@ static BOOL hb_cdxIndexUnLockWrite( LPCDXINDEX pIndex )
             hb_errInternal( EDBF_WRITE, "Write in index page failed (ver.ex)", NULL, NULL );
          }
          pIndex->ulVersion = pIndex->freePage;
-         pIndex->fFlush = TRUE;
+         pIndex->fFlush = HB_TRUE;
 #ifdef HB_CDX_DBGUPDT
          cdxWriteNO++;
 #endif
       }
       else if( pIndex->fChanged )
       {
-         pIndex->fFlush = TRUE;
+         pIndex->fFlush = HB_TRUE;
       }
-      pIndex->fChanged = FALSE;
+      pIndex->fChanged = HB_FALSE;
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
@@ -1559,7 +1559,7 @@ static void hb_cdxIndexDiscardBuffers( LPCDXINDEX pIndex )
    {
       hb_cdxTagClose( pIndex->pCompound );
       hb_cdxTagPoolFree( pIndex->pCompound, 0 );
-      pIndex->pCompound->fRePos = TRUE;
+      pIndex->pCompound->fRePos = HB_TRUE;
       pIndex->pCompound->curKeyState = 0;
       if( pIndex->pCompound->CurKey )
          pIndex->pCompound->CurKey->rec = 0;
@@ -1569,7 +1569,7 @@ static void hb_cdxIndexDiscardBuffers( LPCDXINDEX pIndex )
    {
       hb_cdxTagClose( pTag );
       hb_cdxTagPoolFree( pTag, 0 );
-      pTag->fRePos = TRUE;
+      pTag->fRePos = HB_TRUE;
       pTag->curKeyState = 0;
       if( pTag->CurKey && !pTag->Custom )
          pTag->CurKey->rec = 0;
@@ -1782,13 +1782,13 @@ static void hb_cdxPageCheckKeys( LPCDXPAGE pPage )
 /*
  * Check decoded leaf page if all trailing and duplicate characters are set
  */
-static void hb_cdxPageCheckDupTrl( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys, BOOL fSpc )
+static void hb_cdxPageCheckDupTrl( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys, HB_BOOL fSpc )
 {
    int iNum = pPage->TagParent->uiLen, iKey, iPos, iFree = CDX_EXT_FREESPACE;
    int iLen = iNum + 6;
    BYTE  bDup, bTrl;
    BYTE  bTrail = pPage->TagParent->bTrail;
-   BOOL  bErr = FALSE;
+   HB_BOOL  bErr = HB_FALSE;
 
    for( iKey = 0; iKey < iKeys; iKey++ )
    {
@@ -1811,13 +1811,13 @@ static void hb_cdxPageCheckDupTrl( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys, B
       {
          printf("\r\nbTrl=%d, keybuf->bTrl=%d, iKey=%d/%d\r\n", bTrl, pKeyBuf[ iPos + iNum + 5 ], iKey, iKeys );
          fflush(stdout);
-         bErr = TRUE;
+         bErr = HB_TRUE;
       }
       if( bDup != ( iKey == 0 ? 0 : pKeyBuf[ iPos + iNum + 4 ] ) )
       {
          printf("\r\nbDup=%d, keybuf->bDup=%d (bTrl=%d), iKey=%d/%d\r\n", bDup, pKeyBuf[ iPos + iNum + 4 ], bTrl, iKey, iKeys );
          fflush(stdout);
-         bErr = TRUE;
+         bErr = HB_TRUE;
       }
       if( iKey > 0 )
       {
@@ -1838,7 +1838,7 @@ static void hb_cdxPageCheckDupTrl( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys, B
                     memcmp( &pKeyBuf[ iPos - iLen ], &pKeyBuf[ iPos ], iNum ),
                     pKeyBuf );
             fflush(stdout);
-            bErr = TRUE;
+            bErr = HB_TRUE;
          }
       }
       iFree -= iNum + pPage->ReqByte - bDup - bTrl;
@@ -1848,7 +1848,7 @@ static void hb_cdxPageCheckDupTrl( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys, B
       printf( "\r\nFreeSpace calculated wrong! iFree=%d, pPage->iFree=%d",
               iFree, pPage->iFree );
       fflush(stdout);
-      bErr = TRUE;
+      bErr = HB_TRUE;
    }
    if( bErr )
    {
@@ -1864,7 +1864,7 @@ static void hb_cdxPageCheckDupTrlRaw( LPCDXPAGE pPage )
    BYTE *pKeyBuf = ( BYTE * ) hb_xgrab( pPage->iKeys * ( pPage->TagParent->uiLen + 6 ) );
 
    hb_cdxPageLeafDecode( pPage, pKeyBuf );
-   hb_cdxPageCheckDupTrl( pPage, pKeyBuf, pPage->iKeys, TRUE );
+   hb_cdxPageCheckDupTrl( pPage, pKeyBuf, pPage->iKeys, HB_TRUE );
    hb_xfree( pKeyBuf );
 }
 #endif
@@ -1909,7 +1909,7 @@ static void hb_cdxPageLeafEncode( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys )
 #ifdef HB_CDX_DBGCODE_EXT
    if( ! pKeyBuf )
       hb_cdxErrInternal( "hb_cdxPageLeafEncode: page has no buffer." );
-   hb_cdxPageCheckDupTrl( pPage, pKeyBuf, iKeys, TRUE );
+   hb_cdxPageCheckDupTrl( pPage, pKeyBuf, iKeys, HB_TRUE );
 #endif
    iNum = pPage->TagParent->uiLen;
    iLen = iNum + 6;
@@ -1952,7 +1952,7 @@ static void hb_cdxPageLeafEncode( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys )
       hb_cdxErrInternal( "hb_cdxPageLeafEncode: FreeSpace calculated wrong!!." );
 #endif
    pPage->iKeys = iKeys;
-   pPage->fChanged = TRUE;
+   pPage->fChanged = HB_TRUE;
    pPage->bufKeyNum = 0;
 #ifdef HB_CDX_DBGCODE_EXT
    {
@@ -1962,7 +1962,7 @@ static void hb_cdxPageLeafEncode( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys )
       pPage->pKeyBuf = pKeyBf;
    }
    hb_cdxPageCheckKeys( pPage );
-   hb_cdxPageCheckDupTrl( pPage, pKeyBuf, pPage->iKeys, TRUE );
+   hb_cdxPageCheckDupTrl( pPage, pKeyBuf, pPage->iKeys, HB_TRUE );
 #endif
 }
 
@@ -2025,7 +2025,7 @@ static void hb_cdxPageLeafDecode( LPCDXPAGE pPage, BYTE * pKeyBuf )
    }
 #ifdef HB_CDX_DBGCODE_EXT
    {
-      BOOL fChg = pPage->fChanged;
+      HB_BOOL fChg = pPage->fChanged;
       hb_cdxPageLeafEncode( pPage, pKeyBuf, pPage->iKeys );
       pPage->fChanged = fChg;
    }
@@ -2065,7 +2065,7 @@ static void hb_cdxPageCalcLeafSpace( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys
    RNMask = pPage->RNMask;
    ReqByte = pPage->ReqByte;
 #ifdef HB_CDX_DBGCODE_EXT
-   hb_cdxPageCheckDupTrl( pPage, pKeyBuf, iKeys, FALSE );
+   hb_cdxPageCheckDupTrl( pPage, pKeyBuf, iKeys, HB_FALSE );
 #endif
    for( iKey = 0; iKey < iKeys; iKey++ )
    {
@@ -2185,10 +2185,10 @@ static int hb_cdxPageLeafDelKey( LPCDXPAGE pPage )
                &pPage->pKeyBuf[ ( iKey + 1 ) * iLen ],
                ( pPage->iKeys - iKey ) * iLen );
    }
-   pPage->fBufChanged = pPage->fChanged = TRUE;
+   pPage->fBufChanged = pPage->fChanged = HB_TRUE;
 #ifdef HB_CDX_DBGCODE_EXT
    hb_cdxPageCheckKeys( pPage );
-   hb_cdxPageCheckDupTrl( pPage, pPage->pKeyBuf, pPage->iKeys, TRUE );
+   hb_cdxPageCheckDupTrl( pPage, pPage->pKeyBuf, pPage->iKeys, HB_TRUE );
 #endif
    if( iKey >= pPage->iKeys )
       iRet |= NODE_NEWLASTKEY;
@@ -2236,7 +2236,7 @@ static int hb_cdxPageLeafAddKey( LPCDXPAGE pPage, LPCDXKEY pKey )
 
 #ifdef HB_CDX_DBGCODE_EXT
    hb_cdxPageCheckKeys( pPage );
-   hb_cdxPageCheckDupTrl( pPage, pPage->pKeyBuf, pPage->iKeys, TRUE );
+   hb_cdxPageCheckDupTrl( pPage, pPage->pKeyBuf, pPage->iKeys, HB_TRUE );
 #endif
 
    iTrl = iDup = 0;
@@ -2302,10 +2302,10 @@ static int hb_cdxPageLeafAddKey( LPCDXPAGE pPage, LPCDXKEY pKey )
       iSpc += pPage->iKeys;
    }
    pPage->iFree -= iSpc;
-   pPage->fBufChanged = pPage->fChanged = TRUE;
+   pPage->fBufChanged = pPage->fChanged = HB_TRUE;
 #ifdef HB_CDX_DBGCODE_EXT
    hb_cdxPageCheckKeys( pPage );
-   hb_cdxPageCheckDupTrl( pPage, pPage->pKeyBuf, pPage->iKeys, TRUE );
+   hb_cdxPageCheckDupTrl( pPage, pPage->pKeyBuf, pPage->iKeys, HB_TRUE );
 #endif
    if( iKey >= pPage->iKeys - 1 )
       iRet |= NODE_NEWLASTKEY;
@@ -2320,7 +2320,7 @@ static int hb_cdxPageLeafAddKey( LPCDXPAGE pPage, LPCDXKEY pKey )
 /*
  * set (insert) key in interior node record to (with) given value
  */
-static void hb_cdxPageIntSetKey( LPCDXPAGE pPage, int iKey, BOOL fIns, BYTE * pbVal, ULONG ulRec, ULONG ulPag )
+static void hb_cdxPageIntSetKey( LPCDXPAGE pPage, int iKey, HB_BOOL fIns, BYTE * pbVal, ULONG ulRec, ULONG ulPag )
 {
    int iLen = pPage->TagParent->uiLen;
    int iPos = iKey * ( iLen + 8 );
@@ -2356,7 +2356,7 @@ static void hb_cdxPageIntSetKey( LPCDXPAGE pPage, int iKey, BOOL fIns, BYTE * pb
    if( ulRec )
       HB_PUT_BE_UINT32( &pPage->node.intNode.keyPool[ iPos + iLen ], ulRec );
    HB_PUT_BE_UINT32( &pPage->node.intNode.keyPool[ iPos + iLen + 4 ], ulPag );
-   pPage->fChanged = TRUE;
+   pPage->fChanged = HB_TRUE;
 }
 
 /*
@@ -2387,7 +2387,7 @@ static void hb_cdxPageIntDelKey( LPCDXPAGE pPage, int iKey )
                &pPage->node.intNode.keyPool[ ( iKey + 1 ) * iLen ], ( pPage->iKeys - iKey ) * iLen );
    }
    memset( &pPage->node.intNode.keyPool[ pPage->iKeys * iLen ], 0, iLen );
-   pPage->fChanged = TRUE;
+   pPage->fChanged = HB_TRUE;
 }
 
 /*
@@ -2399,14 +2399,14 @@ static void hb_cdxPageLoad( LPCDXPAGE pPage )
    {
       hb_xfree( pPage->pKeyBuf );
       pPage->pKeyBuf = NULL;
-      pPage->fBufChanged = FALSE;
+      pPage->fBufChanged = HB_FALSE;
    }
    hb_cdxIndexPageRead( pPage->TagParent->pIndex, pPage->Page, ( BYTE * ) &pPage->node, sizeof( CDXNODE ) );
    pPage->PageType = ( BYTE ) HB_GET_LE_UINT16( pPage->node.intNode.attr );
    pPage->Left = HB_GET_LE_UINT32( pPage->node.intNode.leftPtr );
    pPage->Right = HB_GET_LE_UINT32( pPage->node.intNode.rightPtr );
    pPage->iKeys = HB_GET_LE_UINT16( pPage->node.intNode.nKeys );
-   pPage->fChanged  = FALSE;
+   pPage->fChanged  = HB_FALSE;
 
    if( ( pPage->PageType & CDX_NODE_LEAF ) != 0 )
    {
@@ -2470,7 +2470,7 @@ static void hb_cdxPageStore( LPCDXPAGE pPage )
       if( pPage->pKeyBuf && pPage->fBufChanged )
       {
          hb_cdxPageLeafEncode( pPage, pPage->pKeyBuf, pPage->iKeys );
-         pPage->fBufChanged = FALSE;
+         pPage->fBufChanged = HB_FALSE;
       }
 #ifdef HB_CDX_DBGCODE_EXT
       if( pPage->pKeyBuf )
@@ -2484,7 +2484,7 @@ static void hb_cdxPageStore( LPCDXPAGE pPage )
 #ifdef HB_CDX_DBGCODE_EXT
    hb_cdxPageCheckKeys( pPage );
 #endif
-   pPage->fChanged = FALSE;
+   pPage->fChanged = HB_FALSE;
 }
 
 /*
@@ -2536,8 +2536,8 @@ static LPCDXPAGE hb_cdxPageNew( LPCDXTAG pTag, LPCDXPAGE pOwnerPage, ULONG ulPag
       }
       else if( ! ulPage  )
       {
-         pPage->Page = hb_cdxIndexGetAvailPage( pTag->pIndex, FALSE );
-         pPage->fChanged = TRUE;
+         pPage->Page = hb_cdxIndexGetAvailPage( pTag->pIndex, HB_FALSE );
+         pPage->fChanged = HB_TRUE;
       }
       pPage->pPoolPrev = NULL;
       pPage->pPoolNext = pTag->pagePool;
@@ -2557,7 +2557,7 @@ static LPCDXPAGE hb_cdxPageNew( LPCDXTAG pTag, LPCDXPAGE pOwnerPage, ULONG ulPag
 /*
  * free single page
  */
-static void hb_cdxPageFree( LPCDXPAGE pPage, BOOL fReal )
+static void hb_cdxPageFree( LPCDXPAGE pPage, HB_BOOL fReal )
 {
 #ifdef HB_CDX_DBGCODE_EXT
    LPCDXTAG pTag = pPage->TagParent;
@@ -2571,8 +2571,8 @@ static void hb_cdxPageFree( LPCDXPAGE pPage, BOOL fReal )
 
    if( pPage->PageType == CDX_NODE_UNUSED )
    {
-      fReal = TRUE;
-      pPage->fChanged = FALSE;
+      fReal = HB_TRUE;
+      pPage->fChanged = HB_FALSE;
    }
 
    if( fReal )
@@ -2612,7 +2612,7 @@ static void hb_cdxPageFree( LPCDXPAGE pPage, BOOL fReal )
    if( fReal )
    {
       if( pPage->PageType == CDX_NODE_UNUSED )
-         hb_cdxIndexPutAvailPage( pPage->TagParent->pIndex, pPage->Page, FALSE );
+         hb_cdxIndexPutAvailPage( pPage->TagParent->pIndex, pPage->Page, HB_FALSE );
       if( pPage->pKeyBuf )
          hb_xfree( pPage->pKeyBuf );
       hb_xfree( pPage );
@@ -2639,7 +2639,7 @@ static void hb_cdxPageGetChild( LPCDXPAGE pPage )
    {
       if( pPage->Child->Page != ulPage )
       {
-         hb_cdxPageFree( pPage->Child, FALSE );
+         hb_cdxPageFree( pPage->Child, HB_FALSE );
          pPage->Child = NULL;
       }
    }
@@ -2659,7 +2659,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
    int iLen = pPage->TagParent->uiLen + 6,
        iKeys = 0, iFree = 0, iSkip = 0, iBufSize = 0;
    BYTE * pKeyPool = NULL, * pPtr;
-   BOOL fIns;
+   HB_BOOL fIns;
    ULONG ulPage;
    int iRet = 0, i;
 
@@ -2727,7 +2727,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
          else if( i + 1 == iBlncKeys && ( iChildRet & NODE_SPLIT ) == 0 )
          {
             iBlncKeys--;
-            hb_cdxPageFree( childs[i], FALSE );
+            hb_cdxPageFree( childs[i], HB_FALSE );
          }
 #endif
       }
@@ -2745,7 +2745,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
       for( i = iBlncKeys - 1; i > iSkip && childs[i]->iFree >= 0 && childs[i]->iFree < childs[i]->ReqByte; i-- )
       {
          iKeys -= childs[i]->iKeys;
-         hb_cdxPageFree( childs[i], FALSE );
+         hb_cdxPageFree( childs[i], HB_FALSE );
          iBlncKeys--;
       }
    }
@@ -2753,7 +2753,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
         ( iBlncKeys < 2 || iFree < CDX_EXT_FREESPACE ) )
    {
       for( i = 0; i < iBlncKeys; i++ )
-         hb_cdxPageFree( childs[i], FALSE );
+         hb_cdxPageFree( childs[i], HB_FALSE );
       return iRet;
    }
 #ifdef HB_CDX_DSPDBG_INFO
@@ -2808,10 +2808,10 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
    }
 
 #ifdef HB_CDX_DBGCODE_EXT
-   hb_cdxPageCheckDupTrl( pPage, pKeyPool, iKeys, FALSE );
+   hb_cdxPageCheckDupTrl( pPage, pKeyPool, iKeys, HB_FALSE );
 #endif
    pPtr = pKeyPool;
-   fIns = FALSE;
+   fIns = HB_FALSE;
    i = iSkip;
    while( iKeys > 0 )
    {
@@ -2859,7 +2859,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
             iSize = lpTmpPage->iFree - iSize -
                      ( iMaxReq - lpTmpPage->ReqByte ) * lpTmpPage->iKeys;
             if( iSize < 0 )
-               fIns = TRUE;
+               fIns = HB_TRUE;
             else
             {
 #ifdef HB_CDX_DSPDBG_INFO
@@ -2911,7 +2911,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
                {
                   hb_xfree( childs[i]->pKeyBuf );
                   childs[i]->pKeyBuf = NULL;
-                  childs[i]->fBufChanged = FALSE;
+                  childs[i]->fBufChanged = HB_FALSE;
                }
                hb_cdxPageCalcLeafSpace( childs[i], pPtr, iKeys );
                hb_cdxPageLeafEncode( childs[i], pPtr, childs[i]->iKeys );
@@ -2927,7 +2927,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
 #endif
          }
          else
-            fIns = TRUE;
+            fIns = HB_TRUE;
 
          if( fIns )
          {
@@ -2937,12 +2937,12 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
             childs[ i ]->Left  = childs[i-1]->Page;
             childs[ i ]->Right = childs[i-1]->Right;
             childs[i-1]->Right = childs[ i ]->Page;
-            childs[i-1]->fChanged = TRUE;
+            childs[i-1]->fChanged = HB_TRUE;
             if( lpTmpPage != NULL )
             {
                lpTmpPage->Left = childs[i]->Page;
-               lpTmpPage->fChanged = TRUE;
-               hb_cdxPageFree( lpTmpPage, FALSE );
+               lpTmpPage->fChanged = HB_TRUE;
+               hb_cdxPageFree( lpTmpPage, HB_FALSE );
             }
             iBlncKeys++;
             iRet |= NODE_BALANCE;
@@ -2957,7 +2957,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
       {
          hb_xfree( childs[i]->pKeyBuf );
          childs[i]->pKeyBuf = NULL;
-         childs[i]->fBufChanged = FALSE;
+         childs[i]->fBufChanged = HB_FALSE;
       }
       hb_cdxPageCalcLeafSpace( childs[i], pPtr, iKeys );
       if( i == iSkip && i < iBlncKeys && !childs[i]->fChanged &&
@@ -3002,13 +3002,13 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
          Page = childs[iBlncKeys-1]->Page;
          childs[iBlncKeys-1]->Page = childs[i-1]->Page;
          childs[i-1]->Page = Page;
-         hb_cdxPageIntSetKey( pPage, iFirstKey + i - 1, FALSE, NULL, 0, Page );
+         hb_cdxPageIntSetKey( pPage, iFirstKey + i - 1, HB_FALSE, NULL, 0, Page );
          childs[i-1]->Right = childs[iBlncKeys-1]->Right;
-         childs[i-1]->fChanged = TRUE;
+         childs[i-1]->fChanged = HB_TRUE;
          if( i > 1 )
          {
             childs[i-2]->Right = Page;
-            childs[i-2]->fChanged = TRUE;
+            childs[i-2]->fChanged = HB_TRUE;
          }
       }
       else
@@ -3020,7 +3020,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
          {
             Left = childs[i-1]->Page;
             childs[i-1]->Right = Right;
-            childs[i-1]->fChanged  = TRUE;
+            childs[i-1]->fChanged  = HB_TRUE;
          }
          else
          {
@@ -3029,16 +3029,16 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
             {
                lpTmpPage = hb_cdxPageNew( pPage->TagParent, pPage, Left );
                lpTmpPage->Right = Right;
-               lpTmpPage->fChanged  = TRUE;
-               hb_cdxPageFree( lpTmpPage, FALSE );
+               lpTmpPage->fChanged  = HB_TRUE;
+               hb_cdxPageFree( lpTmpPage, HB_FALSE );
             }
          }
          if( Right != CDX_DUMMYNODE )
          {
             lpTmpPage = hb_cdxPageNew( pPage->TagParent, pPage, Right );
             lpTmpPage->Left = Left;
-            lpTmpPage->fChanged  = TRUE;
-            hb_cdxPageFree( lpTmpPage, FALSE );
+            lpTmpPage->fChanged  = HB_TRUE;
+            hb_cdxPageFree( lpTmpPage, HB_FALSE );
          }
       }
       /* Unlink empty pages from parent */
@@ -3054,24 +3054,24 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
          {
             hb_xfree( childs[iBlncKeys ]->pKeyBuf );
             childs[iBlncKeys]->pKeyBuf = NULL;
-            childs[iBlncKeys]->fBufChanged = FALSE;
+            childs[iBlncKeys]->fBufChanged = HB_FALSE;
          }
          hb_cdxPageIntDelKey( pPage, iFirstKey + iBlncKeys );
          childs[iBlncKeys]->Owner    = NULL;
-         childs[iBlncKeys]->fChanged = FALSE;
+         childs[iBlncKeys]->fChanged = HB_FALSE;
          childs[iBlncKeys]->PageType = CDX_NODE_UNUSED;
          childs[iBlncKeys]->Left     = CDX_DUMMYNODE;
          childs[iBlncKeys]->Right    = CDX_DUMMYNODE;
-         hb_cdxPageFree( childs[iBlncKeys], FALSE );
+         hb_cdxPageFree( childs[iBlncKeys], HB_FALSE );
       }
       iRet |= NODE_BALANCE;
    }
    for( i = 0; i < iBlncKeys; i++ )
-      hb_cdxPageFree( childs[i], FALSE );
+      hb_cdxPageFree( childs[i], HB_FALSE );
 
    if( pKeyPool )
       hb_xfree( pKeyPool );
-   pPage->fChanged = TRUE;
+   pPage->fChanged = HB_TRUE;
 #ifdef HB_CDX_DBGCODE_EXT
    hb_cdxPageCheckKeys( pPage );
 #endif
@@ -3088,14 +3088,14 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
        iMin = pPage->TagParent->MaxKeys, iMax = 0, iDiv;
    ULONG ulPage;
    BYTE * pKeyPool = NULL, *pPtr;
-   BOOL fForce = ( iChildRet & ( NODE_SPLIT | NODE_JOIN ) ) != 0;
+   HB_BOOL fForce = ( iChildRet & ( NODE_SPLIT | NODE_JOIN ) ) != 0;
    int iRet = 0, i;
 
    if( !fForce && ( iChildRet & NODE_BALANCE ) == 0 )
       return iRet;
 
    if( pPage->Child && pPage->Child->Child )
-      hb_cdxPageFree( pPage->Child->Child, FALSE );
+      hb_cdxPageFree( pPage->Child->Child, HB_FALSE );
 
 #ifdef HB_CDX_DBGCODE_EXT
    hb_cdxPageCheckKeys( pPage );
@@ -3195,7 +3195,7 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
                   childs[i]->iKeys >= iMin && childs[i]->iKeys <= iMax; i-- )
          {
             iKeys -= childs[i]->iKeys;
-            hb_cdxPageFree( childs[i], FALSE );
+            hb_cdxPageFree( childs[i], HB_FALSE );
             iBlncKeys--;
             iMin = HB_MAX( iKeys / iNeedKeys, 2 );
             iMax = HB_MAX( ( iKeys + iNeedKeys - 1 ) / iNeedKeys, iMin );
@@ -3203,7 +3203,7 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
          while( iBlncKeys > 2 && childs[0]->iKeys >= iMin && childs[0]->iKeys <= iMax )
          {
             iKeys -= childs[0]->iKeys;
-            hb_cdxPageFree( childs[0], FALSE );
+            hb_cdxPageFree( childs[0], HB_FALSE );
             iBlncKeys--;
             iFirstKey++;
             for( i = 0; i < iBlncKeys; i++ )
@@ -3218,7 +3218,7 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
    if( !fForce && ( iBlncKeys < 2 || iDiv < 2 ) )
    {
       for( i = 0; i < iBlncKeys; i++ )
-         hb_cdxPageFree( childs[i], FALSE );
+         hb_cdxPageFree( childs[i], HB_FALSE );
       return iRet;
    }
 
@@ -3247,9 +3247,9 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
       childs[ i ] = hb_cdxPageNew( pPage->TagParent, pPage, 0 );
       childs[ i ]->PageType = CDX_NODE_BRANCH;
       childs[ i ]->iKeys    = 0;
-      childs[ i ]->fChanged = TRUE;
+      childs[ i ]->fChanged = HB_TRUE;
       /* Add new parent key */
-      hb_cdxPageIntSetKey( pPage, iFirstKey + i, TRUE,
+      hb_cdxPageIntSetKey( pPage, iFirstKey + i, HB_TRUE,
                            NULL, 0, childs[iBlncKeys]->Page );
       /* Update siblings links */
       childs[ i ]->Left  = childs[i-1]->Page;
@@ -3261,8 +3261,8 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
       {
          lpTmpPage = hb_cdxPageNew( pPage->TagParent, pPage, childs[iBlncKeys]->Right );
          lpTmpPage->Left = childs[i]->Page;
-         lpTmpPage->fChanged  = TRUE;
-         hb_cdxPageFree( lpTmpPage, FALSE );
+         lpTmpPage->fChanged  = HB_TRUE;
+         hb_cdxPageFree( lpTmpPage, HB_FALSE );
       }
 #ifdef HB_CDX_DSPDBG_INFO
       printf("\r\nint balance: new child[%d]->Page=%lx",iBlncKeys,childs[iBlncKeys]->Page);
@@ -3306,16 +3306,16 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
             {
                lpTmpPage = hb_cdxPageNew( pPage->TagParent, pPage, Left );
                lpTmpPage->Right = Right;
-               lpTmpPage->fChanged = TRUE;
-               hb_cdxPageFree( lpTmpPage, FALSE );
+               lpTmpPage->fChanged = HB_TRUE;
+               hb_cdxPageFree( lpTmpPage, HB_FALSE );
             }
          }
          if( Right != CDX_DUMMYNODE )
          {
             lpTmpPage = hb_cdxPageNew( pPage->TagParent, pPage, Right );
             lpTmpPage->Left = Left;
-            lpTmpPage->fChanged = TRUE;
-            hb_cdxPageFree( lpTmpPage, FALSE );
+            lpTmpPage->fChanged = HB_TRUE;
+            hb_cdxPageFree( lpTmpPage, HB_FALSE );
          }
       }
       /* Unlink empty pages from parent */
@@ -3328,12 +3328,12 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
 #endif
          hb_cdxPageIntDelKey( pPage, iFirstKey + i );
          childs[i]->Owner    = NULL;
-         childs[i]->fChanged = FALSE;
+         childs[i]->fChanged = HB_FALSE;
          childs[i]->PageType = CDX_NODE_UNUSED;
          childs[i]->Left     = CDX_DUMMYNODE;
          childs[i]->Right    = CDX_DUMMYNODE;
          childs[i]->iKeys    = 0;
-         hb_cdxPageFree( childs[i], FALSE );
+         hb_cdxPageFree( childs[i], HB_FALSE );
       }
       iBlncKeys = iNeedKeys;
       iRet |= NODE_BALANCE;
@@ -3355,13 +3355,13 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
          /* TODO: do nothing if iNodeKeys == childs[i]->iKeys && i == iSkip */
          memcpy( childs[i]->node.intNode.keyPool, pPtr, iNodeKeys * iLen );
          childs[i]->iKeys = iNodeKeys;
-         childs[i]->fChanged = TRUE;
+         childs[i]->fChanged = HB_TRUE;
          pPtr += iNodeKeys * iLen;
          iKeys -= iNodeKeys;
          /* update parent key */
          if( iFirstKey + i < pPage->iKeys )
          {
-            hb_cdxPageIntSetKey( pPage, iFirstKey + i, FALSE,
+            hb_cdxPageIntSetKey( pPage, iFirstKey + i, HB_FALSE,
                                  pPtr - iLen, HB_GET_BE_UINT32( pPtr - 8 ),
                                  childs[i]->Page );
          }
@@ -3371,11 +3371,11 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
 #ifdef HB_CDX_DBGCODE_EXT
          hb_cdxPageCheckKeys( childs[i] );
 #endif
-         hb_cdxPageFree( childs[i], FALSE );
+         hb_cdxPageFree( childs[i], HB_FALSE );
       }
       hb_xfree( pKeyPool );
    }
-   pPage->fChanged = TRUE;
+   pPage->fChanged = HB_TRUE;
 #ifdef HB_CDX_DBGCODE_EXT
    hb_cdxPageCheckKeys( pPage );
 #endif
@@ -3404,14 +3404,14 @@ static int hb_cdxPageBalance( LPCDXPAGE pPage, int iChildRet )
          }
          else
          {
-            hb_cdxPageIntSetKey( pPage, pPage->iCurKey, FALSE,
+            hb_cdxPageIntSetKey( pPage, pPage->iCurKey, HB_FALSE,
                                  hb_cdxPageGetKeyVal( pPage->Child, pPage->Child->iKeys-1 ),
                                  hb_cdxPageGetKeyRec( pPage->Child, pPage->Child->iKeys-1 ),
                                  pPage->Child->Page );
 #ifdef HB_CDX_DBGCODE_EXT
             hb_cdxPageCheckKeys( pPage );
 #endif
-            pPage->fChanged = TRUE;
+            pPage->fChanged = HB_TRUE;
             if( pPage->iCurKey >= pPage->iKeys - 1 )
                iRet |= NODE_NEWLASTKEY;
          }
@@ -3455,10 +3455,10 @@ static int hb_cdxPageRootSplit( LPCDXPAGE pPage )
    pPage->Owner = pNewRoot;
    pPage->PageType &= ~CDX_NODE_ROOT;
    pNewRoot->PageType = CDX_NODE_ROOT | CDX_NODE_BRANCH;
-   pNewRoot->fChanged = TRUE;
+   pNewRoot->fChanged = HB_TRUE;
    pNewRoot->Child    = pPage;
    pNewRoot->iCurKey  = 0;
-   hb_cdxPageIntSetKey( pNewRoot, 0, TRUE,
+   hb_cdxPageIntSetKey( pNewRoot, 0, HB_TRUE,
                         hb_cdxPageGetKeyVal( pPage, pPage->iKeys-1 ),
                         hb_cdxPageGetKeyRec( pPage, pPage->iKeys-1 ),
                         pPage->Page );
@@ -3520,7 +3520,7 @@ static void hb_cdxTagHeaderStore( LPCDXTAG pTag )
     * tagHeader.reserved2[ 486 ]
     */
 
-   pTag->TagChanged = FALSE;
+   pTag->TagChanged = HB_FALSE;
    pTag->OptFlags &= ~( CDX_TYPE_UNIQUE | CDX_TYPE_FORFILTER |
                         CDX_TYPE_TEMPORARY | CDX_TYPE_CUSTOM );
    if( pTag->UniqueKey )
@@ -3627,7 +3627,7 @@ static void hb_cdxTagLoad( LPCDXTAG pTag )
    pTag->OptFlags  = tagHeader.indexOpt;
    pTag->UniqueKey = ( pTag->OptFlags & CDX_TYPE_UNIQUE ) != 0;
 #if defined( HB_SIXCDX )
-   pTag->Temporary = FALSE;
+   pTag->Temporary = HB_FALSE;
    pTag->Custom    = ( pTag->OptFlags & CDX_TYPE_CUSTOM ) != 0 &&
                      ( pTag->OptFlags & CDX_TYPE_TEMPORARY ) != 0;
    pTag->ChgOnly   = ( pTag->OptFlags & CDX_TYPE_CUSTOM ) != 0 &&
@@ -3641,23 +3641,23 @@ static void hb_cdxTagLoad( LPCDXTAG pTag )
                      hb_strnicmp( pTag->KeyExpr, "sxNum(", 6 ) == 0 ||
                      hb_strnicmp( pTag->KeyExpr, "sxLog(", 6 ) == 0 )
    /* SIx3 does not support repeated key value for the same record */
-   pTag->MultiKey  = FALSE;
+   pTag->MultiKey  = HB_FALSE;
 #endif
    pTag->Template  = pTag->MultiKey = pTag->Custom;
 #else
    pTag->Temporary = ( pTag->OptFlags & CDX_TYPE_TEMPORARY ) != 0;
    pTag->Custom    = ( pTag->OptFlags & CDX_TYPE_CUSTOM ) != 0;
-   pTag->ChgOnly   = FALSE;
+   pTag->ChgOnly   = HB_FALSE;
    pTag->Partial   = pTag->Temporary || pTag->Custom;
    pTag->Template  = pTag->MultiKey = pTag->Custom;
 #endif
 
    pTag->AscendKey = pTag->UsrAscend = ( HB_GET_LE_UINT16( tagHeader.ascendFlg ) == 0 );
-   pTag->UsrUnique = FALSE;
+   pTag->UsrUnique = HB_FALSE;
    if( tagHeader.indexSig == 0x01 )
       pTag->IgnoreCase = tagHeader.ignoreCase == 1;
    else
-      pTag->IgnoreCase = FALSE;
+      pTag->IgnoreCase = HB_FALSE;
 
    if( pTag->OptFlags & CDX_TYPE_STRUCTURE )
       return;
@@ -3679,7 +3679,7 @@ static void hb_cdxTagLoad( LPCDXTAG pTag )
    if( pTag->uiType == 'C' )
       hb_cdxMakeSortTab( pTag->pIndex->pArea );
    else
-      pTag->IgnoreCase = FALSE;
+      pTag->IgnoreCase = HB_FALSE;
 
    pTag->nField = hb_rddFieldExpIndex( ( AREAP ) pTag->pIndex->pArea,
                                        pTag->KeyExpr );
@@ -3719,7 +3719,7 @@ static void hb_cdxTagFree( LPCDXTAG pTag )
 {
    if( pTag->RootPage != NULL )
    {
-      hb_cdxPageFree( pTag->RootPage, FALSE );
+      hb_cdxPageFree( pTag->RootPage, HB_FALSE );
       pTag->RootPage = NULL;
    }
    hb_cdxTagPoolFlush( pTag );
@@ -3759,15 +3759,15 @@ static LPCDXTAG hb_cdxTagNew( LPCDXINDEX pIndex, const char *szTagName, ULONG Ta
    hb_strncpyUpperTrim( szName, szTagName, sizeof( szName ) - 1 );
    pTag->szName = hb_strdup( szName );
    pTag->pIndex = pIndex;
-   pTag->AscendKey = pTag->UsrAscend = TRUE;
-   pTag->UsrUnique = pTag->IgnoreCase = FALSE;
+   pTag->AscendKey = pTag->UsrAscend = HB_TRUE;
+   pTag->UsrUnique = pTag->IgnoreCase = HB_FALSE;
    pTag->uiType = 'C';
    pTag->bTrail = ' ';
    pTag->CurKey = hb_cdxKeyNew();
    if( TagHdr == CDX_DUMMYNODE )
    {
-      pTag->TagBlock = hb_cdxIndexGetAvailPage( pIndex, TRUE );
-      pTag->TagChanged = TRUE;
+      pTag->TagBlock = hb_cdxIndexGetAvailPage( pIndex, HB_TRUE );
+      pTag->TagChanged = HB_TRUE;
       pTag->OptFlags = CDX_TYPE_COMPACT | CDX_TYPE_COMPOUND;
    }
    else
@@ -3791,14 +3791,14 @@ static void hb_cdxTagClose( LPCDXTAG pTag )
 {
    if( pTag->RootPage != NULL )
    {
-      hb_cdxPageFree( pTag->RootPage, FALSE );
+      hb_cdxPageFree( pTag->RootPage, HB_FALSE );
       pTag->RootPage = NULL;
    }
    if( pTag->TagChanged )
    {
       hb_cdxTagHeaderStore( pTag );
    }
-   pTag->fRePos = TRUE;
+   pTag->fRePos = HB_TRUE;
 }
 
 /*
@@ -3840,7 +3840,7 @@ static void hb_cdxTagPoolFree( LPCDXTAG pTag, int nPagesLeft )
       pPageNext = pPage->pPoolNext;
       if( ! pPage->bUsed )
       {
-         hb_cdxPageFree( pPage, TRUE );
+         hb_cdxPageFree( pPage, HB_TRUE );
       }
       pPage = pPageNext;
    }
@@ -3890,7 +3890,7 @@ static void hb_cdxSetCurKey( LPCDXPAGE pPage )
 static int hb_cdxPageSeekKey( LPCDXPAGE pPage, LPCDXKEY pKey, ULONG ulKeyRec )
 {
    int l, r, n, k;
-   BOOL fLeaf = ( pPage->PageType & CDX_NODE_LEAF ) != 0;
+   HB_BOOL fLeaf = ( pPage->PageType & CDX_NODE_LEAF ) != 0;
 
    if( fLeaf && !pPage->pKeyBuf && pPage->iKeys > 0 )
    {
@@ -3992,24 +3992,24 @@ static int hb_cdxPageSeekKey( LPCDXPAGE pPage, LPCDXKEY pKey, ULONG ulKeyRec )
 /*
  * an interface for fast check record number in record filter
  */
-static BOOL hb_cdxCheckRecordScope( CDXAREAP pArea, ULONG ulRec )
+static HB_BOOL hb_cdxCheckRecordScope( CDXAREAP pArea, ULONG ulRec )
 {
    LONG lRecNo = ( LONG ) ulRec;
 
    if( SELF_COUNTSCOPE( ( AREAP ) pArea, NULL, &lRecNo ) == HB_SUCCESS && lRecNo == 0 )
    {
-      return FALSE;
+      return HB_FALSE;
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * check and avaluate record filter
  */
-static BOOL hb_cdxCheckRecordFilter( CDXAREAP pArea, ULONG ulRecNo )
+static HB_BOOL hb_cdxCheckRecordFilter( CDXAREAP pArea, ULONG ulRecNo )
 {
-   BOOL lResult = FALSE;
-   BOOL fDeleted = hb_setGetDeleted();
+   HB_BOOL lResult = HB_FALSE;
+   HB_BOOL fDeleted = hb_setGetDeleted();
 
    if( pArea->dbfarea.area.dbfi.fFilter && pArea->dbfarea.area.dbfi.fOptimized )
    {
@@ -4036,7 +4036,7 @@ static BOOL hb_cdxCheckRecordFilter( CDXAREAP pArea, ULONG ulRecNo )
          }
       }
       else
-         lResult = TRUE;
+         lResult = HB_TRUE;
    }
    else if( pArea->dbfarea.area.dbfi.itmCobExpr || fDeleted )
    {
@@ -4058,7 +4058,7 @@ static BOOL hb_cdxCheckRecordFilter( CDXAREAP pArea, ULONG ulRecNo )
 /*
  * read Top Key from Page or its children
  */
-static BOOL hb_cdxPageReadTopKey( LPCDXPAGE pPage )
+static HB_BOOL hb_cdxPageReadTopKey( LPCDXPAGE pPage )
 {
    while( ( pPage->PageType & CDX_NODE_LEAF ) == 0 && pPage->iKeys > 0 )
    {
@@ -4067,17 +4067,17 @@ static BOOL hb_cdxPageReadTopKey( LPCDXPAGE pPage )
       pPage = pPage->Child;
    }
    if( pPage->iKeys == 0 )
-      return FALSE;
+      return HB_FALSE;
    pPage->iCurKey = 0;
 
    hb_cdxSetCurKey( pPage );
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * read Bottom Key from Page or its children
  */
-static BOOL hb_cdxPageReadBottomKey( LPCDXPAGE pPage )
+static HB_BOOL hb_cdxPageReadBottomKey( LPCDXPAGE pPage )
 {
    while( ( pPage->PageType & CDX_NODE_LEAF ) == 0 && pPage->iKeys > 0 )
    {
@@ -4086,17 +4086,17 @@ static BOOL hb_cdxPageReadBottomKey( LPCDXPAGE pPage )
       pPage = pPage->Child;
    }
    if( pPage->iKeys == 0 )
-      return FALSE;
+      return HB_FALSE;
    pPage->iCurKey = pPage->iKeys - 1;
 
    hb_cdxSetCurKey( pPage );
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * read Previous Key from Page or its children
  */
-static BOOL hb_cdxPageReadPrevKey( LPCDXPAGE pPage )
+static HB_BOOL hb_cdxPageReadPrevKey( LPCDXPAGE pPage )
 {
    LPCDXPAGE pOwnerPage = NULL;
 
@@ -4116,7 +4116,7 @@ static BOOL hb_cdxPageReadPrevKey( LPCDXPAGE pPage )
             pPage->iCurKey = 0;
             if( pPage->iKeys > 0 )
                hb_cdxSetCurKey( pPage );
-            return FALSE;
+            return HB_FALSE;
          }
          pOwnerPage->Child = hb_cdxPageNew( pPage->TagParent, pPage->Owner, pPage->Left );
          hb_cdxPageFree( pPage, !pPage->fChanged );
@@ -4136,13 +4136,13 @@ static BOOL hb_cdxPageReadPrevKey( LPCDXPAGE pPage )
                                    hb_cdxPageGetKeyRec( pPage, pPage->iCurKey ) ) );
    if( pPage->iCurKey != 0 )
       hb_cdxSetCurKey( pPage );
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * read Next Key from Page or its children
  */
-static BOOL hb_cdxPageReadNextKey( LPCDXPAGE pPage )
+static HB_BOOL hb_cdxPageReadNextKey( LPCDXPAGE pPage )
 {
    LPCDXPAGE pOwnerPage = NULL;
 
@@ -4160,7 +4160,7 @@ static BOOL hb_cdxPageReadNextKey( LPCDXPAGE pPage )
          if( pPage->Right == CDX_DUMMYNODE || !pOwnerPage )
          {
             pPage->iCurKey = pPage->iKeys;
-            return FALSE;
+            return HB_FALSE;
          }
          pOwnerPage->Child = hb_cdxPageNew( pPage->TagParent, pPage->Owner, pPage->Right );
          hb_cdxPageFree( pPage, !pPage->fChanged );
@@ -4180,13 +4180,13 @@ static BOOL hb_cdxPageReadNextKey( LPCDXPAGE pPage )
                                    hb_cdxPageGetKeyRec( pPage, pPage->iCurKey ) ) );
    if( pPage->iCurKey != 0 )
       hb_cdxSetCurKey( pPage );
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * read Previous Unique Key from Page or its children
  */
-static BOOL hb_cdxPageReadPrevUniqKey( LPCDXPAGE pPage )
+static HB_BOOL hb_cdxPageReadPrevUniqKey( LPCDXPAGE pPage )
 {
    LPCDXPAGE pOwnerPage = NULL;
 
@@ -4206,7 +4206,7 @@ static BOOL hb_cdxPageReadPrevUniqKey( LPCDXPAGE pPage )
             pPage->iCurKey = 0;
             if( pPage->iKeys > 0 )
                hb_cdxSetCurKey( pPage );
-            return FALSE;
+            return HB_FALSE;
          }
          pOwnerPage->Child = hb_cdxPageNew( pPage->TagParent, pPage->Owner, pPage->Left );
          hb_cdxPageFree( pPage, !pPage->fChanged );
@@ -4216,13 +4216,13 @@ static BOOL hb_cdxPageReadPrevUniqKey( LPCDXPAGE pPage )
    }
 
    hb_cdxSetCurKey( pPage );
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * read Next Unique Key from Page or its children
  */
-static BOOL hb_cdxPageReadNextUniqKey( LPCDXPAGE pPage )
+static HB_BOOL hb_cdxPageReadNextUniqKey( LPCDXPAGE pPage )
 {
    LPCDXPAGE pOwnerPage = NULL;
    /* BYTE pbVal[CDX_MAXKEY]; */
@@ -4248,7 +4248,7 @@ static BOOL hb_cdxPageReadNextUniqKey( LPCDXPAGE pPage )
             pPage->iCurKey = pPage->iKeys - 1;
             if( pPage->iKeys > 0 )
                hb_cdxSetCurKey( pPage );
-            return FALSE;
+            return HB_FALSE;
          }
          pOwnerPage->Child = hb_cdxPageNew( pPage->TagParent, pPage->Owner, pPage->Right );
          hb_cdxPageFree( pPage, !pPage->fChanged );
@@ -4257,7 +4257,7 @@ static BOOL hb_cdxPageReadNextUniqKey( LPCDXPAGE pPage )
       }
    }
    hb_cdxSetCurKey( pPage );
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
@@ -4265,10 +4265,10 @@ static BOOL hb_cdxPageReadNextUniqKey( LPCDXPAGE pPage )
  */
 static void hb_cdxTagKeyRead( LPCDXTAG pTag, BYTE bTypRead )
 {
-   BOOL fAfter = FALSE, fBof, fEof;
+   HB_BOOL fAfter = HB_FALSE, fBof, fEof;
 
    pTag->CurKey->rec = 0;
-   pTag->fRePos = FALSE;
+   pTag->fRePos = HB_FALSE;
    hb_cdxTagOpen( pTag );
 
    if( pTag->UsrUnique )
@@ -4282,7 +4282,7 @@ static void hb_cdxTagKeyRead( LPCDXTAG pTag, BYTE bTypRead )
          case PREV_RECORD:
             bTypRead = PRVU_RECORD;
          case BTTM_RECORD:
-            fAfter = TRUE;
+            fAfter = HB_TRUE;
             break;
       }
    }
@@ -4389,10 +4389,10 @@ static ULONG hb_cdxTagKeyFind( LPCDXTAG pTag, LPCDXKEY pKey )
    int K;
    ULONG ulKeyRec = pKey->rec;
 
-   pTag->fRePos = FALSE;
+   pTag->fRePos = HB_FALSE;
    hb_cdxTagOpen( pTag );
 
-   pTag->TagBOF = pTag->TagEOF = FALSE;
+   pTag->TagBOF = pTag->TagEOF = HB_FALSE;
    K = hb_cdxPageSeekKey( pTag->RootPage, pKey, ulKeyRec );
    if( ulKeyRec == CDX_MAX_REC_NUM )
       K = - K;
@@ -4400,7 +4400,7 @@ static ULONG hb_cdxTagKeyFind( LPCDXTAG pTag, LPCDXKEY pKey )
    if( K > 0 )
    {
       pTag->CurKey->rec = 0;
-      pTag->TagEOF = TRUE;
+      pTag->TagEOF = HB_TRUE;
    }
    else
    {
@@ -4414,7 +4414,7 @@ static ULONG hb_cdxTagKeyFind( LPCDXTAG pTag, LPCDXKEY pKey )
 /*
  * add the Key into the Tag
  */
-static BOOL hb_cdxTagKeyAdd( LPCDXTAG pTag, LPCDXKEY pKey )
+static HB_BOOL hb_cdxTagKeyAdd( LPCDXTAG pTag, LPCDXKEY pKey )
 {
    hb_cdxTagOpen( pTag );
    if( hb_cdxPageSeekKey( pTag->RootPage, pKey,
@@ -4424,18 +4424,18 @@ static BOOL hb_cdxTagKeyAdd( LPCDXTAG pTag, LPCDXKEY pKey )
       hb_cdxPageKeyInsert( pTag->RootPage, pKey );
       pTag->curKeyState &= ~( CDX_CURKEY_RAWPOS | CDX_CURKEY_LOGPOS |
                               CDX_CURKEY_RAWCNT | CDX_CURKEY_LOGCNT );
-      pTag->fRePos = TRUE;
+      pTag->fRePos = HB_TRUE;
       /* TODO: !!! remove when page leaf balance can save CurKey */
       hb_cdxTagKeyFind( pTag, pKey );
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 /*
  * delete the Key from the Tag
  */
-static BOOL hb_cdxTagKeyDel( LPCDXTAG pTag, LPCDXKEY pKey )
+static HB_BOOL hb_cdxTagKeyDel( LPCDXTAG pTag, LPCDXKEY pKey )
 {
    if( hb_cdxTagKeyFind( pTag, pKey ) != 0 )
    {
@@ -4443,9 +4443,9 @@ static BOOL hb_cdxTagKeyDel( LPCDXTAG pTag, LPCDXKEY pKey )
       pTag->curKeyState &= ~( CDX_CURKEY_RAWPOS | CDX_CURKEY_LOGPOS |
                               CDX_CURKEY_RAWCNT | CDX_CURKEY_LOGCNT );
       pTag->CurKey->rec = 0;
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 /*
@@ -4465,7 +4465,7 @@ static void hb_cdxTagGoTop( LPCDXTAG pTag )
    {
       if( pTag->CurKey->rec == 0 || pTag->TagEOF || ! hb_cdxBottomScope( pTag ) )
       {
-         pTag->TagBOF = pTag->TagEOF = TRUE;
+         pTag->TagBOF = pTag->TagEOF = HB_TRUE;
          pTag->CurKey->rec = 0;
          break;
       }
@@ -4498,7 +4498,7 @@ static void hb_cdxTagGoBottom( LPCDXTAG pTag )
    {
       if( pTag->CurKey->rec == 0 || pTag->TagBOF || ! hb_cdxTopScope( pTag ) )
       {
-         pTag->TagBOF = pTag->TagEOF = TRUE;
+         pTag->TagBOF = pTag->TagEOF = HB_TRUE;
          pTag->CurKey->rec = 0;
          break;
       }
@@ -4522,7 +4522,7 @@ static void hb_cdxTagGoBottom( LPCDXTAG pTag )
  */
 static void hb_cdxTagSkipNext( LPCDXTAG pTag )
 {
-   BOOL fPos = CURKEY_RAWPOS( pTag ), fEof = FALSE;
+   HB_BOOL fPos = CURKEY_RAWPOS( pTag ), fEof = HB_FALSE;
    ULONG ulSkip = 1;
 
    if( pTag->CurKey->rec != 0 )
@@ -4540,7 +4540,7 @@ static void hb_cdxTagSkipNext( LPCDXTAG pTag )
    {
       if( pTag->TagEOF || pTag->CurKey->rec == 0 ||
           !hb_cdxBottomScope( pTag ) || !hb_cdxTopScope( pTag ) )
-         fEof = TRUE;
+         fEof = HB_TRUE;
       else if( ( pTag->OptFlags & CDX_TYPE_STRUCTURE ) != 0 ||
                hb_cdxCheckRecordScope( pTag->pIndex->pArea, pTag->CurKey->rec ) )
          break;
@@ -4551,7 +4551,7 @@ static void hb_cdxTagSkipNext( LPCDXTAG pTag )
    if( fEof )
    {
       pTag->CurKey->rec = 0;
-      pTag->TagEOF = TRUE;
+      pTag->TagEOF = HB_TRUE;
    }
    else if( fPos )
    {
@@ -4565,7 +4565,7 @@ static void hb_cdxTagSkipNext( LPCDXTAG pTag )
  */
 static void hb_cdxTagSkipPrev( LPCDXTAG pTag )
 {
-   BOOL fPos = CURKEY_RAWPOS( pTag ), fBof = FALSE;
+   HB_BOOL fPos = CURKEY_RAWPOS( pTag ), fBof = HB_FALSE;
    ULONG ulSkip = 1;
 
    if( pTag->CurKey->rec == 0 )
@@ -4580,7 +4580,7 @@ static void hb_cdxTagSkipPrev( LPCDXTAG pTag )
    {
       if( pTag->TagBOF || pTag->CurKey->rec == 0 ||
           !hb_cdxBottomScope( pTag ) || !hb_cdxTopScope( pTag ) )
-         fBof = TRUE;
+         fBof = HB_TRUE;
       else if( ( pTag->OptFlags & CDX_TYPE_STRUCTURE ) != 0 ||
                hb_cdxCheckRecordScope( pTag->pIndex->pArea, pTag->CurKey->rec ) )
          break;
@@ -4592,7 +4592,7 @@ static void hb_cdxTagSkipPrev( LPCDXTAG pTag )
    if( fBof )
    {
       hb_cdxTagGoTop( pTag );
-      pTag->TagBOF = TRUE;
+      pTag->TagBOF = HB_TRUE;
    }
    else if( fPos )
    {
@@ -4608,11 +4608,11 @@ static void hb_cdxTagSkipPrev( LPCDXTAG pTag )
 static void hb_cdxReorderTagList( LPCDXTAG * TagListPtr )
 {
    LPCDXTAG *pTagPtr, pTagTmp;
-   BOOL fRepeat = TRUE;
+   HB_BOOL fRepeat = HB_TRUE;
 
    while( fRepeat )
    {
-      fRepeat = FALSE;
+      fRepeat = HB_FALSE;
       pTagPtr = TagListPtr;
       while( *pTagPtr && (*pTagPtr)->pNext )
       {
@@ -4622,7 +4622,7 @@ static void hb_cdxReorderTagList( LPCDXTAG * TagListPtr )
             (*pTagPtr) = (*pTagPtr)->pNext;
             pTagTmp->pNext = (*pTagPtr)->pNext;
             (*pTagPtr)->pNext = pTagTmp;
-            fRepeat = TRUE;
+            fRepeat = HB_TRUE;
          }
          pTagPtr = &(*pTagPtr)->pNext;
       }
@@ -4632,13 +4632,13 @@ static void hb_cdxReorderTagList( LPCDXTAG * TagListPtr )
 /*
  * create new order header, store it and then make an order
  */
-static LPCDXTAG hb_cdxIndexCreateTag( BOOL fStruct, LPCDXINDEX pIndex,
+static LPCDXTAG hb_cdxIndexCreateTag( HB_BOOL fStruct, LPCDXINDEX pIndex,
                                       const char * szTagName,
                                       const char * szKeyExp, PHB_ITEM pKeyItem,
                                       BYTE bType, USHORT uiLen,
                                       const char * szForExp, PHB_ITEM pForItem,
-                                      BOOL fAscnd, BOOL fUniq, BOOL fNoCase,
-                                      BOOL fCustom, BOOL fReindex )
+                                      HB_BOOL fAscnd, HB_BOOL fUniq, HB_BOOL fNoCase,
+                                      HB_BOOL fCustom, HB_BOOL fReindex )
 {
    LPCDXTAG pTag;
 
@@ -4663,16 +4663,16 @@ static LPCDXTAG hb_cdxIndexCreateTag( BOOL fStruct, LPCDXINDEX pIndex,
    pTag->pForItem = pForItem;
    pTag->AscendKey = pTag->UsrAscend = fAscnd;
    pTag->UniqueKey = fUniq;
-   pTag->UsrUnique = FALSE;
+   pTag->UsrUnique = HB_FALSE;
    pTag->IgnoreCase = fNoCase && bType == 'C';
    pTag->Custom = fCustom;
    pTag->Template = pTag->MultiKey = pTag->Custom;
-   pTag->Partial = pTag->ChgOnly = FALSE;
+   pTag->Partial = pTag->ChgOnly = HB_FALSE;
    pTag->uiType = bType;
    pTag->bTrail = ( bType == 'C' ) ? ' ' : '\0';
    pTag->uiLen = uiLen;
    pTag->MaxKeys = CDX_INT_FREESPACE / ( uiLen + 8 );
-   pTag->TagChanged = TRUE;
+   pTag->TagChanged = HB_TRUE;
    hb_cdxTagDoIndex( pTag, fReindex );
 
    return pTag;
@@ -4684,9 +4684,9 @@ static LPCDXTAG hb_cdxIndexCreateTag( BOOL fStruct, LPCDXINDEX pIndex,
 static void hb_cdxIndexCreateStruct( LPCDXINDEX pIndex, char * szTagName )
 {
    /* here we can change default tag name */
-   pIndex->pCompound = hb_cdxIndexCreateTag( TRUE, pIndex, szTagName,
+   pIndex->pCompound = hb_cdxIndexCreateTag( HB_TRUE, pIndex, szTagName,
                            NULL, NULL, 'C', CDX_MAXTAGNAMELEN, NULL, NULL,
-                           TRUE, FALSE, FALSE, FALSE, FALSE );
+                           HB_TRUE, HB_FALSE, HB_FALSE, HB_FALSE, HB_FALSE );
 }
 
 /*
@@ -4708,7 +4708,7 @@ static void hb_cdxIndexFreePages( LPCDXPAGE pPage )
       }
    }
    pPage->PageType = CDX_NODE_UNUSED;
-   hb_cdxPageFree( pPage, FALSE );
+   hb_cdxPageFree( pPage, HB_FALSE );
 }
 
 /*
@@ -4739,9 +4739,9 @@ static void hb_cdxIndexDelTag( LPCDXINDEX pIndex, const char * szTagName )
             {
                if( pPage )
                   hb_cdxIndexFreePages( pPage );
-               hb_cdxIndexPutAvailPage( pIndex, pTag->TagBlock, TRUE );
+               hb_cdxIndexPutAvailPage( pIndex, pTag->TagBlock, HB_TRUE );
             }
-            pTag->TagChanged = FALSE;
+            pTag->TagChanged = HB_FALSE;
          }
       }
       *pTagPtr = pTag->pNext;
@@ -4757,8 +4757,8 @@ static LPCDXTAG hb_cdxIndexAddTag( LPCDXINDEX pIndex, const char * szTagName,
                                    const char * szKeyExp, PHB_ITEM pKeyItem,
                                    BYTE bType, USHORT uiLen,
                                    const char * szForExp, PHB_ITEM pForItem,
-                                   BOOL fAscend, BOOL fUnique, BOOL fNoCase,
-                                   BOOL fCustom, BOOL fReindex )
+                                   HB_BOOL fAscend, HB_BOOL fUnique, HB_BOOL fNoCase,
+                                   HB_BOOL fCustom, HB_BOOL fReindex )
 {
    LPCDXTAG pTag, *pTagPtr;
    LPCDXKEY pKey;
@@ -4769,7 +4769,7 @@ static LPCDXTAG hb_cdxIndexAddTag( LPCDXINDEX pIndex, const char * szTagName,
    hb_cdxIndexDelTag( pIndex, szTagName );
 
    /* Create new tag an add to tag list */
-   pTag = hb_cdxIndexCreateTag( FALSE, pIndex, szTagName, szKeyExp, pKeyItem,
+   pTag = hb_cdxIndexCreateTag( HB_FALSE, pIndex, szTagName, szKeyExp, pKeyItem,
                                 bType, uiLen, szForExp, pForItem,
                                 fAscend, fUnique, fNoCase, fCustom, fReindex );
    pTagPtr = &pIndex->TagList;
@@ -4801,7 +4801,7 @@ static void hb_cdxIndexReindex( LPCDXINDEX pIndex )
    pIndex->nextAvail = 0;
    pIndex->freePage = 0;
    hb_fileTruncAt( pIndex->pFile, 0 );
-   pIndex->fChanged = TRUE;
+   pIndex->fChanged = HB_TRUE;
 
    /* Rebuild the compound (master) tag */
    if( pCompound )
@@ -4816,7 +4816,7 @@ static void hb_cdxIndexReindex( LPCDXINDEX pIndex )
       pTag = pTagList;
       hb_cdxIndexAddTag( pIndex, pTag->szName, pTag->KeyExpr, pTag->pKeyItem,
          ( BYTE ) pTag->uiType, pTag->uiLen, pTag->ForExpr, pTag->pForItem,
-         pTag->AscendKey, pTag->UniqueKey, pTag->IgnoreCase, pTag->Custom, TRUE );
+         pTag->AscendKey, pTag->UniqueKey, pTag->IgnoreCase, pTag->Custom, HB_TRUE );
       pTagList = pTag->pNext;
       pTag->pKeyItem = pTag->pForItem = NULL;
       hb_cdxTagFree( pTag );
@@ -4901,10 +4901,10 @@ static void hb_cdxIndexFree( LPCDXINDEX pIndex )
 /*
  * load orders from index file
  */
-static BOOL hb_cdxIndexLoad( LPCDXINDEX pIndex, char * szBaseName )
+static HB_BOOL hb_cdxIndexLoad( LPCDXINDEX pIndex, char * szBaseName )
 {
    LPCDXTAG TagList, * pTagPtr;
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
 
    TagList = NULL;
    pTagPtr = &TagList;
@@ -4916,7 +4916,7 @@ static BOOL hb_cdxIndexLoad( LPCDXINDEX pIndex, char * szBaseName )
    /* check if index is not corrupted */
    if( pIndex->pCompound )
    {
-      fResult = TRUE;
+      fResult = HB_TRUE;
       pIndex->pCompound->OptFlags = CDX_TYPE_COMPACT | CDX_TYPE_COMPOUND | CDX_TYPE_STRUCTURE;
       hb_cdxTagGoTop( pIndex->pCompound );
       while( !pIndex->pCompound->TagEOF )
@@ -4926,7 +4926,7 @@ static BOOL hb_cdxIndexLoad( LPCDXINDEX pIndex, char * szBaseName )
          /* tag is corrupted - break tags loading */
          if( *pTagPtr == NULL )
          {
-            fResult = FALSE;
+            fResult = HB_FALSE;
             break;
          }
          pTagPtr = &(*pTagPtr)->pNext;
@@ -4952,12 +4952,12 @@ static BOOL hb_cdxIndexLoad( LPCDXINDEX pIndex, char * szBaseName )
  * create index file name
  */
 static void hb_cdxCreateFName( CDXAREAP pArea, const char * szBagName,
-                               BOOL * fProd,
+                               HB_BOOL * fProd,
                                char * szFileName, char * szBaseName )
 {
    PHB_FNAME pFileName;
    PHB_ITEM pExt = NULL;
-   BOOL fName = szBagName && *szBagName;
+   HB_BOOL fName = szBagName && *szBagName;
 
    pFileName = hb_fsFNameSplit( fName ? szBagName : pArea->dbfarea.szDataFileName );
 
@@ -4985,9 +4985,9 @@ static void hb_cdxCreateFName( CDXAREAP pArea, const char * szBagName,
    if( fProd )
    {
       if( ! pFileName->szName )
-         *fProd = FALSE;
+         *fProd = HB_FALSE;
       else if( !fName )
-         *fProd = TRUE;
+         *fProd = HB_TRUE;
       else
       {
          PHB_FNAME pTableFileName = hb_fsFNameSplit( pArea->dbfarea.szDataFileName );
@@ -5016,7 +5016,7 @@ static void hb_cdxCreateFName( CDXAREAP pArea, const char * szBagName,
 /*
  * free (close) used indexes, if not fAll then keep structure index
  */
-static void hb_cdxOrdListClear( CDXAREAP pArea, BOOL fAll, LPCDXINDEX pKeepInd )
+static void hb_cdxOrdListClear( CDXAREAP pArea, HB_BOOL fAll, LPCDXINDEX pKeepInd )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxOrdListClear(%p, %d)", pArea, (int) fAll));
 
@@ -5162,7 +5162,7 @@ static LPCDXTAG hb_cdxFindTag( CDXAREAP pArea, PHB_ITEM pTagItem,
    int iTag = 0, iFind = 0;
    char szTag[ CDX_MAXTAGNAMELEN + 1 ];
    LPCDXINDEX pIndex = pArea->lpIndexes;
-   BOOL fBag;
+   HB_BOOL fBag;
 
    hb_strncpyUpperTrim( szTag, hb_itemGetCPtr( pTagItem ), sizeof( szTag ) - 1 );
    if( ! szTag[0] )
@@ -5180,7 +5180,7 @@ static LPCDXTAG hb_cdxFindTag( CDXAREAP pArea, PHB_ITEM pTagItem,
 
       if( iBag > 0 )
       {
-         fBag = TRUE;
+         fBag = HB_TRUE;
          while( pIndex )
          {
             if( --iBag == 0 )
@@ -5243,35 +5243,35 @@ static LPCDXTAG hb_cdxGetActiveTag( CDXAREAP pArea )
 /*
  * refresh CurKey value and set proper path from RootPage to LeafPage
  */
-static BOOL hb_cdxCurKeyRefresh( CDXAREAP pArea, LPCDXTAG pTag )
+static HB_BOOL hb_cdxCurKeyRefresh( CDXAREAP pArea, LPCDXTAG pTag )
 {
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
    if( !pArea->dbfarea.fPositioned )
    {
-      pTag->TagEOF = TRUE;
-      pTag->fRePos = FALSE;
+      pTag->TagEOF = HB_TRUE;
+      pTag->fRePos = HB_FALSE;
       pTag->CurKey->rec = 0;
-      return FALSE;
+      return HB_FALSE;
    }
    else if( pTag->fRePos || pTag->CurKey->rec != pArea->dbfarea.ulRecNo )
    {
       BYTE buf[CDX_MAXKEY];
-      BOOL fBuf = FALSE;
+      HB_BOOL fBuf = HB_FALSE;
       LPCDXKEY pKey = NULL;
 
       /* Try to find previous if it's key for the same record */
       if( pTag->CurKey->rec == pArea->dbfarea.ulRecNo )
       {
-         fBuf = TRUE;
+         fBuf = HB_TRUE;
          memcpy( buf, pTag->CurKey->val, pTag->CurKey->len );
          pKey = hb_cdxKeyCopy( pKey, pTag->CurKey );
          hb_cdxTagKeyFind( pTag, pKey );
       }
       if( pTag->CurKey->rec != pArea->dbfarea.ulRecNo )
       {
-         BOOL fValidBuf = pArea->dbfarea.fValidBuffer;
+         HB_BOOL fValidBuf = pArea->dbfarea.fValidBuffer;
          /* not found, create new key from DBF and if differs seek again */
          pKey = hb_cdxKeyEval( pKey, pTag );
          if( !fBuf || memcmp( buf, pKey->val, pKey->len ) != 0 )
@@ -5292,13 +5292,13 @@ static BOOL hb_cdxCurKeyRefresh( CDXAREAP pArea, LPCDXTAG pTag )
       hb_cdxKeyFree( pKey );
       return ( pTag->CurKey->rec != 0 && pTag->CurKey->rec == pArea->dbfarea.ulRecNo );
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * skip to next/previous unique key
  */
-static HB_ERRCODE hb_cdxDBOISkipUnique( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward )
+static HB_ERRCODE hb_cdxDBOISkipUnique( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fForward )
 {
    HB_ERRCODE retval;
 
@@ -5313,7 +5313,7 @@ static HB_ERRCODE hb_cdxDBOISkipUnique( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFor
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
-   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
    if( !pArea->dbfarea.fPositioned )
    {
@@ -5325,7 +5325,7 @@ static HB_ERRCODE hb_cdxDBOISkipUnique( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFor
    else
    {
       LPCDXKEY pKey = NULL;
-      BOOL fOut = FALSE;
+      HB_BOOL fOut = HB_FALSE;
 
       hb_cdxIndexLockRead( pTag->pIndex );
       hb_cdxTagRefreshScope( pTag );
@@ -5333,7 +5333,7 @@ static HB_ERRCODE hb_cdxDBOISkipUnique( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFor
       {
          if( pTag->TagEOF || ( fForward ? !hb_cdxBottomScope( pTag ) :
                                           !hb_cdxTopScope( pTag ) ) )
-            fOut = TRUE;
+            fOut = HB_TRUE;
          else if( ( fForward ? pTag->UsrAscend && hb_cdxTopScope( pTag ) :
                               !pTag->UsrAscend && hb_cdxBottomScope( pTag ) ) &&
                    pTag->CurKey->rec != 0 )
@@ -5392,7 +5392,7 @@ static HB_ERRCODE hb_cdxDBOISkipUnique( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFor
          if( fOut || pTag->TagBOF )
          {
             retval = SELF_GOTOP( ( AREAP ) pArea );
-            pArea->dbfarea.area.fBof = TRUE;
+            pArea->dbfarea.area.fBof = HB_TRUE;
          }
          else
          {
@@ -5405,37 +5405,37 @@ static HB_ERRCODE hb_cdxDBOISkipUnique( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFor
    }
    /* Update Bof and Eof flags */
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
    return retval;
 }
 
 /*
- * skip while code block doesn't return TRUE
+ * skip while code block doesn't return HB_TRUE
  */
-static BOOL hb_cdxDBOISkipEval( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
-                                PHB_ITEM pEval )
+static HB_BOOL hb_cdxDBOISkipEval( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fForward,
+                                   PHB_ITEM pEval )
 {
-   BOOL fFound = FALSE, fFirst = TRUE;
+   HB_BOOL fFound = HB_FALSE, fFirst = HB_TRUE;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxDBOISkipEval(%p, %p, %i, %p)", pArea, pTag, fForward, pEval));
 
    if( FAST_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE )
-      return FALSE;
+      return HB_FALSE;
 
    if( ! pTag || hb_itemType( pEval ) != HB_IT_BLOCK )
    {
       if( SELF_SKIP( ( AREAP ) pArea, fForward ? 1 : -1 ) == HB_FAILURE )
-         return FALSE;
+         return HB_FALSE;
       return fForward ? !pArea->dbfarea.area.fEof : !pArea->dbfarea.area.fBof;
    }
 
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
-   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
    hb_cdxIndexLockRead( pTag->pIndex );
    hb_cdxTagRefreshScope( pTag );
@@ -5444,7 +5444,7 @@ static BOOL hb_cdxDBOISkipEval( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
       if( !pTag->TagEOF && pTag->CurKey->rec != 0 &&
           ( fForward ? pTag->UsrAscend : !pTag->UsrAscend ) &&
           hb_cdxTopScope( pTag ) && hb_cdxBottomScope( pTag ) )
-         fFirst = FALSE;
+         fFirst = HB_FALSE;
    }
    if( fForward )
    {
@@ -5460,7 +5460,7 @@ static BOOL hb_cdxDBOISkipEval( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
             SELF_SKIPFILTER( ( AREAP ) pArea, 1 );
             if( pArea->dbfarea.ulRecNo == ulRecNo || hb_cdxEvalSeekCond( pTag, pEval ) )
             {
-               fFound = TRUE;
+               fFound = HB_TRUE;
                break;
             }
          }
@@ -5483,7 +5483,7 @@ static BOOL hb_cdxDBOISkipEval( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
             SELF_SKIPFILTER( ( AREAP ) pArea, -1 );
             if( pArea->dbfarea.ulRecNo == ulRecNo || hb_cdxEvalSeekCond( pTag, pEval ) )
             {
-               fFound = TRUE;
+               fFound = HB_TRUE;
                break;
             }
          }
@@ -5492,27 +5492,27 @@ static BOOL hb_cdxDBOISkipEval( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
       if( !fFound )
       {
          SELF_GOTOP( ( AREAP ) pArea );
-         pArea->dbfarea.area.fBof = TRUE;
+         pArea->dbfarea.area.fBof = HB_TRUE;
       }
    }
    hb_cdxIndexUnLockRead( pTag->pIndex );
 
    /* Update Bof and Eof flags */
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
    return fFound;
 }
 
 /*
- * skip while comparison with given pattern with wildcards doesn't return TRUE
+ * skip while comparison with given pattern with wildcards doesn't return HB_TRUE
  */
-static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
-                                PHB_ITEM pWildItm )
+static HB_BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fForward,
+                                   PHB_ITEM pWildItm )
 {
-   BOOL fFound = FALSE, fFirst = TRUE;
+   HB_BOOL fFound = HB_FALSE, fFirst = HB_TRUE;
    const char *szPattern;
    char *szFree = NULL;
    int iFixed = 0, iStop;
@@ -5520,14 +5520,14 @@ static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxDBOISkipWild(%p, %p, %i, %p)", pArea, pTag, fForward, pWildItm));
 
    if( FAST_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE )
-      return FALSE;
+      return HB_FALSE;
 
    szPattern = hb_itemGetCPtr( pWildItm );
 
    if( ! pTag || pTag->uiType != 'C' || !szPattern || !*szPattern )
    {
       if( SELF_SKIP( ( AREAP ) pArea, fForward ? 1 : -1 ) == HB_FAILURE )
-         return FALSE;
+         return HB_FALSE;
       return fForward ? pArea->dbfarea.fPositioned : !pArea->dbfarea.area.fBof;
    }
 
@@ -5546,7 +5546,7 @@ static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
-   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
    hb_cdxIndexLockRead( pTag->pIndex );
    hb_cdxTagRefreshScope( pTag );
@@ -5555,7 +5555,7 @@ static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
       if( !pTag->TagEOF && pTag->CurKey->rec != 0 &&
            ( fForward ? pTag->UsrAscend : !pTag->UsrAscend ) &&
            hb_cdxTopScope( pTag ) && hb_cdxBottomScope( pTag ) )
-         fFirst = FALSE;
+         fFirst = HB_FALSE;
    }
 
    iStop = pTag->UsrAscend ? -1 : 1;
@@ -5575,12 +5575,12 @@ static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
       if( !hb_cdxTagKeyFind( pTag, pKey ) )
       {
          if( fForward )
-            pTag->TagEOF = TRUE;
+            pTag->TagEOF = HB_TRUE;
          else
-            pTag->TagBOF = TRUE;
+            pTag->TagBOF = HB_TRUE;
       }
       hb_cdxKeyFree( pKey );
-      fFirst = FALSE;
+      fFirst = HB_FALSE;
    }
 
    if( fForward )
@@ -5598,7 +5598,7 @@ static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
             if( pArea->dbfarea.ulRecNo == ulRecNo ||
                 hb_strMatchWild( (const char *) pTag->CurKey->val, szPattern ) )
             {
-               fFound = TRUE;
+               fFound = HB_TRUE;
                break;
             }
          }
@@ -5628,7 +5628,7 @@ static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
             if( pArea->dbfarea.ulRecNo == ulRecNo ||
                 hb_strMatchWild( (const char *) pTag->CurKey->val, szPattern ) )
             {
-               fFound = TRUE;
+               fFound = HB_TRUE;
                break;
             }
          }
@@ -5643,16 +5643,16 @@ static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
       if( !fFound )
       {
          SELF_GOTOP( ( AREAP ) pArea );
-         pArea->dbfarea.area.fBof = TRUE;
+         pArea->dbfarea.area.fBof = HB_TRUE;
       }
    }
    hb_cdxIndexUnLockRead( pTag->pIndex );
 
    /* Update Bof and Eof flags */
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
    if( szFree )
       hb_xfree( szFree );
@@ -5660,7 +5660,7 @@ static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
    return fFound;
 }
 
-static BOOL hb_cdxRegexMatch( CDXAREAP pArea, PHB_REGEX pRegEx, LPCDXKEY pKey )
+static HB_BOOL hb_cdxRegexMatch( CDXAREAP pArea, PHB_REGEX pRegEx, LPCDXKEY pKey )
 {
    char * szKey = ( char * ) pKey->val;
    char szBuff[ CDX_MAXKEY + 1 ];
@@ -5672,34 +5672,34 @@ static BOOL hb_cdxRegexMatch( CDXAREAP pArea, PHB_REGEX pRegEx, LPCDXKEY pKey )
       szKey = szBuff;
    }
 
-   return hb_regexMatch( pRegEx, szKey, pKey->len, FALSE );
+   return hb_regexMatch( pRegEx, szKey, pKey->len, HB_FALSE );
 }
 
 /*
- * skip while regular expression on index key val doesn't return TRUE
+ * skip while regular expression on index key val doesn't return HB_TRUE
  */
-static BOOL hb_cdxDBOISkipRegEx( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
-                                 PHB_ITEM pRegExItm )
+static HB_BOOL hb_cdxDBOISkipRegEx( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fForward,
+                                    PHB_ITEM pRegExItm )
 {
-   BOOL fFound = FALSE, fFirst = TRUE;
+   HB_BOOL fFound = HB_FALSE, fFirst = HB_TRUE;
    PHB_REGEX pRegEx;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxDBOISkipRegEx(%p, %p, %i, %p)", pArea, pTag, fForward, pRegExItm));
 
    if( FAST_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE )
-      return FALSE;
+      return HB_FALSE;
 
    if( !pTag || pTag->uiType != 'C' || ( pRegEx = hb_regexGet( pRegExItm, 0 ) ) == NULL )
    {
       if( SELF_SKIP( ( AREAP ) pArea, fForward ? 1 : -1 ) == HB_FAILURE )
-         return FALSE;
+         return HB_FALSE;
       return fForward ? pArea->dbfarea.fPositioned : !pArea->dbfarea.area.fBof;
    }
 
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
-   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
    hb_cdxIndexLockRead( pTag->pIndex );
    hb_cdxTagRefreshScope( pTag );
@@ -5708,7 +5708,7 @@ static BOOL hb_cdxDBOISkipRegEx( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
       if( !pTag->TagEOF && pTag->CurKey->rec != 0 &&
           ( fForward ? pTag->UsrAscend : !pTag->UsrAscend ) &&
           hb_cdxTopScope( pTag ) && hb_cdxBottomScope( pTag ) )
-         fFirst = FALSE;
+         fFirst = HB_FALSE;
    }
    if( fForward )
    {
@@ -5723,7 +5723,7 @@ static BOOL hb_cdxDBOISkipRegEx( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
             if( pArea->dbfarea.ulRecNo == ulRecNo ||
                 hb_cdxRegexMatch( pArea, pRegEx, pTag->CurKey ) )
             {
-               fFound = TRUE;
+               fFound = HB_TRUE;
                break;
             }
          }
@@ -5744,7 +5744,7 @@ static BOOL hb_cdxDBOISkipRegEx( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
             if( pArea->dbfarea.ulRecNo == ulRecNo ||
                 hb_cdxRegexMatch( pArea, pRegEx, pTag->CurKey ) )
             {
-               fFound = TRUE;
+               fFound = HB_TRUE;
                break;
             }
          }
@@ -5755,16 +5755,16 @@ static BOOL hb_cdxDBOISkipRegEx( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
       else
       {
          SELF_GOTOP( ( AREAP ) pArea );
-         pArea->dbfarea.area.fBof = TRUE;
+         pArea->dbfarea.area.fBof = HB_TRUE;
       }
    }
    hb_cdxIndexUnLockRead( pTag->pIndex );
 
    /* Update Bof and Eof flags */
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
    hb_regexFree( pRegEx );
 
@@ -5786,13 +5786,13 @@ static ULONG hb_cdxDBOIScopeEval( LPCDXTAG pTag, HB_EVALSCOPE_FUNC pFunc, void *
       pTag->topScopeKey = NULL;
    else
       pTag->topScopeKey = hb_cdxKeyPutItem( NULL, pItemLo, CDX_IGNORE_REC_NUM,
-                                            pTag, TRUE, CDX_CMP_PREFIX );
+                                            pTag, HB_TRUE, CDX_CMP_PREFIX );
 
    if( !pItemHi || HB_IS_NIL( pItemHi ) )
       pTag->bottomScopeKey = NULL;
    else
       pTag->bottomScopeKey = hb_cdxKeyPutItem( NULL, pItemHi, CDX_MAX_REC_NUM,
-                                               pTag, TRUE, CDX_CMP_PREFIX );
+                                               pTag, HB_TRUE, CDX_CMP_PREFIX );
 
    hb_cdxIndexLockRead( pTag->pIndex );
    hb_cdxTagGoTop( pTag );
@@ -5812,7 +5812,7 @@ static ULONG hb_cdxDBOIScopeEval( LPCDXTAG pTag, HB_EVALSCOPE_FUNC pFunc, void *
    pTag->bottomScopeKey = pBtmScopeKey;
    pTag->curKeyState &= ~( CDX_CURKEY_RAWPOS | CDX_CURKEY_LOGPOS );
 
-   pTag->fRePos = TRUE;
+   pTag->fRePos = HB_TRUE;
    hb_cdxKeyCopy( pTag->CurKey, pCurKey );
    hb_cdxKeyFree( pCurKey );
 
@@ -5822,14 +5822,14 @@ static ULONG hb_cdxDBOIScopeEval( LPCDXTAG pTag, HB_EVALSCOPE_FUNC pFunc, void *
 /*
  * return number of keys in order
  */
-static LONG hb_cdxDBOIKeyCount( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
+static LONG hb_cdxDBOIKeyCount( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fFilters )
 {
    ULONG ulKeyCount = 0;
-   BOOL fLogOpt = pArea->dbfarea.area.dbfi.itmCobExpr || !pArea->dbfarea.area.dbfi.fFilter;
+   HB_BOOL fLogOpt = pArea->dbfarea.area.dbfi.itmCobExpr || !pArea->dbfarea.area.dbfi.fFilter;
 
    if( pTag )
    {
-      BOOL fCheckFilter = ( fLogOpt && fFilters && pArea->dbfarea.area.dbfi.itmCobExpr );
+      HB_BOOL fCheckFilter = ( fLogOpt && fFilters && pArea->dbfarea.area.dbfi.itmCobExpr );
       ULONG ulRecNo = pArea->dbfarea.ulRecNo;
       LPCDXKEY pCurKey;
       hb_cdxIndexLockRead( pTag->pIndex );
@@ -5851,7 +5851,7 @@ static LONG hb_cdxDBOIKeyCount( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
                   ulKeyCount++;
                hb_cdxTagSkipNext( pTag );
             }
-            pTag->fRePos = TRUE;
+            pTag->fRePos = HB_TRUE;
             hb_cdxKeyCopy( pTag->CurKey, pCurKey );
             hb_cdxKeyFree( pCurKey );
             if( fCheckFilter )
@@ -5880,9 +5880,9 @@ static LONG hb_cdxDBOIKeyCount( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
                   ulKeyCount += pPage->iKeys;
                   pPage->Page = pPage->Right;
                }
-               hb_cdxPageFree( pPage, TRUE );
+               hb_cdxPageFree( pPage, HB_TRUE );
             }
-            pTag->fRePos = TRUE;
+            pTag->fRePos = HB_TRUE;
             hb_cdxKeyCopy( pTag->CurKey, pCurKey );
             hb_cdxKeyFree( pCurKey );
          }
@@ -5925,10 +5925,10 @@ static LONG hb_cdxDBOIKeyCount( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
 /*
  * return logical key position in order
  */
-static LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
+static LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fFilters )
 {
    ULONG ulKeyNo = 0;
-   BOOL fLogOpt = pArea->dbfarea.area.dbfi.itmCobExpr || !pArea->dbfarea.area.dbfi.fFilter;
+   HB_BOOL fLogOpt = pArea->dbfarea.area.dbfi.itmCobExpr || !pArea->dbfarea.area.dbfi.fFilter;
 
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
@@ -5937,7 +5937,7 @@ static LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
       ulKeyNo = 0;
    else if( pTag )
    {
-      BOOL fCheckFilter = ( fLogOpt && fFilters && pArea->dbfarea.area.dbfi.itmCobExpr );
+      HB_BOOL fCheckFilter = ( fLogOpt && fFilters && pArea->dbfarea.area.dbfi.itmCobExpr );
       ULONG ulRecNo = pArea->dbfarea.ulRecNo;
 
       hb_cdxIndexLockRead( pTag->pIndex );
@@ -5968,7 +5968,7 @@ static LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
                         ulKeyNo++;
                      hb_cdxTagSkipPrev( pTag );
                   }
-                  pTag->fRePos = TRUE;
+                  pTag->fRePos = HB_TRUE;
                   hb_cdxKeyCopy( pTag->CurKey, pCurKey );
                   hb_cdxKeyFree( pCurKey );
                   if( fCheckFilter )
@@ -5994,7 +5994,7 @@ static LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
                         ulKeyNo += pPage->iKeys;
                         pPage->Page = pPage->Left;
                      }
-                     hb_cdxPageFree( pPage, TRUE );
+                     hb_cdxPageFree( pPage, HB_TRUE );
                   }
                }
                else
@@ -6011,7 +6011,7 @@ static LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
                         ulKeyNo += pPage->iKeys;
                         pPage->Page = pPage->Right;
                      }
-                     hb_cdxPageFree( pPage, TRUE );
+                     hb_cdxPageFree( pPage, HB_TRUE );
                   }
                }
             }
@@ -6060,17 +6060,17 @@ static LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
 /*
  * DBOI_KEYGOTO goto specific logical record in the index file
  */
-static HB_ERRCODE hb_cdxDBOIKeyGoto( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulKeyNo, BOOL fFilters )
+static HB_ERRCODE hb_cdxDBOIKeyGoto( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulKeyNo, HB_BOOL fFilters )
 {
    HB_ERRCODE retval;
    ULONG ulKeyCnt = ulKeyNo;
-   BOOL fLogOpt = pArea->dbfarea.area.dbfi.itmCobExpr || !pArea->dbfarea.area.dbfi.fFilter;
+   HB_BOOL fLogOpt = pArea->dbfarea.area.dbfi.itmCobExpr || !pArea->dbfarea.area.dbfi.fFilter;
 
    if( ulKeyNo == 0 )
       retval = SELF_GOTO( ( AREAP ) pArea, 0 );
    else if( pTag )
    {
-      BOOL fCheckFilter = ( fLogOpt && fFilters && pArea->dbfarea.area.dbfi.itmCobExpr );
+      HB_BOOL fCheckFilter = ( fLogOpt && fFilters && pArea->dbfarea.area.dbfi.itmCobExpr );
       hb_cdxIndexLockRead( pTag->pIndex );
       hb_cdxTagRefreshScope( pTag );
       if( ! pArea->dbfarea.lpdbPendingRel && ( fFilters ?
@@ -6115,7 +6115,7 @@ static HB_ERRCODE hb_cdxDBOIKeyGoto( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulKeyN
             {
                ulKeyCnt -= pPage->iKeys;
                pOwnerPage->Child = hb_cdxPageNew( pPage->TagParent, pPage->Owner, ulNextPg );
-               hb_cdxPageFree( pPage, FALSE );
+               hb_cdxPageFree( pPage, HB_FALSE );
                pPage = pOwnerPage->Child;
             }
             if( (ULONG) pPage->iKeys >= ulKeyCnt )
@@ -6168,12 +6168,12 @@ static double hb_cdxCountRelKeyPos( LPCDXPAGE pPage )
             pPage->iCurKey ) / pPage->iKeys;
 }
 
-static BOOL hb_cdxGoToRelKeyPos( LPCDXPAGE pPage, double dPos )
+static HB_BOOL hb_cdxGoToRelKeyPos( LPCDXPAGE pPage, double dPos )
 {
    do
    {
       if( pPage->iKeys == 0 )
-         return FALSE;
+         return HB_FALSE;
 
       pPage->iCurKey = ( int ) ( dPos * pPage->iKeys );
       if( pPage->iCurKey >= pPage->iKeys )
@@ -6193,7 +6193,7 @@ static BOOL hb_cdxGoToRelKeyPos( LPCDXPAGE pPage, double dPos )
    }
    while( pPage );
 
-   return TRUE;
+   return HB_TRUE;
 }
 
 static double hb_cdxDBOIGetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag )
@@ -6219,7 +6219,7 @@ static double hb_cdxDBOIGetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag )
    {
       LPCDXKEY pKey;
       double dStart, dStop, dFact = 0.0000000000001;
-      BOOL fOK = TRUE;
+      HB_BOOL fOK = HB_TRUE;
 
       if( pTag->UsrAscend )
       {
@@ -6240,7 +6240,7 @@ static double hb_cdxDBOIGetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag )
       {
          hb_cdxTagKeyFind( pTag, pKey );
          if( pTag->CurKey->rec == 0 || pTag->TagEOF || ! hb_cdxBottomScope( pTag ) )
-            fOK = FALSE;
+            fOK = HB_FALSE;
          else
             dStart = hb_cdxCountRelKeyPos( pTag->RootPage );
       }
@@ -6249,7 +6249,7 @@ static double hb_cdxDBOIGetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag )
       {
          hb_cdxTagKeyFind( pTag, pKey );
          if( pTag->CurKey->rec == 0 || pTag->TagBOF || ! hb_cdxTopScope( pTag ) )
-            fOK = FALSE;
+            fOK = HB_FALSE;
          else
             dStop = hb_cdxCountRelKeyPos( pTag->RootPage );
       }
@@ -6261,7 +6261,7 @@ static double hb_cdxDBOIGetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag )
             dStart = dStop;
             dStop = dTmp;
          }
-         pTag->fRePos = TRUE;
+         pTag->fRePos = HB_TRUE;
          if( hb_cdxCurKeyRefresh( pArea, pTag ) &&
              hb_cdxTopScope( pTag ) && hb_cdxBottomScope( pTag ) )
          {
@@ -6314,17 +6314,17 @@ static void hb_cdxDBOISetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag, double dPos )
    }
    else
    {
-      BOOL fForward = TRUE, fOK = TRUE, fTop = FALSE;
+      HB_BOOL fForward = HB_TRUE, fOK = HB_TRUE, fTop = HB_FALSE;
       hb_cdxIndexLockRead( pTag->pIndex );
       hb_cdxTagRefreshScope( pTag );
 
       if( dPos >= 1.0 )
       {
-         fForward = FALSE;
+         fForward = HB_FALSE;
       }
       else if( dPos <= 0.0 )
       {
-         fTop = TRUE;
+         fTop = HB_TRUE;
       }
       else
       {
@@ -6347,7 +6347,7 @@ static void hb_cdxDBOISetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag, double dPos )
          {
             hb_cdxTagKeyFind( pTag, pKey );
             if( pTag->CurKey->rec == 0 || pTag->TagEOF || ! hb_cdxBottomScope( pTag ) )
-               fOK = FALSE;
+               fOK = HB_FALSE;
             else
                dStart = hb_cdxCountRelKeyPos( pTag->RootPage );
          }
@@ -6356,7 +6356,7 @@ static void hb_cdxDBOISetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag, double dPos )
          {
             hb_cdxTagKeyFind( pTag, pKey );
             if( pTag->CurKey->rec == 0 || pTag->TagBOF || ! hb_cdxTopScope( pTag ) )
-               fOK = FALSE;
+               fOK = HB_FALSE;
             else
                dStop = hb_cdxCountRelKeyPos( pTag->RootPage );
          }
@@ -6371,25 +6371,25 @@ static void hb_cdxDBOISetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag, double dPos )
             }
             if( dStart >= dStop - dFact )
             {
-               fTop = TRUE;
+               fTop = HB_TRUE;
             }
             else
             {
                dPos = dPos * ( dStop - dStart ) + dStart;
-               pTag->fRePos = FALSE;
+               pTag->fRePos = HB_FALSE;
                hb_cdxTagOpen( pTag );
-               pTag->TagBOF = pTag->TagEOF = FALSE;
+               pTag->TagBOF = pTag->TagEOF = HB_FALSE;
                if( !hb_cdxGoToRelKeyPos( pTag->RootPage, dPos ) )
                {
-                  fTop = TRUE;
+                  fTop = HB_TRUE;
                }
                else
                {
                   hb_cdxSetCurKey( pTag->RootPage );
                   if( !hb_cdxTopScope( pTag ) )
-                     fTop = TRUE;
+                     fTop = HB_TRUE;
                   else if( !hb_cdxBottomScope( pTag ) )
-                     fForward = FALSE;
+                     fForward = HB_FALSE;
                }
             }
          }
@@ -6411,7 +6411,7 @@ static void hb_cdxDBOISetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag, double dPos )
                hb_cdxTagSkipNext( pTag );
             }
             if( pTag->TagEOF && !fTop )
-               fForward = FALSE;
+               fForward = HB_FALSE;
          }
          if( !fForward )
          {
@@ -6438,9 +6438,9 @@ static void hb_cdxDBOISetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag, double dPos )
  * custom indexes when the same record can be stored more then once
  * or when the used index key is unknown
  */
-static BOOL hb_cdxDBOIFindRec( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulRecNo, BOOL fCont )
+static HB_BOOL hb_cdxDBOIFindRec( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulRecNo, HB_BOOL fCont )
 {
-   BOOL fFound = FALSE;
+   HB_BOOL fFound = HB_FALSE;
 
    if( pTag && ulRecNo )
    {
@@ -6466,7 +6466,7 @@ static BOOL hb_cdxDBOIFindRec( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulRecNo, BOO
          {
             if( pTag->CurKey->rec == ulRecNo )
             {
-               fFound = TRUE;
+               fFound = HB_TRUE;
                break;
             }
             hb_cdxTagSkipNext( pTag );
@@ -6526,8 +6526,8 @@ static HB_ERRCODE hb_cdxGoBottom( CDXAREAP pArea )
 
    hb_cdxTagGoBottom( pTag );
 
-   pArea->dbfarea.area.fTop = FALSE;
-   pArea->dbfarea.area.fBottom = TRUE;
+   pArea->dbfarea.area.fTop = HB_FALSE;
+   pArea->dbfarea.area.fBottom = HB_TRUE;
 
    retval = SELF_GOTO( ( AREAP ) pArea, pTag->CurKey->rec );
 
@@ -6572,8 +6572,8 @@ static HB_ERRCODE hb_cdxGoTop( CDXAREAP pArea )
 
    hb_cdxTagGoTop( pTag );
 
-   pArea->dbfarea.area.fTop = TRUE;
-   pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = HB_TRUE;
+   pArea->dbfarea.area.fBottom = HB_FALSE;
 
    retval = SELF_GOTO( ( AREAP ) pArea, pTag->CurKey->rec );
 
@@ -6591,7 +6591,7 @@ static HB_ERRCODE hb_cdxGoTop( CDXAREAP pArea )
 }
 
 /* ( DBENTRYP_BIB )   hb_cdxSeek */
-static HB_ERRCODE hb_cdxSeek( CDXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pKeyItm, BOOL fFindLast )
+static HB_ERRCODE hb_cdxSeek( CDXAREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pKeyItm, HB_BOOL fFindLast )
 {
    LPCDXTAG pTag;
 
@@ -6611,14 +6611,14 @@ static HB_ERRCODE hb_cdxSeek( CDXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pKeyItm,
    {
       LPCDXKEY pKey;
       HB_ERRCODE retval = HB_SUCCESS;
-      BOOL  fEOF = FALSE, fLast;
+      HB_BOOL  fEOF = HB_FALSE, fLast;
       ULONG ulRec;
 
       if( pArea->dbfarea.lpdbPendingRel && pArea->dbfarea.lpdbPendingRel->isScoped )
          SELF_FORCEREL( ( AREAP ) pArea );
 
-      pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
       if( pTag->UsrUnique )
          fLast = !pTag->UsrAscend;
@@ -6628,22 +6628,22 @@ static HB_ERRCODE hb_cdxSeek( CDXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pKeyItm,
       /* TODO: runtime error if valtype(pKeyItm) != pTag->Type */
       pKey = hb_cdxKeyPutItem( NULL, pKeyItm,
                                fLast ? CDX_MAX_REC_NUM : CDX_IGNORE_REC_NUM,
-                               pTag, TRUE, CDX_CMP_PREFIX );
+                               pTag, HB_TRUE, CDX_CMP_PREFIX );
 
       hb_cdxIndexLockRead( pTag->pIndex );
       hb_cdxTagRefreshScope( pTag );
       ulRec = hb_cdxTagKeyFind( pTag, pKey );
       if( ( ulRec == 0 && ! fSoftSeek ) || pTag->TagEOF )
-         fEOF = TRUE;
+         fEOF = HB_TRUE;
       else /* if( fSoftSeek ) */
       {
          if( ! hb_cdxBottomScope( pTag ) )
-            fEOF = TRUE;
+            fEOF = HB_TRUE;
          else if( ! hb_cdxTopScope( pTag ) )
          {
             hb_cdxTagGoTop( pTag );
             if( pTag->CurKey->rec == 0 )
-               fEOF = TRUE;
+               fEOF = HB_TRUE;
          }
       }
       hb_cdxIndexUnLockRead( pTag->pIndex );
@@ -6660,7 +6660,7 @@ static HB_ERRCODE hb_cdxSeek( CDXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pKeyItm,
                                           pTag->CurKey->val, pTag->CurKey->len,
                                           pKey->mode ) == 0 );
                if( ! pArea->dbfarea.area.fFound && ! fSoftSeek )
-                  fEOF = TRUE;
+                  fEOF = HB_TRUE;
             }
          }
       }
@@ -6670,7 +6670,7 @@ static HB_ERRCODE hb_cdxSeek( CDXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pKeyItm,
       {
          retval = SELF_GOTO( ( AREAP ) pArea, 0 );
       }
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
       hb_cdxKeyFree( pKey );
       return retval;
    }
@@ -6691,7 +6691,7 @@ static BYTE * hb_cdxPageGetKeyValActual( LPCDXPAGE pPage )
 /*
  * compare two values using Tag conditions (len & type)
  */
-static int hb_cdxValCompareWild( BYTE * val1, BYTE * val2, BOOL fExact )
+static int hb_cdxValCompareWild( BYTE * val1, BYTE * val2, HB_BOOL fExact )
 {
    return ( ( fExact ) ? hb_strMatchWildExact( (const char *) val2, (const char *) val1 ) : hb_strMatchWild( (const char *) val2, (const char *) val1 ) ) ? 0: 1;
 }
@@ -6699,7 +6699,7 @@ static int hb_cdxValCompareWild( BYTE * val1, BYTE * val2, BOOL fExact )
 /*
  * seek given Key in the Page or in its children
  */
-static int hb_cdxPageSeekKeyWild( LPCDXPAGE pPage, LPCDXKEY pKey, ULONG ulKeyRec, BOOL fExact, BOOL fNext  )
+static int hb_cdxPageSeekKeyWild( LPCDXPAGE pPage, LPCDXKEY pKey, ULONG ulKeyRec, HB_BOOL fExact, HB_BOOL fNext  )
 {
     int k;
 
@@ -6737,23 +6737,23 @@ static int hb_cdxPageSeekKeyWild( LPCDXPAGE pPage, LPCDXKEY pKey, ULONG ulKeyRec
 /*
  * find pKey in pTag return 0 or TagNO
  */
-static ULONG hb_cdxTagKeyFindWild( LPCDXTAG pTag, LPCDXKEY pKey, BOOL fNext )
+static ULONG hb_cdxTagKeyFindWild( LPCDXTAG pTag, LPCDXKEY pKey, HB_BOOL fNext )
 {
    int K;
    ULONG ulKeyRec = pKey->rec;
 
-   pTag->fRePos = FALSE;
+   pTag->fRePos = HB_FALSE;
    hb_cdxTagOpen( pTag );
 
-   pTag->TagBOF = pTag->TagEOF = FALSE;
-   K = hb_cdxPageSeekKeyWild( pTag->RootPage, pKey, ulKeyRec, FALSE, fNext );
+   pTag->TagBOF = pTag->TagEOF = HB_FALSE;
+   K = hb_cdxPageSeekKeyWild( pTag->RootPage, pKey, ulKeyRec, HB_FALSE, fNext );
    if( ulKeyRec == CDX_MAX_REC_NUM )
       K = - K;
 
    if( K > 0 )
    {
       pTag->CurKey->rec = 0;
-      pTag->TagEOF = TRUE;
+      pTag->TagEOF = HB_TRUE;
    }
    else
    {
@@ -6766,7 +6766,7 @@ static ULONG hb_cdxTagKeyFindWild( LPCDXTAG pTag, LPCDXKEY pKey, BOOL fNext )
 
 
 /* hb_cdxSeekWild */
-static HB_ERRCODE hb_cdxSeekWild( CDXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pKeyItm, BOOL fFindLast, BOOL fNext, BOOL bAll )
+static HB_ERRCODE hb_cdxSeekWild( CDXAREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pKeyItm, HB_BOOL fFindLast, HB_BOOL fNext, HB_BOOL bAll )
 {
    LPCDXTAG pTag;
 
@@ -6786,14 +6786,14 @@ static HB_ERRCODE hb_cdxSeekWild( CDXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pKeyI
    {
       LPCDXKEY pKey;
       HB_ERRCODE retval = HB_SUCCESS;
-      BOOL  fEOF = FALSE, fLast;
+      HB_BOOL  fEOF = HB_FALSE, fLast;
       ULONG ulRec;
 
       if( ! bAll && pArea->dbfarea.lpdbPendingRel && pArea->dbfarea.lpdbPendingRel->isScoped )
          SELF_FORCEREL( ( AREAP ) pArea );
 
-      pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
       if( pTag->UsrUnique )
          fLast = !pTag->UsrAscend;
@@ -6801,22 +6801,22 @@ static HB_ERRCODE hb_cdxSeekWild( CDXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pKeyI
          fLast = pTag->UsrAscend ? fFindLast : !fFindLast;
 
       /* TODO: runtime error if valtype(pKeyItm) != pTag->Type */
-      pKey = hb_cdxKeyPutItem( NULL, pKeyItm, fLast ? CDX_MAX_REC_NUM : CDX_IGNORE_REC_NUM, pTag, TRUE, FALSE );
+      pKey = hb_cdxKeyPutItem( NULL, pKeyItm, fLast ? CDX_MAX_REC_NUM : CDX_IGNORE_REC_NUM, pTag, HB_TRUE, HB_FALSE );
 
       hb_cdxIndexLockRead( pTag->pIndex );
       hb_cdxTagRefreshScope( pTag );
       ulRec = hb_cdxTagKeyFindWild( pTag, pKey, fNext );
       if( ( ulRec == 0 && ! fSoftSeek ) || pTag->TagEOF )
-         fEOF = TRUE;
+         fEOF = HB_TRUE;
       else /* if( fSoftSeek ) */
       {
          if( ! hb_cdxBottomScope( pTag ) )
-            fEOF = TRUE;
+            fEOF = HB_TRUE;
          else if( ! hb_cdxTopScope( pTag ) )
          {
             hb_cdxTagGoTop( pTag );
             if( pTag->CurKey->rec == 0 )
-               fEOF = TRUE;
+               fEOF = HB_TRUE;
          }
       }
       hb_cdxIndexUnLockRead( pTag->pIndex );
@@ -6829,9 +6829,9 @@ static HB_ERRCODE hb_cdxSeekWild( CDXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pKeyI
             if( retval != HB_FAILURE && ulRec && pArea->dbfarea.fPositioned )
             {
                pArea->dbfarea.area.fFound = ( ulRec == pArea->dbfarea.ulRecNo ||
-                        hb_cdxValCompareWild( pKey->val, pTag->CurKey->val, FALSE ) == 0 );
+                        hb_cdxValCompareWild( pKey->val, pTag->CurKey->val, HB_FALSE ) == 0 );
                if( ! pArea->dbfarea.area.fFound && ! fSoftSeek )
-                  fEOF = TRUE;
+                  fEOF = HB_TRUE;
             }
          }
       }
@@ -6841,7 +6841,7 @@ static HB_ERRCODE hb_cdxSeekWild( CDXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pKeyI
       {
          retval = SELF_GOTO( ( AREAP ) pArea, 0 );
       }
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
       hb_cdxKeyFree( pKey );
       return retval;
    }
@@ -6849,7 +6849,7 @@ static HB_ERRCODE hb_cdxSeekWild( CDXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pKeyI
 
 HB_FUNC( BM_TURBO )
 {
-    bTurbo = HB_ISLOG( 1 ) ? hb_parl( 1 ) : FALSE;
+    bTurbo = HB_ISLOG( 1 ) ? hb_parl( 1 ) : HB_FALSE;
     hb_retl( bTurbo );
 }
 
@@ -6896,8 +6896,8 @@ HB_FUNC( BM_DBSETFILTERARRAY )
             if( SELF_CLEARFILTER( pArea ) != HB_SUCCESS )
                return;
 
-            pArea->dbfi.fOptimized = TRUE;
-            pArea->dbfi.fFilter = TRUE;
+            pArea->dbfi.fOptimized = HB_TRUE;
+            pArea->dbfi.fFilter = HB_TRUE;
 
             SELF_RECCOUNT( ( AREAP ) pArea, &ulRecCount );
             pArea->dbfi.lpvCargo = hb_xgrab( sizeof( BM_FILTER ) );
@@ -6985,7 +6985,7 @@ HB_FUNC( BM_DBSETFILTERARRAYDEL )
 HB_FUNC( BM_DBSEEKWILD )
 {
     PHB_ITEM pKey;
-    BOOL bAll, bNext, bSoftSeek, bFindLast, fFound;
+    HB_BOOL bAll, bNext, bSoftSeek, bFindLast, fFound;
     AREAP pArea = (AREAP) hb_rddGetCurrentWorkAreaPointer();
 
     if( pArea )
@@ -6993,21 +6993,21 @@ HB_FUNC( BM_DBSEEKWILD )
        if( ! HB_ISNIL( 1 ) )
        {
           pKey = hb_param( 1, HB_IT_ANY );
-          bSoftSeek = HB_ISLOG( 2 ) ? (BOOL) hb_parl( 2 ) : hb_setGetSoftSeek();
-          bFindLast = HB_ISLOG( 3 ) ? hb_parl( 3 ) : FALSE;
-          bNext     = HB_ISLOG( 4 ) ? hb_parl( 4 ) : FALSE;
-          bAll      = HB_ISLOG( 5 ) ? hb_parl( 5 ) : FALSE;
+          bSoftSeek = HB_ISLOG( 2 ) ? ( HB_BOOL ) hb_parl( 2 ) : hb_setGetSoftSeek();
+          bFindLast = hb_parl( 3 );
+          bNext     = hb_parl( 4 );
+          bAll      = hb_parl( 5 );
           if( bAll)
           {
              PHB_ITEM pList = hb_itemArrayNew( 0 );
              SELF_GOTOP( ( AREAP ) pArea );
-             if( hb_cdxSeekWild( (CDXAREAP) pArea, bSoftSeek, pKey, bFindLast, FALSE, bAll ) == HB_SUCCESS &&
-                     pArea->fEof == FALSE &&
+             if( hb_cdxSeekWild( (CDXAREAP) pArea, bSoftSeek, pKey, bFindLast, HB_FALSE, bAll ) == HB_SUCCESS &&
+                     pArea->fEof == HB_FALSE &&
                      SELF_FOUND( pArea, &fFound ) == HB_SUCCESS )
              {
                  hb_arrayAddForward( pList, hb_itemPutNL( NULL, ((CDXAREAP) pArea)->dbfarea.ulRecNo ) );
-                 while( hb_cdxSeekWild( (CDXAREAP) pArea, bSoftSeek, pKey, bFindLast, TRUE, bAll ) == HB_SUCCESS &&
-                         pArea->fEof == FALSE &&
+                 while( hb_cdxSeekWild( (CDXAREAP) pArea, bSoftSeek, pKey, bFindLast, HB_TRUE, bAll ) == HB_SUCCESS &&
+                         pArea->fEof == HB_FALSE &&
                          SELF_FOUND( pArea, &fFound ) == HB_SUCCESS )
                  {
                      hb_arrayAdd( pList, hb_itemPutNL( NULL, ((CDXAREAP) pArea)->dbfarea.ulRecNo ) );
@@ -7032,7 +7032,7 @@ HB_FUNC( BM_DBSEEKWILD )
     else
        hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
 
-    hb_retl( FALSE );
+    hb_retl( HB_FALSE );
 }
 
 #endif
@@ -7106,7 +7106,7 @@ static HB_ERRCODE hb_cdxSkip( CDXAREAP pArea, LONG lToSkip )
  */
 static HB_ERRCODE hb_cdxSkipFilter( CDXAREAP pArea, LONG lUpDown )
 {
-   BOOL fBottom, fDeleted;
+   HB_BOOL fBottom, fDeleted;
    HB_ERRCODE uiError;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxSkipFilter(%p, %ld)", pArea, lUpDown));
@@ -7180,7 +7180,7 @@ static HB_ERRCODE hb_cdxSkipFilter( CDXAREAP pArea, LONG lUpDown )
       else
       {
          uiError = SELF_GOTOP( (AREAP) pArea );
-         pArea->dbfarea.area.fBof = TRUE;
+         pArea->dbfarea.area.fBof = HB_TRUE;
       }
    }
    else
@@ -7196,7 +7196,7 @@ static HB_ERRCODE hb_cdxSkipRaw( CDXAREAP pArea, LONG lToSkip )
 {
    LPCDXTAG pTag;
    HB_ERRCODE retval;
-   BOOL fOut = FALSE, fForward;
+   HB_BOOL fOut = HB_FALSE, fForward;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxSkipRaw(%p, %ld)", pArea, lToSkip));
 
@@ -7220,14 +7220,14 @@ static HB_ERRCODE hb_cdxSkipRaw( CDXAREAP pArea, LONG lToSkip )
       if( fForward )
       {
          if( pTag->TagEOF || !hb_cdxBottomScope( pTag ) )
-            fOut = TRUE;
+            fOut = HB_TRUE;
          else if( pTag->UsrAscend && hb_cdxTopScope( pTag ) )
             lToSkip--;
       }
       else if( pArea->dbfarea.fPositioned )
       {
          if( pTag->TagEOF || !hb_cdxTopScope( pTag ) )
-            fOut = TRUE;
+            fOut = HB_TRUE;
          else if( !pTag->UsrAscend && hb_cdxBottomScope( pTag ) )
             lToSkip++;
       }
@@ -7241,7 +7241,7 @@ static HB_ERRCODE hb_cdxSkipRaw( CDXAREAP pArea, LONG lToSkip )
             hb_cdxTagSkipNext( pTag );
             if( pTag->TagEOF )
             {
-               fOut = TRUE;
+               fOut = HB_TRUE;
                break;
             }
          }
@@ -7260,7 +7260,7 @@ static HB_ERRCODE hb_cdxSkipRaw( CDXAREAP pArea, LONG lToSkip )
             hb_cdxTagSkipPrev( pTag );
             if( pTag->TagBOF )
             {
-               fOut = TRUE;
+               fOut = HB_TRUE;
                break;
             }
          }
@@ -7272,16 +7272,16 @@ static HB_ERRCODE hb_cdxSkipRaw( CDXAREAP pArea, LONG lToSkip )
    /* Update Bof and Eof flags */
    /*
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
    */
    return retval;
 }
 
 /* ( DBENTRYP_VF )    hb_cdxAddField        : NULL */
 /* ( DBENTRYP_B )     hb_cdxAppend */
-static HB_ERRCODE hb_cdxAppend( CDXAREAP pArea, BOOL bUnLockAll )
+static HB_ERRCODE hb_cdxAppend( CDXAREAP pArea, HB_BOOL bUnLockAll )
 {
     if( SUPER_APPEND( (AREAP) pArea, bUnLockAll ) == HB_SUCCESS )
     {
@@ -7297,7 +7297,7 @@ static HB_ERRCODE hb_cdxAppend( CDXAREAP pArea, BOOL bUnLockAll )
                 ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->rmap = (ULONG *) hb_xrealloc( ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->rmap, bytes << 2 );
                 ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->Size = ulRecCount;
             }
-            pArea->dbfarea.area.dbfi.fFilter = FALSE;
+            pArea->dbfarea.area.dbfi.fFilter = HB_FALSE;
             if( hb_cdxCheckRecordFilter( pArea, ulRecCount ) )
             {
                 LPCDXTAG pTag;
@@ -7308,7 +7308,7 @@ static HB_ERRCODE hb_cdxAppend( CDXAREAP pArea, BOOL bUnLockAll )
             }
             else
                 BM_ClrBit( ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->rmap, ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->Size, ulRecCount );
-            pArea->dbfarea.area.dbfi.fFilter = TRUE;
+            pArea->dbfarea.area.dbfi.fFilter = HB_TRUE;
         }
         return HB_SUCCESS;
     }
@@ -7323,7 +7323,7 @@ static HB_ERRCODE hb_cdxDeleteRec( CDXAREAP pArea )
     {
         if( pArea->dbfarea.area.dbfi.fFilter && pArea->dbfarea.area.dbfi.fOptimized )
         {
-            pArea->dbfarea.area.dbfi.fFilter = FALSE;
+            pArea->dbfarea.area.dbfi.fFilter = HB_FALSE;
             if( hb_cdxCheckRecordFilter( pArea, pArea->dbfarea.ulRecNo ) )
             {
                 if( ! BM_GetBit( ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->rmap, ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->Size, pArea->dbfarea.ulRecNo ) )
@@ -7346,7 +7346,7 @@ static HB_ERRCODE hb_cdxDeleteRec( CDXAREAP pArea )
                         CURKEY_SETLOGCNT( pTag, (pTag)->logKeyCount - 1 )
                 }
             }
-            pArea->dbfarea.area.dbfi.fFilter = TRUE;
+            pArea->dbfarea.area.dbfi.fFilter = HB_TRUE;
         }
         return HB_SUCCESS;
     }
@@ -7384,7 +7384,7 @@ static HB_ERRCODE hb_cdxFlush( CDXAREAP pArea )
          if( pIndex->pFile && pIndex->fFlush )
          {
             hb_fileCommit( pIndex->pFile );
-            pIndex->fFlush = FALSE;
+            pIndex->fFlush = HB_FALSE;
          }
          pIndex = pIndex->pNext;
       }
@@ -7403,8 +7403,8 @@ static HB_ERRCODE hb_cdxFlush( CDXAREAP pArea )
  */
 static HB_ERRCODE hb_cdxGoCold( CDXAREAP pArea )
 {
-   BOOL fRecordChanged = pArea->dbfarea.fRecordChanged;
-   BOOL fAppend = pArea->dbfarea.fAppend;
+   HB_BOOL fRecordChanged = pArea->dbfarea.fRecordChanged;
+   HB_BOOL fAppend = pArea->dbfarea.fAppend;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxGoCold(%p)", pArea));
 
@@ -7415,7 +7415,7 @@ static HB_ERRCODE hb_cdxGoCold( CDXAREAP pArea )
    {
       LPCDXTAG pTag = pArea->lpIndexes->TagList;
       LPCDXKEY pKey = NULL;
-      BOOL fAdd, fDel, fLck = FALSE;
+      HB_BOOL fAdd, fDel, fLck = HB_FALSE;
       LPDBRELINFO lpdbPendingRel;
 
       if( pArea->dbfarea.fShared )
@@ -7424,13 +7424,13 @@ static HB_ERRCODE hb_cdxGoCold( CDXAREAP pArea )
          {
             if( pArea->fCdxAppend )
                hb_cdxErrInternal( "hb_cdxGoCold: multiple appending without GOCOLD." );
-            pArea->fCdxAppend = TRUE;
+            pArea->fCdxAppend = HB_TRUE;
             return HB_SUCCESS;
          }
          else
          {
             fAppend = pArea->fCdxAppend;
-            pArea->fCdxAppend = FALSE;
+            pArea->fCdxAppend = HB_FALSE;
          }
       }
 
@@ -7457,12 +7457,12 @@ static HB_ERRCODE hb_cdxGoCold( CDXAREAP pArea )
             pKey = hb_cdxKeyEval( pKey, pTag );
 
             if( pTag->pForItem != NULL )
-               fAdd = hb_cdxEvalCond( pArea, pTag->pForItem, TRUE );
+               fAdd = hb_cdxEvalCond( pArea, pTag->pForItem, HB_TRUE );
             else
-               fAdd = TRUE;
+               fAdd = HB_TRUE;
 
             if( fAppend )
-               fDel = FALSE;
+               fDel = HB_FALSE;
             else
             {
                if( hb_cdxValCompare( pTag, pKey->val, pKey->len,
@@ -7482,7 +7482,7 @@ static HB_ERRCODE hb_cdxGoCold( CDXAREAP pArea )
                if( !fLck )
                {
                   hb_cdxIndexLockWrite( pTag->pIndex );
-                  fLck = TRUE;
+                  fLck = HB_TRUE;
                }
                if( fDel )
                   hb_cdxTagKeyDel( pTag, pTag->HotKey );
@@ -7497,7 +7497,7 @@ static HB_ERRCODE hb_cdxGoCold( CDXAREAP pArea )
             if( fLck )
             {
                hb_cdxIndexUnLockWrite( pTag->pIndex );
-               fLck = FALSE;
+               fLck = HB_FALSE;
             }
             if( pTag->pIndex->pNext )
                pTag = pTag->pIndex->pNext->TagList;
@@ -7539,7 +7539,7 @@ static HB_ERRCODE hb_cdxGoHot( CDXAREAP pArea )
          if( !pTag->Custom )
          {
             pTag->HotKey = hb_cdxKeyEval( pTag->HotKey, pTag );
-            pTag->HotFor = pTag->pForItem == NULL || hb_cdxEvalCond( pArea, pTag->pForItem, TRUE );
+            pTag->HotFor = pTag->pForItem == NULL || hb_cdxEvalCond( pArea, pTag->pForItem, HB_TRUE );
          }
 
          if( pTag->pNext )
@@ -7563,7 +7563,7 @@ static HB_ERRCODE hb_cdxPutRec( CDXAREAP pArea, BYTE * pBuffer )
     {
         if( pArea->dbfarea.area.dbfi.fFilter && pArea->dbfarea.area.dbfi.fOptimized )
         {
-            pArea->dbfarea.area.dbfi.fFilter = FALSE;
+            pArea->dbfarea.area.dbfi.fFilter = HB_FALSE;
 
             if( hb_cdxCheckRecordFilter( pArea, pArea->dbfarea.ulRecNo ) )
             {
@@ -7587,7 +7587,7 @@ static HB_ERRCODE hb_cdxPutRec( CDXAREAP pArea, BYTE * pBuffer )
                         CURKEY_SETLOGCNT( pTag, pTag->logKeyCount - 1 )
                 }
             }
-            pArea->dbfarea.area.dbfi.fFilter = TRUE;
+            pArea->dbfarea.area.dbfi.fFilter = HB_TRUE;
         }
         return HB_SUCCESS;
     }
@@ -7602,12 +7602,12 @@ static HB_ERRCODE hb_cdxRecall( CDXAREAP pArea )
     {
         if( pArea->dbfarea.area.dbfi.fFilter && pArea->dbfarea.area.dbfi.fOptimized )
         {
-            pArea->dbfarea.area.dbfi.fFilter = FALSE;
+            pArea->dbfarea.area.dbfi.fFilter = HB_FALSE;
             if( hb_cdxCheckRecordFilter( pArea, pArea->dbfarea.ulRecNo ) )
                 BM_SetBit( ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->rmap, ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->Size, pArea->dbfarea.ulRecNo );
             else
                 BM_ClrBit( ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->rmap, ( ( LPBM_FILTER ) pArea->dbfarea.area.dbfi.lpvCargo)->Size, pArea->dbfarea.ulRecNo );
-            pArea->dbfarea.area.dbfi.fFilter = TRUE;
+            pArea->dbfarea.area.dbfi.fFilter = HB_TRUE;
         }
         return HB_SUCCESS;
     }
@@ -7645,7 +7645,7 @@ static HB_ERRCODE hb_cdxClose( CDXAREAP pArea )
          pArea->pSort = NULL;
       }
 
-      hb_cdxOrdListClear( pArea, TRUE, NULL );
+      hb_cdxOrdListClear( pArea, HB_TRUE, NULL );
       if( pArea->bCdxSortTab )
       {
          hb_xfree( pArea->bCdxSortTab );
@@ -7717,7 +7717,7 @@ static HB_ERRCODE hb_cdxOpen( CDXAREAP pArea, LPDBOPENINFO pOpenInfo )
    {
       char szFileName[ HB_PATH_MAX ];
 
-      pArea->dbfarea.fHasTags = FALSE;
+      pArea->dbfarea.fHasTags = HB_FALSE;
       hb_cdxCreateFName( pArea, NULL, NULL, szFileName, NULL );
       if( hb_spFileExists( szFileName, NULL ) ||
           DBFAREA_DATA( &pArea->dbfarea )->fStrictStruct )
@@ -7743,7 +7743,7 @@ static HB_ERRCODE hb_cdxOpen( CDXAREAP pArea, LPDBOPENINFO pOpenInfo )
    }
    else
    {
-      pArea->dbfarea.fHasTags = FALSE;
+      pArea->dbfarea.fHasTags = HB_FALSE;
    }
 
    return errCode;
@@ -7824,7 +7824,7 @@ static HB_ERRCODE hb_cdxOrderListAdd( CDXAREAP pArea, LPDBORDERINFO pOrderInfo )
    char szBaseName[ CDX_MAXTAGNAMELEN + 1 ];
    char szFileName[ HB_PATH_MAX ];
    LPCDXINDEX pIndex, * pIndexPtr;
-   BOOL fProd, bRetry;
+   HB_BOOL fProd, bRetry;
    PHB_ITEM pError = NULL;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxOrderListAdd(%p, %p)", pArea, pOrderInfo));
@@ -7875,7 +7875,7 @@ static HB_ERRCODE hb_cdxOrderListAdd( CDXAREAP pArea, LPDBORDERINFO pOrderInfo )
             hb_cdxErrorRT( pArea, EG_CORRUPTION, EDBF_CORRUPT,
                            szFileName, hb_fsError(), EF_CANDEFAULT, NULL );
          }
-         bRetry = FALSE;
+         bRetry = HB_FALSE;
       }
 
    } while( bRetry );
@@ -7910,7 +7910,7 @@ static HB_ERRCODE hb_cdxOrderListAdd( CDXAREAP pArea, LPDBORDERINFO pOrderInfo )
    }
 
    if( fProd )
-      pArea->dbfarea.fHasTags = TRUE;
+      pArea->dbfarea.fHasTags = HB_TRUE;
 
    /* bmdbfcdx specific: If there was no controlling order, set this one.
     * This is the behaviour of Clipper's bmdbfcdx, although
@@ -7948,7 +7948,7 @@ static HB_ERRCODE hb_cdxOrderListDelete( CDXAREAP pArea, LPDBORDERINFO pOrderInf
    char szTagName[ CDX_MAXTAGNAMELEN + 1 ];
    char szFileName[ HB_PATH_MAX ];
    LPCDXINDEX pIndex, * pIndexPtr;
-   BOOL fProd;
+   HB_BOOL fProd;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxOrderListDelete(%p, %p)", pArea, pOrderInfo));
 
@@ -8066,8 +8066,8 @@ static HB_ERRCODE hb_cdxOrderListRebuild( CDXAREAP pArea )
 static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderInfo )
 {
    ULONG ulRecNo;
-   BOOL fNewFile, fOpenedIndex, fProd, fAscend = TRUE, fNoCase = FALSE,
-        fCustom = FALSE, fTemporary = FALSE, fExclusive = FALSE;
+   HB_BOOL fNewFile, fOpenedIndex, fProd, fAscend = HB_TRUE, fNoCase = HB_FALSE,
+        fCustom = HB_FALSE, fTemporary = HB_FALSE, fExclusive = HB_FALSE;
    PHB_ITEM pKeyExp, pForExp = NULL, pResult;
    char szCpndTagName[ CDX_MAXTAGNAMELEN + 1 ], szTagName[ CDX_MAXTAGNAMELEN + 1 ];
    char szFileName[ HB_PATH_MAX ], szTempFile[ HB_PATH_MAX ];
@@ -8201,12 +8201,12 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    }
 
    if( pArea->dbfarea.fTemporary )
-      fTemporary = TRUE;
+      fTemporary = HB_TRUE;
 
    /* Test conditional expression */
    if( pForExp )
    {
-      BOOL fOK;
+      HB_BOOL fOK;
 
       if( SELF_EVALBLOCK( ( AREAP ) pArea, pForExp ) == HB_FAILURE )
       {
@@ -8244,12 +8244,12 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    if( pOrderInfo->atomBagName && pOrderInfo->atomBagName[0] )
    {
       hb_strncpyUpperTrim( szTagName, ( char * ) pOrderInfo->atomBagName, sizeof( szTagName ) - 1 );
-      fNewFile = FALSE;
+      fNewFile = HB_FALSE;
    }
    else
    {
       hb_strncpy( szTagName, szCpndTagName, sizeof( szTagName ) - 1 );
-      fNewFile = TRUE;
+      fNewFile = HB_TRUE;
    }
 
    if( !pArea->dbfarea.area.lpdbOrdCondInfo ||
@@ -8279,7 +8279,7 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    if( !fOpenedIndex )
    {
       PHB_FILE pFile;
-      BOOL bRetry, fShared = pArea->dbfarea.fShared && !fTemporary && !fExclusive;
+      HB_BOOL bRetry, fShared = pArea->dbfarea.fShared && !fTemporary && !fExclusive;
       PHB_ITEM pError = NULL;
 
       do
@@ -8287,7 +8287,7 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
          if( fTemporary )
          {
             pFile = hb_fileCreateTemp( NULL, NULL, FC_NORMAL, szTempFile );
-            fNewFile = TRUE;
+            fNewFile = HB_TRUE;
          }
          else
          {
@@ -8303,7 +8303,7 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
                                     &pError ) == E_RETRY;
          else
          {
-            bRetry = FALSE;
+            bRetry = HB_FALSE;
             if( !fNewFile )
                fNewFile = ( hb_fileSize( pFile ) == 0 );
          }
@@ -8318,7 +8318,7 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
          pIndex = hb_cdxIndexNew( pArea );
          pIndex->pFile      = pFile;
          pIndex->fShared    = fShared;
-         pIndex->fReadonly  = FALSE;
+         pIndex->fReadonly  = HB_FALSE;
          pIndex->szFileName = hb_strdup( szFileName );
          pIndex->fDelete = fTemporary;
          if( fTemporary )
@@ -8338,7 +8338,7 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
                               szFileName, hb_fsError(), EF_CANDEFAULT, NULL );
                */
                hb_cdxIndexFreeTags( pIndex );
-               fNewFile = TRUE;
+               fNewFile = HB_TRUE;
             }
          }
       }
@@ -8363,7 +8363,7 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    if( fNewFile )
    {
       hb_fileTruncAt( pIndex->pFile, 0 );
-      pIndex->fChanged = TRUE;
+      pIndex->fChanged = HB_TRUE;
       hb_cdxIndexDropAvailPage( pIndex );
       if( pIndex->pCompound != NULL )
          hb_cdxTagFree( pIndex->pCompound );
@@ -8373,7 +8373,7 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
 
    pTag = hb_cdxIndexAddTag( pIndex, szTagName, hb_itemGetCPtr( pOrderInfo->abExpr ),
                              pKeyExp, bType, uiLen, szFor, pForExp,
-                             fAscend , pOrderInfo->fUnique, fNoCase, fCustom, FALSE );
+                             fAscend , pOrderInfo->fUnique, fNoCase, fCustom, HB_FALSE );
 
    if( pArea->dbfarea.area.lpdbOrdCondInfo && ( !pArea->dbfarea.area.lpdbOrdCondInfo->fAll &&
                                    !pArea->dbfarea.area.lpdbOrdCondInfo->fAdditive ) )
@@ -8385,14 +8385,14 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    /* Update DBF header */
    if( !pArea->dbfarea.fHasTags && !fOpenedIndex && !pIndex->fDelete && fProd )
    {
-      pArea->dbfarea.fHasTags = TRUE;
+      pArea->dbfarea.fHasTags = HB_TRUE;
       if( !pArea->dbfarea.fReadonly && ( pArea->dbfarea.dbfHeader.bHasTags & 0x01 ) == 0 &&
           ( hb_setGetAutOpen() || DBFAREA_DATA( &pArea->dbfarea )->fStrictStruct ) )
          SELF_WRITEDBHEADER( ( AREAP ) pArea );
    }
    else
    {
-      fProd = FALSE;
+      fProd = HB_FALSE;
    }
 
    if( !fOpenedIndex )
@@ -8452,7 +8452,7 @@ static HB_ERRCODE hb_cdxOrderDestroy( CDXAREAP pArea, LPDBORDERINFO pOrderInfo )
                   pArea->lpIndexes = pIndex->pNext;
                   if( pArea->dbfarea.fHasTags )
                   {
-                     pArea->dbfarea.fHasTags = FALSE;
+                     pArea->dbfarea.fHasTags = HB_FALSE;
                      if( !pArea->dbfarea.fReadonly && ( pArea->dbfarea.dbfHeader.bHasTags & 0x01 ) != 0 &&
                          ( hb_setGetAutOpen() || DBFAREA_DATA( &pArea->dbfarea )->fStrictStruct ) )
                         SELF_WRITEDBHEADER( ( AREAP ) pArea );
@@ -8470,7 +8470,7 @@ static HB_ERRCODE hb_cdxOrderDestroy( CDXAREAP pArea, LPDBORDERINFO pOrderInfo )
                      pIndexTmp->pNext = pIndex->pNext;
                   }
                }
-               pIndex->fDelete = TRUE;
+               pIndex->fDelete = HB_TRUE;
                hb_cdxIndexFree( pIndex );
             }
             if( uiTag < pArea->uiTag )
@@ -8565,7 +8565,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
 
       case DBOI_ISREINDEX:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
-                               pArea->pSort ? pArea->pSort->fReindex : FALSE );
+                               pArea->pSort ? pArea->pSort->fReindex : HB_FALSE );
          return HB_SUCCESS;
 
       case DBOI_LOCKOFFSET:
@@ -8741,11 +8741,11 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
          {
             pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
                hb_cdxDBOIKeyGoto( pArea, pTag,
-                  hb_itemGetNL( pInfo->itmNewVal ), TRUE ) == HB_SUCCESS );
+                  hb_itemGetNL( pInfo->itmNewVal ), HB_TRUE ) == HB_SUCCESS );
          }
          else
             pInfo->itmResult = hb_itemPutNL( pInfo->itmResult,
-                                    hb_cdxDBOIKeyNo( pArea, pTag, TRUE ) );
+                                    hb_cdxDBOIKeyNo( pArea, pTag, HB_TRUE ) );
          break;
 
       /* TODO: is this ok?  DBOI_RECNO == DBOI_KEYNORAW ? No, it isn't. */
@@ -8755,21 +8755,21 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
          {
             pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
                hb_cdxDBOIKeyGoto( pArea, pTag,
-                  hb_itemGetNL( pInfo->itmNewVal ), FALSE ) == HB_SUCCESS );
+                  hb_itemGetNL( pInfo->itmNewVal ), HB_FALSE ) == HB_SUCCESS );
          }
          else
             pInfo->itmResult = hb_itemPutNL( pInfo->itmResult,
-                                    hb_cdxDBOIKeyNo( pArea, pTag, FALSE ) );
+                                    hb_cdxDBOIKeyNo( pArea, pTag, HB_FALSE ) );
          break;
 
       case DBOI_KEYCOUNT:
          pInfo->itmResult = hb_itemPutNL( pInfo->itmResult,
-                                    hb_cdxDBOIKeyCount( pArea, pTag, TRUE ) );
+                                    hb_cdxDBOIKeyCount( pArea, pTag, HB_TRUE ) );
          break;
 
       case DBOI_KEYCOUNTRAW:
          pInfo->itmResult = hb_itemPutNL( pInfo->itmResult,
-                                    hb_cdxDBOIKeyCount( pArea, pTag, FALSE ) );
+                                    hb_cdxDBOIKeyCount( pArea, pTag, HB_FALSE ) );
          break;
 
       case DBOI_RELKEYPOS:
@@ -8784,13 +8784,13 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
       case DBOI_FINDREC:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
                   hb_cdxDBOIFindRec( pArea, pTag,
-                              hb_itemGetNL( pInfo->itmNewVal ), FALSE ) );
+                              hb_itemGetNL( pInfo->itmNewVal ), HB_FALSE ) );
          break;
 
       case DBOI_FINDRECCONT:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
                   hb_cdxDBOIFindRec( pArea, pTag,
-                              hb_itemGetNL( pInfo->itmNewVal ), TRUE ) );
+                              hb_itemGetNL( pInfo->itmNewVal ), HB_TRUE ) );
          break;
 
       case DBOI_SKIPUNIQUE:
@@ -8801,32 +8801,32 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
 
       case DBOI_SKIPEVAL:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
-               hb_cdxDBOISkipEval( pArea, pTag, TRUE, pInfo->itmNewVal ) );
+               hb_cdxDBOISkipEval( pArea, pTag, HB_TRUE, pInfo->itmNewVal ) );
          break;
 
       case DBOI_SKIPEVALBACK:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
-               hb_cdxDBOISkipEval( pArea, pTag, FALSE, pInfo->itmNewVal ) );
+               hb_cdxDBOISkipEval( pArea, pTag, HB_FALSE, pInfo->itmNewVal ) );
          break;
 
       case DBOI_SKIPWILD:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
-               hb_cdxDBOISkipWild( pArea, pTag, TRUE, pInfo->itmNewVal ) );
+               hb_cdxDBOISkipWild( pArea, pTag, HB_TRUE, pInfo->itmNewVal ) );
          break;
 
       case DBOI_SKIPWILDBACK:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
-               hb_cdxDBOISkipWild( pArea, pTag, FALSE, pInfo->itmNewVal ) );
+               hb_cdxDBOISkipWild( pArea, pTag, HB_FALSE, pInfo->itmNewVal ) );
          break;
 
       case DBOI_SKIPREGEX:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
-            hb_cdxDBOISkipRegEx( pArea, pTag, TRUE, pInfo->itmNewVal ) );
+            hb_cdxDBOISkipRegEx( pArea, pTag, HB_TRUE, pInfo->itmNewVal ) );
          break;
 
       case DBOI_SKIPREGEXBACK:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
-            hb_cdxDBOISkipRegEx( pArea, pTag, FALSE, pInfo->itmNewVal ) );
+            hb_cdxDBOISkipRegEx( pArea, pTag, HB_FALSE, pInfo->itmNewVal ) );
          break;
 
       case DBOI_SCOPEEVAL:
@@ -8890,7 +8890,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
          break;
 
       case DBOI_UNIQUE:
-         pInfo->itmResult = hb_itemPutL( pInfo->itmResult, ( pTag ? pTag->UniqueKey || pTag->UsrUnique : FALSE ) );
+         pInfo->itmResult = hb_itemPutL( pInfo->itmResult, ( pTag ? pTag->UniqueKey || pTag->UsrUnique : HB_FALSE ) );
          if( pTag && pInfo->itmNewVal && HB_IS_LOGICAL( pInfo->itmNewVal ) && !pTag->UniqueKey )
          {
             pTag->UsrUnique = hb_itemGetL( pInfo->itmNewVal );
@@ -8935,7 +8935,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
             }
             if( pTag->CurKey->rec == pArea->dbfarea.ulRecNo )
                pInfo->itmResult = hb_cdxKeyGetItem( pTag->CurKey,
-                                           pInfo->itmResult, pTag, TRUE );
+                                           pInfo->itmResult, pTag, HB_TRUE );
          }
          break;
 
@@ -9015,19 +9015,19 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
             {
                if( !pTag->Template )
                {
-                  BOOL fNewVal = hb_itemGetL( pInfo->itmNewVal );
+                  HB_BOOL fNewVal = hb_itemGetL( pInfo->itmNewVal );
                   if( pTag->Custom ? ! fNewVal : fNewVal )
                   {
                      pTag->Custom = fNewVal;
-                     pTag->Partial = TRUE;
-                     pTag->ChgOnly = FALSE;
-                     pTag->TagChanged = TRUE;
+                     pTag->Partial = HB_TRUE;
+                     pTag->ChgOnly = HB_FALSE;
+                     pTag->TagChanged = HB_TRUE;
                      /* This is a hacks to emulate both SIX3 and COMIX behavior
                       * which should be cleaned. I intentionally not used
                       * HB_SIXCDX macro here [druzus]
                       */
                      if( pTag->Custom )
-                        pTag->Template = pTag->MultiKey = TRUE;
+                        pTag->Template = pTag->MultiKey = HB_TRUE;
                   }
                }
                hb_cdxIndexUnLockWrite( pTag->pIndex );
@@ -9055,7 +9055,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
            if( hb_cdxIndexLockWrite( pTag->pIndex ) )
            {
               if( pTag->Custom && !pTag->Template )
-                 pTag->Template = TRUE;
+                 pTag->Template = HB_TRUE;
               hb_cdxIndexUnLockWrite( pTag->pIndex );
            }
         }
@@ -9068,7 +9068,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
            if( hb_cdxIndexLockWrite( pTag->pIndex ) )
            {
               if( pTag->Custom && !pTag->MultiKey )
-                 pTag->MultiKey = TRUE;
+                 pTag->MultiKey = HB_TRUE;
               hb_cdxIndexUnLockWrite( pTag->pIndex );
            }
         }
@@ -9078,7 +9078,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
       case DBOI_KEYADD:
          if( !pTag )
          {
-            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, FALSE );
+            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, HB_FALSE );
          }
          else
          {
@@ -9089,9 +9089,9 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
 
                if( !pArea->dbfarea.fPositioned ||
                    ( pTag->pForItem &&
-                     !hb_cdxEvalCond( pArea, pTag->pForItem, TRUE ) ) )
+                     !hb_cdxEvalCond( pArea, pTag->pForItem, HB_TRUE ) ) )
                {
-                  pInfo->itmResult = hb_itemPutL( pInfo->itmResult, FALSE );
+                  pInfo->itmResult = hb_itemPutL( pInfo->itmResult, HB_FALSE );
                }
                else
                {
@@ -9101,7 +9101,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                       pTag->Template )
                      pKey = hb_cdxKeyPutItem( NULL, pInfo->itmNewVal,
                                               pArea->dbfarea.ulRecNo, pTag,
-                                              TRUE, CDX_CMP_EXACT );
+                                              HB_TRUE, CDX_CMP_EXACT );
                   else
                      pKey = hb_cdxKeyEval( NULL, pTag );
                   pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
@@ -9120,7 +9120,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
       case DBOI_KEYDELETE:
          if( !pTag )
          {
-            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, FALSE );
+            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, HB_FALSE );
          }
          else
          {
@@ -9131,9 +9131,9 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
 
                if( !pArea->dbfarea.fPositioned ||
                    ( pTag->pForItem &&
-                     !hb_cdxEvalCond( pArea, pTag->pForItem, TRUE ) ) )
+                     !hb_cdxEvalCond( pArea, pTag->pForItem, HB_TRUE ) ) )
                {
-                  pInfo->itmResult = hb_itemPutL( pInfo->itmResult, FALSE );
+                  pInfo->itmResult = hb_itemPutL( pInfo->itmResult, HB_FALSE );
                }
                else
                {
@@ -9143,7 +9143,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                       pTag->Template )
                      pKey = hb_cdxKeyPutItem( NULL, pInfo->itmNewVal,
                                               pArea->dbfarea.ulRecNo, pTag,
-                                              TRUE, CDX_CMP_EXACT );
+                                              HB_TRUE, CDX_CMP_EXACT );
                   else
                   {
                      if( pTag->CurKey->rec != pArea->dbfarea.ulRecNo )
@@ -9181,7 +9181,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                                                  pTag->pIndex->lockRead > 0 );
          }
          else
-            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, FALSE );
+            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, HB_FALSE );
          break;
 
       case DBOI_WRITELOCK:
@@ -9198,7 +9198,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                                                  pTag->pIndex->lockWrite > 0 );
          }
          else
-            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, FALSE );
+            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, HB_FALSE );
          break;
 
       case DBOI_UPDATECOUNTER:
@@ -9230,7 +9230,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
          break;
 
       case DBOI_LARGEFILE:
-         pInfo->itmResult = hb_itemPutL( pInfo->itmResult, FALSE );
+         pInfo->itmResult = hb_itemPutL( pInfo->itmResult, HB_FALSE );
          break;
 
       case DBOI_INDEXTYPE:
@@ -9304,7 +9304,7 @@ static HB_ERRCODE hb_cdxSetFilter( CDXAREAP pArea, LPDBFILTERINFO pFilterInfo )
         pArea->dbfarea.area.dbfi.lpvCargo = hb_xgrab( sizeof( BM_FILTER ) );
         memset( pArea->dbfarea.area.dbfi.lpvCargo, 0, sizeof( BM_FILTER ) );
 
-        pArea->dbfarea.area.dbfi.fFilter = FALSE;
+        pArea->dbfarea.area.dbfi.fFilter = HB_FALSE;
 
         pTag = hb_cdxGetActiveTag( pArea );
         SELF_RECCOUNT( ( AREAP ) pArea, &ulRecCount );
@@ -9348,7 +9348,7 @@ static HB_ERRCODE hb_cdxSetFilter( CDXAREAP pArea, LPDBFILTERINFO pFilterInfo )
                 SELF_SKIP( ( AREAP ) pArea, 1 );
             }
         }
-        pArea->dbfarea.area.dbfi.fFilter = TRUE;
+        pArea->dbfarea.area.dbfi.fFilter = HB_TRUE;
     }
 
     return HB_SUCCESS;
@@ -9416,12 +9416,12 @@ static HB_ERRCODE hb_cdxRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect
       case RDDI_MULTITAG:
       case RDDI_SORTRECNO:
       case RDDI_STRUCTORD:
-         hb_itemPutL( pItem, TRUE );
+         hb_itemPutL( pItem, HB_TRUE );
          break;
 
       case RDDI_STRICTSTRUCT:
       {
-         BOOL fStrictStruct = pData->fStrictStruct;
+         HB_BOOL fStrictStruct = pData->fStrictStruct;
          if( hb_itemType( pItem ) == HB_IT_LOGICAL )
             pData->fStrictStruct = hb_itemGetL( pItem );
          hb_itemPutL( pItem, fStrictStruct );
@@ -9454,14 +9454,14 @@ static int hb_cdxQuickSortCompare( LPCDXSORTINFO pSort, BYTE * pKey1, BYTE * pKe
    return i;
 }
 
-static BOOL hb_cdxQSort( LPCDXSORTINFO pSort, BYTE * pSrc, BYTE * pBuf, LONG lKeys )
+static HB_BOOL hb_cdxQSort( LPCDXSORTINFO pSort, BYTE * pSrc, BYTE * pBuf, LONG lKeys )
 {
    if( lKeys > 1 )
    {
       int iLen = pSort->keyLen + 4;
       LONG l1, l2;
       BYTE * pPtr1, * pPtr2, *pDst;
-      BOOL f1, f2;
+      HB_BOOL f1, f2;
 
       l1 = lKeys >> 1;
       l2 = lKeys - l1;
@@ -9509,7 +9509,7 @@ static BOOL hb_cdxQSort( LPCDXSORTINFO pSort, BYTE * pSrc, BYTE * pBuf, LONG lKe
       }
       return !f1;
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 static void hb_cdxSortSortPage( LPCDXSORTINFO pSort )
@@ -9530,7 +9530,7 @@ static void hb_cdxSortSortPage( LPCDXSORTINFO pSort )
 static void hb_cdxSortAddNodeKey( LPCDXSORTINFO pSort, int iLevel, BYTE *pKeyVal, ULONG ulRec, ULONG ulPage )
 {
    LPCDXPAGE pPage;
-   BOOL fNew;
+   HB_BOOL fNew;
    int iLen = pSort->keyLen, iDup = 0, iTrl = 0, iTmp, iPos;
    BYTE *pTmp;
 
@@ -9559,7 +9559,7 @@ static void hb_cdxSortAddNodeKey( LPCDXSORTINFO pSort, int iLevel, BYTE *pKeyVal
    }
    if( pPage == NULL )
    {
-      fNew = TRUE;
+      fNew = HB_TRUE;
    }
    else
    {
@@ -9605,7 +9605,7 @@ static void hb_cdxSortAddNodeKey( LPCDXSORTINFO pSort, int iLevel, BYTE *pKeyVal
             pTmp = &pSort->NodeList[ iLevel ]->node.intNode.keyPool[ iPos ];
             hb_cdxSortAddNodeKey( pSort, iLevel + 1, pTmp, HB_GET_BE_UINT32( &pTmp[ iLen ] ), pSort->NodeList[ iLevel ]->Page );
          }
-         hb_cdxPageFree( pSort->NodeList[ iLevel ], TRUE );
+         hb_cdxPageFree( pSort->NodeList[ iLevel ], HB_TRUE );
       }
       pSort->NodeList[ iLevel ] = pPage;
    }
@@ -9727,7 +9727,7 @@ static void hb_cdxSortOrderPages( LPCDXSORTINFO pSort )
    }
 }
 
-static BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, BYTE ** pKeyVal, ULONG *pulRec )
+static HB_BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, BYTE ** pKeyVal, ULONG *pulRec )
 {
    int iLen = pSort->keyLen, i;
    LONG l, r, m;
@@ -9786,14 +9786,14 @@ static BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, BYTE ** pKeyVal, ULONG *pulRe
       pSort->pSwapPage[ ulPage ].ulCurKey++;
       pSort->pSwapPage[ ulPage ].ulKeys--;
       pSort->pSwapPage[ ulPage ].ulKeyBuf--;
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 #else
 
-static BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, BYTE ** pKeyVal, ULONG *pulRec )
+static HB_BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, BYTE ** pKeyVal, ULONG *pulRec )
 {
    int i, iLen = pSort->keyLen;
    ULONG ulPage, ulKeyPage = 0, ulRec = 0, ulRecTmp;
@@ -9831,9 +9831,9 @@ static BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, BYTE ** pKeyVal, ULONG *pulRe
       pSort->pSwapPage[ ulKeyPage ].ulKeyBuf--;
       *pulRec = ulRec;
       *pKeyVal = pKey;
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 #endif
@@ -9972,7 +9972,7 @@ static void hb_cdxSortFree( LPCDXSORTINFO pSort )
 
 static void hb_cdxSortOut( LPCDXSORTINFO pSort )
 {
-   BOOL fUnique = pSort->fUnique, fNext;
+   HB_BOOL fUnique = pSort->fUnique, fNext;
    ULONG ulPage, ulRec, ulKey;
    BYTE * pKeyVal;
    int iLen = pSort->keyLen, iLevel;
@@ -10058,20 +10058,20 @@ static void hb_cdxSortOut( LPCDXSORTINFO pSort )
    }
 
    iLevel = 0;
-   fNext = TRUE;
+   fNext = HB_TRUE;
    do
    {
       if( iLevel + 1 == CDX_STACKSIZE || pSort->NodeList[ iLevel + 1 ] == NULL )
       {
          pSort->NodeList[ iLevel ]->PageType |= CDX_NODE_ROOT;
          pSort->pTag->RootBlock = pSort->NodeList[ iLevel ]->Page;
-         fNext = FALSE;
+         fNext = HB_FALSE;
       }
       else
       {
          hb_cdxSortAddNodeKey( pSort, iLevel + 1, pSort->pLastKey, pSort->ulLastRec, pSort->NodeList[ iLevel ]->Page );
       }
-      hb_cdxPageFree( pSort->NodeList[ iLevel ], TRUE );
+      hb_cdxPageFree( pSort->NodeList[ iLevel ], HB_TRUE );
       iLevel++;
    }
    while( fNext );
@@ -10085,7 +10085,7 @@ static void hb_cdxTagEmptyIndex( LPCDXTAG pTag )
    hb_cdxPageLeafInitSpace( pTag->RootPage );
 }
 
-static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
+static void hb_cdxTagDoIndex( LPCDXTAG pTag, HB_BOOL fReindex )
 {
    LPCDXAREA pArea = pTag->pIndex->pArea;
    LPCDXSORTINFO pSort;
@@ -10117,7 +10117,7 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
    if( ( pTag->OptFlags & CDX_TYPE_STRUCTURE ) == 0 && pEvalItem )
    {
       SELF_GOTO( ( AREAP ) pArea, 0 );
-      if( !hb_cdxEvalCond( pArea, pEvalItem, FALSE ) )
+      if( !hb_cdxEvalCond( pArea, pEvalItem, HB_FALSE ) )
       {
          hb_cdxSortFree( pSort );
          pArea->pSort = NULL;
@@ -10134,7 +10134,7 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
    {
       USHORT uiSaveTag = pArea->uiTag;
       ULONG ulStartRec = 0, ulNextCount = 0;
-      BOOL fDirectRead, fUseFilter = FALSE;
+      HB_BOOL fDirectRead, fUseFilter = HB_FALSE;
       BYTE * pSaveRecBuff = pArea->dbfarea.pRecord, cTemp[8];
       int iRecBuff = 0, iRecBufSize = USHRT_MAX / pArea->dbfarea.uiRecordLen, iRec;
 
@@ -10165,7 +10165,7 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
          }
          else if( pArea->dbfarea.area.lpdbOrdCondInfo->fUseFilter )
          {
-            fUseFilter = TRUE;
+            fUseFilter = HB_TRUE;
          }
          else if( !pArea->dbfarea.area.lpdbOrdCondInfo->fUseCurrent )
          {
@@ -10219,7 +10219,7 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
             pArea->dbfarea.ulRecNo = ulRecNo;
             if( SELF_GETREC( ( AREAP ) pArea, NULL ) == HB_FAILURE )
                break;
-            pArea->dbfarea.fValidBuffer = pArea->dbfarea.fPositioned = TRUE;
+            pArea->dbfarea.fValidBuffer = pArea->dbfarea.fPositioned = HB_TRUE;
             pArea->dbfarea.fDeleted = pArea->dbfarea.pRecord[ 0 ] == '*';
             /* Force relational movement in child WorkAreas */
             if( pArea->dbfarea.area.lpdbRelations )
@@ -10234,18 +10234,18 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
             if( lStep >= pArea->dbfarea.area.lpdbOrdCondInfo->lStep )
             {
                lStep = 0;
-               if( !hb_cdxEvalCond( pArea, pEvalItem, FALSE ) )
+               if( !hb_cdxEvalCond( pArea, pEvalItem, HB_FALSE ) )
                   break;
             }
             ++lStep;
          }
 #endif
 
-         if( pWhileItem && !hb_cdxEvalCond( NULL, pWhileItem, FALSE ) )
+         if( pWhileItem && !hb_cdxEvalCond( NULL, pWhileItem, HB_FALSE ) )
             break;
 
          if( ulRecNo <= ulRecCount &&
-              ( pForItem == NULL || hb_cdxEvalCond( pArea, pForItem, FALSE ) ) )
+              ( pForItem == NULL || hb_cdxEvalCond( pArea, pForItem, HB_FALSE ) ) )
          {
             double d;
 
@@ -10323,7 +10323,7 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
             if( lStep >= pArea->dbfarea.area.lpdbOrdCondInfo->lStep )
             {
                lStep = 0;
-               if( !hb_cdxEvalCond( pArea, pEvalItem, FALSE ) )
+               if( !hb_cdxEvalCond( pArea, pEvalItem, HB_FALSE ) )
                   break;
             }
             ++lStep;
@@ -10356,8 +10356,8 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
 #if !defined( HB_SIXCDX )
       if( pEvalItem && lStep )
       {
-         /* pArea->dbfarea.area.fEof = TRUE; */
-         hb_cdxEvalCond( pArea, pEvalItem, FALSE );
+         /* pArea->dbfarea.area.fEof = HB_TRUE; */
+         hb_cdxEvalCond( pArea, pEvalItem, HB_FALSE );
       }
 #endif
    }
@@ -10366,8 +10366,8 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
    if( pEvalItem )
    {
       SELF_GOTO( ( AREAP ) pArea, 0 );
-      pArea->dbfarea.area.fBof = FALSE;
-      hb_cdxEvalCond( pArea, pEvalItem, FALSE );
+      pArea->dbfarea.area.fBof = HB_FALSE;
+      hb_cdxEvalCond( pArea, pEvalItem, HB_FALSE );
    }
 #endif
 
diff --git a/harbour/contrib/hbbmcdx/hbbmcdx.h b/harbour/contrib/hbbmcdx/hbbmcdx.h
index a763d804bf..1ec88b33a8 100644
--- a/harbour/contrib/hbbmcdx/hbbmcdx.h
+++ b/harbour/contrib/hbbmcdx/hbbmcdx.h
@@ -270,7 +270,7 @@ typedef struct _CDXPAGE
    int      iKeys;
    int      iCurKey;
 
-   BOOL     fChanged;
+   HB_BOOL  fChanged;
    BYTE     bUsed;
 
    ULONG    RNMask;
@@ -280,7 +280,7 @@ typedef struct _CDXPAGE
    BYTE     TCBits;
    BYTE     DCMask;
    BYTE     TCMask;
-   BOOL     fBufChanged;
+   HB_BOOL  fBufChanged;
    union
    {
       CDXEXTNODE extNode;
@@ -312,7 +312,7 @@ typedef CDXSTACK * LPCDXSTACK;
 typedef struct _CDXLIST
 {
    ULONG    ulAddr;
-   BOOL     fStat;
+   HB_BOOL  fStat;
    struct _CDXLIST * pNext;
 } CDXLIST;
 typedef CDXLIST * LPCDXLIST;
@@ -329,23 +329,23 @@ typedef struct _CDXTAG
    USHORT   nField;           /* Field number for simple (one field) key expersion */
    BYTE     bTrail;           /* trailing character for shorter key value */
    BYTE     OptFlags;         /* index options flag */
-   BOOL     AscendKey;        /* ascending/descending order flag */
-   BOOL     UniqueKey;        /* unique order flag */
-   BOOL     Temporary;        /* temporary order flag */
-   BOOL     Custom;           /* custom order flag */
-   BOOL     Template;         /* user keyadata in ordKeyAdd()/ordKeyDel() accepted */
-   BOOL     MultiKey;         /* repeated key values in custom indexes accepted */
-   BOOL     Partial;          /* order is updated only partially - missing keys possible */
-   BOOL     ChgOnly;          /* only existing key modifications are updated, no new key added */
-   BOOL     UsrAscend;        /* user settable ascending/descending order flag */
-   BOOL     UsrUnique;        /* user settable unique order flag */
-   BOOL     IgnoreCase;       /* ignore case (upper keys) */
+   HB_BOOL  AscendKey;        /* ascending/descending order flag */
+   HB_BOOL  UniqueKey;        /* unique order flag */
+   HB_BOOL  Temporary;        /* temporary order flag */
+   HB_BOOL  Custom;           /* custom order flag */
+   HB_BOOL  Template;         /* user keyadata in ordKeyAdd()/ordKeyDel() accepted */
+   HB_BOOL  MultiKey;         /* repeated key values in custom indexes accepted */
+   HB_BOOL  Partial;          /* order is updated only partially - missing keys possible */
+   HB_BOOL  ChgOnly;          /* only existing key modifications are updated, no new key added */
+   HB_BOOL  UsrAscend;        /* user settable ascending/descending order flag */
+   HB_BOOL  UsrUnique;        /* user settable unique order flag */
+   HB_BOOL  IgnoreCase;       /* ignore case (upper keys) */
 
-   BOOL     TagChanged;
-   BOOL     TagBOF;
-   BOOL     TagEOF;
+   HB_BOOL  TagChanged;
+   HB_BOOL  TagBOF;
+   HB_BOOL  TagEOF;
 
-   BOOL     fRePos;
+   HB_BOOL  fRePos;
    int      curKeyState;      /* see: CDX_CURKEY_* */
    ULONG    rawKeyCount;
    ULONG    rawKeyPos;
@@ -365,7 +365,7 @@ typedef struct _CDXTAG
    LPCDXPAGE RootPage;        /* pointer to root of keys tree in memory */
    LPCDXKEY  CurKey;          /* current value of key expression */
    LPCDXKEY  HotKey;          /* value of hot key expression */
-   BOOL      HotFor;          /* index FOR condition for HotKey */
+   HB_BOOL   HotFor;          /* index FOR condition for HotKey */
 
    PHB_ITEM  topScope;        /* Top scope HB_ITEM */
    LPCDXKEY  topScopeKey;     /* Top scope index key */
@@ -385,9 +385,9 @@ typedef struct _CDXINDEX
    struct _CDXINDEX * pNext;  /* The next index in the list */
    LPCDXTAG    pCompound;     /* Compound tag */
    LPCDXTAG    TagList;       /* List of tags in index file */
-   BOOL        fShared;       /* Shared file */
-   BOOL        fReadonly;     /* Read only file */
-   BOOL        fDelete;       /* delete on close flag */
+   HB_BOOL     fShared;       /* Shared file */
+   HB_BOOL     fReadonly;     /* Read only file */
+   HB_BOOL     fDelete;       /* delete on close flag */
    ULONG       nextAvail;     /* offset to next free page in the end of index file */
    ULONG       freePage;      /* offset to next free page inside index file */
    LPCDXLIST   freeLst;       /* list of free pages in index file */
@@ -395,12 +395,12 @@ typedef struct _CDXINDEX
    int         lockRead;      /* number of read lock set */
    HB_FOFFSET  ulLockPos;     /* readlock position for CL53 lock scheme */
 #ifdef HB_CDX_DBGCODE
-   BOOL        RdLck;
-   BOOL        WrLck;
+   HB_BOOL     RdLck;
+   HB_BOOL     WrLck;
 #endif
-   BOOL        fChanged;      /* changes written to index, need upadte ulVersion */
+   HB_BOOL     fChanged;      /* changes written to index, need upadte ulVersion */
    ULONG       ulVersion;     /* network version/update flag */
-   BOOL        fFlush;        /* changes written to index, need upadte ulVersion */
+   HB_BOOL     fFlush;        /* changes written to index, need upadte ulVersion */
 } CDXINDEX;
 typedef CDXINDEX * LPCDXINDEX;
 
@@ -422,8 +422,8 @@ typedef struct
    char *   szTempFileName;   /* temporary file name */
    int      keyLen;           /* key length */
    BYTE     bTrl;             /* filler char for shorter keys */
-   BOOL     fUnique;          /* TRUE if index is unique */
-   BOOL     fReindex;         /* TRUE if reindexing is in process */
+   HB_BOOL  fUnique;          /* HB_TRUE if index is unique */
+   HB_BOOL  fReindex;         /* HB_TRUE if reindexing is in process */
    ULONG    ulMaxRec;         /* the highest record number */
    ULONG    ulTotKeys;        /* total number of keys indexed */
    ULONG    ulKeys;           /* keys in curently created page */
@@ -466,7 +466,7 @@ typedef struct _CDXAREA
    *  example.
    */
 
-   BOOL           fCdxAppend;    /* Appended record changed */
+   HB_BOOL        fCdxAppend;    /* Appended record changed */
    LPCDXINDEX     lpIndexes;     /* Pointer to indexes array  */
    USHORT         uiTag;         /* current tag focus */
    LPCDXSORTINFO  pSort;         /* Index build structure */
@@ -485,13 +485,14 @@ typedef CDXAREA * LPCDXAREA;
 #define BM_ClrBit(m,b,r) do { if((r)<=(b)) (m)[((r)-1)>>5] = (m)[((r)-1)>>5] & ~(1<<(((r)-1)%32)); } while(0)
 #define BM_GetBit(m,b,r) ( ((r)<=(b)) ? (m)[((r)-1)>>5] & (1<<(((r)-1)%32)) : 0 )
 
-typedef struct _BM_FILTER_ {
-    PHB_ITEM itmCobExpr;       /* Block representation of the FILTER expression */
-    PHB_ITEM abFilterText;     /* String representation of FILTER expression */
-    BOOL     fFilter;          /* flag to indicate that filter is active */
-    BOOL     fOptimized;       /* Is (should be) filter optimized */
-    ULONG*   rmap;
-    ULONG    Size;
+typedef struct _BM_FILTER_
+{
+   PHB_ITEM itmCobExpr;       /* Block representation of the FILTER expression */
+   PHB_ITEM abFilterText;     /* String representation of FILTER expression */
+   HB_BOOL  fFilter;          /* flag to indicate that filter is active */
+   HB_BOOL  fOptimized;       /* Is (should be) filter optimized */
+   ULONG *  rmap;
+   ULONG    Size;
 } BM_FILTER;
 
 typedef BM_FILTER * LPBM_FILTER;
@@ -511,12 +512,12 @@ static HB_ERRCODE hb_cdxGoBottom( CDXAREAP pArea );
 #define hb_cdxGoTo                                 NULL
 #define hb_cdxGoToId                               NULL
 static HB_ERRCODE hb_cdxGoTop( CDXAREAP pArea );
-static HB_ERRCODE hb_cdxSeek( CDXAREAP pArea, BOOL bSoftSeek, PHB_ITEM pKey, BOOL bFindLast );
+static HB_ERRCODE hb_cdxSeek( CDXAREAP pArea, HB_BOOL bSoftSeek, PHB_ITEM pKey, HB_BOOL bFindLast );
 static HB_ERRCODE hb_cdxSkip( CDXAREAP pArea, LONG lToSkip );
 static HB_ERRCODE hb_cdxSkipFilter( CDXAREAP pArea, LONG lUpDown );
 static HB_ERRCODE hb_cdxSkipRaw( CDXAREAP pArea, LONG lToSkip );
 #define hb_cdxAddField                             NULL
-static HB_ERRCODE hb_cdxAppend( CDXAREAP pArea, BOOL bUnLockAll );
+static HB_ERRCODE hb_cdxAppend( CDXAREAP pArea, HB_BOOL bUnLockAll );
 #define hb_cdxCreateFields                         NULL
 static HB_ERRCODE hb_cdxDeleteRec( CDXAREAP pArea );
 #define hb_cdxDeleted                              NULL
diff --git a/harbour/include/hbapirdd.h b/harbour/include/hbapirdd.h
index 93760bed8e..861d49bc3b 100644
--- a/harbour/include/hbapirdd.h
+++ b/harbour/include/hbapirdd.h
@@ -192,8 +192,8 @@ typedef struct
    USHORT         unused;
    const char *   abName;           /* The qualified name of the data store */
    const char *   atomAlias;        /* The logical name of the data store */
-   BOOL           fShared;          /* Share mode of the data store */
-   BOOL           fReadonly;        /* Readonly mode of the data store */
+   HB_BOOL        fShared;          /* Share mode of the data store */
+   HB_BOOL        fReadonly;        /* Readonly mode of the data store */
    const char *   cdpId;            /* Id of a codepage */
    ULONG          ulConnection;     /* connection handler for RDDs which support it */
    void *         lpdbHeader;       /* Pointer to a header of the data store */
@@ -211,7 +211,7 @@ typedef DBOPENINFO * LPDBOPENINFO;
 
 typedef struct _DBORDERCONDINFO
 {
-   BOOL           fActive;
+   HB_BOOL        fActive;
    char *         abFor;
    char *         abWhile;
    PHB_ITEM       itmCobFor;
@@ -221,18 +221,18 @@ typedef struct _DBORDERCONDINFO
    PHB_ITEM       itmStartRecID;
    LONG           lNextCount;
    PHB_ITEM       itmRecID;
-   BOOL           fRest;
-   BOOL           fDescending;
-   BOOL           fScoped;
-   BOOL           fAll;
-   BOOL           fAdditive;
-   BOOL           fUseCurrent;
-   BOOL           fCustom;
-   BOOL           fNoOptimize;
-   BOOL           fCompound;
-   BOOL           fUseFilter;
-   BOOL           fTemporary;
-   BOOL           fExclusive;
+   HB_BOOL        fRest;
+   HB_BOOL        fDescending;
+   HB_BOOL        fScoped;
+   HB_BOOL        fAll;
+   HB_BOOL        fAdditive;
+   HB_BOOL        fUseCurrent;
+   HB_BOOL        fCustom;
+   HB_BOOL        fNoOptimize;
+   HB_BOOL        fCompound;
+   HB_BOOL        fUseFilter;
+   HB_BOOL        fTemporary;
+   HB_BOOL        fExclusive;
    void *         lpvCargo;
 } DBORDERCONDINFO;
 
@@ -245,7 +245,7 @@ typedef struct
    const char *   abConstrName;     /* Name of relational integrity constraint */
    const char *   abTargetName;     /* Name of target relation table */
    PHB_ITEM       itmRelationKey;   /* Array of columns in source table to match target primary key */
-   BOOL           fEnabled;         /* Is constraint enabled ? */
+   HB_BOOL        fEnabled;         /* Is constraint enabled ? */
 } DBCONSTRAINTINFO;
 
 typedef DBCONSTRAINTINFO * LPDBCONSTRAINTINFO;
@@ -263,7 +263,7 @@ typedef struct
    const char *       abBagName;          /* Name of the Order bag */
    const char*        atomBagName;        /* Name of the Order */
    PHB_ITEM           itmOrder;
-   BOOL               fUnique;            /* Flag to determine if all keys are unique */
+   HB_BOOL            fUnique;            /* Flag to determine if all keys are unique */
    PHB_ITEM           itmCobExpr;         /* Code block containing the KEY expression */
    PHB_ITEM           abExpr;             /* String containing the KEY expression */
    LPDBCONSTRAINTINFO lpdbConstraintInfo; /* Relational constraint info */
@@ -286,7 +286,7 @@ typedef struct
    PHB_ITEM itmCobExpr;   /* Code block containing the KEY expression */
    PHB_ITEM itmResult;    /* Operation result */
    PHB_ITEM itmNewVal;    /* New Setting   */
-   BOOL     fAllTags;     /* Open all tags */
+   HB_BOOL  fAllTags;     /* Open all tags */
 } DBORDERINFO;
 
 typedef DBORDERINFO * LPDBORDERINFO;
@@ -308,12 +308,12 @@ typedef struct
    PHB_ITEM lNext;       /* NEXT record */
    PHB_ITEM itmRecID;    /* single record ID */
    PHB_ITEM fRest;       /* TRUE if start from the current record */
-   BOOL     fIgnoreFilter;       /* process should ignore any filter condition */
-   BOOL     fIncludeDeleted;     /* process should include deleted records */
-   BOOL     fLast;               /* last record of the current scope required */
-   BOOL     fIgnoreDuplicates;   /* process should ignore duplicate key value */
-   BOOL     fBackward;           /* skip backward */
-   BOOL     fOptimized;          /* Is (should be) scope optimized */
+   HB_BOOL  fIgnoreFilter;       /* process should ignore any filter condition */
+   HB_BOOL  fIncludeDeleted;     /* process should include deleted records */
+   HB_BOOL  fLast;               /* last record of the current scope required */
+   HB_BOOL  fIgnoreDuplicates;   /* process should ignore duplicate key value */
+   HB_BOOL  fBackward;           /* skip backward */
+   HB_BOOL  fOptimized;          /* Is (should be) scope optimized */
 } DBSCOPEINFO;
 
 typedef DBSCOPEINFO * LPDBSCOPEINFO;
@@ -345,8 +345,8 @@ typedef struct
 {
    PHB_ITEM itmCobExpr;       /* Block representation of the FILTER expression */
    PHB_ITEM abFilterText;     /* String representation of FILTER expression */
-   BOOL     fFilter;          /* flag to indicate that filter is active */
-   BOOL     fOptimized;       /* Is (should be) filter optimized */
+   HB_BOOL  fFilter;          /* flag to indicate that filter is active */
+   HB_BOOL  fOptimized;       /* Is (should be) filter optimized */
    void *   lpvCargo;         /* RDD specific extended filter info */
 } DBFILTERINFO;
 
@@ -364,8 +364,8 @@ typedef struct _DBRELINFO
 {
    PHB_ITEM            itmCobExpr;   /* Block representation of the relational SEEK key */
    PHB_ITEM            abKey;        /* String representation of the relational SEEK key */
-   BOOL                isScoped;     /* Is this relation scoped */
-   BOOL                isOptimized;  /* Is relation optimized */
+   HB_BOOL             isScoped;     /* Is this relation scoped */
+   HB_BOOL             isOptimized;  /* Is relation optimized */
    struct _AREA      * lpaParent;    /* The parent of this relation */
    struct _AREA      * lpaChild;     /* The parents children */
    struct _DBRELINFO * lpdbriNext;   /* Next child or parent */
@@ -563,11 +563,11 @@ typedef struct _AREA
    LPFIELD lpFields;             /* Pointer to an array of fields */
    void * lpFieldExtents;        /* Void ptr for additional field properties */
    PHB_ITEM valResult;           /* All purpose result holder */
-   BOOL fTop;                    /* TRUE if "top" */
-   BOOL fBottom;                 /* TRUE if "bottom" */
-   BOOL fBof;                    /* TRUE if "bof" */
-   BOOL fEof;                    /* TRUE if "eof" */
-   BOOL fFound;                  /* TRUE if "found" */
+   HB_BOOL fTop;                 /* HB_TRUE if "top" */
+   HB_BOOL fBottom;              /* HB_TRUE if "bottom" */
+   HB_BOOL fBof;                 /* HB_TRUE if "bof" */
+   HB_BOOL fEof;                 /* HB_TRUE if "eof" */
+   HB_BOOL fFound;               /* HB_TRUE if "found" */
    DBSCOPEINFO dbsi;             /* Info regarding last LOCATE */
    DBFILTERINFO dbfi;            /* Filter in effect */
    LPDBORDERCONDINFO lpdbOrdCondInfo;
@@ -589,8 +589,8 @@ typedef AREA * LPAREA;
 /*--------------------* Virtual Method Table *----------------------*/
 
 typedef HB_ERRCODE ( * DBENTRYP_V     )( AREAP area );
-typedef HB_ERRCODE ( * DBENTRYP_BP    )( AREAP area, BOOL * param );
-typedef HB_ERRCODE ( * DBENTRYP_B     )( AREAP area, BOOL param );
+typedef HB_ERRCODE ( * DBENTRYP_BP    )( AREAP area, HB_BOOL * param );
+typedef HB_ERRCODE ( * DBENTRYP_B     )( AREAP area, HB_BOOL param );
 typedef HB_ERRCODE ( * DBENTRYP_L     )( AREAP area, LONG param );
 typedef HB_ERRCODE ( * DBENTRYP_UL    )( AREAP area, ULONG param );
 typedef HB_ERRCODE ( * DBENTRYP_I     )( AREAP area, PHB_ITEM param );
@@ -625,10 +625,10 @@ typedef HB_ERRCODE ( * DBENTRYP_VSP   )( AREAP area, USHORT action, ULONG lRecor
 typedef HB_ERRCODE ( * DBENTRYP_SVL   )( AREAP area, USHORT index, ULONG * param );
 typedef HB_ERRCODE ( * DBENTRYP_SSI   )( AREAP area, USHORT p1, USHORT p2, PHB_ITEM p3 );
 typedef HB_ERRCODE ( * DBENTRYP_ISI   )( AREAP area, PHB_ITEM p1, USHORT p2, PHB_ITEM p3 );
-typedef HB_ERRCODE ( * DBENTRYP_BIB   )( AREAP area, BOOL p1, PHB_ITEM p2, BOOL p3 );
+typedef HB_ERRCODE ( * DBENTRYP_BIB   )( AREAP area, HB_BOOL p1, PHB_ITEM p2, HB_BOOL p3 );
 typedef HB_ERRCODE ( * DBENTRYP_VPL   )( AREAP area, void * p1, LONG p2 );
 typedef HB_ERRCODE ( * DBENTRYP_VPLP  )( AREAP area, void * p1, LONG * p2 );
-typedef HB_ERRCODE ( * DBENTRYP_LSP   )( AREAP area, ULONG p1, BOOL * p2 );
+typedef HB_ERRCODE ( * DBENTRYP_LSP   )( AREAP area, ULONG p1, HB_BOOL * p2 );
 
 /* this methods DO USE take a Workarea but an RDDNODE */
 
@@ -1188,19 +1188,19 @@ extern HB_EXPORT PHB_ITEM     hb_rddList( USHORT uiType );
 extern HB_EXPORT void         hb_rddCloseAll( void );
 extern HB_EXPORT void         hb_rddFlushAll( void );
 extern HB_EXPORT void         hb_rddUnLockAll( void );
-extern HB_EXPORT BOOL         hb_rddGetNetErr( void );
-extern HB_EXPORT void         hb_rddSetNetErr( BOOL fNetErr );
+extern HB_EXPORT HB_BOOL      hb_rddGetNetErr( void );
+extern HB_EXPORT void         hb_rddSetNetErr( HB_BOOL fNetErr );
 
 extern HB_EXPORT HB_ERRCODE   hb_rddOpenTable(
                                  const char * szFileName, const char * szDriver,
                                  USHORT uiArea, const char *szAlias,
-                                 BOOL fShared, BOOL fReadonly,
+                                 HB_BOOL fShared, HB_BOOL fReadonly,
                                  const char * szCpId, ULONG ulConnection,
                                  PHB_ITEM pStruct, PHB_ITEM pDelim );
 extern HB_EXPORT HB_ERRCODE   hb_rddCreateTable(
                                  const char * szFileName, const char * szDriver,
                                  USHORT uiArea, const char *szAlias,
-                                 BOOL fKeepOpen,
+                                 HB_BOOL fKeepOpen,
                                  const char * szCpId, ULONG ulConnection,
                                  PHB_ITEM pStruct, PHB_ITEM pDelim );
 extern HB_EXPORT HB_ERRCODE   hb_rddCreateTableTemp(
@@ -1216,7 +1216,7 @@ extern HB_EXPORT HB_ERRCODE   hb_rddTransRecords(
                                  AREAP pArea,
                                  const char *szFileName, const char *szDriver,
                                  ULONG ulConnection,
-                                 PHB_ITEM pFields, BOOL fExport,
+                                 PHB_ITEM pFields, HB_BOOL fExport,
                                  PHB_ITEM pCobFor, PHB_ITEM pStrFor,
                                  PHB_ITEM pCobWhile, PHB_ITEM pStrWhile,
                                  PHB_ITEM pNext, PHB_ITEM pRecID,
@@ -1230,7 +1230,7 @@ extern HB_EXPORT HB_ERRCODE   hb_rddEvalWA( PHB_ITEM pBlock );
 
 extern HB_EXPORT HB_ERRCODE   hb_rddDetachArea( AREAP pArea, PHB_ITEM pCargo );
 extern HB_EXPORT AREAP        hb_rddRequestArea( const char * szAlias, PHB_ITEM pCargo,
-                                                 BOOL fNewArea, BOOL fWait );
+                                                 HB_BOOL fNewArea, HB_BOOL fWait );
 
 typedef HB_ERRCODE ( * WACALLBACK )( AREAP, void * );
 extern HB_EXPORT HB_ERRCODE   hb_rddIterateWorkAreas( WACALLBACK pCallBack, void * cargo );
diff --git a/harbour/include/hbdbsort.h b/harbour/include/hbdbsort.h
index a2ce7606c8..485cb83cc5 100644
--- a/harbour/include/hbdbsort.h
+++ b/harbour/include/hbdbsort.h
@@ -83,10 +83,10 @@ typedef DBQUICKSORT * LPDBQUICKSORT;
  *  PROTOTYPES
  *  ----------
  */
-extern BOOL hb_dbQSortInit( LPDBQUICKSORT pQuickSort, LPDBSORTINFO pSortInfo, USHORT uiRecordLen );
-extern void hb_dbQSortExit( LPDBQUICKSORT pQuickSort );
-extern BOOL hb_dbQSortAdvance( LPDBQUICKSORT pQuickSort, USHORT uiCount );
-extern void hb_dbQSortComplete( LPDBQUICKSORT pQuickSort );
+extern HB_BOOL hb_dbQSortInit( LPDBQUICKSORT pQuickSort, LPDBSORTINFO pSortInfo, USHORT uiRecordLen );
+extern void    hb_dbQSortExit( LPDBQUICKSORT pQuickSort );
+extern HB_BOOL hb_dbQSortAdvance( LPDBQUICKSORT pQuickSort, USHORT uiCount );
+extern void    hb_dbQSortComplete( LPDBQUICKSORT pQuickSort );
 
 HB_EXTERN_END
 
diff --git a/harbour/include/hbrddcdx.h b/harbour/include/hbrddcdx.h
index c635d5ff6a..135baf17f3 100644
--- a/harbour/include/hbrddcdx.h
+++ b/harbour/include/hbrddcdx.h
@@ -265,7 +265,7 @@ typedef struct _CDXPAGE
    int      iKeys;
    int      iCurKey;
 
-   BOOL     fChanged;
+   HB_BOOL  fChanged;
    BYTE     bUsed;
 
    ULONG    RNMask;
@@ -275,7 +275,7 @@ typedef struct _CDXPAGE
    BYTE     TCBits;
    BYTE     DCMask;
    BYTE     TCMask;
-   BOOL     fBufChanged;
+   HB_BOOL  fBufChanged;
    union
    {
       CDXEXTNODE extNode;
@@ -307,7 +307,7 @@ typedef CDXSTACK * LPCDXSTACK;
 typedef struct _CDXLIST
 {
    ULONG    ulAddr;
-   BOOL     fStat;
+   HB_BOOL  fStat;
    struct _CDXLIST * pNext;
 } CDXLIST;
 typedef CDXLIST * LPCDXLIST;
@@ -324,23 +324,23 @@ typedef struct _CDXTAG
    USHORT   nField;           /* Field number for simple (one field) key expersion */
    BYTE     bTrail;           /* trailing character for shorter key value */
    BYTE     OptFlags;         /* index options flag */
-   BOOL     AscendKey;        /* ascending/descending order flag */
-   BOOL     UniqueKey;        /* unique order flag */
-   BOOL     Temporary;        /* temporary order flag */
-   BOOL     Custom;           /* custom order flag */
-   BOOL     Template;         /* user keyadata in ordKeyAdd()/ordKeyDel() accepted */
-   BOOL     MultiKey;         /* repeated key values in custom indexes accepted */
-   BOOL     Partial;          /* order is updated only partially - missing keys possible */
-   BOOL     ChgOnly;          /* only existing key modifications are updated, no new key added */
-   BOOL     UsrAscend;        /* user settable ascending/descending order flag */
-   BOOL     UsrUnique;        /* user settable unique order flag */
-   BOOL     IgnoreCase;       /* ignore case (upper keys) */
+   HB_BOOL  AscendKey;        /* ascending/descending order flag */
+   HB_BOOL  UniqueKey;        /* unique order flag */
+   HB_BOOL  Temporary;        /* temporary order flag */
+   HB_BOOL  Custom;           /* custom order flag */
+   HB_BOOL  Template;         /* user keyadata in ordKeyAdd()/ordKeyDel() accepted */
+   HB_BOOL  MultiKey;         /* repeated key values in custom indexes accepted */
+   HB_BOOL  Partial;          /* order is updated only partially - missing keys possible */
+   HB_BOOL  ChgOnly;          /* only existing key modifications are updated, no new key added */
+   HB_BOOL  UsrAscend;        /* user settable ascending/descending order flag */
+   HB_BOOL  UsrUnique;        /* user settable unique order flag */
+   HB_BOOL  IgnoreCase;       /* ignore case (upper keys) */
 
-   BOOL     TagChanged;
-   BOOL     TagBOF;
-   BOOL     TagEOF;
+   HB_BOOL  TagChanged;
+   HB_BOOL  TagBOF;
+   HB_BOOL  TagEOF;
 
-   BOOL     fRePos;
+   HB_BOOL  fRePos;
    int      curKeyState;      /* see: CDX_CURKEY_* */
    ULONG    rawKeyCount;
    ULONG    rawKeyPos;
@@ -360,7 +360,7 @@ typedef struct _CDXTAG
    LPCDXPAGE RootPage;        /* pointer to root of keys tree in memory */
    LPCDXKEY  CurKey;          /* current value of key expression */
    LPCDXKEY  HotKey;          /* value of hot key expression */
-   BOOL      HotFor;          /* index FOR condition for HotKey */
+   HB_BOOL   HotFor;          /* index FOR condition for HotKey */
 
    PHB_ITEM  topScope;        /* Top scope HB_ITEM */
    LPCDXKEY  topScopeKey;     /* Top scope index key */
@@ -380,9 +380,9 @@ typedef struct _CDXINDEX
    struct _CDXINDEX * pNext;  /* The next index in the list */
    LPCDXTAG    pCompound;     /* Compound tag */
    LPCDXTAG    TagList;       /* List of tags in index file */
-   BOOL        fShared;       /* Shared file */
-   BOOL        fReadonly;     /* Read only file */
-   BOOL        fDelete;       /* delete on close flag */
+   HB_BOOL     fShared;       /* Shared file */
+   HB_BOOL     fReadonly;     /* Read only file */
+   HB_BOOL     fDelete;       /* delete on close flag */
    ULONG       nextAvail;     /* offset to next free page in the end of index file */
    ULONG       freePage;      /* offset to next free page inside index file */
    LPCDXLIST   freeLst;       /* list of free pages in index file */
@@ -390,12 +390,12 @@ typedef struct _CDXINDEX
    int         lockRead;      /* number of read lock set */
    HB_FOFFSET  ulLockPos;     /* readlock position for CL53 lock scheme */
 #ifdef HB_CDX_DBGCODE
-   BOOL        RdLck;
-   BOOL        WrLck;
+   HB_BOOL     RdLck;
+   HB_BOOL     WrLck;
 #endif
-   BOOL        fChanged;      /* changes written to index, need upadte ulVersion */
+   HB_BOOL     fChanged;      /* changes written to index, need upadte ulVersion */
    ULONG       ulVersion;     /* network version/update flag */
-   BOOL        fFlush;        /* changes written to index, need upadte ulVersion */
+   HB_BOOL     fFlush;        /* changes written to index, need upadte ulVersion */
 } CDXINDEX;
 typedef CDXINDEX * LPCDXINDEX;
 
@@ -417,8 +417,8 @@ typedef struct
    char *   szTempFileName;   /* temporary file name */
    int      keyLen;           /* key length */
    BYTE     bTrl;             /* filler char for shorter keys */
-   BOOL     fUnique;          /* TRUE if index is unique */
-   BOOL     fReindex;         /* TRUE if reindexing is in process */
+   HB_BOOL  fUnique;          /* HB_TRUE if index is unique */
+   HB_BOOL  fReindex;         /* HB_TRUE if reindexing is in process */
    ULONG    ulMaxRec;         /* the highest record number */
    ULONG    ulTotKeys;        /* total number of keys indexed */
    ULONG    ulKeys;           /* keys in curently created page */
@@ -464,8 +464,8 @@ typedef struct _CDXAREA
    LPCDXSORTINFO  pSort;         /* Index build structure */
    LPCDXINDEX     lpIndexes;     /* Pointer to indexes array  */
    BYTE *         bCdxSortTab;   /* Table with sorted characters */
-   BOOL           fCdxAppend;    /* Appended record changed */
-   BOOL           fSortCDP;      /* Use CDP functions for sorting */
+   HB_BOOL        fCdxAppend;    /* Appended record changed */
+   HB_BOOL        fSortCDP;      /* Use CDP functions for sorting */
    USHORT         uiTag;         /* current tag focus */
 
 } CDXAREA;
diff --git a/harbour/include/hbrdddbf.h b/harbour/include/hbrdddbf.h
index 841670e18f..a0756d4d3d 100644
--- a/harbour/include/hbrdddbf.h
+++ b/harbour/include/hbrdddbf.h
@@ -143,11 +143,11 @@ typedef struct _DBFDATA
    USHORT   uiDirtyRead;      /* HB_IDXREAD_CLEANMASK */
    ULONG    ulMemoBlockSize;  /* 0 */
 
-   BOOL     fSortRecNo;
-   BOOL     fMultiKey;
-   BOOL     fStruct;
-   BOOL     fStrictStruct;
-   BOOL     fMultiTag;
+   HB_BOOL  fSortRecNo;
+   HB_BOOL  fMultiKey;
+   HB_BOOL  fStruct;
+   HB_BOOL  fStrictStruct;
+   HB_BOOL  fMultiTag;
 } DBFDATA, * LPDBFDATA;
 
 typedef struct _HB_DBFFIELDBITS
@@ -199,27 +199,27 @@ typedef struct _DBFAREA
    BYTE *   pRecord;                /* Buffer of record data */
    ULONG    ulRecCount;             /* Total records */
    ULONG    ulRecNo;                /* Current record */
-   BOOL     fAutoInc;               /* WorkArea with auto increment fields */
-   BOOL     fHasMemo;               /* WorkArea with Memo fields */
-   BOOL     fHasTags;               /* WorkArea with MDX or CDX index */
-   BOOL     fModStamp;              /* WorkArea with modification autoupdate fields */
-   BOOL     fDataFlush;             /* data was written to DBF and not commited */
-   BOOL     fMemoFlush;             /* data was written to MEMO and not commited */
-   BOOL     fShared;                /* Shared file */
-   BOOL     fReadonly;              /* Read only file */
-   BOOL     fTemporary;             /* Temporary file */
-   BOOL     fValidBuffer;           /* State of buffer */
-   BOOL     fPositioned;            /* Positioned record */
-   BOOL     fRecordChanged;         /* Record changed */
-   BOOL     fAppend;                /* TRUE if new record is added */
-   BOOL     fDeleted;               /* TRUE if record is deleted */
-   BOOL     fEncrypted;             /* TRUE if record is encrypted */
-   BOOL     fTableEncrypted;        /* TRUE if table is encrypted */
-   BOOL     fUpdateHeader;          /* Update header of file */
-   BOOL     fFLocked;               /* TRUE if file is locked */
-   BOOL     fHeaderLocked;          /* TRUE if DBF header is locked */
-   BOOL     fPackMemo;              /* Pack memo file in pack operation */
-   BOOL     fTrigger;               /* Execute trigger function */
+   HB_BOOL  fAutoInc;               /* WorkArea with auto increment fields */
+   HB_BOOL  fHasMemo;               /* WorkArea with Memo fields */
+   HB_BOOL  fHasTags;               /* WorkArea with MDX or CDX index */
+   HB_BOOL  fModStamp;              /* WorkArea with modification autoupdate fields */
+   HB_BOOL  fDataFlush;             /* data was written to DBF and not commited */
+   HB_BOOL  fMemoFlush;             /* data was written to MEMO and not commited */
+   HB_BOOL  fShared;                /* Shared file */
+   HB_BOOL  fReadonly;              /* Read only file */
+   HB_BOOL  fTemporary;             /* Temporary file */
+   HB_BOOL  fValidBuffer;           /* State of buffer */
+   HB_BOOL  fPositioned;            /* Positioned record */
+   HB_BOOL  fRecordChanged;         /* Record changed */
+   HB_BOOL  fAppend;                /* HB_TRUE if new record is added */
+   HB_BOOL  fDeleted;               /* HB_TRUE if record is deleted */
+   HB_BOOL  fEncrypted;             /* HB_TRUE if record is encrypted */
+   HB_BOOL  fTableEncrypted;        /* HB_TRUE if table is encrypted */
+   HB_BOOL  fUpdateHeader;          /* Update header of file */
+   HB_BOOL  fFLocked;               /* HB_TRUE if file is locked */
+   HB_BOOL  fHeaderLocked;          /* HB_TRUE if DBF header is locked */
+   HB_BOOL  fPackMemo;              /* Pack memo file in pack operation */
+   HB_BOOL  fTrigger;               /* Execute trigger function */
    LPDBOPENINFO lpdbOpenInfo;       /* Pointer to current dbOpenInfo structure in OPEN/CREATE methods */
    LPDBRELINFO lpdbPendingRel;      /* Pointer to parent rel struct */
    ULONG *  pLocksPos;              /* List of records locked */
@@ -246,8 +246,8 @@ extern HB_EXPORT HB_ERRCODE hb_dbfSetMemoData( DBFAREAP pArea, USHORT uiIndex,
                                                ULONG ulBlock, ULONG ulSize,
                                                ULONG ulType );
 extern HB_EXPORT HB_ERRCODE hb_dbfGetEGcode( HB_ERRCODE errCode );
-extern HB_EXPORT BOOL       hb_dbfLockIdxFile( PHB_FILE pFile, BYTE bScheme, USHORT usMode, HB_FOFFSET *pPoolPos );
-extern HB_EXPORT BOOL       hb_dbfLockIdxGetData( BYTE bScheme, HB_FOFFSET *ulPos, HB_FOFFSET *ulPool );
+extern HB_EXPORT HB_BOOL    hb_dbfLockIdxFile( PHB_FILE pFile, BYTE bScheme, USHORT usMode, HB_FOFFSET *pPoolPos );
+extern HB_EXPORT HB_BOOL    hb_dbfLockIdxGetData( BYTE bScheme, HB_FOFFSET *ulPos, HB_FOFFSET *ulPool );
 
 extern HB_EXPORT void hb_dbfTranslateRec( DBFAREAP pArea, BYTE * pBuffer, PHB_CODEPAGE cdp_src, PHB_CODEPAGE cdp_dest );
 
diff --git a/harbour/include/hbrdddel.h b/harbour/include/hbrdddel.h
index 36c18c174e..815a7f3ef5 100644
--- a/harbour/include/hbrdddel.h
+++ b/harbour/include/hbrdddel.h
@@ -99,12 +99,12 @@ typedef struct _DELIMAREA
    HB_FOFFSET ulBufferStart;        /* Start offset of read buffer */
    ULONG    ulRecNo;                /* Current record */
    ULONG    ulRecCount;             /* Number of records (in export) */
-   BOOL     fTransRec;              /* Can put whole records */
-   BOOL     fFlush;                 /* Data was written to table and not commited */
-   BOOL     fShared;                /* Shared file */
-   BOOL     fReadonly;              /* Read only file */
-   BOOL     fPositioned;            /* Positioned record */
-   BOOL     fRecordChanged;         /* Record changed */
+   HB_BOOL  fTransRec;              /* Can put whole records */
+   HB_BOOL  fFlush;                 /* Data was written to table and not commited */
+   HB_BOOL  fShared;                /* Shared file */
+   HB_BOOL  fReadonly;              /* Read only file */
+   HB_BOOL  fPositioned;            /* Positioned record */
+   HB_BOOL  fRecordChanged;         /* Record changed */
 } DELIMAREA;
 
 typedef DELIMAREA * LPDELIMAREA;
diff --git a/harbour/include/hbrddfpt.h b/harbour/include/hbrddfpt.h
index 17ad50e1e7..bc04442e0f 100644
--- a/harbour/include/hbrddfpt.h
+++ b/harbour/include/hbrddfpt.h
@@ -206,9 +206,9 @@ typedef FPTBLOCK * LPFPTBLOCK;
 /* MEMO internal memory structures */
 typedef struct _MEMOGCITEM
 {
-   ULONG ulOffset;                  /* Number of blocks */
-   ULONG ulSize;                    /* Block number */
-   BOOL  fChanged;                  /* Mark the free page as changed */
+   ULONG   ulOffset;                /* Number of blocks */
+   ULONG   ulSize;                  /* Block number */
+   HB_BOOL fChanged;                /* Mark the free page as changed */
 } MEMOGCITEM;
 typedef MEMOGCITEM * LPMEMOGCITEM;
 
diff --git a/harbour/include/hbrddnsx.h b/harbour/include/hbrddnsx.h
index f464f50641..e5d7636a7c 100644
--- a/harbour/include/hbrddnsx.h
+++ b/harbour/include/hbrddnsx.h
@@ -314,7 +314,7 @@ typedef struct _NSXLEAFPAGE
 } NSXLEAFPAGE;
 typedef NSXLEAFPAGE * LPNSXLEAFPAGE;
 
-#if 0 
+#if 0
 /* meta structures for description only, cannot be compiled due to
    variable member sizes */
 typedef struct _NSXBRANCHKEY
@@ -376,7 +376,7 @@ typedef TREE_STACK * LPTREESTACK;
 typedef struct _HB_PAGEINFO
 {
    ULONG    Page;
-   BOOL     Changed;
+   HB_BOOL  Changed;
    int      iUsed;
    USHORT   uiKeys;
    USHORT   uiOffset;
@@ -409,20 +409,20 @@ typedef struct _TAGINFO
    HB_NSXSCOPE bottom;
 
 
-   BOOL        fUsrDescend;
-   BOOL        AscendKey;
-   BOOL        UniqueKey;
+   HB_BOOL     fUsrDescend;
+   HB_BOOL     AscendKey;
+   HB_BOOL     UniqueKey;
 
-   BOOL        Custom;
-   BOOL        ChgOnly;
-   BOOL        Partial;
-   BOOL        Template;
-   BOOL        MultiKey;
+   HB_BOOL     Custom;
+   HB_BOOL     ChgOnly;
+   HB_BOOL     Partial;
+   HB_BOOL     Template;
+   HB_BOOL     MultiKey;
 
-   BOOL        HdrChanged;
-   BOOL        TagBOF;
-   BOOL        TagEOF;
-   BOOL        HotFor;
+   HB_BOOL     HdrChanged;
+   HB_BOOL     TagBOF;
+   HB_BOOL     TagEOF;
+   HB_BOOL     HotFor;
 
    ULONG       HeadBlock;
    ULONG       RootBlock;
@@ -459,20 +459,20 @@ typedef struct _NSXINDEX
    ULONG       FileSize;      /* index file size */
    struct     _NSXAREA * pArea;
    PHB_FILE    pFile;
-   BOOL        fDelete;       /* delete on close flag */
-   BOOL        fReadonly;
-   BOOL        fShared;
-   BOOL        fFlush;
-   BOOL        LargeFile;
-   BOOL        Changed;
-   BOOL        Update;
-   BOOL        Production;    /* Production index */
+   HB_BOOL     fDelete;       /* delete on close flag */
+   HB_BOOL     fReadonly;
+   HB_BOOL     fShared;
+   HB_BOOL     fFlush;
+   HB_BOOL     LargeFile;
+   HB_BOOL     Changed;
+   HB_BOOL     Update;
+   HB_BOOL     Production;    /* Production index */
    HB_FOFFSET  ulLockPos;     /* readlock position for CL53 lock scheme */
    int         lockWrite;     /* number of write lock set */
    int         lockRead;      /* number of read lock set */
 
    NSXROOTHEADER  HeaderBuff;
-   BOOL        fValidHeader;
+   HB_BOOL     fValidHeader;
    int         iTags;
    LPTAGINFO * lpTags;
 
@@ -507,8 +507,8 @@ typedef struct
    int         keyLen;           /* key length */
    UCHAR       trailChar;        /* index key trail character */
    UCHAR       recSize;          /* record size in leaf keys */
-   BOOL        fUnique;          /* TRUE if index is unique */
-   BOOL        fReindex;         /* TRUE if reindexing is in process */
+   HB_BOOL     fUnique;          /* HB_TRUE if index is unique */
+   HB_BOOL     fReindex;         /* HB_TRUE if reindexing is in process */
    ULONG       ulMaxRec;         /* the highest record number */
    ULONG       ulTotKeys;        /* total number of keys indexed */
    ULONG       ulKeys;           /* keys in curently created page */
@@ -553,8 +553,8 @@ typedef struct _NSXAREA
    *  example.
    */
 
-   BOOL           fIdxAppend;       /* TRUE if new record is added */
-   BOOL           fSetTagNumbers;   /* Tag number should be recreated */
+   HB_BOOL        fIdxAppend;       /* HB_TRUE if new record is added */
+   HB_BOOL        fSetTagNumbers;   /* Tag number should be recreated */
    LPNSXINDEX     lpIndexes;        /* Pointer to list of indexes */
    LPTAGINFO      lpCurTag;         /* Pointer to current order */
    LPNSXSORTINFO  pSort;            /* Index build structure */
diff --git a/harbour/include/hbrddntx.h b/harbour/include/hbrddntx.h
index e0af2e649b..dd49437f30 100644
--- a/harbour/include/hbrddntx.h
+++ b/harbour/include/hbrddntx.h
@@ -181,7 +181,7 @@ typedef TREE_STACK * LPTREESTACK;
 typedef struct _HB_PAGEINFO
 {
    ULONG    Page;
-   BOOL     Changed;
+   HB_BOOL  Changed;
    int      iUsed;
    USHORT   uiKeys;
    struct  _HB_PAGEINFO * pNext;
@@ -214,21 +214,21 @@ typedef struct _TAGINFO
 
    USHORT      Signature;
 
-   BOOL        fTagName;
-   BOOL        fUsrDescend;
-   BOOL        AscendKey;
-   BOOL        UniqueKey;
+   HB_BOOL     fTagName;
+   HB_BOOL     fUsrDescend;
+   HB_BOOL     AscendKey;
+   HB_BOOL     UniqueKey;
 
-   BOOL        Custom;
-   BOOL        ChgOnly;
-   BOOL        Partial;
-   BOOL        Template;
-   BOOL        MultiKey;
-   BOOL        fSortRec;
+   HB_BOOL     Custom;
+   HB_BOOL     ChgOnly;
+   HB_BOOL     Partial;
+   HB_BOOL     Template;
+   HB_BOOL     MultiKey;
+   HB_BOOL     fSortRec;
 
-   BOOL        HdrChanged;
-   BOOL        TagBOF;
-   BOOL        TagEOF;
+   HB_BOOL     HdrChanged;
+   HB_BOOL     TagBOF;
+   HB_BOOL     TagEOF;
    ULONG       HeadBlock;
    ULONG       RootBlock;
    USHORT      uiNumber;
@@ -243,7 +243,7 @@ typedef struct _TAGINFO
    ULONG       keyCount;
    LPKEYINFO   CurKeyInfo;
    LPKEYINFO   HotKeyInfo;
-   BOOL        HotFor;
+   HB_BOOL     HotFor;
 
    struct     _NTXINDEX * Owner;
 } TAGINFO;
@@ -258,21 +258,21 @@ typedef struct _NTXINDEX
    ULONG       TagBlock;      /* Index attr, next free page */
    struct     _NTXAREA * Owner;
    PHB_FILE    DiskFile;
-   BOOL        fDelete;       /* delete on close flag */
-   BOOL        fReadonly;
-   BOOL        fShared;
-   BOOL        fFlush;
-   BOOL        LargeFile;
-   BOOL        Changed;
-   BOOL        Update;
-   BOOL        Compound;
-   BOOL        Production;    /* Production index */
+   HB_BOOL     fDelete;       /* delete on close flag */
+   HB_BOOL     fReadonly;
+   HB_BOOL     fShared;
+   HB_BOOL     fFlush;
+   HB_BOOL     LargeFile;
+   HB_BOOL     Changed;
+   HB_BOOL     Update;
+   HB_BOOL     Compound;
+   HB_BOOL     Production;    /* Production index */
    HB_FOFFSET  ulLockPos;     /* readlock position for CL53 lock scheme */
    int         lockWrite;     /* number of write lock set */
    int         lockRead;      /* number of read lock set */
 
    BYTE *      HeaderBuff;    /* TODO: make it member */
-   BOOL        fValidHeader;
+   HB_BOOL     fValidHeader;
    int         iTags;
    LPTAGINFO * lpTags;
 
@@ -305,8 +305,8 @@ typedef struct
    HB_FHANDLE hTempFile;      /* handle to temporary file */
    char *   szTempFileName;   /* temporary file name */
    int      keyLen;           /* key length */
-   BOOL     fUnique;          /* TRUE if index is unique */
-   BOOL     fReindex;         /* TRUE if reindexing is in process */
+   HB_BOOL  fUnique;          /* HB_TRUE if index is unique */
+   HB_BOOL  fReindex;         /* HB_TRUE if reindexing is in process */
    ULONG    ulMaxRec;         /* the highest record number */
    ULONG    ulTotKeys;        /* total number of keys indexed */
    ULONG    ulKeys;           /* keys in curently created page */
@@ -350,8 +350,8 @@ typedef struct _NTXAREA
    *  example.
    */
 
-   BOOL           fNtxAppend;       /* TRUE if new record is added */
-   BOOL           fSetTagNumbers;   /* Tag number should be recreated */
+   HB_BOOL        fNtxAppend;       /* HB_TRUE if new record is added */
+   HB_BOOL        fSetTagNumbers;   /* Tag number should be recreated */
    LPNTXINDEX     lpIndexes;        /* Pointer to list of indexes */
    LPTAGINFO      lpCurTag;         /* Pointer to current order */
    LPNTXSORTINFO  pSort;            /* Index build structure */
diff --git a/harbour/include/hbrddsdf.h b/harbour/include/hbrddsdf.h
index 541c11da27..b32eb34ef0 100644
--- a/harbour/include/hbrddsdf.h
+++ b/harbour/include/hbrddsdf.h
@@ -92,12 +92,12 @@ typedef struct _SDFAREA
    HB_FOFFSET ulFileSize;           /* File table size in export mode */
    ULONG    ulRecNo;                /* Current record */
    ULONG    ulRecCount;             /* Number of records (in export) */
-   BOOL     fTransRec;              /* Can put whole records */
-   BOOL     fFlush;                 /* Data was written to SDF and not commited */
-   BOOL     fShared;                /* Shared file */
-   BOOL     fReadonly;              /* Read only file */
-   BOOL     fPositioned;            /* Positioned record */
-   BOOL     fRecordChanged;         /* Record changed */
+   HB_BOOL  fTransRec;              /* Can put whole records */
+   HB_BOOL  fFlush;                 /* Data was written to SDF and not commited */
+   HB_BOOL  fShared;                /* Shared file */
+   HB_BOOL  fReadonly;              /* Read only file */
+   HB_BOOL  fPositioned;            /* Positioned record */
+   HB_BOOL  fRecordChanged;         /* Record changed */
 } SDFAREA;
 
 typedef SDFAREA * LPSDFAREA;
diff --git a/harbour/src/rdd/dbcmd.c b/harbour/src/rdd/dbcmd.c
index eda6b1765d..230240cca7 100644
--- a/harbour/src/rdd/dbcmd.c
+++ b/harbour/src/rdd/dbcmd.c
@@ -265,7 +265,7 @@ HB_FUNC( DBF )
 
 HB_FUNC( BOF )
 {
-   BOOL bBof = TRUE;
+   HB_BOOL bBof = HB_TRUE;
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
 
    if( pArea )
@@ -280,11 +280,11 @@ HB_FUNC( DBAPPEND )
 
    if( pArea )
    {
-      BOOL bUnLockAll = hb_parldef( 1, 1 );
+      HB_BOOL bUnLockAll = hb_parldef( 1, 1 );
       HB_ERRCODE errCode;
 
       /* Clipper clears NETERR flag before APPEND */
-      hb_rddSetNetErr( FALSE );
+      hb_rddSetNetErr( HB_FALSE );
       errCode = SELF_APPEND( pArea, bUnLockAll );
       hb_retl( errCode == HB_SUCCESS );
    }
@@ -337,7 +337,7 @@ HB_FUNC( DBCREATE )
    const char * szFileName, * szAlias, * szDriver, * szCpId;
    USHORT uiSize, uiLen;
    PHB_ITEM pStruct, pFieldDesc, pDelim;
-   BOOL fKeepOpen, fCurrArea;
+   HB_BOOL fKeepOpen, fCurrArea;
    ULONG ulConnection;
 
    /*
@@ -464,7 +464,7 @@ HB_FUNC( __DBOPENSDF )
    const char * szFileName, * szAlias, * szDriver, * szCpId;
    USHORT uiSize, uiLen;
    PHB_ITEM pStruct, pFieldDesc, pDelim;
-   BOOL fKeepOpen, fCurrArea;
+   HB_BOOL fKeepOpen, fCurrArea;
    ULONG ulConnection;
    HB_ERRCODE errCode;
 
@@ -511,7 +511,7 @@ HB_FUNC( __DBOPENSDF )
 
    errCode = hb_rddOpenTable( szFileName, szDriver,
                               fCurrArea ? hb_rddGetCurrentWorkAreaNumber() : 0,
-                              szAlias, TRUE, TRUE,
+                              szAlias, HB_TRUE, HB_TRUE,
                               szCpId, ulConnection,
                               pStruct, pDelim );
 
@@ -597,14 +597,14 @@ HB_FUNC( __DBLOCATE )
       dbScopeInfo.itmRecID    = hb_param( 4, HB_IT_NUMERIC );
       dbScopeInfo.fRest       = hb_param( 5, HB_IT_LOGICAL );
 
-      dbScopeInfo.fIgnoreFilter     = TRUE;
-      dbScopeInfo.fIncludeDeleted   = TRUE;
-      dbScopeInfo.fLast             = FALSE;
-      dbScopeInfo.fIgnoreDuplicates = FALSE;
-      dbScopeInfo.fBackward         = FALSE;
+      dbScopeInfo.fIgnoreFilter     = HB_TRUE;
+      dbScopeInfo.fIncludeDeleted   = HB_TRUE;
+      dbScopeInfo.fLast             = HB_FALSE;
+      dbScopeInfo.fIgnoreDuplicates = HB_FALSE;
+      dbScopeInfo.fBackward         = HB_FALSE;
 
       if( SELF_SETLOCATE( pArea, &dbScopeInfo ) == HB_SUCCESS )
-         SELF_LOCATE( pArea, FALSE );
+         SELF_LOCATE( pArea, HB_FALSE );
    }
    else
       hb_errRT_DBCMD( EG_NOTABLE, EG_NOTABLE, NULL, HB_ERR_FUNCNAME );
@@ -633,7 +633,7 @@ HB_FUNC( __DBCONTINUE )
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
 
    if( pArea )
-      SELF_LOCATE( pArea, TRUE );
+      SELF_LOCATE( pArea, HB_TRUE );
    else
       hb_errRT_DBCMD( EG_NOTABLE, EDBCMD_NOTABLE, NULL, HB_ERR_FUNCNAME );
 }
@@ -692,7 +692,7 @@ HB_FUNC( DBRLOCK )
    if( pArea )
    {
       DBLOCKINFO dbLockInfo;
-      dbLockInfo.fResult = FALSE;
+      dbLockInfo.fResult = HB_FALSE;
       dbLockInfo.itmRecID = hb_param( 1, HB_IT_ANY );
       if( !dbLockInfo.itmRecID || HB_ISNIL( 1 ) )
          dbLockInfo.uiMethod = DBLM_EXCLUSIVE;
@@ -739,12 +739,12 @@ HB_FUNC( DBSEEK )
       if( ! HB_ISNIL( 1 ) )
       {
          PHB_ITEM pKey = hb_param( 1, HB_IT_ANY );
-         BOOL bSoftSeek = HB_ISLOG( 2 ) ? ( BOOL ) hb_parl( 2 ) : hb_setGetSoftSeek();
-         BOOL bFindLast = hb_parl( 3 ), fFound = FALSE;
+         HB_BOOL bSoftSeek = HB_ISLOG( 2 ) ? ( HB_BOOL ) hb_parl( 2 ) : hb_setGetSoftSeek();
+         HB_BOOL bFindLast = hb_parl( 3 ), fFound = HB_FALSE;
          if( SELF_SEEK( pArea, bSoftSeek, pKey, bFindLast ) == HB_SUCCESS )
          {
             if( SELF_FOUND( pArea, &fFound ) != HB_SUCCESS )
-               fFound = FALSE;
+               fFound = HB_FALSE;
          }
          hb_retl( fFound );
       }
@@ -814,9 +814,9 @@ HB_FUNC( DBSETFILTER )
             pFilterInfo.abFilterText = pText;
          else
             pFilterInfo.abFilterText = hb_itemPutC( NULL, NULL );
-         pFilterInfo.fFilter = TRUE;
+         pFilterInfo.fFilter = HB_TRUE;
          pFilterInfo.lpvCargo = NULL;
-         pFilterInfo.fOptimized = FALSE;
+         pFilterInfo.fOptimized = HB_FALSE;
          SELF_SETFILTER( pArea, &pFilterInfo );
          if( !pText )
             hb_itemRelease( pFilterInfo.abFilterText );
@@ -912,7 +912,7 @@ HB_FUNC( __DBZAP )
 
 HB_FUNC( DELETED )
 {
-   BOOL bDeleted = FALSE;
+   HB_BOOL bDeleted = HB_FALSE;
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
 
    if( pArea )
@@ -922,7 +922,7 @@ HB_FUNC( DELETED )
 
 HB_FUNC( EOF )
 {
-   BOOL bEof = TRUE;
+   HB_BOOL bEof = HB_TRUE;
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
 
    if( pArea )
@@ -1017,7 +1017,7 @@ HB_FUNC( FLOCK )
    if( pArea )
    {
       DBLOCKINFO dbLockInfo;
-      dbLockInfo.fResult = FALSE;
+      dbLockInfo.fResult = HB_FALSE;
       dbLockInfo.itmRecID = NULL;
       dbLockInfo.uiMethod = DBLM_FILE;
       SELF_LOCK( pArea, &dbLockInfo );
@@ -1029,7 +1029,7 @@ HB_FUNC( FLOCK )
 
 HB_FUNC( FOUND )
 {
-   BOOL bFound = FALSE;
+   HB_BOOL bFound = HB_FALSE;
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
 
    if( pArea )
@@ -1087,7 +1087,7 @@ HB_FUNC( LOCK )
    if( pArea )
    {
       DBLOCKINFO dbLockInfo;
-      dbLockInfo.fResult = FALSE;
+      dbLockInfo.fResult = HB_FALSE;
       dbLockInfo.itmRecID = NULL;
       dbLockInfo.uiMethod = DBLM_EXCLUSIVE;
       SELF_LOCK( pArea, &dbLockInfo );
@@ -1236,11 +1236,11 @@ HB_FUNC( ORDCONDSET )
       lpdbOrdCondInfo->fExclusive    = hb_parl( 20 );
 
       if( lpdbOrdCondInfo->itmCobWhile )
-         lpdbOrdCondInfo->fRest = TRUE;
+         lpdbOrdCondInfo->fRest = HB_TRUE;
       if( lpdbOrdCondInfo->lNextCount || lpdbOrdCondInfo->itmRecID ||
                lpdbOrdCondInfo->fRest || lpdbOrdCondInfo->fUseCurrent ||
           lpdbOrdCondInfo->fUseFilter )
-         lpdbOrdCondInfo->fAll = FALSE;
+         lpdbOrdCondInfo->fAll = HB_FALSE;
 
       lpdbOrdCondInfo->fActive = !lpdbOrdCondInfo->fAll ||
                lpdbOrdCondInfo->abFor || lpdbOrdCondInfo->itmCobFor ||
@@ -1254,7 +1254,7 @@ HB_FUNC( ORDCONDSET )
       hb_retl( SELF_ORDSETCOND( pArea, lpdbOrdCondInfo ) == HB_SUCCESS );
    }
    else
-      hb_retl( FALSE );
+      hb_retl( HB_FALSE );
 }
 
 HB_FUNC( ORDCREATE )
@@ -1270,7 +1270,7 @@ HB_FUNC( ORDCREATE )
       dbOrderInfo.abBagName = hb_parcx( 1 );
       dbOrderInfo.atomBagName = hb_parcx( 2 );
       dbOrderInfo.itmOrder = NULL;
-      dbOrderInfo.fUnique = HB_ISLOG( 5 ) ? ( BOOL ) hb_parl( 5 ) : hb_setGetUnique();
+      dbOrderInfo.fUnique = HB_ISLOG( 5 ) ? ( HB_BOOL ) hb_parl( 5 ) : hb_setGetUnique();
       dbOrderInfo.abExpr = hb_param( 3, HB_IT_STRING );
       if( ( ( dbOrderInfo.abBagName == NULL || dbOrderInfo.abBagName[ 0 ] == 0 ) &&
             ( dbOrderInfo.atomBagName == NULL || dbOrderInfo.atomBagName[ 0 ] == 0 ) ) ||
@@ -1314,7 +1314,7 @@ HB_FUNC( ORDBAGCLEAR )
       hb_retl( SELF_ORDLSTDELETE( pArea, &pOrderInfo ) == HB_SUCCESS );
    }
    else
-      hb_retl( FALSE );
+      hb_retl( HB_FALSE );
 }
 
 HB_FUNC( ORDDESTROY )
@@ -1332,7 +1332,7 @@ HB_FUNC( ORDDESTROY )
       hb_retl( SELF_ORDDESTROY( pArea, &pOrderInfo ) == HB_SUCCESS );
    }
    else
-      hb_retl( FALSE );
+      hb_retl( HB_FALSE );
 }
 
 HB_FUNC( ORDFOR )
@@ -1362,7 +1362,7 @@ HB_FUNC( ORDFOR )
       pOrderInfo.itmNewVal = hb_param( 3, HB_IT_STRING );
       pOrderInfo.itmResult = hb_itemPutC( NULL, NULL );
       pOrderInfo.itmCobExpr = NULL;
-      pOrderInfo.fAllTags = FALSE;
+      pOrderInfo.fAllTags = HB_FALSE;
       SELF_ORDINFO( pArea, DBOI_CONDITION, &pOrderInfo );
       hb_itemReturnRelease( pOrderInfo.itmResult );
    }
@@ -1413,7 +1413,7 @@ HB_FUNC( ORDLISTADD )
       HB_ERRCODE errCode;
 
       /* Clipper clears NETERR flag when index is open */
-      hb_rddSetNetErr( FALSE );
+      hb_rddSetNetErr( HB_FALSE );
 
       memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
       pOrderInfo.atomBagName = hb_param( 1, HB_IT_STRING );
@@ -1624,7 +1624,7 @@ HB_FUNC( RLOCK )
    if( pArea )
    {
       DBLOCKINFO dbLockInfo;
-      dbLockInfo.fResult = FALSE;
+      dbLockInfo.fResult = HB_FALSE;
       dbLockInfo.itmRecID = NULL;
       dbLockInfo.uiMethod = DBLM_EXCLUSIVE;
       SELF_LOCK( pArea, &dbLockInfo );
@@ -1804,7 +1804,7 @@ HB_FUNC( DBSETRELATION )
       dbRelations.itmCobExpr = hb_itemNew( hb_param( 2, HB_IT_BLOCK ) );
       dbRelations.abKey = hb_itemNew( hb_param( 3, HB_IT_STRING ) );
       dbRelations.isScoped = hb_parl( 4 );
-      dbRelations.isOptimized = FALSE;
+      dbRelations.isOptimized = HB_FALSE;
       dbRelations.lpaChild = pChildArea;
       dbRelations.lpaParent = pArea;
       dbRelations.lpdbriNext = NULL;
@@ -1878,8 +1878,8 @@ HB_FUNC( __DBARRANGE )
       dbSortInfo.dbtri.dbsci.fLast =
       dbSortInfo.dbtri.dbsci.fIgnoreDuplicates =
       dbSortInfo.dbtri.dbsci.fBackward =
-      dbSortInfo.dbtri.dbsci.fOptimized = FALSE;
-      dbSortInfo.dbtri.dbsci.fIncludeDeleted = TRUE;
+      dbSortInfo.dbtri.dbsci.fOptimized = HB_FALSE;
+      dbSortInfo.dbtri.dbsci.fIncludeDeleted = HB_TRUE;
 
       pFields = hb_param( 8, HB_IT_ARRAY );
       dbSortInfo.uiItemCount = pFields ? ( USHORT ) hb_arrayLen( pFields ) : 0;
@@ -1979,11 +1979,11 @@ HB_FUNC( __DBTRANS )
             dbTransInfo.dbsci.itmRecID    = HB_ISNIL( 6 ) ? NULL : hb_param( 6, HB_IT_ANY );
             dbTransInfo.dbsci.fRest       = hb_param( 7, HB_IT_LOGICAL );
 
-            dbTransInfo.dbsci.fIgnoreFilter     = TRUE;
-            dbTransInfo.dbsci.fIncludeDeleted   = TRUE;
-            dbTransInfo.dbsci.fLast             = FALSE;
-            dbTransInfo.dbsci.fIgnoreDuplicates = FALSE;
-            dbTransInfo.dbsci.fBackward         = FALSE;
+            dbTransInfo.dbsci.fIgnoreFilter     = HB_TRUE;
+            dbTransInfo.dbsci.fIncludeDeleted   = HB_TRUE;
+            dbTransInfo.dbsci.fLast             = HB_FALSE;
+            dbTransInfo.dbsci.fIgnoreDuplicates = HB_FALSE;
+            dbTransInfo.dbsci.fBackward         = HB_FALSE;
 
             errCode = SELF_TRANS( dbTransInfo.lpaSource, &dbTransInfo );
          }
@@ -2011,7 +2011,7 @@ HB_FUNC( __DBAPP )
                hb_parc( 8 ),                     /* RDD */
                hb_parnl( 9 ),                    /* connection */
                hb_param( 2, HB_IT_ARRAY ),       /* Fields */
-               FALSE,                            /* Export? */
+               HB_FALSE,                         /* Export? */
                hb_param( 3, HB_IT_BLOCK ),       /* cobFor */
                NULL,                             /* lpStrFor */
                hb_param( 4, HB_IT_BLOCK ),       /* cobWhile */
@@ -2034,7 +2034,7 @@ HB_FUNC( __DBCOPY )
                hb_parc( 8 ),                     /* RDD */
                hb_parnl( 9 ),                    /* connection */
                hb_param( 2, HB_IT_ARRAY ),       /* Fields */
-               TRUE,                             /* Export? */
+               HB_TRUE,                          /* Export? */
                hb_param( 3, HB_IT_BLOCK ),       /* cobFor */
                NULL,                             /* lpStrFor */
                hb_param( 4, HB_IT_BLOCK ),       /* cobWhile */
diff --git a/harbour/src/rdd/dbcmd53.c b/harbour/src/rdd/dbcmd53.c
index 70cb35d702..b8f7ec2902 100644
--- a/harbour/src/rdd/dbcmd53.c
+++ b/harbour/src/rdd/dbcmd53.c
@@ -124,7 +124,7 @@ HB_FUNC( ORDKEYGOTO )
       DBORDERINFO pOrderInfo;
       memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
       pOrderInfo.itmNewVal = hb_param( 1 , HB_IT_NUMERIC );
-      pOrderInfo.itmResult = hb_itemPutL( NULL, FALSE );
+      pOrderInfo.itmResult = hb_itemPutL( NULL, HB_FALSE );
       SELF_ORDINFO( pArea, DBOI_POSITION, &pOrderInfo );
       hb_itemReturnRelease( pOrderInfo.itmResult );
    }
@@ -158,7 +158,7 @@ HB_FUNC( ORDFINDREC )
       DBORDERINFO pOrderInfo;
       memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
       pOrderInfo.itmNewVal = hb_param( 1 , HB_IT_NUMERIC );
-      pOrderInfo.itmResult = hb_itemPutL( NULL, FALSE );
+      pOrderInfo.itmResult = hb_itemPutL( NULL, HB_FALSE );
       SELF_ORDINFO( pArea, hb_parl( 2 ) ? DBOI_FINDRECCONT :
                                           DBOI_FINDREC, &pOrderInfo );
       hb_itemReturnRelease( pOrderInfo.itmResult );
@@ -186,7 +186,7 @@ HB_FUNC( ORDSKIPUNIQUE )
       DBORDERINFO pOrderInfo;
       memset( &pOrderInfo, 0, sizeof( DBORDERINFO ) );
       pOrderInfo.itmNewVal = hb_param( 1, HB_IT_ANY );
-      pOrderInfo.itmResult = hb_itemPutL( NULL, FALSE );
+      pOrderInfo.itmResult = hb_itemPutL( NULL, HB_FALSE );
       SELF_ORDINFO( pArea, DBOI_SKIPUNIQUE, &pOrderInfo );
       hb_itemReturnRelease( pOrderInfo.itmResult );
    }
@@ -268,7 +268,7 @@ HB_FUNC( ORDDESCEND )
       pOrderInfo.atomBagName = hb_param( 2, HB_IT_STRING );
       /* Either or both may be NIL */
       pOrderInfo.itmNewVal = hb_param( 3 , HB_IT_LOGICAL );
-      pOrderInfo.itmResult = hb_itemPutL( NULL, FALSE );
+      pOrderInfo.itmResult = hb_itemPutL( NULL, HB_FALSE );
       SELF_ORDINFO( pArea, DBOI_ISDESC, &pOrderInfo );
       hb_itemReturnRelease( pOrderInfo.itmResult );
    }
@@ -290,7 +290,7 @@ HB_FUNC( ORDISUNIQUE )
       pOrderInfo.atomBagName = hb_param( 2, HB_IT_STRING );
       /* HARBOUR extension: NewVal to set/reset unique flag */
       pOrderInfo.itmNewVal = hb_param( 3 , HB_IT_LOGICAL );
-      pOrderInfo.itmResult = hb_itemPutL( NULL, FALSE );
+      pOrderInfo.itmResult = hb_itemPutL( NULL, HB_FALSE );
       SELF_ORDINFO( pArea, DBOI_UNIQUE, &pOrderInfo );
       hb_itemReturnRelease( pOrderInfo.itmResult );
    }
@@ -312,7 +312,7 @@ HB_FUNC( ORDCUSTOM )
       pOrderInfo.atomBagName = hb_param( 2, HB_IT_STRING );
       /* Either or both may be NIL */
       pOrderInfo.itmNewVal = hb_param( 3 , HB_IT_LOGICAL );
-      pOrderInfo.itmResult = hb_itemPutL( NULL, FALSE );
+      pOrderInfo.itmResult = hb_itemPutL( NULL, HB_FALSE );
       SELF_ORDINFO( pArea, DBOI_CUSTOM, &pOrderInfo );
       hb_itemReturnRelease( pOrderInfo.itmResult );
    }
@@ -383,7 +383,7 @@ HB_FUNC( DBORDERINFO )
          pOrderInfo.itmNewVal = hb_param( 4 , HB_IT_ANY );
          pOrderInfo.itmResult = hb_itemNew( NULL );
          pOrderInfo.itmCobExpr = NULL;
-         pOrderInfo.fAllTags = FALSE;
+         pOrderInfo.fAllTags = HB_FALSE;
          SELF_ORDINFO( pArea, hb_itemGetNI( pType ), &pOrderInfo );
          hb_itemReturnRelease( pOrderInfo.itmResult );
       }
diff --git a/harbour/src/rdd/dbdetach.c b/harbour/src/rdd/dbdetach.c
index c05c45a36d..e81bc687cf 100644
--- a/harbour/src/rdd/dbdetach.c
+++ b/harbour/src/rdd/dbdetach.c
@@ -102,7 +102,7 @@ HB_FUNC( HB_DBREQUEST )
 {
    const char * szAlias;
    PHB_ITEM pCargo;
-   BOOL fNewArea, fWait;
+   HB_BOOL fNewArea, fWait;
    AREAP pArea;
 
    if( HB_ISNIL( 1 ) || HB_ISCHAR( 1 ) )
diff --git a/harbour/src/rdd/dbf1.c b/harbour/src/rdd/dbf1.c
index 0597b7db92..71bcdb91ed 100644
--- a/harbour/src/rdd/dbf1.c
+++ b/harbour/src/rdd/dbf1.c
@@ -87,14 +87,14 @@ static RDDFUNCS dbfSuper;
 static HB_LONG hb_dbfGetRowVer( DBFAREAP pArea, USHORT uiField, HB_LONG * pValue )
 {
    DBFFIELD dbField;
-   BOOL fLck = FALSE;
+   HB_BOOL fLck = HB_FALSE;
 
    *pValue = 0;
    if( pArea->fShared && !pArea->fFLocked && !pArea->fHeaderLocked )
    {
       if( SELF_RAWLOCK( ( AREAP ) pArea, HEADER_LOCK, 0 ) != HB_SUCCESS )
          return HB_FAILURE;
-      fLck = TRUE;
+      fLck = HB_TRUE;
    }
 
    if( hb_fileReadAt( pArea->pDataFile, &dbField, sizeof( dbField ),
@@ -317,7 +317,7 @@ static void hb_dbfSetBlankRecord( DBFAREAP pArea, int iType )
    }
 }
 
-static void hb_dbfAllocNullFlag( DBFAREAP pArea, USHORT uiField, BOOL fLength )
+static void hb_dbfAllocNullFlag( DBFAREAP pArea, USHORT uiField, HB_BOOL fLength )
 {
    if( !pArea->pFieldBits )
    {
@@ -330,7 +330,7 @@ static void hb_dbfAllocNullFlag( DBFAREAP pArea, USHORT uiField, BOOL fLength )
       pArea->pFieldBits[ uiField ].uiNullBit = pArea->uiNullCount++;
 }
 
-static BOOL hb_dbfGetNullFlag( DBFAREAP pArea, USHORT uiBit )
+static HB_BOOL hb_dbfGetNullFlag( DBFAREAP pArea, USHORT uiBit )
 {
    return ( pArea->pRecord[ pArea->uiNullOffset + ( uiBit >> 3 ) ] &
             ( 1 << ( uiBit & 0x07 ) ) ) != 0;
@@ -349,10 +349,10 @@ static void hb_dbfClearNullFlag( BYTE * pRecord, USHORT uiNullOffset, USHORT uiB
 /*
  * Executes user trigger function
  */
-static BOOL hb_dbfTriggerDo( DBFAREAP pArea, int iEvent,
-                             int iField, PHB_ITEM pItem )
+static HB_BOOL hb_dbfTriggerDo( DBFAREAP pArea, int iEvent,
+                                int iField, PHB_ITEM pItem )
 {
-   BOOL fResult = TRUE;
+   HB_BOOL fResult = HB_TRUE;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfTriggerDo(%p,%d,%d,%p)", pArea, iEvent, iField, pItem));
 
@@ -424,14 +424,14 @@ static ULONG hb_dbfCalcRecCount( DBFAREAP pArea )
 /*
  * Read current record from file.
  */
-static BOOL hb_dbfReadRecord( DBFAREAP pArea )
+static HB_BOOL hb_dbfReadRecord( DBFAREAP pArea )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfReadRecord(%p)", pArea));
 
    if( !pArea->fPositioned )
    {
-      pArea->fValidBuffer = TRUE;
-      return TRUE;
+      pArea->fValidBuffer = HB_TRUE;
+      return HB_TRUE;
    }
 
    if( pArea->ulRecNo > pArea->ulRecCount )
@@ -442,8 +442,8 @@ static BOOL hb_dbfReadRecord( DBFAREAP pArea )
 
       if( pArea->ulRecNo > pArea->ulRecCount )
       {
-         pArea->area.fEof = pArea->fValidBuffer = TRUE;
-         return TRUE;
+         pArea->area.fEof = pArea->fValidBuffer = HB_TRUE;
+         return HB_TRUE;
       }
    }
 
@@ -463,41 +463,41 @@ static BOOL hb_dbfReadRecord( DBFAREAP pArea )
       hb_errPutFileName( pError, pArea->szDataFileName );
       SELF_ERROR( ( AREAP ) pArea, pError );
       hb_itemRelease( pError );
-      return FALSE;
+      return HB_FALSE;
    }
 
    if( SELF_GETREC( ( AREAP ) pArea, NULL ) == HB_FAILURE )
-      return FALSE;
+      return HB_FALSE;
 
    /* Set flags */
-   pArea->fValidBuffer = pArea->fPositioned = TRUE;
+   pArea->fValidBuffer = pArea->fPositioned = HB_TRUE;
    pArea->fDeleted = pArea->pRecord[ 0 ] == '*';
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * Write current record to file.
  */
-static BOOL hb_dbfWriteRecord( DBFAREAP pArea )
+static HB_BOOL hb_dbfWriteRecord( DBFAREAP pArea )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfWriteRecord(%p)", pArea));
 
    if( SELF_PUTREC( ( AREAP ) pArea, NULL ) == HB_FAILURE )
-      return FALSE;
+      return HB_FALSE;
 
-   pArea->fRecordChanged = FALSE;
-   pArea->fDataFlush = TRUE;
-   return TRUE;
+   pArea->fRecordChanged = HB_FALSE;
+   pArea->fDataFlush = HB_TRUE;
+   return HB_TRUE;
 }
 
 /*
  * Set encryption password
  */
-static BOOL hb_dbfPasswordSet( DBFAREAP pArea, PHB_ITEM pPasswd, BOOL fRaw )
+static HB_BOOL hb_dbfPasswordSet( DBFAREAP pArea, PHB_ITEM pPasswd, HB_BOOL fRaw )
 {
    char pKeyBuffer[ 8 ];
    ULONG ulLen;
-   BOOL fKeySet = FALSE, fSet;
+   HB_BOOL fKeySet = HB_FALSE, fSet;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfPasswordSet(%p,%p,%d)", pArea, pPasswd, fRaw));
 
@@ -529,7 +529,7 @@ static BOOL hb_dbfPasswordSet( DBFAREAP pArea, PHB_ITEM pPasswd, BOOL fRaw )
       if( pArea->pRecord && pArea->fPositioned )
       {
          SELF_GOCOLD( ( AREAP ) pArea );
-         pArea->fValidBuffer = FALSE;
+         pArea->fValidBuffer = HB_FALSE;
       }
       if( pArea->pCryptKey )
       {
@@ -552,7 +552,7 @@ static BOOL hb_dbfPasswordSet( DBFAREAP pArea, PHB_ITEM pPasswd, BOOL fRaw )
             hb_sxEnCrypt( pKeyBuffer, pArea->pCryptKey, pKeyBuffer, 8 );
          else
             memcpy( pArea->pCryptKey, pKeyBuffer, 8 );
-         fKeySet = TRUE;
+         fKeySet = HB_TRUE;
       }
    }
 
@@ -562,7 +562,7 @@ static BOOL hb_dbfPasswordSet( DBFAREAP pArea, PHB_ITEM pPasswd, BOOL fRaw )
 /*
  * Encrypt/Decrypt table
  */
-static void hb_dbfTableCrypt( DBFAREAP pArea, PHB_ITEM pPasswd, BOOL fEncrypt )
+static void hb_dbfTableCrypt( DBFAREAP pArea, PHB_ITEM pPasswd, HB_BOOL fEncrypt )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfTableCrypt(%p,%p,%d)", pArea, pPasswd, fEncrypt));
 
@@ -579,7 +579,7 @@ static void hb_dbfTableCrypt( DBFAREAP pArea, PHB_ITEM pPasswd, BOOL fEncrypt )
 
          pOldCryptKey = pArea->pCryptKey;
          pArea->pCryptKey = NULL;
-         hb_dbfPasswordSet( pArea, pPasswd, FALSE );
+         hb_dbfPasswordSet( pArea, pPasswd, HB_FALSE );
          pNewCryptKey = pArea->pCryptKey;
          if( !fEncrypt && pNewCryptKey )
          {
@@ -621,7 +621,7 @@ static void hb_dbfTableCrypt( DBFAREAP pArea, PHB_ITEM pPasswd, BOOL fEncrypt )
          if( errCode == HB_SUCCESS )
          {
             pArea->fTableEncrypted = fEncrypt;
-            pArea->fUpdateHeader = TRUE;
+            pArea->fUpdateHeader = HB_TRUE;
             SELF_WRITEDBHEADER( ( AREAP ) pArea );
          }
       }
@@ -693,7 +693,7 @@ static HB_ERRCODE hb_dbfUnlockRecord( DBFAREAP pArea, ULONG ulRecNo )
  * Lock a record.
  */
 static HB_ERRCODE hb_dbfLockRecord( DBFAREAP pArea, ULONG ulRecNo, USHORT * pResult,
-                                    BOOL bExclusive )
+                                    HB_BOOL bExclusive )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfLockRecord(%p, %lu, %p, %i)", pArea, ulRecNo,
             pResult, (int) bExclusive));
@@ -706,7 +706,7 @@ static HB_ERRCODE hb_dbfLockRecord( DBFAREAP pArea, ULONG ulRecNo, USHORT * pRes
 
    if( pArea->fFLocked )
    {
-      * pResult = TRUE;
+      * pResult = HB_TRUE;
       return HB_SUCCESS;
    }
 
@@ -724,7 +724,7 @@ static HB_ERRCODE hb_dbfLockRecord( DBFAREAP pArea, ULONG ulRecNo, USHORT * pRes
       {
          if( pArea->pLocksPos[ ul ] == ulRecNo )
          {
-            * pResult = TRUE;
+            * pResult = HB_TRUE;
             return HB_SUCCESS;
          }
       }
@@ -743,7 +743,7 @@ static HB_ERRCODE hb_dbfLockRecord( DBFAREAP pArea, ULONG ulRecNo, USHORT * pRes
                                                      sizeof( ULONG ) );
       }
       pArea->pLocksPos[ pArea->ulNumLocksPos++ ] = ulRecNo;
-      * pResult = TRUE;
+      * pResult = HB_TRUE;
       if( ulRecNo == pArea->ulRecNo )
       {
          if( !pArea->fPositioned )
@@ -755,12 +755,12 @@ static HB_ERRCODE hb_dbfLockRecord( DBFAREAP pArea, ULONG ulRecNo, USHORT * pRes
          {
             if( SELF_GOCOLD( ( AREAP ) pArea ) != HB_SUCCESS )
                return HB_FAILURE;
-            pArea->fValidBuffer = FALSE;
+            pArea->fValidBuffer = HB_FALSE;
          }
       }
    }
    else
-      * pResult = FALSE;
+      * pResult = HB_FALSE;
    return HB_SUCCESS;
 }
 
@@ -791,11 +791,11 @@ static HB_ERRCODE hb_dbfLockFile( DBFAREAP pArea, USHORT * pResult )
       else if( !pArea->fRecordChanged )
       {
          SELF_GOCOLD( ( AREAP ) pArea );
-         pArea->fValidBuffer = FALSE;
+         pArea->fValidBuffer = HB_FALSE;
       }
    }
    else
-      * pResult = TRUE;
+      * pResult = HB_TRUE;
 
    return HB_SUCCESS;
 }
@@ -820,7 +820,7 @@ static HB_ERRCODE hb_dbfUnlockFile( DBFAREAP pArea )
 /*
  * Test if a record is locked.
  */
-static BOOL hb_dbfIsLocked( DBFAREAP pArea, ULONG ulRecNo )
+static HB_BOOL hb_dbfIsLocked( DBFAREAP pArea, ULONG ulRecNo )
 {
    ULONG ulCount;
 
@@ -830,11 +830,11 @@ static BOOL hb_dbfIsLocked( DBFAREAP pArea, ULONG ulRecNo )
    while( ulCount > 0 )
    {
       if( pArea->pLocksPos[ ulCount - 1 ] == ulRecNo )
-         return TRUE;
+         return HB_TRUE;
       ulCount --;
    }
 
-   return FALSE;
+   return HB_FALSE;
 }
 
 /*
@@ -1117,7 +1117,7 @@ HB_ERRCODE hb_dbfSetMemoData( DBFAREAP pArea, USHORT uiIndex,
  * This function is common for different MEMO implementation
  * so I left it in DBF.
  */
-BOOL hb_dbfLockIdxGetData( BYTE bScheme, HB_FOFFSET *ulPos, HB_FOFFSET *ulPool )
+HB_BOOL hb_dbfLockIdxGetData( BYTE bScheme, HB_FOFFSET *ulPos, HB_FOFFSET *ulPool )
 {
    switch( bScheme )
    {
@@ -1149,9 +1149,9 @@ BOOL hb_dbfLockIdxGetData( BYTE bScheme, HB_FOFFSET *ulPos, HB_FOFFSET *ulPool )
 #endif
 
       default:
-         return FALSE;
+         return HB_FALSE;
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
@@ -1159,10 +1159,10 @@ BOOL hb_dbfLockIdxGetData( BYTE bScheme, HB_FOFFSET *ulPos, HB_FOFFSET *ulPool )
  * This function is common for different MEMO implementation
  * so I left it in DBF.
  */
-BOOL hb_dbfLockIdxFile( PHB_FILE pFile, BYTE bScheme, USHORT usMode, HB_FOFFSET *pPoolPos )
+HB_BOOL hb_dbfLockIdxFile( PHB_FILE pFile, BYTE bScheme, USHORT usMode, HB_FOFFSET *pPoolPos )
 {
    HB_FOFFSET ulPos, ulPool, ulSize = 1;
-   BOOL fRet = FALSE;
+   HB_BOOL fRet = HB_FALSE;
 
    if( !hb_dbfLockIdxGetData( bScheme, &ulPos, &ulPool ) )
    {
@@ -1203,7 +1203,7 @@ BOOL hb_dbfLockIdxFile( PHB_FILE pFile, BYTE bScheme, USHORT usMode, HB_FOFFSET
             break;
 
          default:
-            return FALSE;
+            return HB_FALSE;
       }
       fRet = hb_fileLock( pFile, ulPos + *pPoolPos, ulSize, usMode );
       if( fRet || ( usMode & FLX_WAIT ) == 0 || ( usMode & FL_MASK ) != FL_LOCK )
@@ -1285,7 +1285,7 @@ static HB_ERRCODE hb_dbfLockData( DBFAREAP pArea,
 /*
  * Determine logical beginning of file.
  */
-static HB_ERRCODE hb_dbfBof( DBFAREAP pArea, BOOL * pBof )
+static HB_ERRCODE hb_dbfBof( DBFAREAP pArea, HB_BOOL * pBof )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfBof(%p, %p)", pArea, pBof));
 
@@ -1302,7 +1302,7 @@ static HB_ERRCODE hb_dbfBof( DBFAREAP pArea, BOOL * pBof )
 /*
  * Determine logical end of file.
  */
-static HB_ERRCODE hb_dbfEof( DBFAREAP pArea, BOOL * pEof )
+static HB_ERRCODE hb_dbfEof( DBFAREAP pArea, HB_BOOL * pEof )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfEof(%p, %p)", pArea, pEof));
 
@@ -1319,7 +1319,7 @@ static HB_ERRCODE hb_dbfEof( DBFAREAP pArea, BOOL * pEof )
 /*
  * Determine outcome of the last search operation.
  */
-static HB_ERRCODE hb_dbfFound( DBFAREAP pArea, BOOL * pFound )
+static HB_ERRCODE hb_dbfFound( DBFAREAP pArea, HB_BOOL * pFound )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfFound(%p, %p)", pArea, pFound));
 
@@ -1347,8 +1347,8 @@ static HB_ERRCODE hb_dbfGoBottom( DBFAREAP pArea )
    if( pArea->fShared )
       pArea->ulRecCount = hb_dbfCalcRecCount( pArea );
 
-   pArea->area.fTop = FALSE;
-   pArea->area.fBottom = TRUE;
+   pArea->area.fTop = HB_FALSE;
+   pArea->area.fBottom = HB_TRUE;
    if( SELF_GOTO( ( AREAP ) pArea, pArea->ulRecCount ) != HB_SUCCESS )
       return HB_FAILURE;
 
@@ -1383,19 +1383,19 @@ static HB_ERRCODE hb_dbfGoTo( DBFAREAP pArea, ULONG ulRecNo )
    if( ulRecNo <= pArea->ulRecCount && ulRecNo >= 1 )
    {
       pArea->ulRecNo = ulRecNo;
-      pArea->area.fBof = pArea->area.fEof = pArea->fValidBuffer = FALSE;
-      pArea->fPositioned = TRUE;
+      pArea->area.fBof = pArea->area.fEof = pArea->fValidBuffer = HB_FALSE;
+      pArea->fPositioned = HB_TRUE;
    }
    else /* Out of space */
    {
       pArea->ulRecNo = pArea->ulRecCount + 1;
-      pArea->area.fBof = pArea->area.fEof = pArea->fValidBuffer = TRUE;
-      pArea->fPositioned = pArea->fDeleted = pArea->fEncrypted = FALSE;
+      pArea->area.fBof = pArea->area.fEof = pArea->fValidBuffer = HB_TRUE;
+      pArea->fPositioned = pArea->fDeleted = pArea->fEncrypted = HB_FALSE;
 
       /* Clear record buffer */
       hb_dbfSetBlankRecord( pArea, HB_BLANK_EOF );
    }
-   pArea->area.fFound = FALSE;
+   pArea->area.fFound = HB_FALSE;
 
    /* Force relational movement in child WorkAreas */
    if( pArea->area.lpdbRelations )
@@ -1434,8 +1434,8 @@ static HB_ERRCODE hb_dbfGoTop( DBFAREAP pArea )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfGoTop(%p)", pArea));
 
-   pArea->area.fTop = TRUE;
-   pArea->area.fBottom = FALSE;
+   pArea->area.fTop = HB_TRUE;
+   pArea->area.fBottom = HB_FALSE;
 
    if( SELF_GOTO( ( AREAP ) pArea, 1 ) == HB_FAILURE )
       return HB_FAILURE;
@@ -1460,7 +1460,7 @@ static HB_ERRCODE hb_dbfSkip( DBFAREAP pArea, LONG lToSkip )
          return HB_FAILURE;
    }
 
-   pArea->area.fTop = pArea->area.fBottom = FALSE;
+   pArea->area.fTop = pArea->area.fBottom = HB_FALSE;
 
    if( lToSkip == 0 || pArea->area.dbfi.itmCobExpr || pArea->area.dbfi.fFilter ||
        hb_setGetDeleted() )
@@ -1475,14 +1475,14 @@ static HB_ERRCODE hb_dbfSkip( DBFAREAP pArea, LONG lToSkip )
    if( errCode == HB_SUCCESS && pArea->area.fBof && lToSkip < 0 )
    {
       errCode = SELF_GOTOP( ( AREAP ) pArea );
-      pArea->area.fBof = TRUE;
+      pArea->area.fBof = HB_TRUE;
    }
 
    /* Update Bof and Eof flags */
    if( lToSkip < 0 )
-      pArea->area.fEof = FALSE;
+      pArea->area.fEof = HB_FALSE;
    else /* if( lToSkip > 0 ) */
-      pArea->area.fBof = FALSE;
+      pArea->area.fBof = HB_FALSE;
 
    return errCode;
 }
@@ -1506,7 +1506,7 @@ static HB_ERRCODE hb_dbfSkipRaw( DBFAREAP pArea, LONG lToSkip )
 
    if( lToSkip == 0 )
    {
-      BOOL bBof, bEof;
+      HB_BOOL bBof, bEof;
 
       /* Save flags */
       bBof = pArea->area.fBof;
@@ -1521,7 +1521,7 @@ static HB_ERRCODE hb_dbfSkipRaw( DBFAREAP pArea, LONG lToSkip )
    else if( lToSkip < 0 && ( ULONG ) ( -lToSkip ) >= pArea->ulRecNo )
    {
       errCode = SELF_GOTO( ( AREAP ) pArea, 1 );
-      pArea->area.fBof = TRUE;
+      pArea->area.fBof = HB_TRUE;
    }
    else
    {
@@ -1554,7 +1554,7 @@ static HB_ERRCODE hb_dbfAddField( DBFAREAP pArea, LPDBFIELDINFO pFieldInfo )
 /*
  * Append a record to the WorkArea.
  */
-static HB_ERRCODE hb_dbfAppend( DBFAREAP pArea, BOOL bUnLockAll )
+static HB_ERRCODE hb_dbfAppend( DBFAREAP pArea, HB_BOOL bUnLockAll )
 {
    ULONG ulNewRecord;
    PHB_ITEM pError;
@@ -1596,14 +1596,14 @@ static HB_ERRCODE hb_dbfAppend( DBFAREAP pArea, BOOL bUnLockAll )
 
    if( pArea->fShared )
    {
-      fLocked = FALSE;
+      fLocked = HB_FALSE;
       if( SELF_RAWLOCK( ( AREAP ) pArea, APPEND_LOCK, 0 ) == HB_SUCCESS )
       {
          /* Update RecCount */
          pArea->ulRecCount = hb_dbfCalcRecCount( pArea );
          ulNewRecord = pArea->ulRecCount + 1;
          if( pArea->fFLocked || hb_dbfIsLocked( pArea, ulNewRecord ) )
-            fLocked = TRUE;
+            fLocked = HB_TRUE;
          else if( hb_dbfLockRecord( pArea, ulNewRecord, &fLocked, bUnLockAll ) != HB_SUCCESS )
          {
             if( fLocked )
@@ -1630,11 +1630,11 @@ static HB_ERRCODE hb_dbfAppend( DBFAREAP pArea, BOOL bUnLockAll )
    hb_dbfSetBlankRecord( pArea, HB_BLANK_APPEND );
 
    pArea->fValidBuffer = pArea->fUpdateHeader = pArea->fRecordChanged =
-   pArea->fAppend = pArea->fPositioned = TRUE;
+   pArea->fAppend = pArea->fPositioned = HB_TRUE;
    pArea->ulRecCount ++;
    pArea->ulRecNo = pArea->ulRecCount;
    pArea->fDeleted = pArea->area.fBof = pArea->area.fEof =
-   pArea->area.fFound = FALSE;
+   pArea->area.fFound = HB_FALSE;
    pArea->fEncrypted = pArea->pCryptKey != NULL && !pArea->fHasMemo;
 
    if( pArea->fShared )
@@ -1679,14 +1679,14 @@ static HB_ERRCODE hb_dbfDeleteRec( DBFAREAP pArea )
       return HB_FAILURE;
 
    pArea->pRecord[ 0 ] = '*';
-   pArea->fDeleted = TRUE;
+   pArea->fDeleted = HB_TRUE;
    return HB_SUCCESS;
 }
 
 /*
  * Determine deleted status for a record.
  */
-static HB_ERRCODE hb_dbfDeleted( DBFAREAP pArea, BOOL * pDeleted )
+static HB_ERRCODE hb_dbfDeleted( DBFAREAP pArea, HB_BOOL * pDeleted )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfDeleted(%p, %p)", pArea, pDeleted));
 
@@ -1729,12 +1729,12 @@ static HB_ERRCODE hb_dbfFlush( DBFAREAP pArea )
       if( pArea->fDataFlush )
       {
          hb_fileCommit( pArea->pDataFile );
-         pArea->fDataFlush = FALSE;
+         pArea->fDataFlush = HB_FALSE;
       }
       if( pArea->fHasMemo && pArea->pMemoFile && pArea->fMemoFlush )
       {
          hb_fileCommit( pArea->pMemoFile );
-         pArea->fMemoFlush = FALSE;
+         pArea->fMemoFlush = HB_FALSE;
       }
    }
 
@@ -1760,7 +1760,7 @@ static HB_ERRCODE hb_dbfGetRec( DBFAREAP pArea, BYTE ** pBuffer )
    {
       if( pArea->pRecord[ 0 ] == 'D' || pArea->pRecord[ 0 ] == 'E' )
       {
-         pArea->fEncrypted = TRUE;
+         pArea->fEncrypted = HB_TRUE;
          pArea->pRecord[ 0 ] = pArea->pRecord[ 0 ] == 'D' ? '*' : ' ';
          if( pArea->pCryptKey && pArea->bCryptType == DB_CRYPT_SIX )
          {
@@ -1771,7 +1771,7 @@ static HB_ERRCODE hb_dbfGetRec( DBFAREAP pArea, BYTE ** pBuffer )
       }
       else
       {
-         pArea->fEncrypted = FALSE;
+         pArea->fEncrypted = HB_FALSE;
       }
    }
    return HB_SUCCESS;
@@ -1784,7 +1784,7 @@ static HB_ERRCODE hb_dbfGetValue( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem
 {
    LPFIELD pField;
    PHB_ITEM pError;
-   BOOL fError;
+   HB_BOOL fError;
    char * pszVal;
    ULONG ulLen;;
 
@@ -1800,7 +1800,7 @@ static HB_ERRCODE hb_dbfGetValue( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem
    if( !pArea->fValidBuffer && !hb_dbfReadRecord( pArea ) )
       return HB_FAILURE;
 
-   fError = FALSE;
+   fError = HB_FALSE;
    uiIndex--;
    pField = pArea->area.lpFields + uiIndex;
    switch( pField->uiType )
@@ -1907,7 +1907,7 @@ static HB_ERRCODE hb_dbfGetValue( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem
                default:
                   dValue = 0;
                   iLen = 0;
-                  fError = TRUE;
+                  fError = HB_TRUE;
                   break;
             }
             hb_itemPutNDLen( pItem, hb_numDecConv( dValue, ( int ) pField->uiDec ),
@@ -1937,7 +1937,7 @@ static HB_ERRCODE hb_dbfGetValue( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem
 #endif
                   break;
                default:
-                  fError = TRUE;
+                  fError = HB_TRUE;
                   break;
             }
          }
@@ -1958,13 +1958,13 @@ static HB_ERRCODE hb_dbfGetValue( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem
           */
          /*
          if( pField->uiLen > 20 )
-            fError = TRUE;
+            fError = HB_TRUE;
          else
          */
          {
             HB_LONG lVal;
             double dVal;
-            BOOL fDbl;
+            HB_BOOL fDbl;
 
             fDbl = hb_strnToNum( (const char *) pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
                                  pField->uiLen, &lVal, &dVal );
@@ -1997,13 +1997,13 @@ static HB_ERRCODE hb_dbfGetValue( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem
          }
          else
          {
-            fError = TRUE;
+            fError = HB_TRUE;
          }
          break;
 
       case HB_FT_MEMO:
       default:
-         fError = TRUE;
+         fError = HB_TRUE;
          break;
    }
 
@@ -2072,8 +2072,8 @@ static HB_ERRCODE hb_dbfGoCold( DBFAREAP pArea )
 
       if( pArea->fAppend )
       {
-         pArea->fUpdateHeader = TRUE;
-         pArea->fAppend = FALSE;
+         pArea->fUpdateHeader = HB_TRUE;
+         pArea->fAppend = HB_FALSE;
       }
 
       /* Update header */
@@ -2113,7 +2113,7 @@ static HB_ERRCODE hb_dbfGoHot( DBFAREAP pArea )
       hb_itemRelease( pError );
       return HB_FAILURE;
    }
-   pArea->fRecordChanged = TRUE;
+   pArea->fRecordChanged = HB_TRUE;
    return HB_SUCCESS;
 }
 
@@ -2149,7 +2149,7 @@ static HB_ERRCODE hb_dbfPutRec( DBFAREAP pArea, const BYTE * pBuffer )
       if( pArea->pRecord[ 0 ] == 'D' || pArea->pRecord[ 0 ] == 'E' )
       {
          if( !pArea->fHasMemo )
-            pArea->fEncrypted = TRUE;
+            pArea->fEncrypted = HB_TRUE;
          pArea->pRecord[ 0 ] = pArea->pRecord[ 0 ] == 'D' ? '*' : ' ';
       }
 
@@ -2164,7 +2164,7 @@ static HB_ERRCODE hb_dbfPutRec( DBFAREAP pArea, const BYTE * pBuffer )
       {
          /* This enables record encryption in update operation */
          if( pArea->bCryptType == DB_CRYPT_SIX && !pArea->fHasMemo )
-            pArea->fEncrypted = TRUE;
+            pArea->fEncrypted = HB_TRUE;
 
          if( pArea->bCryptType == DB_CRYPT_SIX && pArea->fEncrypted )
          {
@@ -2541,7 +2541,7 @@ static HB_ERRCODE hb_dbfRecall( DBFAREAP pArea )
       return HB_FAILURE;
 
    pArea->pRecord[ 0 ] = ' ';
-   pArea->fDeleted = FALSE;
+   pArea->fDeleted = HB_FALSE;
    return HB_SUCCESS;
 }
 
@@ -2684,7 +2684,7 @@ static HB_ERRCODE hb_dbfClose( DBFAREAP pArea )
          hb_fileDelete( pArea->szMemoFileName );
    }
 
-   pArea->fTemporary = FALSE;
+   pArea->fTemporary = HB_FALSE;
 
    /* Free field offset array */
    if( pArea->pFieldOffset )
@@ -2730,7 +2730,7 @@ static HB_ERRCODE hb_dbfClose( DBFAREAP pArea )
    if( pArea->fTrigger )
    {
       hb_dbfTriggerDo( pArea, EVENT_POSTCLOSE, 0, NULL );
-      pArea->fTrigger = FALSE;
+      pArea->fTrigger = HB_FALSE;
    }
 
    return HB_SUCCESS;
@@ -2744,7 +2744,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
    HB_ERRCODE errCode = HB_SUCCESS;
    ULONG ulSize;
    USHORT uiCount;
-   BOOL fRetry, fError, fRawBlob;
+   HB_BOOL fRetry, fError, fRawBlob;
    DBFFIELD * pThisField;
    BYTE * pBuffer;
    PHB_FNAME pFileName;
@@ -2779,7 +2779,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
       hb_xfree( pFileName );
    }
 
-   pItem = hb_itemPutL( pItem, FALSE );
+   pItem = hb_itemPutL( pItem, HB_FALSE );
    fRawBlob = SELF_RDDINFO( SELF_RDDNODE( &pArea->area ), RDDI_BLOB_SUPPORT, pCreateInfo->ulConnection, pItem ) == HB_SUCCESS &&
               hb_itemGetL( pItem );
 
@@ -2863,7 +2863,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
             fRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
          }
          else
-            fRetry = FALSE;
+            fRetry = HB_FALSE;
       } while( fRetry );
 
       if( pError )
@@ -2886,7 +2886,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
    memset( pBuffer, 0, ulSize + sizeof( DBFFIELD ) + 1 );
    pThisField = ( DBFFIELD * ) pBuffer;
 
-   pArea->fHasMemo = fError = FALSE;
+   pArea->fHasMemo = fError = HB_FALSE;
 
    /* Size for deleted flag */
    pArea->uiRecordLen = 1;
@@ -2923,7 +2923,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
                pField->uiLen = 10;
             pThisField->bLen = ( BYTE ) pField->uiLen;
             pArea->uiRecordLen += pField->uiLen;
-            pArea->fHasMemo = TRUE;
+            pArea->fHasMemo = HB_TRUE;
             break;
 
          case HB_FT_BLOB:
@@ -2933,7 +2933,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
             pThisField->bLen = ( BYTE ) pField->uiLen;
             pThisField->bFieldFlags = HB_FF_BINARY;
             pArea->uiRecordLen += pField->uiLen;
-            pArea->fHasMemo = TRUE;
+            pArea->fHasMemo = HB_TRUE;
             break;
 
          case HB_FT_IMAGE:
@@ -2943,7 +2943,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
             pThisField->bLen = ( BYTE ) pField->uiLen;
             pThisField->bFieldFlags = HB_FF_BINARY;
             pArea->uiRecordLen += pField->uiLen;
-            pArea->fHasMemo = TRUE;
+            pArea->fHasMemo = HB_TRUE;
             break;
 
          case HB_FT_OLE:
@@ -2953,12 +2953,12 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
             pThisField->bLen = ( BYTE ) pField->uiLen;
             pThisField->bFieldFlags = HB_FF_BINARY;
             pArea->uiRecordLen += pField->uiLen;
-            pArea->fHasMemo = TRUE;
+            pArea->fHasMemo = HB_TRUE;
             break;
 
          case HB_FT_ANY:
             if( pArea->bTableType == DB_DBF_VFP )
-               fError = TRUE;
+               fError = HB_TRUE;
             else
             {
                pThisField->bType = 'V';
@@ -2972,7 +2972,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
                if( pThisField->bLen >= 6 )
                {
                   pArea->uiMemoVersion = DB_MEMOVER_SIX;
-                  pArea->fHasMemo = TRUE;
+                  pArea->fHasMemo = HB_TRUE;
                }
             }
             break;
@@ -3036,7 +3036,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
                pThisField->bType = 'Q';
             pThisField->bLen = ( BYTE ) pField->uiLen;
             pArea->uiRecordLen += pField->uiLen;
-            hb_dbfAllocNullFlag( pArea, uiCount, TRUE );
+            hb_dbfAllocNullFlag( pArea, uiCount, HB_TRUE );
             break;
 
          case HB_FT_TIME:
@@ -3059,7 +3059,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
             pField->uiLen = 8;
             pThisField->bLen = ( BYTE ) pField->uiLen;
             pArea->uiRecordLen += pField->uiLen;
-            pArea->fModStamp = TRUE;
+            pArea->fModStamp = HB_TRUE;
             break;
 
          case HB_FT_ROWVER:
@@ -3069,7 +3069,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
             HB_PUT_LE_UINT32( pThisField->bCounter, 1 );
             pThisField->bStep = 1;
             pArea->uiRecordLen += pField->uiLen;
-            pArea->fModStamp = TRUE;
+            pArea->fModStamp = HB_TRUE;
             break;
 
          case HB_FT_AUTOINC:
@@ -3079,11 +3079,11 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
             HB_PUT_LE_UINT32( pThisField->bCounter, 1 );
             pThisField->bStep = 1;
             pArea->uiRecordLen += pField->uiLen;
-            pArea->fAutoInc = TRUE;
+            pArea->fAutoInc = HB_TRUE;
             break;
 
          default:
-            fError = TRUE;
+            fError = HB_TRUE;
       }
       if( fError )
       {
@@ -3117,13 +3117,13 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
       ulSize += sizeof( DBFFIELD );
    }
 
-   pArea->fShared = FALSE;    /* pCreateInfo->fShared */
-   pArea->fReadonly = FALSE;  /* pCreateInfo->fReadonly */
+   pArea->fShared = HB_FALSE;    /* pCreateInfo->fShared */
+   pArea->fReadonly = HB_FALSE;  /* pCreateInfo->fReadonly */
    pArea->ulRecCount = 0;
    pArea->uiHeaderLen = ( USHORT ) ( sizeof( DBFHEADER ) + ulSize );
    if( fRawBlob )
    {
-      pArea->fHasMemo = TRUE;
+      pArea->fHasMemo = HB_TRUE;
    }
    if( !pArea->fHasMemo )
    {
@@ -3144,8 +3144,8 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
    if( SELF_RDDINFO( SELF_RDDNODE( &pArea->area ), RDDI_PENDINGPASSWORD,
                      pCreateInfo->ulConnection, pItem ) == HB_SUCCESS )
    {
-      if( hb_dbfPasswordSet( pArea, pItem, FALSE ) )
-         pArea->fTableEncrypted = TRUE;
+      if( hb_dbfPasswordSet( pArea, pItem, HB_FALSE ) )
+         pArea->fTableEncrypted = HB_TRUE;
    }
    else
    {
@@ -3153,8 +3153,8 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
       if( SELF_RDDINFO( SELF_RDDNODE( &pArea->area ), RDDI_PASSWORD,
                         pCreateInfo->ulConnection, pItem ) == HB_SUCCESS )
       {
-         if( hb_dbfPasswordSet( pArea, pItem, FALSE ) )
-            pArea->fTableEncrypted = TRUE;
+         if( hb_dbfPasswordSet( pArea, pItem, HB_FALSE ) )
+            pArea->fTableEncrypted = HB_TRUE;
       }
    }
    hb_itemRelease( pItem );
@@ -3162,7 +3162,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
    if( !fRawBlob )
    {
       /* Force write new header */
-      pArea->fUpdateHeader = TRUE;
+      pArea->fUpdateHeader = HB_TRUE;
       /* Write header */
       errCode = SELF_WRITEDBHEADER( ( AREAP ) pArea );
       if( errCode != HB_SUCCESS )
@@ -3191,7 +3191,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
          pArea->lpdbOpenInfo = NULL;
          return HB_FAILURE;
       }
-      pArea->fDataFlush = TRUE;
+      pArea->fDataFlush = HB_TRUE;
    }
    hb_xfree( pBuffer );
 
@@ -3220,7 +3220,7 @@ static HB_ERRCODE hb_dbfCreate( DBFAREAP pArea, LPDBOPENINFO pCreateInfo )
 
    /* Alloc buffer */
    pArea->pRecord = ( BYTE * ) hb_xgrab( pArea->uiRecordLen );
-   pArea->fValidBuffer = FALSE;
+   pArea->fValidBuffer = HB_FALSE;
 
    /* Update the number of record for corrupted headers */
    pArea->ulRecCount = hb_dbfCalcRecCount( pArea );
@@ -3243,7 +3243,7 @@ static HB_ERRCODE hb_dbfInfo( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
    {
       case DBI_ISDBF:
       case DBI_CANPUTREC:
-         hb_itemPutL( pItem, TRUE );
+         hb_itemPutL( pItem, HB_TRUE );
          break;
 
       case DBI_GETHEADERSIZE:
@@ -3297,7 +3297,7 @@ static HB_ERRCODE hb_dbfInfo( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
 
       case DBI_SHARED:
       {
-         BOOL fShared = pArea->fShared;
+         HB_BOOL fShared = pArea->fShared;
 
          if( HB_IS_LOGICAL( pItem ) )
          {
@@ -3334,12 +3334,12 @@ static HB_ERRCODE hb_dbfInfo( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
          break;
 
       case DBI_DECRYPT:
-         hb_dbfTableCrypt( pArea, pItem, FALSE );
+         hb_dbfTableCrypt( pArea, pItem, HB_FALSE );
          hb_itemPutL( pItem, !pArea->fTableEncrypted );
          break;
 
       case DBI_ENCRYPT:
-         hb_dbfTableCrypt( pArea, pItem, TRUE );
+         hb_dbfTableCrypt( pArea, pItem, HB_TRUE );
          hb_itemPutL( pItem, pArea->fTableEncrypted );
          break;
 
@@ -3388,17 +3388,17 @@ static HB_ERRCODE hb_dbfInfo( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
             if( pArea->fAppend )
             {
                hb_dbfSetBlankRecord( pArea, HB_BLANK_ROLLBACK );
-               pArea->fDeleted = FALSE;
+               pArea->fDeleted = HB_FALSE;
             }
             else
             {
-               pArea->fRecordChanged = pArea->fValidBuffer = FALSE;
+               pArea->fRecordChanged = pArea->fValidBuffer = HB_FALSE;
             }
          }
          break;
 
       case DBI_PASSWORD:
-         hb_dbfPasswordSet( pArea, pItem, FALSE );
+         hb_dbfPasswordSet( pArea, pItem, HB_FALSE );
          break;
 
       case DBI_TRIGGER:
@@ -3419,7 +3419,7 @@ static HB_ERRCODE hb_dbfInfo( DBFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
 
       case DBI_DIRTYREAD:
       {
-         BOOL fDirty = HB_DIRTYREAD( pArea );
+         HB_BOOL fDirty = HB_DIRTYREAD( pArea );
 
          if( HB_IS_LOGICAL( pItem ) )
             pArea->uiDirtyRead = hb_itemGetL( pItem ) ?
@@ -3487,7 +3487,7 @@ static HB_ERRCODE hb_dbfRecInfo( DBFAREAP pArea, PHB_ITEM pRecID, USHORT uiInfoT
 {
    ULONG ulRecNo = hb_itemGetNL( pRecID ), ulPrevRec = 0;
    HB_ERRCODE errResult = HB_SUCCESS;
-   BOOL bDeleted;
+   HB_BOOL bDeleted;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfRecInfo(%p, %p, %hu, %p)", pArea, pRecID, uiInfoType, pInfo));
 
@@ -3626,7 +3626,7 @@ static HB_ERRCODE hb_dbfNewArea( DBFAREAP pArea )
       return HB_FAILURE;
 
    pArea->pDataFile = pArea->pMemoFile = pArea->pMemoTmpFile = NULL;
-   pArea->fDataFlush = pArea->fMemoFlush = FALSE;
+   pArea->fDataFlush = pArea->fMemoFlush = HB_FALSE;
    /* Index dirty read flag initialized to global RDD setting */
    pArea->uiDirtyRead = HB_IDXREAD_DEFAULT;
    /* Size for deleted records flag */
@@ -3650,7 +3650,7 @@ static HB_ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
    HB_ERRCODE errCode;
    USHORT uiFlags, uiFields, uiCount, uiSkip;
    ULONG ulSize;
-   BOOL fRetry, fRawBlob;
+   HB_BOOL fRetry, fRawBlob;
    PHB_ITEM pError, pItem;
    PHB_FNAME pFileName;
    BYTE * pBuffer;
@@ -3727,7 +3727,7 @@ static HB_ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
     *   2: force exclusive mode.
     * */
    if( hb_setGetAutoShare() == 2 )
-      pArea->fShared = FALSE;
+      pArea->fShared = HB_FALSE;
    uiFlags = (pArea->fReadonly ? FO_READ : FO_READWRITE) |
              (pArea->fShared ? FO_DENYNONE : FO_EXCLUSIVE);
    pError = NULL;
@@ -3771,7 +3771,7 @@ static HB_ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
    {
       uiFields = uiSkip = 0;
       pBuffer = NULL;
-      pArea->fHasMemo = TRUE;
+      pArea->fHasMemo = HB_TRUE;
    }
    else
    {
@@ -3796,7 +3796,7 @@ static HB_ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
             fRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
          }
          else
-            fRetry = FALSE;
+            fRetry = HB_FALSE;
       } while( fRetry );
 
       if( pError )
@@ -4021,21 +4021,21 @@ static HB_ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
             dbFieldInfo.uiType = HB_FT_MODTIME;
             if( dbFieldInfo.uiLen != 8 )
                errCode = HB_FAILURE;
-            pArea->fModStamp = TRUE;
+            pArea->fModStamp = HB_TRUE;
             break;
 
          case '^':
             dbFieldInfo.uiType = HB_FT_ROWVER;
             if( dbFieldInfo.uiLen != 8 )
                errCode = HB_FAILURE;
-            pArea->fModStamp = TRUE;
+            pArea->fModStamp = HB_TRUE;
             break;
 
          case '+':
             dbFieldInfo.uiType = HB_FT_AUTOINC;
             if( dbFieldInfo.uiLen != 4 )
                errCode = HB_FAILURE;
-            pArea->fAutoInc = TRUE;
+            pArea->fAutoInc = HB_TRUE;
             break;
 
          case 'Q':
@@ -4044,7 +4044,7 @@ static HB_ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
                dbFieldInfo.uiFlags |= HB_FF_BINARY;
             else
                dbFieldInfo.uiFlags |= HB_FF_BINARY & pField->bFieldFlags;
-            hb_dbfAllocNullFlag( pArea, uiCount, TRUE );
+            hb_dbfAllocNullFlag( pArea, uiCount, HB_TRUE );
             break;
 
          case 'V':
@@ -4052,7 +4052,7 @@ static HB_ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
             {
                dbFieldInfo.uiType = HB_FT_VARLENGTH;
                /* dbFieldInfo.uiFlags &= ~HB_FF_BINARY; */
-               hb_dbfAllocNullFlag( pArea, uiCount, TRUE );
+               hb_dbfAllocNullFlag( pArea, uiCount, HB_TRUE );
             }
             else
             {
@@ -4060,32 +4060,32 @@ static HB_ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
                if( dbFieldInfo.uiLen >= 6 )
                {
                   pArea->uiMemoVersion = DB_MEMOVER_SIX;
-                  pArea->fHasMemo = TRUE;
+                  pArea->fHasMemo = HB_TRUE;
                }
             }
             break;
 
          case 'M':
             dbFieldInfo.uiType = HB_FT_MEMO;
-            pArea->fHasMemo = TRUE;
+            pArea->fHasMemo = HB_TRUE;
             break;
 
          case 'P':
             dbFieldInfo.uiType = HB_FT_IMAGE;
             dbFieldInfo.uiFlags |= HB_FF_BINARY;
-            pArea->fHasMemo = TRUE;
+            pArea->fHasMemo = HB_TRUE;
             break;
 
          case 'W':
             dbFieldInfo.uiType = HB_FT_BLOB;
             dbFieldInfo.uiFlags |= HB_FF_BINARY;
-            pArea->fHasMemo = TRUE;
+            pArea->fHasMemo = HB_TRUE;
             break;
 
          case 'G':
             dbFieldInfo.uiType = HB_FT_OLE;
             dbFieldInfo.uiFlags |= HB_FF_BINARY;
-            pArea->fHasMemo = TRUE;
+            pArea->fHasMemo = HB_TRUE;
             break;
 
          case '0':
@@ -4108,7 +4108,7 @@ static HB_ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
          if( pArea->bTableType == DB_DBF_VFP &&
              ( pField->bFieldFlags & HB_FF_NULLABLE ) != 0 )
          {
-            hb_dbfAllocNullFlag( pArea, uiCount, FALSE );
+            hb_dbfAllocNullFlag( pArea, uiCount, HB_FALSE );
          }
          /* Add field */
          errCode = SELF_ADDFIELD( ( AREAP ) pArea, &dbFieldInfo );
@@ -4144,7 +4144,7 @@ static HB_ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
    if( SELF_RDDINFO( SELF_RDDNODE( &pArea->area ), RDDI_PENDINGPASSWORD,
                      pOpenInfo->ulConnection, pItem ) == HB_SUCCESS )
    {
-      hb_dbfPasswordSet( pArea, pItem, FALSE );
+      hb_dbfPasswordSet( pArea, pItem, HB_FALSE );
    }
    else
    {
@@ -4152,7 +4152,7 @@ static HB_ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
       if( SELF_RDDINFO( SELF_RDDNODE( &pArea->area ), RDDI_PASSWORD,
                         pOpenInfo->ulConnection, pItem ) == HB_SUCCESS )
       {
-         hb_dbfPasswordSet( pArea, pItem, FALSE );
+         hb_dbfPasswordSet( pArea, pItem, HB_FALSE );
       }
    }
    hb_itemRelease( pItem );
@@ -4183,7 +4183,7 @@ static HB_ERRCODE hb_dbfOpen( DBFAREAP pArea, LPDBOPENINFO pOpenInfo )
 
    /* Alloc buffer */
    pArea->pRecord = ( BYTE * ) hb_xgrab( pArea->uiRecordLen );
-   pArea->fValidBuffer = FALSE;
+   pArea->fValidBuffer = HB_FALSE;
 
    /* Update the number of record for corrupted headers */
    pArea->ulRecCount = hb_dbfCalcRecCount( pArea );
@@ -4219,7 +4219,7 @@ static HB_ERRCODE hb_dbfStructSize( DBFAREAP pArea, USHORT * uiSize )
 /*
  * Pack helper function called for each packed record
  */
-static HB_ERRCODE hb_dbfPackRec( DBFAREAP pArea, ULONG ulRecNo, BOOL *fWritten )
+static HB_ERRCODE hb_dbfPackRec( DBFAREAP pArea, ULONG ulRecNo, HB_BOOL *fWritten )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfPackRec(%p, %lu, %p)", pArea, ulRecNo, fWritten));
 
@@ -4237,7 +4237,7 @@ static HB_ERRCODE hb_dbfPack( DBFAREAP pArea )
 {
    ULONG ulRecIn, ulRecOut, ulEvery, ulUserEvery;
    PHB_ITEM pError, pBlock;
-   BOOL fWritten;
+   HB_BOOL fWritten;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfPack(%p)", pArea));
 
@@ -4336,7 +4336,7 @@ static HB_ERRCODE hb_dbfPack( DBFAREAP pArea )
          if( pArea->ulRecNo != ulRecOut || pArea->fRecordChanged )
          {
             pArea->ulRecNo = ulRecOut;
-            pArea->fRecordChanged = TRUE;
+            pArea->fRecordChanged = HB_TRUE;
             if( ! hb_dbfWriteRecord( pArea ) )
             {
                if( pBlock )
@@ -4366,7 +4366,7 @@ static HB_ERRCODE hb_dbfPack( DBFAREAP pArea )
    {
       pArea->ulRecCount = ulRecOut;
       /* Force write new header */
-      pArea->fUpdateHeader = TRUE;
+      pArea->fUpdateHeader = HB_TRUE;
       if( SELF_WRITEDBHEADER( ( AREAP ) pArea ) != HB_SUCCESS )
          return HB_FAILURE;
    }
@@ -4420,7 +4420,7 @@ static HB_ERRCODE hb_dbfSort( DBFAREAP pArea, LPDBSORTINFO pSortInfo )
 {
    ULONG ulRecNo;
    USHORT uiCount;
-   BOOL bMoreRecords, bLimited, bValidRecord;
+   HB_BOOL bMoreRecords, bLimited, bValidRecord;
    HB_ERRCODE errCode;
    DBQUICKSORT dbQuickSort;
    BYTE * pBuffer;
@@ -4440,12 +4440,12 @@ static HB_ERRCODE hb_dbfSort( DBFAREAP pArea, LPDBSORTINFO pSortInfo )
    if( pSortInfo->dbtri.dbsci.itmRecID )
    {
       errCode = SELF_GOTOID( ( AREAP ) pArea, pSortInfo->dbtri.dbsci.itmRecID );
-      bMoreRecords = bLimited = TRUE;
+      bMoreRecords = bLimited = HB_TRUE;
    }
    else if( pSortInfo->dbtri.dbsci.lNext )
    {
       ulRecNo = hb_itemGetNL( pSortInfo->dbtri.dbsci.lNext );
-      bLimited = TRUE;
+      bLimited = HB_TRUE;
       bMoreRecords = ( ulRecNo > 0 );
    }
    else
@@ -4454,8 +4454,8 @@ static HB_ERRCODE hb_dbfSort( DBFAREAP pArea, LPDBSORTINFO pSortInfo )
           ( !pSortInfo->dbtri.dbsci.fRest ||
             !hb_itemGetL( pSortInfo->dbtri.dbsci.fRest ) ) )
          errCode = SELF_GOTOP( ( AREAP ) pArea );
-      bMoreRecords = TRUE;
-      bLimited = FALSE;
+      bMoreRecords = HB_TRUE;
+      bLimited = HB_FALSE;
    }
 
    while( errCode == HB_SUCCESS && !pArea->area.fEof && bMoreRecords )
@@ -4550,7 +4550,7 @@ static HB_ERRCODE hb_dbfTrans( DBFAREAP pArea, LPDBTRANSINFO pTransInfo )
          pTransInfo->uiFlags |= DBTF_PUTREC;
       else
       {
-         PHB_ITEM pPutRec = hb_itemPutL( NULL, FALSE );
+         PHB_ITEM pPutRec = hb_itemPutL( NULL, HB_FALSE );
          if( SELF_INFO( ( AREAP ) pTransInfo->lpaDest, DBI_CANPUTREC, pPutRec ) != HB_SUCCESS )
          {
             hb_itemRelease( pPutRec );
@@ -4607,7 +4607,7 @@ static HB_ERRCODE hb_dbfZap( DBFAREAP pArea )
    if( SELF_GOCOLD( ( AREAP ) pArea ) != HB_SUCCESS )
       return HB_FAILURE;
 
-   pArea->fUpdateHeader = TRUE;
+   pArea->fUpdateHeader = HB_TRUE;
    pArea->ulRecCount = 0;
    if( SELF_WRITEDBHEADER( ( AREAP ) pArea ) != HB_SUCCESS )
       return HB_FAILURE;
@@ -4783,7 +4783,7 @@ static HB_ERRCODE hb_dbfRawLock( DBFAREAP pArea, USHORT uiAction, ULONG ulRecNo
    HB_ERRCODE errCode = HB_SUCCESS;
    HB_FOFFSET ulPos, ulFlSize, ulRlSize;
    int iDir;
-   BOOL fLck;
+   HB_BOOL fLck;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfRawLock(%p, %hu, %lu)", pArea, uiAction, ulRecNo));
 
@@ -4805,7 +4805,7 @@ static HB_ERRCODE hb_dbfRawLock( DBFAREAP pArea, USHORT uiAction, ULONG ulRecNo
                if( !fLck )
                   errCode = HB_FAILURE;
                else
-                  pArea->fFLocked = TRUE;
+                  pArea->fFLocked = HB_TRUE;
             }
             break;
 
@@ -4819,7 +4819,7 @@ static HB_ERRCODE hb_dbfRawLock( DBFAREAP pArea, USHORT uiAction, ULONG ulRecNo
 
                if( !fLck )
                   errCode = HB_FAILURE;
-               pArea->fFLocked = FALSE;
+               pArea->fFLocked = HB_FALSE;
             }
             break;
 
@@ -4867,7 +4867,7 @@ static HB_ERRCODE hb_dbfRawLock( DBFAREAP pArea, USHORT uiAction, ULONG ulRecNo
                if( !fLck )
                   errCode = HB_FAILURE;
                else
-                  pArea->fHeaderLocked = TRUE;
+                  pArea->fHeaderLocked = HB_TRUE;
             }
             break;
 
@@ -4877,7 +4877,7 @@ static HB_ERRCODE hb_dbfRawLock( DBFAREAP pArea, USHORT uiAction, ULONG ulRecNo
             {
                if( !hb_fileLock( pArea->pDataFile, ulPos, 1, FL_UNLOCK ) )
                   errCode = HB_FAILURE;
-               pArea->fHeaderLocked = FALSE;
+               pArea->fHeaderLocked = HB_FALSE;
             }
             break;
       }
@@ -4897,21 +4897,21 @@ static HB_ERRCODE hb_dbfLock( DBFAREAP pArea, LPDBLOCKINFO pLockInfo )
       switch( pLockInfo->uiMethod )
       {
          case DBLM_EXCLUSIVE:
-            return hb_dbfLockRecord( pArea, 0, &pLockInfo->fResult, TRUE );
+            return hb_dbfLockRecord( pArea, 0, &pLockInfo->fResult, HB_TRUE );
 
          case DBLM_MULTIPLE:
             return hb_dbfLockRecord( pArea, hb_itemGetNL( pLockInfo->itmRecID ),
-                                     &pLockInfo->fResult, FALSE );
+                                     &pLockInfo->fResult, HB_FALSE );
 
          case DBLM_FILE:
             return hb_dbfLockFile( pArea, &pLockInfo->fResult );
 
          default:
-            pLockInfo->fResult = FALSE;
+            pLockInfo->fResult = HB_FALSE;
       }
    }
    else
-      pLockInfo->fResult = TRUE;
+      pLockInfo->fResult = HB_TRUE;
 
    return HB_SUCCESS;
 }
@@ -4965,7 +4965,7 @@ static HB_ERRCODE hb_dbfCreateMemFile( DBFAREAP pArea, LPDBOPENINFO pCreateInfo
       SELF_ERROR( ( AREAP ) pArea, pError );
       hb_itemRelease( pError );
    }
-   pArea->fHasMemo = FALSE;
+   pArea->fHasMemo = HB_FALSE;
    return HB_FAILURE;
 }
 
@@ -5144,7 +5144,7 @@ static HB_ERRCODE hb_dbfPutValueFile( DBFAREAP pArea, USHORT uiIndex, const char
  */
 static HB_ERRCODE hb_dbfReadDBHeader( DBFAREAP pArea )
 {
-   BOOL fRetry, fError;
+   HB_BOOL fRetry, fError;
    PHB_ITEM pError;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfReadDBHeader(%p)", pArea));
@@ -5153,17 +5153,17 @@ static HB_ERRCODE hb_dbfReadDBHeader( DBFAREAP pArea )
    /* Try read */
    do
    {
-      fError = FALSE;
+      fError = HB_FALSE;
 
       if( hb_fileReadAt( pArea->pDataFile, &pArea->dbfHeader,
                          sizeof( DBFHEADER ), 0 ) != sizeof( DBFHEADER ) )
       {
-         fError = TRUE;
+         fError = HB_TRUE;
       }
       else
       {
          pArea->fAutoInc = pArea->fModStamp =
-         pArea->fTableEncrypted = pArea->fHasMemo = FALSE;
+         pArea->fTableEncrypted = pArea->fHasMemo = HB_FALSE;
          pArea->bTableType = DB_DBF_STD;
          pArea->bMemoType  = DB_MEMO_NONE;
          pArea->bCryptType = DB_CRYPT_NONE;
@@ -5173,14 +5173,14 @@ static HB_ERRCODE hb_dbfReadDBHeader( DBFAREAP pArea )
          switch( pArea->dbfHeader.bVersion )
          {
             case 0x31:
-               pArea->fAutoInc = TRUE;
+               pArea->fAutoInc = HB_TRUE;
             case 0x30:
             case 0x32:
                pArea->bTableType = DB_DBF_VFP;
                if( pArea->dbfHeader.bHasTags & 0x02 )
                {
                   pArea->bMemoType = DB_MEMO_FPT;
-                  pArea->fHasMemo = TRUE;
+                  pArea->fHasMemo = HB_TRUE;
                }
                break;
 
@@ -5188,48 +5188,48 @@ static HB_ERRCODE hb_dbfReadDBHeader( DBFAREAP pArea )
                break;
 
             case 0x83:
-               pArea->fHasMemo = TRUE;
+               pArea->fHasMemo = HB_TRUE;
                pArea->bMemoType = DB_MEMO_DBT;
                break;
 
             case 0xE5:
-               pArea->fHasMemo = TRUE;
+               pArea->fHasMemo = HB_TRUE;
                pArea->bMemoType = DB_MEMO_SMT;
                break;
 
             case 0xF5:
-               pArea->fHasMemo = TRUE;
+               pArea->fHasMemo = HB_TRUE;
                pArea->bMemoType = DB_MEMO_FPT;
                break;
 
             case 0x06:
-               pArea->fTableEncrypted = TRUE;
+               pArea->fTableEncrypted = HB_TRUE;
                pArea->bCryptType = DB_CRYPT_SIX;
                break;
 
             case 0x86:
-               pArea->fTableEncrypted = TRUE;
-               pArea->fHasMemo = TRUE;
+               pArea->fTableEncrypted = HB_TRUE;
+               pArea->fHasMemo = HB_TRUE;
                pArea->bCryptType = DB_CRYPT_SIX;
                pArea->bMemoType = DB_MEMO_DBT;
                break;
 
             case 0xE6:
-               pArea->fHasMemo = TRUE;
-               pArea->fTableEncrypted = TRUE;
+               pArea->fHasMemo = HB_TRUE;
+               pArea->fTableEncrypted = HB_TRUE;
                pArea->bCryptType = DB_CRYPT_SIX;
                pArea->bMemoType = DB_MEMO_SMT;
                break;
 
             case 0xF6:
-               pArea->fHasMemo = TRUE;
-               pArea->fTableEncrypted = TRUE;
+               pArea->fHasMemo = HB_TRUE;
+               pArea->fTableEncrypted = HB_TRUE;
                pArea->bCryptType = DB_CRYPT_SIX;
                pArea->bMemoType = DB_MEMO_FPT;
                break;
 
             default:
-               fError = TRUE;
+               fError = HB_TRUE;
          }
       }
       if( fError )
@@ -5247,7 +5247,7 @@ static HB_ERRCODE hb_dbfReadDBHeader( DBFAREAP pArea )
          fRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
       }
       else
-         fRetry = FALSE;
+         fRetry = HB_FALSE;
    } while( fRetry );
 
    if( pError )
@@ -5269,7 +5269,7 @@ static HB_ERRCODE hb_dbfReadDBHeader( DBFAREAP pArea )
 static HB_ERRCODE hb_dbfWriteDBHeader( DBFAREAP pArea )
 {
    int iYear, iMonth, iDay;
-   BOOL fLck = FALSE;
+   HB_BOOL fLck = HB_FALSE;
    HB_ERRCODE errCode;
    PHB_ITEM pError;
 
@@ -5321,7 +5321,7 @@ static HB_ERRCODE hb_dbfWriteDBHeader( DBFAREAP pArea )
       {
          if( SELF_RAWLOCK( ( AREAP ) pArea, HEADER_LOCK, 0 ) != HB_SUCCESS )
             return HB_FAILURE;
-         fLck = TRUE;
+         fLck = HB_TRUE;
       }
       pArea->ulRecCount = hb_dbfCalcRecCount( pArea );
    }
@@ -5349,8 +5349,8 @@ static HB_ERRCODE hb_dbfWriteDBHeader( DBFAREAP pArea )
       errCode = HB_FAILURE;
    }
    /* TODO: add RT error */
-   pArea->fDataFlush = TRUE;
-   pArea->fUpdateHeader = FALSE;
+   pArea->fDataFlush = HB_TRUE;
+   pArea->fUpdateHeader = HB_FALSE;
    if( fLck )
    {
       if( SELF_RAWLOCK( ( AREAP ) pArea, HEADER_UNLOCK, 0 ) != HB_SUCCESS )
@@ -5378,7 +5378,7 @@ static HB_ERRCODE hb_dbfDrop( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pIte
    const char * szFile, * szExt;
    PHB_ITEM pFileExt = NULL;
    PHB_FNAME pFileName;
-   BOOL fTable = FALSE, fResult = FALSE;
+   HB_BOOL fTable = HB_FALSE, fResult = HB_FALSE;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfDrop(%p,%p,%p,%lu)", pRDD, pItemTable, pItemIndex, ulConnect));
 
@@ -5389,7 +5389,7 @@ static HB_ERRCODE hb_dbfDrop( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pIte
       szFile = hb_itemGetCPtr( pItemTable );
       if( !szFile[ 0 ] )
          return HB_FAILURE;
-      fTable = TRUE;
+      fTable = HB_TRUE;
    }
 
    pFileName = hb_fsFNameSplit( szFile );
@@ -5460,7 +5460,7 @@ static HB_ERRCODE hb_dbfExists( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pI
    const char * szFile;
    PHB_ITEM pFileExt = NULL;
    PHB_FNAME pFileName;
-   BOOL fTable = FALSE;
+   HB_BOOL fTable = HB_FALSE;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfExists(%p,%p,%p,%lu)", pRDD, pItemTable, pItemIndex, ulConnect));
 
@@ -5470,7 +5470,7 @@ static HB_ERRCODE hb_dbfExists( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pI
       szFile = hb_itemGetCPtr( pItemTable );
       if( !szFile[ 0 ] )
          return HB_FAILURE;
-      fTable = TRUE;
+      fTable = HB_TRUE;
    }
 
    pFileName = hb_fsFNameSplit( szFile );
@@ -5497,7 +5497,7 @@ static HB_ERRCODE hb_dbfRename( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pI
    const char * szFile, * szExt;
    PHB_ITEM pFileExt = NULL;
    PHB_FNAME pFileName, pFileNameNew;
-   BOOL fTable = FALSE, fResult = FALSE;
+   HB_BOOL fTable = HB_FALSE, fResult = HB_FALSE;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_dbfRename(%p,%p,%p,%p,%lu)", pRDD, pItemTable, pItemIndex, pItemNew, ulConnect));
 
@@ -5508,7 +5508,7 @@ static HB_ERRCODE hb_dbfRename( LPRDDNODE pRDD, PHB_ITEM pItemTable, PHB_ITEM pI
       szFile = hb_itemGetCPtr( pItemTable );
       if( !szFile[ 0 ] )
          return HB_FAILURE;
-      fTable = TRUE;
+      fTable = HB_TRUE;
    }
 
    pFileName = hb_fsFNameSplit( szFile );
@@ -5667,7 +5667,7 @@ static HB_ERRCODE hb_dbfRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect
       case RDDI_ISDBF:
       case RDDI_CANPUTREC:
       case RDDI_LOCAL:
-         hb_itemPutL( pItem, TRUE );
+         hb_itemPutL( pItem, HB_TRUE );
          break;
 
       case RDDI_TABLEEXT:
@@ -5717,7 +5717,7 @@ static HB_ERRCODE hb_dbfRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect
       }
       case RDDI_DIRTYREAD:
       {
-         BOOL fDirty = ( pData->uiDirtyRead == HB_IDXREAD_DIRTYMASK );
+         HB_BOOL fDirty = ( pData->uiDirtyRead == HB_IDXREAD_DIRTYMASK );
          if( HB_IS_LOGICAL( pItem ) )
          {
             pData->uiDirtyRead = hb_itemGetL( pItem ) ?
@@ -5729,11 +5729,11 @@ static HB_ERRCODE hb_dbfRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect
       case RDDI_TRIGGER:
       {
          char * szTrigger = pData->szTrigger;
-         BOOL fFree = FALSE;
+         HB_BOOL fFree = HB_FALSE;
 
          if( HB_IS_STRING( pItem ) )
          {
-            fFree = TRUE;
+            fFree = HB_TRUE;
             pData->szTrigger = hb_itemGetCLen( pItem ) > 0 ?
                                hb_itemGetC( pItem ) : NULL;
          }
@@ -5771,11 +5771,11 @@ static HB_ERRCODE hb_dbfRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect
       case RDDI_PASSWORD:
       {
          char * szPasswd = pData->szPasswd;
-         BOOL fFree = FALSE;
+         HB_BOOL fFree = HB_FALSE;
 
          if( HB_IS_STRING( pItem ) )
          {
-            fFree = TRUE;
+            fFree = HB_TRUE;
             pData->szPasswd = hb_itemGetCLen( pItem ) > 0 ?
                               hb_itemGetC( pItem ) : NULL;
          }
diff --git a/harbour/src/rdd/dbfcdx/dbfcdx1.c b/harbour/src/rdd/dbfcdx/dbfcdx1.c
index 81849d5a53..9c221a9c39 100644
--- a/harbour/src/rdd/dbfcdx/dbfcdx1.c
+++ b/harbour/src/rdd/dbfcdx/dbfcdx1.c
@@ -83,13 +83,13 @@
 #include "hbapicdp.h"
 
 /*
- * Tag->fRePos = TRUE means that rootPage->...->childLeafPage path is
+ * Tag->fRePos = HB_TRUE means that rootPage->...->childLeafPage path is
  * bad and has to be reloaded
  * CurKey->rec == 0 means that there is no correct CurKey
  */
 
 /* create a new Tag (make index) */
-static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex );
+static void hb_cdxTagDoIndex( LPCDXTAG pTag, HB_BOOL fReindex );
 
 /* Close Tag */
 static void hb_cdxTagClose( LPCDXTAG pTag );
@@ -231,7 +231,7 @@ static void hb_cdxMakeSortTab( CDXAREAP pArea )
       if( pArea->dbfarea.area.cdPage->nMulti ||
           pArea->dbfarea.area.cdPage->nACSort )
       {
-         pArea->fSortCDP = TRUE;
+         pArea->fSortCDP = HB_TRUE;
       }
       else
       {
@@ -495,7 +495,7 @@ static BYTE hb_cdxItemTypeCmp( BYTE bType )
  * store Item in index key
  * TODO: uiType check and generate RT error if necessary
  */
-static LPCDXKEY hb_cdxKeyPutItem( LPCDXKEY pKey, PHB_ITEM pItem, ULONG ulRec, LPCDXTAG pTag, BOOL fTrans, int iMode )
+static LPCDXKEY hb_cdxKeyPutItem( LPCDXKEY pKey, PHB_ITEM pItem, ULONG ulRec, LPCDXTAG pTag, HB_BOOL fTrans, int iMode )
 {
    BYTE buf[CDX_MAXKEY], *ptr;
    ULONG ulLen = 0;
@@ -603,7 +603,7 @@ static LPCDXKEY hb_cdxKeyPutItem( LPCDXKEY pKey, PHB_ITEM pItem, ULONG ulRec, LP
 /*
  * get Item from index key
  */
-static PHB_ITEM hb_cdxKeyGetItem( LPCDXKEY pKey, PHB_ITEM pItem, LPCDXTAG pTag, BOOL fTrans )
+static PHB_ITEM hb_cdxKeyGetItem( LPCDXKEY pKey, PHB_ITEM pItem, LPCDXTAG pTag, HB_BOOL fTrans )
 {
    double d;
 
@@ -678,7 +678,7 @@ static LPCDXKEY hb_cdxKeyEval( LPCDXKEY pKey, LPCDXTAG pTag )
    {
       pItem = hb_itemNew( NULL );
       SELF_GETVALUE( ( AREAP ) pArea, pTag->nField, pItem );
-      pKey = hb_cdxKeyPutItem( pKey, pItem, pArea->dbfarea.ulRecNo, pTag, FALSE, CDX_CMP_EXACT );
+      pKey = hb_cdxKeyPutItem( pKey, pItem, pArea->dbfarea.ulRecNo, pTag, HB_FALSE, CDX_CMP_EXACT );
       hb_itemRelease( pItem );
    }
    else
@@ -691,7 +691,7 @@ static LPCDXKEY hb_cdxKeyEval( LPCDXKEY pKey, LPCDXTAG pTag )
          iCurrArea = 0;
 
       pItem = hb_vmEvalBlockOrMacro( pTag->pKeyItem );
-      pKey = hb_cdxKeyPutItem( pKey, pItem, pArea->dbfarea.ulRecNo, pTag, FALSE, CDX_CMP_EXACT );
+      pKey = hb_cdxKeyPutItem( pKey, pItem, pArea->dbfarea.ulRecNo, pTag, HB_FALSE, CDX_CMP_EXACT );
 
       if( iCurrArea )
          hb_rddSelectWorkAreaNumber( iCurrArea );
@@ -705,10 +705,10 @@ static LPCDXKEY hb_cdxKeyEval( LPCDXKEY pKey, LPCDXTAG pTag )
 /*
  * evaluate conditional expression and return the result
  */
-static BOOL hb_cdxEvalCond( CDXAREAP pArea, PHB_ITEM pCondItem, BOOL fSetWA )
+static HB_BOOL hb_cdxEvalCond( CDXAREAP pArea, PHB_ITEM pCondItem, HB_BOOL fSetWA )
 {
    int iCurrArea = 0;
-   BOOL fRet;
+   HB_BOOL fRet;
 
    if( fSetWA )
    {
@@ -730,12 +730,12 @@ static BOOL hb_cdxEvalCond( CDXAREAP pArea, PHB_ITEM pCondItem, BOOL fSetWA )
 /*
  * evaluate seek/skip block: {|key, rec| ... }
  */
-static BOOL hb_cdxEvalSeekCond( LPCDXTAG pTag, PHB_ITEM pCondItem )
+static HB_BOOL hb_cdxEvalSeekCond( LPCDXTAG pTag, PHB_ITEM pCondItem )
 {
-   BOOL fRet;
+   HB_BOOL fRet;
    PHB_ITEM pKeyVal, pKeyRec;
 
-   pKeyVal = hb_cdxKeyGetItem( pTag->CurKey, NULL, pTag, TRUE );
+   pKeyVal = hb_cdxKeyGetItem( pTag->CurKey, NULL, pTag, HB_TRUE );
    pKeyRec = hb_itemPutNInt( NULL, pTag->CurKey->rec );
 
    fRet = hb_itemGetL( hb_vmEvalBlockV( pCondItem, 2, pKeyVal, pKeyRec ) );
@@ -749,7 +749,7 @@ static BOOL hb_cdxEvalSeekCond( LPCDXTAG pTag, PHB_ITEM pCondItem )
 /*
  * check if Key is in top scope
  */
-static BOOL hb_cdxTopScope( LPCDXTAG pTag )
+static HB_BOOL hb_cdxTopScope( LPCDXTAG pTag )
 {
    LPCDXKEY pKey;
 
@@ -774,7 +774,7 @@ static BOOL hb_cdxTopScope( LPCDXTAG pTag )
 /*
  * check if Key is in bottom scope
  */
-static BOOL hb_cdxBottomScope( LPCDXTAG pTag )
+static HB_BOOL hb_cdxBottomScope( LPCDXTAG pTag )
 {
    LPCDXKEY pKey;
 
@@ -873,7 +873,7 @@ static void hb_cdxTagSetScope( LPCDXTAG pTag, USHORT nScope, PHB_ITEM pItem )
       if( *pScope == NULL )
          *pScope = hb_itemNew( NULL );
       hb_itemCopy( *pScope, pItem );
-      *pScopeKey = hb_cdxKeyPutItem( *pScopeKey, pScopeVal, ulRec, pTag, TRUE, CDX_CMP_PREFIX );
+      *pScopeKey = hb_cdxKeyPutItem( *pScopeKey, pScopeVal, ulRec, pTag, HB_TRUE, CDX_CMP_PREFIX );
       pTag->curKeyState &= ~( CDX_CURKEY_RAWCNT | CDX_CURKEY_LOGCNT );
       if( nScope == 0 )
          pTag->curKeyState &= ~( CDX_CURKEY_RAWPOS | CDX_CURKEY_LOGPOS );
@@ -920,14 +920,14 @@ static void hb_cdxTagRefreshScope( LPCDXTAG pTag )
       pItem = hb_vmEvalBlock( pTag->topScope );
       pTag->topScopeKey = hb_cdxKeyPutItem( pTag->topScopeKey, pItem,
                                             pTag->topScopeKey->rec, pTag,
-                                            TRUE, CDX_CMP_PREFIX );
+                                            HB_TRUE, CDX_CMP_PREFIX );
    }
    if( hb_itemType( pTag->bottomScope ) == HB_IT_BLOCK )
    {
       pItem = hb_vmEvalBlock( pTag->bottomScope );
       pTag->bottomScopeKey = hb_cdxKeyPutItem( pTag->bottomScopeKey, pItem,
                                                pTag->bottomScopeKey->rec, pTag,
-                                               TRUE, CDX_CMP_PREFIX );
+                                               HB_TRUE, CDX_CMP_PREFIX );
    }
 }
 
@@ -955,11 +955,11 @@ static void hb_cdxTagPoolCheck( LPCDXTAG pTag )
  */
 static void hb_cdxTagCheckBuffers( LPCDXTAG pTag )
 {
-   BOOL fChanged = FALSE;
+   HB_BOOL fChanged = HB_FALSE;
 
    hb_cdxTagPoolCheck( pTag );
    if( pTag->TagChanged )
-      fChanged = TRUE;
+      fChanged = HB_TRUE;
    else
    {
       LPCDXPAGE pPage = pTag->pagePool;
@@ -997,7 +997,7 @@ static void hb_cdxIndexCheckBuffers( LPCDXINDEX pIndex )
 /*
  * get free index page
  */
-static ULONG hb_cdxIndexGetAvailPage( LPCDXINDEX pIndex, BOOL bHeader )
+static ULONG hb_cdxIndexGetAvailPage( LPCDXINDEX pIndex, HB_BOOL bHeader )
 {
    PHB_FILE pFile = pIndex->pFile;
    BYTE byBuf[4];
@@ -1055,7 +1055,7 @@ static ULONG hb_cdxIndexGetAvailPage( LPCDXINDEX pIndex, BOOL bHeader )
             fOffset += CDX_PAGELEN;
          }
          while( --iCnt );
-         pIndex->fChanged = TRUE;
+         pIndex->fChanged = HB_TRUE;
       }
    }
    return ulPos;
@@ -1064,7 +1064,7 @@ static ULONG hb_cdxIndexGetAvailPage( LPCDXINDEX pIndex, BOOL bHeader )
 /*
  * free index page
  */
-static void hb_cdxIndexPutAvailPage( LPCDXINDEX pIndex, ULONG ulPos, BOOL bHeader )
+static void hb_cdxIndexPutAvailPage( LPCDXINDEX pIndex, ULONG ulPos, HB_BOOL bHeader )
 {
    if( ulPos != 0 && ulPos != CDX_DUMMYNODE )
    {
@@ -1081,7 +1081,7 @@ static void hb_cdxIndexPutAvailPage( LPCDXINDEX pIndex, ULONG ulPos, BOOL bHeade
          pLst = (LPCDXLIST) hb_xgrab( sizeof( CDXLIST ) );
          pLst->ulAddr = pIndex->freePage;
          pIndex->freePage = ulPos;
-         pLst->fStat = TRUE;
+         pLst->fStat = HB_TRUE;
          pLst->pNext = pIndex->freeLst;
          pIndex->freeLst = pLst;
          ulPos += CDX_PAGELEN;
@@ -1097,7 +1097,7 @@ static void hb_cdxIndexFlushAvailPage( LPCDXINDEX pIndex )
    LPCDXLIST pLst = pIndex->freeLst;
    BYTE byPageBuf[CDX_PAGELEN];
    ULONG ulPos;
-   BOOL fClean = TRUE;
+   HB_BOOL fClean = HB_TRUE;
 
    if( pIndex->fReadonly )
       hb_errInternal( 9101, "hb_cdxIndexPutAvailPage on readonly database.", NULL, NULL );
@@ -1110,16 +1110,16 @@ static void hb_cdxIndexFlushAvailPage( LPCDXINDEX pIndex )
       if( fClean )
       {
          memset( byPageBuf, 0, CDX_PAGELEN );
-         fClean = FALSE;
+         fClean = HB_FALSE;
       }
       HB_PUT_LE_UINT32( byPageBuf, pLst->ulAddr );
       if( hb_fileWriteAt( pIndex->pFile, byPageBuf, CDX_PAGELEN, ulPos ) != CDX_PAGELEN )
       {
          hb_errInternal( EDBF_WRITE, "Write in index page failed.", NULL, NULL );
       }
-      pIndex->fChanged = TRUE;
+      pIndex->fChanged = HB_TRUE;
       ulPos = pLst->ulAddr;
-      pLst->fStat = FALSE;
+      pLst->fStat = HB_FALSE;
       pLst = pLst->pNext;
 #ifdef HB_CDX_DBGUPDT
       cdxWriteNO++;
@@ -1155,7 +1155,7 @@ static void hb_cdxIndexPageWrite( LPCDXINDEX pIndex, ULONG ulPos, BYTE * pBuffer
 
    if( hb_fileWriteAt( pIndex->pFile, pBuffer, uiSize, ulPos ) != ( ULONG ) uiSize )
       hb_errInternal( EDBF_WRITE, "Write in index page failed.", NULL, NULL );
-   pIndex->fChanged = TRUE;
+   pIndex->fChanged = HB_TRUE;
 #ifdef HB_CDX_DBGUPDT
    cdxWriteNO++;
 #endif
@@ -1213,16 +1213,16 @@ static void hb_cdxIndexCheckVersion( LPCDXINDEX pIndex )
 /*
  * lock index for reading (shared lock)
  */
-static BOOL hb_cdxIndexLockRead( LPCDXINDEX pIndex )
+static HB_BOOL hb_cdxIndexLockRead( LPCDXINDEX pIndex )
 {
-   BOOL ret;
+   HB_BOOL ret;
 
    if( pIndex->lockRead > 0 || pIndex->lockWrite > 0 ||
         !pIndex->pArea->dbfarea.fShared || !pIndex->fShared ||
         HB_DIRTYREAD( &pIndex->pArea->dbfarea ) )
    {
       pIndex->lockRead++;
-      return TRUE;
+      return HB_TRUE;
    }
 #ifdef HB_CDX_DBGCODE
    if( pIndex->lockRead != 0 )
@@ -1230,7 +1230,7 @@ static BOOL hb_cdxIndexLockRead( LPCDXINDEX pIndex )
 
    if( pIndex->WrLck || pIndex->RdLck )
       hb_errInternal( 9107, "hb_cdxIndexLockRead: lock failure (*)", NULL, NULL );
-   pIndex->RdLck = TRUE;
+   pIndex->RdLck = HB_TRUE;
 #endif
 
    ret = hb_dbfLockIdxFile( pIndex->pFile, pIndex->pArea->dbfarea.bLockType,
@@ -1249,9 +1249,9 @@ static BOOL hb_cdxIndexLockRead( LPCDXINDEX pIndex )
 /*
  * lock index for writing (exclusive lock)
  */
-static BOOL hb_cdxIndexLockWrite( LPCDXINDEX pIndex )
+static HB_BOOL hb_cdxIndexLockWrite( LPCDXINDEX pIndex )
 {
-   BOOL ret;
+   HB_BOOL ret;
 
    if( pIndex->fReadonly )
       hb_errInternal( 9101, "hb_cdxIndexLockWrite: readonly index.", NULL, NULL );
@@ -1260,19 +1260,19 @@ static BOOL hb_cdxIndexLockWrite( LPCDXINDEX pIndex )
    if( pIndex->lockWrite > 0 )
    {
       pIndex->lockWrite++;
-      return TRUE;
+      return HB_TRUE;
    }
    if( pIndex->lockWrite != 0 )
       hb_errInternal( 9105, "hb_cdxIndexLockWrite: bad count of locks.", NULL, NULL );
 
    if( !pIndex->pArea->dbfarea.fShared || !pIndex->fShared )
-      ret = TRUE;
+      ret = HB_TRUE;
    else
    {
 #ifdef HB_CDX_DBGCODE
       if( pIndex->WrLck || pIndex->RdLck )
          hb_errInternal( 9107, "hb_cdxIndexLockWrite: lock failure (*)", NULL, NULL );
-      pIndex->WrLck = TRUE;
+      pIndex->WrLck = HB_TRUE;
 #endif
       ret = hb_dbfLockIdxFile( pIndex->pFile, pIndex->pArea->dbfarea.bLockType,
                                FL_LOCK | FLX_EXCLUSIVE | FLX_WAIT, &pIndex->ulLockPos );
@@ -1292,7 +1292,7 @@ static BOOL hb_cdxIndexLockWrite( LPCDXINDEX pIndex )
 /*
  * remove index read lock (shared lock)
  */
-static BOOL hb_cdxIndexUnLockRead( LPCDXINDEX pIndex )
+static HB_BOOL hb_cdxIndexUnLockRead( LPCDXINDEX pIndex )
 {
    pIndex->lockRead--;
    if( pIndex->lockRead < 0 )
@@ -1301,7 +1301,7 @@ static BOOL hb_cdxIndexUnLockRead( LPCDXINDEX pIndex )
    }
    if( pIndex->lockRead || pIndex->lockWrite )
    {
-      return TRUE;
+      return HB_TRUE;
    }
 #ifdef HB_CDX_DBGCODE_EXT
    hb_cdxIndexCheckBuffers( pIndex );
@@ -1315,25 +1315,25 @@ static BOOL hb_cdxIndexUnLockRead( LPCDXINDEX pIndex )
 #ifdef HB_CDX_DBGCODE
       if( pIndex->WrLck || ! pIndex->RdLck )
          hb_errInternal( 9108, "hb_cdxIndexUnLockRead: unlock error (*)", NULL, NULL );
-      pIndex->RdLck = FALSE;
+      pIndex->RdLck = HB_FALSE;
 #endif
       if( !hb_dbfLockIdxFile( pIndex->pFile, pIndex->pArea->dbfarea.bLockType, FL_UNLOCK, &pIndex->ulLockPos ) )
       {
          hb_errInternal( 9108, "hb_cdxIndexUnLockRead: unlock error.", NULL, NULL );
       }
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * remove index write lock (exclusive lock)
  */
-static BOOL hb_cdxIndexUnLockWrite( LPCDXINDEX pIndex )
+static HB_BOOL hb_cdxIndexUnLockWrite( LPCDXINDEX pIndex )
 {
    if( pIndex->lockWrite > 1 )
    {
       pIndex->lockWrite--;
-      return TRUE;
+      return HB_TRUE;
    }
 
    if( pIndex->lockWrite < 1 )
@@ -1361,13 +1361,13 @@ static BOOL hb_cdxIndexUnLockWrite( LPCDXINDEX pIndex )
          {
             hb_errInternal( EDBF_WRITE, "Write in index page failed (ver)", NULL, NULL );
          }
-         pIndex->fFlush = TRUE;
-         pIndex->fChanged = FALSE;
+         pIndex->fFlush = HB_TRUE;
+         pIndex->fChanged = HB_FALSE;
       }
 #ifdef HB_CDX_DBGCODE
       if( ! pIndex->WrLck || pIndex->RdLck )
          hb_errInternal( 9108, "hb_cdxIndexUnLockWrite: unlock error (*)", NULL, NULL );
-      pIndex->WrLck = FALSE;
+      pIndex->WrLck = HB_FALSE;
 #endif
       if( !hb_dbfLockIdxFile( pIndex->pFile, pIndex->pArea->dbfarea.bLockType, FL_UNLOCK, &pIndex->ulLockPos ) )
       {
@@ -1385,18 +1385,18 @@ static BOOL hb_cdxIndexUnLockWrite( LPCDXINDEX pIndex )
             hb_errInternal( EDBF_WRITE, "Write in index page failed (ver.ex)", NULL, NULL );
          }
          pIndex->ulVersion = pIndex->freePage;
-         pIndex->fFlush = TRUE;
+         pIndex->fFlush = HB_TRUE;
 #ifdef HB_CDX_DBGUPDT
          cdxWriteNO++;
 #endif
       }
       else if( pIndex->fChanged )
       {
-         pIndex->fFlush = TRUE;
+         pIndex->fFlush = HB_TRUE;
       }
-      pIndex->fChanged = FALSE;
+      pIndex->fChanged = HB_FALSE;
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
@@ -1415,7 +1415,7 @@ static void hb_cdxIndexDiscardBuffers( LPCDXINDEX pIndex )
    {
       hb_cdxTagClose( pIndex->pCompound );
       hb_cdxTagPoolFree( pIndex->pCompound, 0 );
-      pIndex->pCompound->fRePos = TRUE;
+      pIndex->pCompound->fRePos = HB_TRUE;
       pIndex->pCompound->curKeyState = 0;
       if( pIndex->pCompound->CurKey )
          pIndex->pCompound->CurKey->rec = 0;
@@ -1425,7 +1425,7 @@ static void hb_cdxIndexDiscardBuffers( LPCDXINDEX pIndex )
    {
       hb_cdxTagClose( pTag );
       hb_cdxTagPoolFree( pTag, 0 );
-      pTag->fRePos = TRUE;
+      pTag->fRePos = HB_TRUE;
       pTag->curKeyState = 0;
       if( pTag->CurKey && !pTag->Custom )
          pTag->CurKey->rec = 0;
@@ -1638,13 +1638,13 @@ static void hb_cdxPageCheckKeys( LPCDXPAGE pPage )
 /*
  * Check decoded leaf page if all trailing and duplicate characters are set
  */
-static void hb_cdxPageCheckDupTrl( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys, BOOL fSpc )
+static void hb_cdxPageCheckDupTrl( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys, HB_BOOL fSpc )
 {
    int iNum = pPage->TagParent->uiLen, iKey, iPos, iFree = CDX_EXT_FREESPACE;
    int iLen = iNum + 6;
    BYTE  bDup, bTrl;
    BYTE  bTrail = pPage->TagParent->bTrail;
-   BOOL  bErr = FALSE;
+   HB_BOOL  bErr = HB_FALSE;
 
    for( iKey = 0; iKey < iKeys; iKey++ )
    {
@@ -1667,13 +1667,13 @@ static void hb_cdxPageCheckDupTrl( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys, B
       {
          printf("\r\nbTrl=%d, keybuf->bTrl=%d, iKey=%d/%d\r\n", bTrl, pKeyBuf[ iPos + iNum + 5 ], iKey, iKeys );
          fflush(stdout);
-         bErr = TRUE;
+         bErr = HB_TRUE;
       }
       if( bDup != ( iKey == 0 ? 0 : pKeyBuf[ iPos + iNum + 4 ] ) )
       {
          printf("\r\nbDup=%d, keybuf->bDup=%d (bTrl=%d), iKey=%d/%d\r\n", bDup, pKeyBuf[ iPos + iNum + 4 ], bTrl, iKey, iKeys );
          fflush(stdout);
-         bErr = TRUE;
+         bErr = HB_TRUE;
       }
       if( iKey > 0 )
       {
@@ -1694,7 +1694,7 @@ static void hb_cdxPageCheckDupTrl( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys, B
                     memcmp( &pKeyBuf[ iPos - iLen ], &pKeyBuf[ iPos ], iNum ),
                     pKeyBuf );
             fflush(stdout);
-            bErr = TRUE;
+            bErr = HB_TRUE;
          }
       }
       iFree -= iNum + pPage->ReqByte - bDup - bTrl;
@@ -1704,7 +1704,7 @@ static void hb_cdxPageCheckDupTrl( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys, B
       printf( "\r\nFreeSpace calculated wrong! iFree=%d, pPage->iFree=%d",
               iFree, pPage->iFree );
       fflush(stdout);
-      bErr = TRUE;
+      bErr = HB_TRUE;
    }
    if( bErr )
    {
@@ -1720,7 +1720,7 @@ static void hb_cdxPageCheckDupTrlRaw( LPCDXPAGE pPage )
    BYTE *pKeyBuf = (BYTE *) hb_xgrab( pPage->iKeys * ( pPage->TagParent->uiLen + 6 ) );
 
    hb_cdxPageLeafDecode( pPage, pKeyBuf );
-   hb_cdxPageCheckDupTrl( pPage, pKeyBuf, pPage->iKeys, TRUE );
+   hb_cdxPageCheckDupTrl( pPage, pKeyBuf, pPage->iKeys, HB_TRUE );
    hb_xfree( pKeyBuf );
 }
 #endif
@@ -1765,7 +1765,7 @@ static void hb_cdxPageLeafEncode( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys )
 #ifdef HB_CDX_DBGCODE_EXT
    if( ! pKeyBuf )
       hb_cdxErrInternal( "hb_cdxPageLeafEncode: page has no buffer." );
-   hb_cdxPageCheckDupTrl( pPage, pKeyBuf, iKeys, TRUE );
+   hb_cdxPageCheckDupTrl( pPage, pKeyBuf, iKeys, HB_TRUE );
 #endif
    iNum = pPage->TagParent->uiLen;
    iLen = iNum + 6;
@@ -1808,7 +1808,7 @@ static void hb_cdxPageLeafEncode( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys )
       hb_cdxErrInternal( "hb_cdxPageLeafEncode: FreeSpace calculated wrong!!." );
 #endif
    pPage->iKeys = iKeys;
-   pPage->fChanged = TRUE;
+   pPage->fChanged = HB_TRUE;
    pPage->bufKeyNum = 0;
 #ifdef HB_CDX_DBGCODE_EXT
    {
@@ -1818,7 +1818,7 @@ static void hb_cdxPageLeafEncode( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys )
       pPage->pKeyBuf = pKeyBf;
    }
    hb_cdxPageCheckKeys( pPage );
-   hb_cdxPageCheckDupTrl( pPage, pKeyBuf, pPage->iKeys, TRUE );
+   hb_cdxPageCheckDupTrl( pPage, pKeyBuf, pPage->iKeys, HB_TRUE );
 #endif
 }
 
@@ -1881,7 +1881,7 @@ static void hb_cdxPageLeafDecode( LPCDXPAGE pPage, BYTE * pKeyBuf )
    }
 #ifdef HB_CDX_DBGCODE_EXT
    {
-      BOOL fChg = pPage->fChanged;
+      HB_BOOL fChg = pPage->fChanged;
       hb_cdxPageLeafEncode( pPage, pKeyBuf, pPage->iKeys );
       pPage->fChanged = fChg;
    }
@@ -1921,7 +1921,7 @@ static void hb_cdxPageCalcLeafSpace( LPCDXPAGE pPage, BYTE * pKeyBuf, int iKeys
    RNMask = pPage->RNMask;
    ReqByte = pPage->ReqByte;
 #ifdef HB_CDX_DBGCODE_EXT
-   hb_cdxPageCheckDupTrl( pPage, pKeyBuf, iKeys, FALSE );
+   hb_cdxPageCheckDupTrl( pPage, pKeyBuf, iKeys, HB_FALSE );
 #endif
    for( iKey = 0; iKey < iKeys; iKey++ )
    {
@@ -2041,10 +2041,10 @@ static int hb_cdxPageLeafDelKey( LPCDXPAGE pPage )
                &pPage->pKeyBuf[ ( iKey + 1 ) * iLen ],
                ( pPage->iKeys - iKey ) * iLen );
    }
-   pPage->fBufChanged = pPage->fChanged = TRUE;
+   pPage->fBufChanged = pPage->fChanged = HB_TRUE;
 #ifdef HB_CDX_DBGCODE_EXT
    hb_cdxPageCheckKeys( pPage );
-   hb_cdxPageCheckDupTrl( pPage, pPage->pKeyBuf, pPage->iKeys, TRUE );
+   hb_cdxPageCheckDupTrl( pPage, pPage->pKeyBuf, pPage->iKeys, HB_TRUE );
 #endif
    if( iKey >= pPage->iKeys )
       iRet |= NODE_NEWLASTKEY;
@@ -2092,7 +2092,7 @@ static int hb_cdxPageLeafAddKey( LPCDXPAGE pPage, LPCDXKEY pKey )
 
 #ifdef HB_CDX_DBGCODE_EXT
    hb_cdxPageCheckKeys( pPage );
-   hb_cdxPageCheckDupTrl( pPage, pPage->pKeyBuf, pPage->iKeys, TRUE );
+   hb_cdxPageCheckDupTrl( pPage, pPage->pKeyBuf, pPage->iKeys, HB_TRUE );
 #endif
 
    iTrl = iDup = 0;
@@ -2159,10 +2159,10 @@ static int hb_cdxPageLeafAddKey( LPCDXPAGE pPage, LPCDXKEY pKey )
       iSpc += pPage->iKeys;
    }
    pPage->iFree -= iSpc;
-   pPage->fBufChanged = pPage->fChanged = TRUE;
+   pPage->fBufChanged = pPage->fChanged = HB_TRUE;
 #ifdef HB_CDX_DBGCODE_EXT
    hb_cdxPageCheckKeys( pPage );
-   hb_cdxPageCheckDupTrl( pPage, pPage->pKeyBuf, pPage->iKeys, TRUE );
+   hb_cdxPageCheckDupTrl( pPage, pPage->pKeyBuf, pPage->iKeys, HB_TRUE );
 #endif
    if( iKey >= pPage->iKeys - 1 )
       iRet |= NODE_NEWLASTKEY;
@@ -2177,7 +2177,7 @@ static int hb_cdxPageLeafAddKey( LPCDXPAGE pPage, LPCDXKEY pKey )
 /*
  * set (insert) key in interior node record to (with) given value
  */
-static void hb_cdxPageIntSetKey( LPCDXPAGE pPage, int iKey, BOOL fIns, BYTE * pbVal, ULONG ulRec, ULONG ulPag )
+static void hb_cdxPageIntSetKey( LPCDXPAGE pPage, int iKey, HB_BOOL fIns, BYTE * pbVal, ULONG ulRec, ULONG ulPag )
 {
    int iLen = pPage->TagParent->uiLen;
    int iPos = iKey * ( iLen + 8 );
@@ -2213,7 +2213,7 @@ static void hb_cdxPageIntSetKey( LPCDXPAGE pPage, int iKey, BOOL fIns, BYTE * pb
    if( ulRec )
       HB_PUT_BE_UINT32( &pPage->node.intNode.keyPool[ iPos + iLen ], ulRec );
    HB_PUT_BE_UINT32( &pPage->node.intNode.keyPool[ iPos + iLen + 4 ], ulPag );
-   pPage->fChanged = TRUE;
+   pPage->fChanged = HB_TRUE;
 }
 
 /*
@@ -2244,7 +2244,7 @@ static void hb_cdxPageIntDelKey( LPCDXPAGE pPage, int iKey )
                &pPage->node.intNode.keyPool[ ( iKey + 1 ) * iLen ], ( pPage->iKeys - iKey ) * iLen );
    }
    memset( &pPage->node.intNode.keyPool[ pPage->iKeys * iLen ], 0, iLen );
-   pPage->fChanged = TRUE;
+   pPage->fChanged = HB_TRUE;
 }
 
 /*
@@ -2256,14 +2256,14 @@ static void hb_cdxPageLoad( LPCDXPAGE pPage )
    {
       hb_xfree( pPage->pKeyBuf );
       pPage->pKeyBuf = NULL;
-      pPage->fBufChanged = FALSE;
+      pPage->fBufChanged = HB_FALSE;
    }
    hb_cdxIndexPageRead( pPage->TagParent->pIndex, pPage->Page, (BYTE *) &pPage->node, sizeof( CDXNODE ) );
    pPage->PageType = ( BYTE ) HB_GET_LE_UINT16( pPage->node.intNode.attr );
    pPage->Left = HB_GET_LE_UINT32( pPage->node.intNode.leftPtr );
    pPage->Right = HB_GET_LE_UINT32( pPage->node.intNode.rightPtr );
    pPage->iKeys = HB_GET_LE_UINT16( pPage->node.intNode.nKeys );
-   pPage->fChanged  = FALSE;
+   pPage->fChanged  = HB_FALSE;
 
    if( ( pPage->PageType & CDX_NODE_LEAF ) != 0 )
    {
@@ -2327,7 +2327,7 @@ static void hb_cdxPageStore( LPCDXPAGE pPage )
       if( pPage->pKeyBuf && pPage->fBufChanged )
       {
          hb_cdxPageLeafEncode( pPage, pPage->pKeyBuf, pPage->iKeys );
-         pPage->fBufChanged = FALSE;
+         pPage->fBufChanged = HB_FALSE;
       }
 #ifdef HB_CDX_DBGCODE_EXT
       if( pPage->pKeyBuf )
@@ -2341,7 +2341,7 @@ static void hb_cdxPageStore( LPCDXPAGE pPage )
 #ifdef HB_CDX_DBGCODE_EXT
    hb_cdxPageCheckKeys( pPage );
 #endif
-   pPage->fChanged = FALSE;
+   pPage->fChanged = HB_FALSE;
 }
 
 /*
@@ -2393,8 +2393,8 @@ static LPCDXPAGE hb_cdxPageNew( LPCDXTAG pTag, LPCDXPAGE pOwnerPage, ULONG ulPag
       }
       else if( ! ulPage  )
       {
-         pPage->Page = hb_cdxIndexGetAvailPage( pTag->pIndex, FALSE );
-         pPage->fChanged = TRUE;
+         pPage->Page = hb_cdxIndexGetAvailPage( pTag->pIndex, HB_FALSE );
+         pPage->fChanged = HB_TRUE;
       }
       pPage->pPoolPrev = NULL;
       pPage->pPoolNext = pTag->pagePool;
@@ -2414,7 +2414,7 @@ static LPCDXPAGE hb_cdxPageNew( LPCDXTAG pTag, LPCDXPAGE pOwnerPage, ULONG ulPag
 /*
  * free single page
  */
-static void hb_cdxPageFree( LPCDXPAGE pPage, BOOL fReal )
+static void hb_cdxPageFree( LPCDXPAGE pPage, HB_BOOL fReal )
 {
 #ifdef HB_CDX_DBGCODE_EXT
    LPCDXTAG pTag = pPage->TagParent;
@@ -2428,8 +2428,8 @@ static void hb_cdxPageFree( LPCDXPAGE pPage, BOOL fReal )
 
    if( pPage->PageType == CDX_NODE_UNUSED )
    {
-      fReal = TRUE;
-      pPage->fChanged = FALSE;
+      fReal = HB_TRUE;
+      pPage->fChanged = HB_FALSE;
    }
 
    if( fReal )
@@ -2469,7 +2469,7 @@ static void hb_cdxPageFree( LPCDXPAGE pPage, BOOL fReal )
    if( fReal )
    {
       if( pPage->PageType == CDX_NODE_UNUSED )
-         hb_cdxIndexPutAvailPage( pPage->TagParent->pIndex, pPage->Page, FALSE );
+         hb_cdxIndexPutAvailPage( pPage->TagParent->pIndex, pPage->Page, HB_FALSE );
       if( pPage->pKeyBuf )
          hb_xfree( pPage->pKeyBuf );
       hb_xfree( pPage );
@@ -2496,7 +2496,7 @@ static void hb_cdxPageGetChild( LPCDXPAGE pPage )
    {
       if( pPage->Child->Page != ulPage )
       {
-         hb_cdxPageFree( pPage->Child, FALSE );
+         hb_cdxPageFree( pPage->Child, HB_FALSE );
          pPage->Child = NULL;
       }
    }
@@ -2516,7 +2516,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
    int iLen = pPage->TagParent->uiLen + 6,
        iKeys = 0, iFree = 0, iSkip = 0, iBufSize = 0;
    BYTE * pKeyPool = NULL, * pPtr;
-   BOOL fIns;
+   HB_BOOL fIns;
    ULONG ulPage;
    int iRet = 0, i;
 
@@ -2584,7 +2584,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
          else if( i + 1 == iBlncKeys && ( iChildRet & NODE_SPLIT ) == 0 )
          {
             iBlncKeys--;
-            hb_cdxPageFree( childs[i], FALSE );
+            hb_cdxPageFree( childs[i], HB_FALSE );
          }
 #endif
       }
@@ -2602,7 +2602,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
       for( i = iBlncKeys - 1; i > iSkip && childs[i]->iFree >= 0 && childs[i]->iFree < childs[i]->ReqByte; i-- )
       {
          iKeys -= childs[i]->iKeys;
-         hb_cdxPageFree( childs[i], FALSE );
+         hb_cdxPageFree( childs[i], HB_FALSE );
          iBlncKeys--;
       }
    }
@@ -2610,7 +2610,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
         ( iBlncKeys < 2 || iFree < CDX_EXT_FREESPACE ) )
    {
       for( i = 0; i < iBlncKeys; i++ )
-         hb_cdxPageFree( childs[i], FALSE );
+         hb_cdxPageFree( childs[i], HB_FALSE );
       return iRet;
    }
 #ifdef HB_CDX_DSPDBG_INFO
@@ -2665,10 +2665,10 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
    }
 
 #ifdef HB_CDX_DBGCODE_EXT
-   hb_cdxPageCheckDupTrl( pPage, pKeyPool, iKeys, FALSE );
+   hb_cdxPageCheckDupTrl( pPage, pKeyPool, iKeys, HB_FALSE );
 #endif
    pPtr = pKeyPool;
-   fIns = FALSE;
+   fIns = HB_FALSE;
    i = iSkip;
    while( iKeys > 0 )
    {
@@ -2716,7 +2716,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
             iSize = lpTmpPage->iFree - iSize -
                      ( iMaxReq - lpTmpPage->ReqByte ) * lpTmpPage->iKeys;
             if( iSize < 0 )
-               fIns = TRUE;
+               fIns = HB_TRUE;
             else
             {
 #ifdef HB_CDX_DSPDBG_INFO
@@ -2768,7 +2768,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
                {
                   hb_xfree( childs[i]->pKeyBuf );
                   childs[i]->pKeyBuf = NULL;
-                  childs[i]->fBufChanged = FALSE;
+                  childs[i]->fBufChanged = HB_FALSE;
                }
                hb_cdxPageCalcLeafSpace( childs[i], pPtr, iKeys );
                hb_cdxPageLeafEncode( childs[i], pPtr, childs[i]->iKeys );
@@ -2784,7 +2784,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
 #endif
          }
          else
-            fIns = TRUE;
+            fIns = HB_TRUE;
 
          if( fIns )
          {
@@ -2794,12 +2794,12 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
             childs[ i ]->Left  = childs[i-1]->Page;
             childs[ i ]->Right = childs[i-1]->Right;
             childs[i-1]->Right = childs[ i ]->Page;
-            childs[i-1]->fChanged = TRUE;
+            childs[i-1]->fChanged = HB_TRUE;
             if( lpTmpPage != NULL )
             {
                lpTmpPage->Left = childs[i]->Page;
-               lpTmpPage->fChanged = TRUE;
-               hb_cdxPageFree( lpTmpPage, FALSE );
+               lpTmpPage->fChanged = HB_TRUE;
+               hb_cdxPageFree( lpTmpPage, HB_FALSE );
             }
             iBlncKeys++;
             iRet |= NODE_BALANCE;
@@ -2814,7 +2814,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
       {
          hb_xfree( childs[i]->pKeyBuf );
          childs[i]->pKeyBuf = NULL;
-         childs[i]->fBufChanged = FALSE;
+         childs[i]->fBufChanged = HB_FALSE;
       }
       hb_cdxPageCalcLeafSpace( childs[i], pPtr, iKeys );
       if( i == iSkip && i < iBlncKeys && !childs[i]->fChanged &&
@@ -2859,13 +2859,13 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
          Page = childs[iBlncKeys-1]->Page;
          childs[iBlncKeys-1]->Page = childs[i-1]->Page;
          childs[i-1]->Page = Page;
-         hb_cdxPageIntSetKey( pPage, iFirstKey + i - 1, FALSE, NULL, 0, Page );
+         hb_cdxPageIntSetKey( pPage, iFirstKey + i - 1, HB_FALSE, NULL, 0, Page );
          childs[i-1]->Right = childs[iBlncKeys-1]->Right;
-         childs[i-1]->fChanged = TRUE;
+         childs[i-1]->fChanged = HB_TRUE;
          if( i > 1 )
          {
             childs[i-2]->Right = Page;
-            childs[i-2]->fChanged = TRUE;
+            childs[i-2]->fChanged = HB_TRUE;
          }
       }
       else
@@ -2877,7 +2877,7 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
          {
             Left = childs[i-1]->Page;
             childs[i-1]->Right = Right;
-            childs[i-1]->fChanged  = TRUE;
+            childs[i-1]->fChanged  = HB_TRUE;
          }
          else
          {
@@ -2886,16 +2886,16 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
             {
                lpTmpPage = hb_cdxPageNew( pPage->TagParent, pPage, Left );
                lpTmpPage->Right = Right;
-               lpTmpPage->fChanged  = TRUE;
-               hb_cdxPageFree( lpTmpPage, FALSE );
+               lpTmpPage->fChanged  = HB_TRUE;
+               hb_cdxPageFree( lpTmpPage, HB_FALSE );
             }
          }
          if( Right != CDX_DUMMYNODE )
          {
             lpTmpPage = hb_cdxPageNew( pPage->TagParent, pPage, Right );
             lpTmpPage->Left = Left;
-            lpTmpPage->fChanged  = TRUE;
-            hb_cdxPageFree( lpTmpPage, FALSE );
+            lpTmpPage->fChanged  = HB_TRUE;
+            hb_cdxPageFree( lpTmpPage, HB_FALSE );
          }
       }
       /* Unlink empty pages from parent */
@@ -2911,24 +2911,24 @@ static int hb_cdxPageKeyLeafBalance( LPCDXPAGE pPage, int iChildRet )
          {
             hb_xfree( childs[iBlncKeys ]->pKeyBuf );
             childs[iBlncKeys]->pKeyBuf = NULL;
-            childs[iBlncKeys]->fBufChanged = FALSE;
+            childs[iBlncKeys]->fBufChanged = HB_FALSE;
          }
          hb_cdxPageIntDelKey( pPage, iFirstKey + iBlncKeys );
          childs[iBlncKeys]->Owner    = NULL;
-         childs[iBlncKeys]->fChanged = FALSE;
+         childs[iBlncKeys]->fChanged = HB_FALSE;
          childs[iBlncKeys]->PageType = CDX_NODE_UNUSED;
          childs[iBlncKeys]->Left     = CDX_DUMMYNODE;
          childs[iBlncKeys]->Right    = CDX_DUMMYNODE;
-         hb_cdxPageFree( childs[iBlncKeys], FALSE );
+         hb_cdxPageFree( childs[iBlncKeys], HB_FALSE );
       }
       iRet |= NODE_BALANCE;
    }
    for( i = 0; i < iBlncKeys; i++ )
-      hb_cdxPageFree( childs[i], FALSE );
+      hb_cdxPageFree( childs[i], HB_FALSE );
 
    if( pKeyPool )
       hb_xfree( pKeyPool );
-   pPage->fChanged = TRUE;
+   pPage->fChanged = HB_TRUE;
 #ifdef HB_CDX_DBGCODE_EXT
    hb_cdxPageCheckKeys( pPage );
 #endif
@@ -2945,14 +2945,14 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
        iMin = pPage->TagParent->MaxKeys, iMax = 0, iDiv;
    ULONG ulPage;
    BYTE * pKeyPool = NULL, *pPtr;
-   BOOL fForce = ( iChildRet & ( NODE_SPLIT | NODE_JOIN ) ) != 0;
+   HB_BOOL fForce = ( iChildRet & ( NODE_SPLIT | NODE_JOIN ) ) != 0;
    int iRet = 0, i;
 
    if( !fForce && ( iChildRet & NODE_BALANCE ) == 0 )
       return iRet;
 
    if( pPage->Child && pPage->Child->Child )
-      hb_cdxPageFree( pPage->Child->Child, FALSE );
+      hb_cdxPageFree( pPage->Child->Child, HB_FALSE );
 
 #ifdef HB_CDX_DBGCODE_EXT
    hb_cdxPageCheckKeys( pPage );
@@ -3052,7 +3052,7 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
                   childs[i]->iKeys >= iMin && childs[i]->iKeys <= iMax; i-- )
          {
             iKeys -= childs[i]->iKeys;
-            hb_cdxPageFree( childs[i], FALSE );
+            hb_cdxPageFree( childs[i], HB_FALSE );
             iBlncKeys--;
             iMin = HB_MAX( iKeys / iNeedKeys, 2 );
             iMax = HB_MAX( ( iKeys + iNeedKeys - 1 ) / iNeedKeys, iMin );
@@ -3060,7 +3060,7 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
          while( iBlncKeys > 2 && childs[0]->iKeys >= iMin && childs[0]->iKeys <= iMax )
          {
             iKeys -= childs[0]->iKeys;
-            hb_cdxPageFree( childs[0], FALSE );
+            hb_cdxPageFree( childs[0], HB_FALSE );
             iBlncKeys--;
             iFirstKey++;
             for( i = 0; i < iBlncKeys; i++ )
@@ -3075,7 +3075,7 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
    if( !fForce && ( iBlncKeys < 2 || iDiv < 2 ) )
    {
       for( i = 0; i < iBlncKeys; i++ )
-         hb_cdxPageFree( childs[i], FALSE );
+         hb_cdxPageFree( childs[i], HB_FALSE );
       return iRet;
    }
 
@@ -3104,9 +3104,9 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
       childs[ i ] = hb_cdxPageNew( pPage->TagParent, pPage, 0 );
       childs[ i ]->PageType = CDX_NODE_BRANCH;
       childs[ i ]->iKeys    = 0;
-      childs[ i ]->fChanged = TRUE;
+      childs[ i ]->fChanged = HB_TRUE;
       /* Add new parent key */
-      hb_cdxPageIntSetKey( pPage, iFirstKey + i, TRUE,
+      hb_cdxPageIntSetKey( pPage, iFirstKey + i, HB_TRUE,
                            NULL, 0, childs[iBlncKeys]->Page );
       /* Update siblings links */
       childs[ i ]->Left  = childs[i-1]->Page;
@@ -3118,8 +3118,8 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
       {
          lpTmpPage = hb_cdxPageNew( pPage->TagParent, pPage, childs[iBlncKeys]->Right );
          lpTmpPage->Left = childs[i]->Page;
-         lpTmpPage->fChanged  = TRUE;
-         hb_cdxPageFree( lpTmpPage, FALSE );
+         lpTmpPage->fChanged  = HB_TRUE;
+         hb_cdxPageFree( lpTmpPage, HB_FALSE );
       }
 #ifdef HB_CDX_DSPDBG_INFO
       printf("\r\nint balance: new child[%d]->Page=%lx",iBlncKeys,childs[iBlncKeys]->Page);
@@ -3163,16 +3163,16 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
             {
                lpTmpPage = hb_cdxPageNew( pPage->TagParent, pPage, Left );
                lpTmpPage->Right = Right;
-               lpTmpPage->fChanged = TRUE;
-               hb_cdxPageFree( lpTmpPage, FALSE );
+               lpTmpPage->fChanged = HB_TRUE;
+               hb_cdxPageFree( lpTmpPage, HB_FALSE );
             }
          }
          if( Right != CDX_DUMMYNODE )
          {
             lpTmpPage = hb_cdxPageNew( pPage->TagParent, pPage, Right );
             lpTmpPage->Left = Left;
-            lpTmpPage->fChanged = TRUE;
-            hb_cdxPageFree( lpTmpPage, FALSE );
+            lpTmpPage->fChanged = HB_TRUE;
+            hb_cdxPageFree( lpTmpPage, HB_FALSE );
          }
       }
       /* Unlink empty pages from parent */
@@ -3185,12 +3185,12 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
 #endif
          hb_cdxPageIntDelKey( pPage, iFirstKey + i );
          childs[i]->Owner    = NULL;
-         childs[i]->fChanged = FALSE;
+         childs[i]->fChanged = HB_FALSE;
          childs[i]->PageType = CDX_NODE_UNUSED;
          childs[i]->Left     = CDX_DUMMYNODE;
          childs[i]->Right    = CDX_DUMMYNODE;
          childs[i]->iKeys    = 0;
-         hb_cdxPageFree( childs[i], FALSE );
+         hb_cdxPageFree( childs[i], HB_FALSE );
       }
       iBlncKeys = iNeedKeys;
       iRet |= NODE_BALANCE;
@@ -3215,13 +3215,13 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
          /* TODO: do nothing if iNodeKeys == childs[i]->iKeys && i == iSkip */
          memcpy( childs[i]->node.intNode.keyPool, pPtr, iNodeKeys * iLen );
          childs[i]->iKeys = iNodeKeys;
-         childs[i]->fChanged = TRUE;
+         childs[i]->fChanged = HB_TRUE;
          pPtr += iNodeKeys * iLen;
          iKeys -= iNodeKeys;
          /* update parent key */
          if( iFirstKey + i < pPage->iKeys )
          {
-            hb_cdxPageIntSetKey( pPage, iFirstKey + i, FALSE,
+            hb_cdxPageIntSetKey( pPage, iFirstKey + i, HB_FALSE,
                                  pPtr - iLen, HB_GET_BE_UINT32( pPtr - 8 ),
                                  childs[i]->Page );
          }
@@ -3231,11 +3231,11 @@ static int hb_cdxPageKeyIntBalance( LPCDXPAGE pPage, int iChildRet )
 #ifdef HB_CDX_DBGCODE_EXT
          hb_cdxPageCheckKeys( childs[i] );
 #endif
-         hb_cdxPageFree( childs[i], FALSE );
+         hb_cdxPageFree( childs[i], HB_FALSE );
       }
       hb_xfree( pKeyPool );
    }
-   pPage->fChanged = TRUE;
+   pPage->fChanged = HB_TRUE;
 #ifdef HB_CDX_DBGCODE_EXT
    hb_cdxPageCheckKeys( pPage );
 #endif
@@ -3264,14 +3264,14 @@ static int hb_cdxPageBalance( LPCDXPAGE pPage, int iChildRet )
          }
          else
          {
-            hb_cdxPageIntSetKey( pPage, pPage->iCurKey, FALSE,
+            hb_cdxPageIntSetKey( pPage, pPage->iCurKey, HB_FALSE,
                                  hb_cdxPageGetKeyVal( pPage->Child, pPage->Child->iKeys-1 ),
                                  hb_cdxPageGetKeyRec( pPage->Child, pPage->Child->iKeys-1 ),
                                  pPage->Child->Page );
 #ifdef HB_CDX_DBGCODE_EXT
             hb_cdxPageCheckKeys( pPage );
 #endif
-            pPage->fChanged = TRUE;
+            pPage->fChanged = HB_TRUE;
             if( pPage->iCurKey >= pPage->iKeys - 1 )
                iRet |= NODE_NEWLASTKEY;
          }
@@ -3315,10 +3315,10 @@ static int hb_cdxPageRootSplit( LPCDXPAGE pPage )
    pPage->Owner = pNewRoot;
    pPage->PageType &= ~CDX_NODE_ROOT;
    pNewRoot->PageType = CDX_NODE_ROOT | CDX_NODE_BRANCH;
-   pNewRoot->fChanged = TRUE;
+   pNewRoot->fChanged = HB_TRUE;
    pNewRoot->Child    = pPage;
    pNewRoot->iCurKey  = 0;
-   hb_cdxPageIntSetKey( pNewRoot, 0, TRUE,
+   hb_cdxPageIntSetKey( pNewRoot, 0, HB_TRUE,
                         hb_cdxPageGetKeyVal( pPage, pPage->iKeys-1 ),
                         hb_cdxPageGetKeyRec( pPage, pPage->iKeys-1 ),
                         pPage->Page );
@@ -3380,7 +3380,7 @@ static void hb_cdxTagHeaderStore( LPCDXTAG pTag )
     * tagHeader.reserved2[ 486 ]
     */
 
-   pTag->TagChanged = FALSE;
+   pTag->TagChanged = HB_FALSE;
    pTag->OptFlags &= ~( CDX_TYPE_UNIQUE | CDX_TYPE_FORFILTER |
                         CDX_TYPE_TEMPORARY | CDX_TYPE_CUSTOM );
    if( pTag->UniqueKey )
@@ -3487,7 +3487,7 @@ static void hb_cdxTagLoad( LPCDXTAG pTag )
    pTag->OptFlags  = tagHeader.indexOpt;
    pTag->UniqueKey = ( pTag->OptFlags & CDX_TYPE_UNIQUE ) != 0;
 #if defined( HB_SIXCDX )
-   pTag->Temporary = FALSE;
+   pTag->Temporary = HB_FALSE;
    pTag->Custom    = ( pTag->OptFlags & CDX_TYPE_CUSTOM ) != 0 &&
                      ( pTag->OptFlags & CDX_TYPE_TEMPORARY ) != 0;
    pTag->ChgOnly   = ( pTag->OptFlags & CDX_TYPE_CUSTOM ) != 0 &&
@@ -3501,23 +3501,23 @@ static void hb_cdxTagLoad( LPCDXTAG pTag )
                      hb_strnicmp( pTag->KeyExpr, "sxNum(", 6 ) == 0 ||
                      hb_strnicmp( pTag->KeyExpr, "sxLog(", 6 ) == 0 )
    /* SIx3 does not support repeated key value for the same record */
-   pTag->MultiKey  = FALSE;
+   pTag->MultiKey  = HB_FALSE;
 #endif
    pTag->Template  = pTag->MultiKey = pTag->Custom;
 #else
    pTag->Temporary = ( pTag->OptFlags & CDX_TYPE_TEMPORARY ) != 0;
    pTag->Custom    = ( pTag->OptFlags & CDX_TYPE_CUSTOM ) != 0;
-   pTag->ChgOnly   = FALSE;
+   pTag->ChgOnly   = HB_FALSE;
    pTag->Partial   = pTag->Temporary || pTag->Custom;
    pTag->Template  = pTag->MultiKey = pTag->Custom;
 #endif
 
    pTag->AscendKey = pTag->UsrAscend = ( HB_GET_LE_UINT16( tagHeader.ascendFlg ) == 0 );
-   pTag->UsrUnique = FALSE;
+   pTag->UsrUnique = HB_FALSE;
    if( tagHeader.indexSig == 0x01 )
       pTag->IgnoreCase = tagHeader.ignoreCase == 1;
    else
-      pTag->IgnoreCase = FALSE;
+      pTag->IgnoreCase = HB_FALSE;
 
    if( pTag->OptFlags & CDX_TYPE_STRUCTURE )
       return;
@@ -3539,7 +3539,7 @@ static void hb_cdxTagLoad( LPCDXTAG pTag )
    if( pTag->uiType == 'C' )
       hb_cdxMakeSortTab( pTag->pIndex->pArea );
    else
-      pTag->IgnoreCase = FALSE;
+      pTag->IgnoreCase = HB_FALSE;
 
    pTag->nField = hb_rddFieldExpIndex( ( AREAP ) pTag->pIndex->pArea,
                                        pTag->KeyExpr );
@@ -3579,7 +3579,7 @@ static void hb_cdxTagFree( LPCDXTAG pTag )
 {
    if( pTag->RootPage != NULL )
    {
-      hb_cdxPageFree( pTag->RootPage, FALSE );
+      hb_cdxPageFree( pTag->RootPage, HB_FALSE );
       pTag->RootPage = NULL;
    }
    hb_cdxTagPoolFlush( pTag );
@@ -3619,15 +3619,15 @@ static LPCDXTAG hb_cdxTagNew( LPCDXINDEX pIndex, const char *szTagName, ULONG Ta
    hb_strncpyUpperTrim( szName, szTagName, sizeof( szName ) - 1 );
    pTag->szName = hb_strdup( szName );
    pTag->pIndex = pIndex;
-   pTag->AscendKey = pTag->UsrAscend = TRUE;
-   pTag->UsrUnique = pTag->IgnoreCase = FALSE;
+   pTag->AscendKey = pTag->UsrAscend = HB_TRUE;
+   pTag->UsrUnique = pTag->IgnoreCase = HB_FALSE;
    pTag->uiType = 'C';
    pTag->bTrail = ' ';
    pTag->CurKey = hb_cdxKeyNew();
    if( TagHdr == CDX_DUMMYNODE )
    {
-      pTag->TagBlock = hb_cdxIndexGetAvailPage( pIndex, TRUE );
-      pTag->TagChanged = TRUE;
+      pTag->TagBlock = hb_cdxIndexGetAvailPage( pIndex, HB_TRUE );
+      pTag->TagChanged = HB_TRUE;
       pTag->OptFlags = CDX_TYPE_COMPACT | CDX_TYPE_COMPOUND;
    }
    else
@@ -3651,14 +3651,14 @@ static void hb_cdxTagClose( LPCDXTAG pTag )
 {
    if( pTag->RootPage != NULL )
    {
-      hb_cdxPageFree( pTag->RootPage, FALSE );
+      hb_cdxPageFree( pTag->RootPage, HB_FALSE );
       pTag->RootPage = NULL;
    }
    if( pTag->TagChanged )
    {
       hb_cdxTagHeaderStore( pTag );
    }
-   pTag->fRePos = TRUE;
+   pTag->fRePos = HB_TRUE;
 }
 
 /*
@@ -3700,7 +3700,7 @@ static void hb_cdxTagPoolFree( LPCDXTAG pTag, int nPagesLeft )
       pPageNext = pPage->pPoolNext;
       if( ! pPage->bUsed )
       {
-         hb_cdxPageFree( pPage, TRUE );
+         hb_cdxPageFree( pPage, HB_TRUE );
       }
       pPage = pPageNext;
    }
@@ -3750,7 +3750,7 @@ static void hb_cdxSetCurKey( LPCDXPAGE pPage )
 static int hb_cdxPageSeekKey( LPCDXPAGE pPage, LPCDXKEY pKey, ULONG ulKeyRec )
 {
    int l, r, n, k;
-   BOOL fLeaf = ( pPage->PageType & CDX_NODE_LEAF ) != 0;
+   HB_BOOL fLeaf = ( pPage->PageType & CDX_NODE_LEAF ) != 0;
 
    if( fLeaf && !pPage->pKeyBuf && pPage->iKeys > 0 )
    {
@@ -3852,24 +3852,24 @@ static int hb_cdxPageSeekKey( LPCDXPAGE pPage, LPCDXKEY pKey, ULONG ulKeyRec )
 /*
  * an interface for fast check record number in record filter
  */
-static BOOL hb_cdxCheckRecordScope( CDXAREAP pArea, ULONG ulRec )
+static HB_BOOL hb_cdxCheckRecordScope( CDXAREAP pArea, ULONG ulRec )
 {
    LONG lRecNo = ( LONG ) ulRec;
 
    if( SELF_COUNTSCOPE( ( AREAP ) pArea, NULL, &lRecNo ) == HB_SUCCESS && lRecNo == 0 )
    {
-      return FALSE;
+      return HB_FALSE;
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * check and avaluate record filter
  */
-static BOOL hb_cdxCheckRecordFilter( CDXAREAP pArea, ULONG ulRecNo )
+static HB_BOOL hb_cdxCheckRecordFilter( CDXAREAP pArea, ULONG ulRecNo )
 {
-   BOOL lResult = FALSE;
-   BOOL fDeleted = hb_setGetDeleted();
+   HB_BOOL lResult = HB_FALSE;
+   HB_BOOL fDeleted = hb_setGetDeleted();
 
    if( pArea->dbfarea.area.dbfi.itmCobExpr || fDeleted )
    {
@@ -3891,7 +3891,7 @@ static BOOL hb_cdxCheckRecordFilter( CDXAREAP pArea, ULONG ulRecNo )
 /*
  * read Top Key from Page or its children
  */
-static BOOL hb_cdxPageReadTopKey( LPCDXPAGE pPage )
+static HB_BOOL hb_cdxPageReadTopKey( LPCDXPAGE pPage )
 {
    while( ( pPage->PageType & CDX_NODE_LEAF ) == 0 && pPage->iKeys > 0 )
    {
@@ -3900,17 +3900,17 @@ static BOOL hb_cdxPageReadTopKey( LPCDXPAGE pPage )
       pPage = pPage->Child;
    }
    if( pPage->iKeys == 0 )
-      return FALSE;
+      return HB_FALSE;
    pPage->iCurKey = 0;
 
    hb_cdxSetCurKey( pPage );
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * read Bottom Key from Page or its children
  */
-static BOOL hb_cdxPageReadBottomKey( LPCDXPAGE pPage )
+static HB_BOOL hb_cdxPageReadBottomKey( LPCDXPAGE pPage )
 {
    while( ( pPage->PageType & CDX_NODE_LEAF ) == 0 && pPage->iKeys > 0 )
    {
@@ -3919,17 +3919,17 @@ static BOOL hb_cdxPageReadBottomKey( LPCDXPAGE pPage )
       pPage = pPage->Child;
    }
    if( pPage->iKeys == 0 )
-      return FALSE;
+      return HB_FALSE;
    pPage->iCurKey = pPage->iKeys - 1;
 
    hb_cdxSetCurKey( pPage );
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * read Previous Key from Page or its children
  */
-static BOOL hb_cdxPageReadPrevKey( LPCDXPAGE pPage )
+static HB_BOOL hb_cdxPageReadPrevKey( LPCDXPAGE pPage )
 {
    LPCDXPAGE pOwnerPage = NULL;
 
@@ -3949,7 +3949,7 @@ static BOOL hb_cdxPageReadPrevKey( LPCDXPAGE pPage )
             pPage->iCurKey = 0;
             if( pPage->iKeys > 0 )
                hb_cdxSetCurKey( pPage );
-            return FALSE;
+            return HB_FALSE;
          }
          pOwnerPage->Child = hb_cdxPageNew( pPage->TagParent, pPage->Owner, pPage->Left );
          hb_cdxPageFree( pPage, !pPage->fChanged );
@@ -3969,13 +3969,13 @@ static BOOL hb_cdxPageReadPrevKey( LPCDXPAGE pPage )
                                    hb_cdxPageGetKeyRec( pPage, pPage->iCurKey ) ) );
    if( pPage->iCurKey != 0 )
       hb_cdxSetCurKey( pPage );
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * read Next Key from Page or its children
  */
-static BOOL hb_cdxPageReadNextKey( LPCDXPAGE pPage )
+static HB_BOOL hb_cdxPageReadNextKey( LPCDXPAGE pPage )
 {
    LPCDXPAGE pOwnerPage = NULL;
 
@@ -3993,7 +3993,7 @@ static BOOL hb_cdxPageReadNextKey( LPCDXPAGE pPage )
          if( pPage->Right == CDX_DUMMYNODE || !pOwnerPage )
          {
             pPage->iCurKey = pPage->iKeys;
-            return FALSE;
+            return HB_FALSE;
          }
          pOwnerPage->Child = hb_cdxPageNew( pPage->TagParent, pPage->Owner, pPage->Right );
          hb_cdxPageFree( pPage, !pPage->fChanged );
@@ -4013,13 +4013,13 @@ static BOOL hb_cdxPageReadNextKey( LPCDXPAGE pPage )
                                    hb_cdxPageGetKeyRec( pPage, pPage->iCurKey ) ) );
    if( pPage->iCurKey != 0 )
       hb_cdxSetCurKey( pPage );
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * read Previous Unique Key from Page or its children
  */
-static BOOL hb_cdxPageReadPrevUniqKey( LPCDXPAGE pPage )
+static HB_BOOL hb_cdxPageReadPrevUniqKey( LPCDXPAGE pPage )
 {
    LPCDXPAGE pOwnerPage = NULL;
 
@@ -4039,7 +4039,7 @@ static BOOL hb_cdxPageReadPrevUniqKey( LPCDXPAGE pPage )
             pPage->iCurKey = 0;
             if( pPage->iKeys > 0 )
                hb_cdxSetCurKey( pPage );
-            return FALSE;
+            return HB_FALSE;
          }
          pOwnerPage->Child = hb_cdxPageNew( pPage->TagParent, pPage->Owner, pPage->Left );
          hb_cdxPageFree( pPage, !pPage->fChanged );
@@ -4049,13 +4049,13 @@ static BOOL hb_cdxPageReadPrevUniqKey( LPCDXPAGE pPage )
    }
 
    hb_cdxSetCurKey( pPage );
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * read Next Unique Key from Page or its children
  */
-static BOOL hb_cdxPageReadNextUniqKey( LPCDXPAGE pPage )
+static HB_BOOL hb_cdxPageReadNextUniqKey( LPCDXPAGE pPage )
 {
    LPCDXPAGE pOwnerPage = NULL;
    /* BYTE pbVal[CDX_MAXKEY]; */
@@ -4081,7 +4081,7 @@ static BOOL hb_cdxPageReadNextUniqKey( LPCDXPAGE pPage )
             pPage->iCurKey = pPage->iKeys - 1;
             if( pPage->iKeys > 0 )
                hb_cdxSetCurKey( pPage );
-            return FALSE;
+            return HB_FALSE;
          }
          pOwnerPage->Child = hb_cdxPageNew( pPage->TagParent, pPage->Owner, pPage->Right );
          hb_cdxPageFree( pPage, !pPage->fChanged );
@@ -4090,7 +4090,7 @@ static BOOL hb_cdxPageReadNextUniqKey( LPCDXPAGE pPage )
       }
    }
    hb_cdxSetCurKey( pPage );
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
@@ -4098,10 +4098,10 @@ static BOOL hb_cdxPageReadNextUniqKey( LPCDXPAGE pPage )
  */
 static void hb_cdxTagKeyRead( LPCDXTAG pTag, BYTE bTypRead )
 {
-   BOOL fAfter = FALSE, fBof, fEof;
+   HB_BOOL fAfter = HB_FALSE, fBof, fEof;
 
    pTag->CurKey->rec = 0;
-   pTag->fRePos = FALSE;
+   pTag->fRePos = HB_FALSE;
    hb_cdxTagOpen( pTag );
 
    if( pTag->UsrUnique )
@@ -4115,7 +4115,7 @@ static void hb_cdxTagKeyRead( LPCDXTAG pTag, BYTE bTypRead )
          case PREV_RECORD:
             bTypRead = PRVU_RECORD;
          case BTTM_RECORD:
-            fAfter = TRUE;
+            fAfter = HB_TRUE;
             break;
       }
    }
@@ -4222,10 +4222,10 @@ static ULONG hb_cdxTagKeyFind( LPCDXTAG pTag, LPCDXKEY pKey )
    int K;
    ULONG ulKeyRec = pKey->rec;
 
-   pTag->fRePos = FALSE;
+   pTag->fRePos = HB_FALSE;
    hb_cdxTagOpen( pTag );
 
-   pTag->TagBOF = pTag->TagEOF = FALSE;
+   pTag->TagBOF = pTag->TagEOF = HB_FALSE;
    K = hb_cdxPageSeekKey( pTag->RootPage, pKey, ulKeyRec );
    if( ulKeyRec == CDX_MAX_REC_NUM )
       K = - K;
@@ -4233,7 +4233,7 @@ static ULONG hb_cdxTagKeyFind( LPCDXTAG pTag, LPCDXKEY pKey )
    if( K > 0 )
    {
       pTag->CurKey->rec = 0;
-      pTag->TagEOF = TRUE;
+      pTag->TagEOF = HB_TRUE;
    }
    else
    {
@@ -4272,16 +4272,16 @@ static ULONG hb_cdxTagKeySeek( LPCDXTAG pTag, LPCDXKEY pKey )
    }
 
    pTag->CurKey->rec = 0;
-   pTag->fRePos = FALSE;
+   pTag->fRePos = HB_FALSE;
    hb_cdxTagOpen( pTag );
 
-   pTag->TagBOF = pTag->TagEOF = FALSE;
+   pTag->TagBOF = pTag->TagEOF = HB_FALSE;
    K = hb_cdxPageSeekKey( pTag->RootPage, pKey, ulKeyRec );
    if( ulKeyRec == CDX_MAX_REC_NUM )
       K = - K;
 
    if( K > 0 )
-      pTag->TagEOF = TRUE;
+      pTag->TagEOF = HB_TRUE;
    else
    {
       hb_cdxSetCurKey( pTag->RootPage );
@@ -4295,7 +4295,7 @@ static ULONG hb_cdxTagKeySeek( LPCDXTAG pTag, LPCDXKEY pKey )
 /*
  * add the Key into the Tag
  */
-static BOOL hb_cdxTagKeyAdd( LPCDXTAG pTag, LPCDXKEY pKey )
+static HB_BOOL hb_cdxTagKeyAdd( LPCDXTAG pTag, LPCDXKEY pKey )
 {
    hb_cdxTagOpen( pTag );
    if( hb_cdxPageSeekKey( pTag->RootPage, pKey,
@@ -4305,18 +4305,18 @@ static BOOL hb_cdxTagKeyAdd( LPCDXTAG pTag, LPCDXKEY pKey )
       hb_cdxPageKeyInsert( pTag->RootPage, pKey );
       pTag->curKeyState &= ~( CDX_CURKEY_RAWPOS | CDX_CURKEY_LOGPOS |
                               CDX_CURKEY_RAWCNT | CDX_CURKEY_LOGCNT );
-      pTag->fRePos = TRUE;
+      pTag->fRePos = HB_TRUE;
       /* TODO: !!! remove when page leaf balance can save CurKey */
       hb_cdxTagKeyFind( pTag, pKey );
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 /*
  * delete the Key from the Tag
  */
-static BOOL hb_cdxTagKeyDel( LPCDXTAG pTag, LPCDXKEY pKey )
+static HB_BOOL hb_cdxTagKeyDel( LPCDXTAG pTag, LPCDXKEY pKey )
 {
    if( hb_cdxTagKeyFind( pTag, pKey ) != 0 )
    {
@@ -4324,9 +4324,9 @@ static BOOL hb_cdxTagKeyDel( LPCDXTAG pTag, LPCDXKEY pKey )
       pTag->curKeyState &= ~( CDX_CURKEY_RAWPOS | CDX_CURKEY_LOGPOS |
                               CDX_CURKEY_RAWCNT | CDX_CURKEY_LOGCNT );
       pTag->CurKey->rec = 0;
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 /*
@@ -4346,7 +4346,7 @@ static void hb_cdxTagGoTop( LPCDXTAG pTag )
    {
       if( pTag->CurKey->rec == 0 || pTag->TagEOF || ! hb_cdxBottomScope( pTag ) )
       {
-         pTag->TagBOF = pTag->TagEOF = TRUE;
+         pTag->TagBOF = pTag->TagEOF = HB_TRUE;
          pTag->CurKey->rec = 0;
          break;
       }
@@ -4379,7 +4379,7 @@ static void hb_cdxTagGoBottom( LPCDXTAG pTag )
    {
       if( pTag->CurKey->rec == 0 || pTag->TagBOF || ! hb_cdxTopScope( pTag ) )
       {
-         pTag->TagBOF = pTag->TagEOF = TRUE;
+         pTag->TagBOF = pTag->TagEOF = HB_TRUE;
          pTag->CurKey->rec = 0;
          break;
       }
@@ -4403,7 +4403,7 @@ static void hb_cdxTagGoBottom( LPCDXTAG pTag )
  */
 static void hb_cdxTagSkipNext( LPCDXTAG pTag )
 {
-   BOOL fPos = CURKEY_RAWPOS( pTag ), fEof = FALSE;
+   HB_BOOL fPos = CURKEY_RAWPOS( pTag ), fEof = HB_FALSE;
    ULONG ulSkip = 1;
 
    if( pTag->CurKey->rec != 0 )
@@ -4421,7 +4421,7 @@ static void hb_cdxTagSkipNext( LPCDXTAG pTag )
    {
       if( pTag->TagEOF || pTag->CurKey->rec == 0 ||
           !hb_cdxBottomScope( pTag ) || !hb_cdxTopScope( pTag ) )
-         fEof = TRUE;
+         fEof = HB_TRUE;
       else if( ( pTag->OptFlags & CDX_TYPE_STRUCTURE ) != 0 ||
                hb_cdxCheckRecordScope( pTag->pIndex->pArea, pTag->CurKey->rec ) )
          break;
@@ -4432,7 +4432,7 @@ static void hb_cdxTagSkipNext( LPCDXTAG pTag )
    if( fEof )
    {
       pTag->CurKey->rec = 0;
-      pTag->TagEOF = TRUE;
+      pTag->TagEOF = HB_TRUE;
    }
    else if( fPos )
    {
@@ -4446,7 +4446,7 @@ static void hb_cdxTagSkipNext( LPCDXTAG pTag )
  */
 static void hb_cdxTagSkipPrev( LPCDXTAG pTag )
 {
-   BOOL fPos = CURKEY_RAWPOS( pTag ), fBof = FALSE;
+   HB_BOOL fPos = CURKEY_RAWPOS( pTag ), fBof = HB_FALSE;
    ULONG ulSkip = 1;
 
    if( pTag->CurKey->rec == 0 )
@@ -4461,7 +4461,7 @@ static void hb_cdxTagSkipPrev( LPCDXTAG pTag )
    {
       if( pTag->TagBOF || pTag->CurKey->rec == 0 ||
           !hb_cdxBottomScope( pTag ) || !hb_cdxTopScope( pTag ) )
-         fBof = TRUE;
+         fBof = HB_TRUE;
       else if( ( pTag->OptFlags & CDX_TYPE_STRUCTURE ) != 0 ||
                hb_cdxCheckRecordScope( pTag->pIndex->pArea, pTag->CurKey->rec ) )
          break;
@@ -4473,7 +4473,7 @@ static void hb_cdxTagSkipPrev( LPCDXTAG pTag )
    if( fBof )
    {
       hb_cdxTagGoTop( pTag );
-      pTag->TagBOF = TRUE;
+      pTag->TagBOF = HB_TRUE;
    }
    else if( fPos )
    {
@@ -4489,11 +4489,11 @@ static void hb_cdxTagSkipPrev( LPCDXTAG pTag )
 static void hb_cdxReorderTagList( LPCDXTAG * TagListPtr )
 {
    LPCDXTAG *pTagPtr, pTagTmp;
-   BOOL fRepeat = TRUE;
+   HB_BOOL fRepeat = HB_TRUE;
 
    while( fRepeat )
    {
-      fRepeat = FALSE;
+      fRepeat = HB_FALSE;
       pTagPtr = TagListPtr;
       while( *pTagPtr && (*pTagPtr)->pNext )
       {
@@ -4503,7 +4503,7 @@ static void hb_cdxReorderTagList( LPCDXTAG * TagListPtr )
             (*pTagPtr) = (*pTagPtr)->pNext;
             pTagTmp->pNext = (*pTagPtr)->pNext;
             (*pTagPtr)->pNext = pTagTmp;
-            fRepeat = TRUE;
+            fRepeat = HB_TRUE;
          }
          pTagPtr = &(*pTagPtr)->pNext;
       }
@@ -4513,13 +4513,13 @@ static void hb_cdxReorderTagList( LPCDXTAG * TagListPtr )
 /*
  * create new order header, store it and then make an order
  */
-static LPCDXTAG hb_cdxIndexCreateTag( BOOL fStruct, LPCDXINDEX pIndex,
+static LPCDXTAG hb_cdxIndexCreateTag( HB_BOOL fStruct, LPCDXINDEX pIndex,
                                       const char * szTagName,
                                       const char * szKeyExp, PHB_ITEM pKeyItem,
                                       BYTE bType, USHORT uiLen,
                                       const char * szForExp, PHB_ITEM pForItem,
-                                      BOOL fAscnd, BOOL fUniq, BOOL fNoCase,
-                                      BOOL fCustom, BOOL fReindex )
+                                      HB_BOOL fAscnd, HB_BOOL fUniq, HB_BOOL fNoCase,
+                                      HB_BOOL fCustom, HB_BOOL fReindex )
 {
    LPCDXTAG pTag;
 
@@ -4544,16 +4544,16 @@ static LPCDXTAG hb_cdxIndexCreateTag( BOOL fStruct, LPCDXINDEX pIndex,
    pTag->pForItem = pForItem;
    pTag->AscendKey = pTag->UsrAscend = fAscnd;
    pTag->UniqueKey = fUniq;
-   pTag->UsrUnique = FALSE;
+   pTag->UsrUnique = HB_FALSE;
    pTag->IgnoreCase = fNoCase && bType == 'C';
    pTag->Custom = fCustom;
    pTag->Template = pTag->MultiKey = pTag->Custom;
-   pTag->Partial = pTag->ChgOnly = FALSE;
+   pTag->Partial = pTag->ChgOnly = HB_FALSE;
    pTag->uiType = bType;
    pTag->bTrail = ( bType == 'C' ) ? ' ' : '\0';
    pTag->uiLen = uiLen;
    pTag->MaxKeys = CDX_INT_FREESPACE / ( uiLen + 8 );
-   pTag->TagChanged = TRUE;
+   pTag->TagChanged = HB_TRUE;
    hb_cdxTagDoIndex( pTag, fReindex );
 
    return pTag;
@@ -4565,9 +4565,9 @@ static LPCDXTAG hb_cdxIndexCreateTag( BOOL fStruct, LPCDXINDEX pIndex,
 static void hb_cdxIndexCreateStruct( LPCDXINDEX pIndex, char * szTagName )
 {
    /* here we can change default tag name */
-   pIndex->pCompound = hb_cdxIndexCreateTag( TRUE, pIndex, szTagName,
+   pIndex->pCompound = hb_cdxIndexCreateTag( HB_TRUE, pIndex, szTagName,
                            NULL, NULL, 'C', CDX_MAXTAGNAMELEN, NULL, NULL,
-                           TRUE, FALSE, FALSE, FALSE, FALSE );
+                           HB_TRUE, HB_FALSE, HB_FALSE, HB_FALSE, HB_FALSE );
 }
 
 /*
@@ -4589,7 +4589,7 @@ static void hb_cdxIndexFreePages( LPCDXPAGE pPage )
       }
    }
    pPage->PageType = CDX_NODE_UNUSED;
-   hb_cdxPageFree( pPage, FALSE );
+   hb_cdxPageFree( pPage, HB_FALSE );
 }
 
 /*
@@ -4620,9 +4620,9 @@ static void hb_cdxIndexDelTag( LPCDXINDEX pIndex, const char * szTagName )
             {
                if( pPage )
                   hb_cdxIndexFreePages( pPage );
-               hb_cdxIndexPutAvailPage( pIndex, pTag->TagBlock, TRUE );
+               hb_cdxIndexPutAvailPage( pIndex, pTag->TagBlock, HB_TRUE );
             }
-            pTag->TagChanged = FALSE;
+            pTag->TagChanged = HB_FALSE;
          }
       }
       *pTagPtr = pTag->pNext;
@@ -4638,8 +4638,8 @@ static LPCDXTAG hb_cdxIndexAddTag( LPCDXINDEX pIndex, const char * szTagName,
                                    const char * szKeyExp, PHB_ITEM pKeyItem,
                                    BYTE bType, USHORT uiLen,
                                    const char * szForExp, PHB_ITEM pForItem,
-                                   BOOL fAscend, BOOL fUnique, BOOL fNoCase,
-                                   BOOL fCustom, BOOL fReindex )
+                                   HB_BOOL fAscend, HB_BOOL fUnique, HB_BOOL fNoCase,
+                                   HB_BOOL fCustom, HB_BOOL fReindex )
 {
    LPCDXTAG pTag, *pTagPtr;
    LPCDXKEY pKey;
@@ -4650,7 +4650,7 @@ static LPCDXTAG hb_cdxIndexAddTag( LPCDXINDEX pIndex, const char * szTagName,
    hb_cdxIndexDelTag( pIndex, szTagName );
 
    /* Create new tag an add to tag list */
-   pTag = hb_cdxIndexCreateTag( FALSE, pIndex, szTagName, szKeyExp, pKeyItem,
+   pTag = hb_cdxIndexCreateTag( HB_FALSE, pIndex, szTagName, szKeyExp, pKeyItem,
                                 bType, uiLen, szForExp, pForItem,
                                 fAscend, fUnique, fNoCase, fCustom, fReindex );
    pTagPtr = &pIndex->TagList;
@@ -4682,7 +4682,7 @@ static void hb_cdxIndexReindex( LPCDXINDEX pIndex )
    pIndex->nextAvail = 0;
    pIndex->freePage = 0;
    hb_fileTruncAt( pIndex->pFile, 0 );
-   pIndex->fChanged = TRUE;
+   pIndex->fChanged = HB_TRUE;
 
    /* Rebuild the compound (master) tag */
    if( pCompound )
@@ -4697,7 +4697,7 @@ static void hb_cdxIndexReindex( LPCDXINDEX pIndex )
       pTag = pTagList;
       hb_cdxIndexAddTag( pIndex, pTag->szName, pTag->KeyExpr, pTag->pKeyItem,
          ( BYTE ) pTag->uiType, pTag->uiLen, pTag->ForExpr, pTag->pForItem,
-         pTag->AscendKey, pTag->UniqueKey, pTag->IgnoreCase, pTag->Custom, TRUE );
+         pTag->AscendKey, pTag->UniqueKey, pTag->IgnoreCase, pTag->Custom, HB_TRUE );
       pTagList = pTag->pNext;
       pTag->pKeyItem = pTag->pForItem = NULL;
       hb_cdxTagFree( pTag );
@@ -4782,10 +4782,10 @@ static void hb_cdxIndexFree( LPCDXINDEX pIndex )
 /*
  * load orders from index file
  */
-static BOOL hb_cdxIndexLoad( LPCDXINDEX pIndex, char * szBaseName )
+static HB_BOOL hb_cdxIndexLoad( LPCDXINDEX pIndex, char * szBaseName )
 {
    LPCDXTAG TagList, * pTagPtr;
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
 
    TagList = NULL;
    pTagPtr = &TagList;
@@ -4797,7 +4797,7 @@ static BOOL hb_cdxIndexLoad( LPCDXINDEX pIndex, char * szBaseName )
    /* check if index is not corrupted */
    if( pIndex->pCompound )
    {
-      fResult = TRUE;
+      fResult = HB_TRUE;
       pIndex->pCompound->OptFlags = CDX_TYPE_COMPACT | CDX_TYPE_COMPOUND | CDX_TYPE_STRUCTURE;
       hb_cdxTagGoTop( pIndex->pCompound );
       while( !pIndex->pCompound->TagEOF )
@@ -4807,7 +4807,7 @@ static BOOL hb_cdxIndexLoad( LPCDXINDEX pIndex, char * szBaseName )
          /* tag is corrupted - break tags loading */
          if( *pTagPtr == NULL )
          {
-            fResult = FALSE;
+            fResult = HB_FALSE;
             break;
          }
          pTagPtr = &(*pTagPtr)->pNext;
@@ -4833,12 +4833,12 @@ static BOOL hb_cdxIndexLoad( LPCDXINDEX pIndex, char * szBaseName )
  * create index file name
  */
 static void hb_cdxCreateFName( CDXAREAP pArea, const char * szBagName,
-                               BOOL * fProd,
+                               HB_BOOL * fProd,
                                char * szFileName, char * szBaseName )
 {
    PHB_FNAME pFileName;
    PHB_ITEM pExt = NULL;
-   BOOL fName = szBagName && *szBagName;
+   HB_BOOL fName = szBagName && *szBagName;
 
    pFileName = hb_fsFNameSplit( fName ? szBagName : pArea->dbfarea.szDataFileName );
 
@@ -4866,9 +4866,9 @@ static void hb_cdxCreateFName( CDXAREAP pArea, const char * szBagName,
    if( fProd )
    {
       if( ! pFileName->szName )
-         *fProd = FALSE;
+         *fProd = HB_FALSE;
       else if( !fName )
-         *fProd = TRUE;
+         *fProd = HB_TRUE;
       else
       {
          PHB_FNAME pTableFileName = hb_fsFNameSplit( pArea->dbfarea.szDataFileName );
@@ -4897,7 +4897,7 @@ static void hb_cdxCreateFName( CDXAREAP pArea, const char * szBagName,
 /*
  * free (close) used indexes, if not fAll then keep structure index
  */
-static void hb_cdxOrdListClear( CDXAREAP pArea, BOOL fAll, LPCDXINDEX pKeepInd )
+static void hb_cdxOrdListClear( CDXAREAP pArea, HB_BOOL fAll, LPCDXINDEX pKeepInd )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxOrdListClear(%p, %d)", pArea, (int) fAll));
 
@@ -5043,7 +5043,7 @@ static LPCDXTAG hb_cdxFindTag( CDXAREAP pArea, PHB_ITEM pTagItem,
    int iTag = 0, iFind = 0;
    char szTag[ CDX_MAXTAGNAMELEN + 1 ];
    LPCDXINDEX pIndex = pArea->lpIndexes;
-   BOOL fBag;
+   HB_BOOL fBag;
 
    hb_strncpyUpperTrim( szTag, hb_itemGetCPtr( pTagItem ), sizeof( szTag ) - 1 );
    if( ! szTag[0] )
@@ -5061,7 +5061,7 @@ static LPCDXTAG hb_cdxFindTag( CDXAREAP pArea, PHB_ITEM pTagItem,
 
       if( iBag > 0 )
       {
-         fBag = TRUE;
+         fBag = HB_TRUE;
          while( pIndex )
          {
             if( --iBag == 0 )
@@ -5124,35 +5124,35 @@ static LPCDXTAG hb_cdxGetActiveTag( CDXAREAP pArea )
 /*
  * refresh CurKey value and set proper path from RootPage to LeafPage
  */
-static BOOL hb_cdxCurKeyRefresh( CDXAREAP pArea, LPCDXTAG pTag )
+static HB_BOOL hb_cdxCurKeyRefresh( CDXAREAP pArea, LPCDXTAG pTag )
 {
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
    if( !pArea->dbfarea.fPositioned )
    {
-      pTag->TagEOF = TRUE;
-      pTag->fRePos = FALSE;
+      pTag->TagEOF = HB_TRUE;
+      pTag->fRePos = HB_FALSE;
       pTag->CurKey->rec = 0;
-      return FALSE;
+      return HB_FALSE;
    }
    else if( pTag->fRePos || pTag->CurKey->rec != pArea->dbfarea.ulRecNo )
    {
       BYTE buf[CDX_MAXKEY];
-      BOOL fBuf = FALSE;
+      HB_BOOL fBuf = HB_FALSE;
       LPCDXKEY pKey = NULL;
 
       /* Try to find previous if it's key for the same record */
       if( pTag->CurKey->rec == pArea->dbfarea.ulRecNo )
       {
-         fBuf = TRUE;
+         fBuf = HB_TRUE;
          memcpy( buf, pTag->CurKey->val, pTag->CurKey->len );
          pKey = hb_cdxKeyCopy( pKey, pTag->CurKey );
          hb_cdxTagKeyFind( pTag, pKey );
       }
       if( pTag->CurKey->rec != pArea->dbfarea.ulRecNo )
       {
-         BOOL fValidBuf = pArea->dbfarea.fValidBuffer;
+         HB_BOOL fValidBuf = pArea->dbfarea.fValidBuffer;
          /* not found, create new key from DBF and if differs seek again */
          pKey = hb_cdxKeyEval( pKey, pTag );
          if( !fBuf || memcmp( buf, pKey->val, pKey->len ) != 0 )
@@ -5173,7 +5173,7 @@ static BOOL hb_cdxCurKeyRefresh( CDXAREAP pArea, LPCDXTAG pTag )
       hb_cdxKeyFree( pKey );
       return ( pTag->CurKey->rec != 0 && pTag->CurKey->rec == pArea->dbfarea.ulRecNo );
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
@@ -5182,7 +5182,7 @@ static BOOL hb_cdxCurKeyRefresh( CDXAREAP pArea, LPCDXTAG pTag )
 static HB_ERRCODE hb_cdxDBOISkipUnique( CDXAREAP pArea, LPCDXTAG pTag, LONG lToSkip )
 {
    HB_ERRCODE retval;
-   BOOL fForward;
+   HB_BOOL fForward;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxDBOISkipUnique(%p, %p, %ld)", pArea, pTag, lToSkip));
 
@@ -5195,7 +5195,7 @@ static HB_ERRCODE hb_cdxDBOISkipUnique( CDXAREAP pArea, LPCDXTAG pTag, LONG lToS
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
-   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
    /* CL53 DBFCDX when index is active use this parameter
       only to chose forward or backward skipping */
@@ -5211,7 +5211,7 @@ static HB_ERRCODE hb_cdxDBOISkipUnique( CDXAREAP pArea, LPCDXTAG pTag, LONG lToS
    else
    {
       LPCDXKEY pKey = NULL;
-      BOOL fOut = FALSE;
+      HB_BOOL fOut = HB_FALSE;
 
       hb_cdxIndexLockRead( pTag->pIndex );
       hb_cdxTagRefreshScope( pTag );
@@ -5219,7 +5219,7 @@ static HB_ERRCODE hb_cdxDBOISkipUnique( CDXAREAP pArea, LPCDXTAG pTag, LONG lToS
       {
          if( pTag->TagEOF || ( fForward ? !hb_cdxBottomScope( pTag ) :
                                           !hb_cdxTopScope( pTag ) ) )
-            fOut = TRUE;
+            fOut = HB_TRUE;
          else if( ( fForward ? pTag->UsrAscend && hb_cdxTopScope( pTag ) :
                               !pTag->UsrAscend && hb_cdxBottomScope( pTag ) ) &&
                    pTag->CurKey->rec != 0 )
@@ -5278,7 +5278,7 @@ static HB_ERRCODE hb_cdxDBOISkipUnique( CDXAREAP pArea, LPCDXTAG pTag, LONG lToS
          if( fOut || pTag->TagBOF )
          {
             retval = SELF_GOTOP( ( AREAP ) pArea );
-            pArea->dbfarea.area.fBof = TRUE;
+            pArea->dbfarea.area.fBof = HB_TRUE;
          }
          else
          {
@@ -5291,37 +5291,37 @@ static HB_ERRCODE hb_cdxDBOISkipUnique( CDXAREAP pArea, LPCDXTAG pTag, LONG lToS
    }
    /* Update Bof and Eof flags */
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
    return retval;
 }
 
 /*
- * skip while code block doesn't return TRUE
+ * skip while code block doesn't return HB_TRUE
  */
-static BOOL hb_cdxDBOISkipEval( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
-                                PHB_ITEM pEval )
+static HB_BOOL hb_cdxDBOISkipEval( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fForward,
+                                   PHB_ITEM pEval )
 {
-   BOOL fFound = FALSE, fFirst = TRUE;
+   HB_BOOL fFound = HB_FALSE, fFirst = HB_TRUE;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxDBOISkipEval(%p, %p, %i, %p)", pArea, pTag, fForward, pEval));
 
    if( FAST_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE )
-      return FALSE;
+      return HB_FALSE;
 
    if( ! pTag || hb_itemType( pEval ) != HB_IT_BLOCK )
    {
       if( SELF_SKIP( ( AREAP ) pArea, fForward ? 1 : -1 ) == HB_FAILURE )
-         return FALSE;
+         return HB_FALSE;
       return fForward ? !pArea->dbfarea.area.fEof : !pArea->dbfarea.area.fBof;
    }
 
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
-   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
    hb_cdxIndexLockRead( pTag->pIndex );
    hb_cdxTagRefreshScope( pTag );
@@ -5330,7 +5330,7 @@ static BOOL hb_cdxDBOISkipEval( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
       if( !pTag->TagEOF && pTag->CurKey->rec != 0 &&
           ( fForward ? pTag->UsrAscend : !pTag->UsrAscend ) &&
           hb_cdxTopScope( pTag ) && hb_cdxBottomScope( pTag ) )
-         fFirst = FALSE;
+         fFirst = HB_FALSE;
    }
    if( fForward )
    {
@@ -5346,7 +5346,7 @@ static BOOL hb_cdxDBOISkipEval( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
             SELF_SKIPFILTER( ( AREAP ) pArea, 1 );
             if( pArea->dbfarea.ulRecNo == ulRecNo || hb_cdxEvalSeekCond( pTag, pEval ) )
             {
-               fFound = TRUE;
+               fFound = HB_TRUE;
                break;
             }
          }
@@ -5369,7 +5369,7 @@ static BOOL hb_cdxDBOISkipEval( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
             SELF_SKIPFILTER( ( AREAP ) pArea, -1 );
             if( pArea->dbfarea.ulRecNo == ulRecNo || hb_cdxEvalSeekCond( pTag, pEval ) )
             {
-               fFound = TRUE;
+               fFound = HB_TRUE;
                break;
             }
          }
@@ -5378,27 +5378,27 @@ static BOOL hb_cdxDBOISkipEval( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
       if( !fFound )
       {
          SELF_GOTOP( ( AREAP ) pArea );
-         pArea->dbfarea.area.fBof = TRUE;
+         pArea->dbfarea.area.fBof = HB_TRUE;
       }
    }
    hb_cdxIndexUnLockRead( pTag->pIndex );
 
    /* Update Bof and Eof flags */
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
    return fFound;
 }
 
 /*
- * skip while comparison with given pattern with wildcards doesn't return TRUE
+ * skip while comparison with given pattern with wildcards doesn't return HB_TRUE
  */
-static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
-                                PHB_ITEM pWildItm )
+static HB_BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fForward,
+                                   PHB_ITEM pWildItm )
 {
-   BOOL fFound = FALSE, fFirst = TRUE;
+   HB_BOOL fFound = HB_FALSE, fFirst = HB_TRUE;
    const char *szPattern;
    char *szFree = NULL;
    int iFixed = 0, iStop;
@@ -5406,14 +5406,14 @@ static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxDBOISkipWild(%p, %p, %i, %p)", pArea, pTag, fForward, pWildItm));
 
    if( FAST_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE )
-      return FALSE;
+      return HB_FALSE;
 
    szPattern = hb_itemGetCPtr( pWildItm );
 
    if( ! pTag || pTag->uiType != 'C' || !szPattern || !*szPattern )
    {
       if( SELF_SKIP( ( AREAP ) pArea, fForward ? 1 : -1 ) == HB_FAILURE )
-         return FALSE;
+         return HB_FALSE;
       return fForward ? pArea->dbfarea.fPositioned : !pArea->dbfarea.area.fBof;
    }
 
@@ -5431,7 +5431,7 @@ static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
-   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
    hb_cdxIndexLockRead( pTag->pIndex );
    hb_cdxTagRefreshScope( pTag );
@@ -5440,7 +5440,7 @@ static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
       if( !pTag->TagEOF && pTag->CurKey->rec != 0 &&
            ( fForward ? pTag->UsrAscend : !pTag->UsrAscend ) &&
            hb_cdxTopScope( pTag ) && hb_cdxBottomScope( pTag ) )
-         fFirst = FALSE;
+         fFirst = HB_FALSE;
    }
 
    iStop = pTag->UsrAscend ? -1 : 1;
@@ -5460,12 +5460,12 @@ static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
       if( !hb_cdxTagKeyFind( pTag, pKey ) )
       {
          if( fForward )
-            pTag->TagEOF = TRUE;
+            pTag->TagEOF = HB_TRUE;
          else
-            pTag->TagBOF = TRUE;
+            pTag->TagBOF = HB_TRUE;
       }
       hb_cdxKeyFree( pKey );
-      fFirst = FALSE;
+      fFirst = HB_FALSE;
    }
 
    if( fForward )
@@ -5483,7 +5483,7 @@ static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
             if( pArea->dbfarea.ulRecNo == ulRecNo ||
                 hb_strMatchWild( (const char *) pTag->CurKey->val, szPattern ) )
             {
-               fFound = TRUE;
+               fFound = HB_TRUE;
                break;
             }
          }
@@ -5513,7 +5513,7 @@ static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
             if( pArea->dbfarea.ulRecNo == ulRecNo ||
                 hb_strMatchWild( (const char *) pTag->CurKey->val, szPattern ) )
             {
-               fFound = TRUE;
+               fFound = HB_TRUE;
                break;
             }
          }
@@ -5528,16 +5528,16 @@ static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
       if( !fFound )
       {
          SELF_GOTOP( ( AREAP ) pArea );
-         pArea->dbfarea.area.fBof = TRUE;
+         pArea->dbfarea.area.fBof = HB_TRUE;
       }
    }
    hb_cdxIndexUnLockRead( pTag->pIndex );
 
    /* Update Bof and Eof flags */
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
    if( szFree )
       hb_xfree( szFree );
@@ -5545,7 +5545,7 @@ static BOOL hb_cdxDBOISkipWild( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
    return fFound;
 }
 
-static BOOL hb_cdxRegexMatch( CDXAREAP pArea, PHB_REGEX pRegEx, LPCDXKEY pKey )
+static HB_BOOL hb_cdxRegexMatch( CDXAREAP pArea, PHB_REGEX pRegEx, LPCDXKEY pKey )
 {
    char * szKey = ( char * ) pKey->val;
    ULONG ulLen = pKey->len;
@@ -5560,34 +5560,34 @@ static BOOL hb_cdxRegexMatch( CDXAREAP pArea, PHB_REGEX pRegEx, LPCDXKEY pKey )
       szKey = szBuff;
    }
 
-   return hb_regexMatch( pRegEx, szKey, ulLen, FALSE );
+   return hb_regexMatch( pRegEx, szKey, ulLen, HB_FALSE );
 }
 
 /*
- * skip while regular expression on index key val doesn't return TRUE
+ * skip while regular expression on index key val doesn't return HB_TRUE
  */
-static BOOL hb_cdxDBOISkipRegEx( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
-                                 PHB_ITEM pRegExItm )
+static HB_BOOL hb_cdxDBOISkipRegEx( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fForward,
+                                    PHB_ITEM pRegExItm )
 {
-   BOOL fFound = FALSE, fFirst = TRUE;
+   HB_BOOL fFound = HB_FALSE, fFirst = HB_TRUE;
    PHB_REGEX pRegEx;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxDBOISkipRegEx(%p, %p, %i, %p)", pArea, pTag, fForward, pRegExItm));
 
    if( FAST_GOCOLD( ( AREAP ) pArea ) == HB_FAILURE )
-      return FALSE;
+      return HB_FALSE;
 
    if( !pTag || pTag->uiType != 'C' || ( pRegEx = hb_regexGet( pRegExItm, 0 ) ) == NULL )
    {
       if( SELF_SKIP( ( AREAP ) pArea, fForward ? 1 : -1 ) == HB_FAILURE )
-         return FALSE;
+         return HB_FALSE;
       return fForward ? pArea->dbfarea.fPositioned : !pArea->dbfarea.area.fBof;
    }
 
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
-   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
    hb_cdxIndexLockRead( pTag->pIndex );
    hb_cdxTagRefreshScope( pTag );
@@ -5596,7 +5596,7 @@ static BOOL hb_cdxDBOISkipRegEx( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
       if( !pTag->TagEOF && pTag->CurKey->rec != 0 &&
           ( fForward ? pTag->UsrAscend : !pTag->UsrAscend ) &&
           hb_cdxTopScope( pTag ) && hb_cdxBottomScope( pTag ) )
-         fFirst = FALSE;
+         fFirst = HB_FALSE;
    }
    if( fForward )
    {
@@ -5611,7 +5611,7 @@ static BOOL hb_cdxDBOISkipRegEx( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
             if( pArea->dbfarea.ulRecNo == ulRecNo ||
                 hb_cdxRegexMatch( pArea, pRegEx, pTag->CurKey ) )
             {
-               fFound = TRUE;
+               fFound = HB_TRUE;
                break;
             }
          }
@@ -5632,7 +5632,7 @@ static BOOL hb_cdxDBOISkipRegEx( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
             if( pArea->dbfarea.ulRecNo == ulRecNo ||
                 hb_cdxRegexMatch( pArea, pRegEx, pTag->CurKey ) )
             {
-               fFound = TRUE;
+               fFound = HB_TRUE;
                break;
             }
          }
@@ -5643,16 +5643,16 @@ static BOOL hb_cdxDBOISkipRegEx( CDXAREAP pArea, LPCDXTAG pTag, BOOL fForward,
       else
       {
          SELF_GOTOP( ( AREAP ) pArea );
-         pArea->dbfarea.area.fBof = TRUE;
+         pArea->dbfarea.area.fBof = HB_TRUE;
       }
    }
    hb_cdxIndexUnLockRead( pTag->pIndex );
 
    /* Update Bof and Eof flags */
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
    hb_regexFree( pRegEx );
 
@@ -5674,13 +5674,13 @@ static ULONG hb_cdxDBOIScopeEval( LPCDXTAG pTag, HB_EVALSCOPE_FUNC pFunc, void *
       pTag->topScopeKey = NULL;
    else
       pTag->topScopeKey = hb_cdxKeyPutItem( NULL, pItemLo, CDX_IGNORE_REC_NUM,
-                                            pTag, TRUE, CDX_CMP_PREFIX );
+                                            pTag, HB_TRUE, CDX_CMP_PREFIX );
 
    if( !pItemHi || HB_IS_NIL( pItemHi ) )
       pTag->bottomScopeKey = NULL;
    else
       pTag->bottomScopeKey = hb_cdxKeyPutItem( NULL, pItemHi, CDX_MAX_REC_NUM,
-                                               pTag, TRUE, CDX_CMP_PREFIX );
+                                               pTag, HB_TRUE, CDX_CMP_PREFIX );
 
    hb_cdxIndexLockRead( pTag->pIndex );
    hb_cdxTagGoTop( pTag );
@@ -5700,7 +5700,7 @@ static ULONG hb_cdxDBOIScopeEval( LPCDXTAG pTag, HB_EVALSCOPE_FUNC pFunc, void *
    pTag->bottomScopeKey = pBtmScopeKey;
    pTag->curKeyState &= ~( CDX_CURKEY_RAWPOS | CDX_CURKEY_LOGPOS );
 
-   pTag->fRePos = TRUE;
+   pTag->fRePos = HB_TRUE;
    hb_cdxKeyCopy( pTag->CurKey, pCurKey );
    hb_cdxKeyFree( pCurKey );
 
@@ -5710,14 +5710,14 @@ static ULONG hb_cdxDBOIScopeEval( LPCDXTAG pTag, HB_EVALSCOPE_FUNC pFunc, void *
 /*
  * return number of keys in order
  */
-static LONG hb_cdxDBOIKeyCount( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
+static LONG hb_cdxDBOIKeyCount( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fFilters )
 {
    ULONG ulKeyCount = 0;
-   BOOL fLogOpt = pArea->dbfarea.area.dbfi.itmCobExpr || !pArea->dbfarea.area.dbfi.fFilter;
+   HB_BOOL fLogOpt = pArea->dbfarea.area.dbfi.itmCobExpr || !pArea->dbfarea.area.dbfi.fFilter;
 
    if( pTag )
    {
-      BOOL fCheckFilter = ( fLogOpt && fFilters && pArea->dbfarea.area.dbfi.itmCobExpr );
+      HB_BOOL fCheckFilter = ( fLogOpt && fFilters && pArea->dbfarea.area.dbfi.itmCobExpr );
       ULONG ulRecNo = pArea->dbfarea.ulRecNo;
       LPCDXKEY pCurKey;
       hb_cdxIndexLockRead( pTag->pIndex );
@@ -5739,7 +5739,7 @@ static LONG hb_cdxDBOIKeyCount( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
                   ulKeyCount++;
                hb_cdxTagSkipNext( pTag );
             }
-            pTag->fRePos = TRUE;
+            pTag->fRePos = HB_TRUE;
             hb_cdxKeyCopy( pTag->CurKey, pCurKey );
             hb_cdxKeyFree( pCurKey );
             if( fCheckFilter )
@@ -5768,9 +5768,9 @@ static LONG hb_cdxDBOIKeyCount( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
                   ulKeyCount += pPage->iKeys;
                   pPage->Page = pPage->Right;
                }
-               hb_cdxPageFree( pPage, TRUE );
+               hb_cdxPageFree( pPage, HB_TRUE );
             }
-            pTag->fRePos = TRUE;
+            pTag->fRePos = HB_TRUE;
             hb_cdxKeyCopy( pTag->CurKey, pCurKey );
             hb_cdxKeyFree( pCurKey );
          }
@@ -5815,10 +5815,10 @@ static LONG hb_cdxDBOIKeyCount( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
 /*
  * return logical key position in order
  */
-static LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
+static LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, HB_BOOL fFilters )
 {
    ULONG ulKeyNo = 0;
-   BOOL fLogOpt = pArea->dbfarea.area.dbfi.itmCobExpr || !pArea->dbfarea.area.dbfi.fFilter;
+   HB_BOOL fLogOpt = pArea->dbfarea.area.dbfi.itmCobExpr || !pArea->dbfarea.area.dbfi.fFilter;
 
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
@@ -5827,7 +5827,7 @@ static LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
       ulKeyNo = 0;
    else if( pTag )
    {
-      BOOL fCheckFilter = ( fLogOpt && fFilters && pArea->dbfarea.area.dbfi.itmCobExpr );
+      HB_BOOL fCheckFilter = ( fLogOpt && fFilters && pArea->dbfarea.area.dbfi.itmCobExpr );
       ULONG ulRecNo = pArea->dbfarea.ulRecNo;
 
       hb_cdxIndexLockRead( pTag->pIndex );
@@ -5858,7 +5858,7 @@ static LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
                         ulKeyNo++;
                      hb_cdxTagSkipPrev( pTag );
                   }
-                  pTag->fRePos = TRUE;
+                  pTag->fRePos = HB_TRUE;
                   hb_cdxKeyCopy( pTag->CurKey, pCurKey );
                   hb_cdxKeyFree( pCurKey );
                   if( fCheckFilter )
@@ -5884,7 +5884,7 @@ static LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
                         ulKeyNo += pPage->iKeys;
                         pPage->Page = pPage->Left;
                      }
-                     hb_cdxPageFree( pPage, TRUE );
+                     hb_cdxPageFree( pPage, HB_TRUE );
                   }
                }
                else
@@ -5901,7 +5901,7 @@ static LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
                         ulKeyNo += pPage->iKeys;
                         pPage->Page = pPage->Right;
                      }
-                     hb_cdxPageFree( pPage, TRUE );
+                     hb_cdxPageFree( pPage, HB_TRUE );
                   }
                }
             }
@@ -5950,17 +5950,17 @@ static LONG hb_cdxDBOIKeyNo( CDXAREAP pArea, LPCDXTAG pTag, BOOL fFilters )
 /*
  * DBOI_KEYGOTO goto specific logical record in the index file
  */
-static HB_ERRCODE hb_cdxDBOIKeyGoto( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulKeyNo, BOOL fFilters )
+static HB_ERRCODE hb_cdxDBOIKeyGoto( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulKeyNo, HB_BOOL fFilters )
 {
    HB_ERRCODE retval;
    ULONG ulKeyCnt = ulKeyNo;
-   BOOL fLogOpt = pArea->dbfarea.area.dbfi.itmCobExpr || !pArea->dbfarea.area.dbfi.fFilter;
+   HB_BOOL fLogOpt = pArea->dbfarea.area.dbfi.itmCobExpr || !pArea->dbfarea.area.dbfi.fFilter;
 
    if( ulKeyNo == 0 )
       retval = SELF_GOTO( ( AREAP ) pArea, 0 );
    else if( pTag )
    {
-      BOOL fCheckFilter = ( fLogOpt && fFilters && pArea->dbfarea.area.dbfi.itmCobExpr );
+      HB_BOOL fCheckFilter = ( fLogOpt && fFilters && pArea->dbfarea.area.dbfi.itmCobExpr );
       hb_cdxIndexLockRead( pTag->pIndex );
       hb_cdxTagRefreshScope( pTag );
       if( ! pArea->dbfarea.lpdbPendingRel && ( fFilters ?
@@ -6005,7 +6005,7 @@ static HB_ERRCODE hb_cdxDBOIKeyGoto( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulKeyN
             {
                ulKeyCnt -= pPage->iKeys;
                pOwnerPage->Child = hb_cdxPageNew( pPage->TagParent, pPage->Owner, ulNextPg );
-               hb_cdxPageFree( pPage, FALSE );
+               hb_cdxPageFree( pPage, HB_FALSE );
                pPage = pOwnerPage->Child;
             }
             if( (ULONG) pPage->iKeys >= ulKeyCnt )
@@ -6058,12 +6058,12 @@ static double hb_cdxCountRelKeyPos( LPCDXPAGE pPage )
             pPage->iCurKey ) / pPage->iKeys;
 }
 
-static BOOL hb_cdxGoToRelKeyPos( LPCDXPAGE pPage, double dPos )
+static HB_BOOL hb_cdxGoToRelKeyPos( LPCDXPAGE pPage, double dPos )
 {
    do
    {
       if( pPage->iKeys == 0 )
-         return FALSE;
+         return HB_FALSE;
 
       pPage->iCurKey = ( int ) ( dPos * pPage->iKeys );
       if( pPage->iCurKey >= pPage->iKeys )
@@ -6083,7 +6083,7 @@ static BOOL hb_cdxGoToRelKeyPos( LPCDXPAGE pPage, double dPos )
    }
    while( pPage );
 
-   return TRUE;
+   return HB_TRUE;
 }
 
 static double hb_cdxDBOIGetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag )
@@ -6109,7 +6109,7 @@ static double hb_cdxDBOIGetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag )
    {
       LPCDXKEY pKey;
       double dStart, dStop, dFact = 0.0000000000001;
-      BOOL fOK = TRUE;
+      HB_BOOL fOK = HB_TRUE;
 
       if( pTag->UsrAscend )
       {
@@ -6130,7 +6130,7 @@ static double hb_cdxDBOIGetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag )
       {
          hb_cdxTagKeyFind( pTag, pKey );
          if( pTag->CurKey->rec == 0 || pTag->TagEOF || ! hb_cdxBottomScope( pTag ) )
-            fOK = FALSE;
+            fOK = HB_FALSE;
          else
             dStart = hb_cdxCountRelKeyPos( pTag->RootPage );
       }
@@ -6139,7 +6139,7 @@ static double hb_cdxDBOIGetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag )
       {
          hb_cdxTagKeyFind( pTag, pKey );
          if( pTag->CurKey->rec == 0 || pTag->TagBOF || ! hb_cdxTopScope( pTag ) )
-            fOK = FALSE;
+            fOK = HB_FALSE;
          else
             dStop = hb_cdxCountRelKeyPos( pTag->RootPage );
       }
@@ -6151,7 +6151,7 @@ static double hb_cdxDBOIGetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag )
             dStart = dStop;
             dStop = dTmp;
          }
-         pTag->fRePos = TRUE;
+         pTag->fRePos = HB_TRUE;
          if( hb_cdxCurKeyRefresh( pArea, pTag ) &&
              hb_cdxTopScope( pTag ) && hb_cdxBottomScope( pTag ) )
          {
@@ -6204,17 +6204,17 @@ static void hb_cdxDBOISetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag, double dPos )
    }
    else
    {
-      BOOL fForward = TRUE, fOK = TRUE, fTop = FALSE;
+      HB_BOOL fForward = HB_TRUE, fOK = HB_TRUE, fTop = HB_FALSE;
       hb_cdxIndexLockRead( pTag->pIndex );
       hb_cdxTagRefreshScope( pTag );
 
       if( dPos >= 1.0 )
       {
-         fForward = FALSE;
+         fForward = HB_FALSE;
       }
       else if( dPos <= 0.0 )
       {
-         fTop = TRUE;
+         fTop = HB_TRUE;
       }
       else
       {
@@ -6237,7 +6237,7 @@ static void hb_cdxDBOISetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag, double dPos )
          {
             hb_cdxTagKeyFind( pTag, pKey );
             if( pTag->CurKey->rec == 0 || pTag->TagEOF || ! hb_cdxBottomScope( pTag ) )
-               fOK = FALSE;
+               fOK = HB_FALSE;
             else
                dStart = hb_cdxCountRelKeyPos( pTag->RootPage );
          }
@@ -6246,7 +6246,7 @@ static void hb_cdxDBOISetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag, double dPos )
          {
             hb_cdxTagKeyFind( pTag, pKey );
             if( pTag->CurKey->rec == 0 || pTag->TagBOF || ! hb_cdxTopScope( pTag ) )
-               fOK = FALSE;
+               fOK = HB_FALSE;
             else
                dStop = hb_cdxCountRelKeyPos( pTag->RootPage );
          }
@@ -6261,25 +6261,25 @@ static void hb_cdxDBOISetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag, double dPos )
             }
             if( dStart >= dStop - dFact )
             {
-               fTop = TRUE;
+               fTop = HB_TRUE;
             }
             else
             {
                dPos = dPos * ( dStop - dStart ) + dStart;
-               pTag->fRePos = FALSE;
+               pTag->fRePos = HB_FALSE;
                hb_cdxTagOpen( pTag );
-               pTag->TagBOF = pTag->TagEOF = FALSE;
+               pTag->TagBOF = pTag->TagEOF = HB_FALSE;
                if( !hb_cdxGoToRelKeyPos( pTag->RootPage, dPos ) )
                {
-                  fTop = TRUE;
+                  fTop = HB_TRUE;
                }
                else
                {
                   hb_cdxSetCurKey( pTag->RootPage );
                   if( !hb_cdxTopScope( pTag ) )
-                     fTop = TRUE;
+                     fTop = HB_TRUE;
                   else if( !hb_cdxBottomScope( pTag ) )
-                     fForward = FALSE;
+                     fForward = HB_FALSE;
                }
             }
          }
@@ -6301,7 +6301,7 @@ static void hb_cdxDBOISetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag, double dPos )
                hb_cdxTagSkipNext( pTag );
             }
             if( pTag->TagEOF && !fTop )
-               fForward = FALSE;
+               fForward = HB_FALSE;
          }
          if( !fForward )
          {
@@ -6328,9 +6328,9 @@ static void hb_cdxDBOISetRelKeyPos( CDXAREAP pArea, LPCDXTAG pTag, double dPos )
  * custom indexes when the same record can be stored more then once
  * or when the used index key is unknown
  */
-static BOOL hb_cdxDBOIFindRec( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulRecNo, BOOL fCont )
+static HB_BOOL hb_cdxDBOIFindRec( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulRecNo, HB_BOOL fCont )
 {
-   BOOL fFound = FALSE;
+   HB_BOOL fFound = HB_FALSE;
 
    if( pTag && ulRecNo )
    {
@@ -6356,7 +6356,7 @@ static BOOL hb_cdxDBOIFindRec( CDXAREAP pArea, LPCDXTAG pTag, ULONG ulRecNo, BOO
          {
             if( pTag->CurKey->rec == ulRecNo )
             {
-               fFound = TRUE;
+               fFound = HB_TRUE;
                break;
             }
             hb_cdxTagSkipNext( pTag );
@@ -6416,8 +6416,8 @@ static HB_ERRCODE hb_cdxGoBottom( CDXAREAP pArea )
 
    hb_cdxTagGoBottom( pTag );
 
-   pArea->dbfarea.area.fTop = FALSE;
-   pArea->dbfarea.area.fBottom = TRUE;
+   pArea->dbfarea.area.fTop = HB_FALSE;
+   pArea->dbfarea.area.fBottom = HB_TRUE;
 
    retval = SELF_GOTO( ( AREAP ) pArea, pTag->CurKey->rec );
 
@@ -6462,8 +6462,8 @@ static HB_ERRCODE hb_cdxGoTop( CDXAREAP pArea )
 
    hb_cdxTagGoTop( pTag );
 
-   pArea->dbfarea.area.fTop = TRUE;
-   pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = HB_TRUE;
+   pArea->dbfarea.area.fBottom = HB_FALSE;
 
    retval = SELF_GOTO( ( AREAP ) pArea, pTag->CurKey->rec );
 
@@ -6481,7 +6481,7 @@ static HB_ERRCODE hb_cdxGoTop( CDXAREAP pArea )
 }
 
 /* ( DBENTRYP_BIB )   hb_cdxSeek */
-static HB_ERRCODE hb_cdxSeek( CDXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pKeyItm, BOOL fFindLast )
+static HB_ERRCODE hb_cdxSeek( CDXAREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pKeyItm, HB_BOOL fFindLast )
 {
    LPCDXTAG pTag;
 
@@ -6501,14 +6501,14 @@ static HB_ERRCODE hb_cdxSeek( CDXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pKeyItm,
    {
       LPCDXKEY pKey;
       HB_ERRCODE retval = HB_SUCCESS;
-      BOOL  fEOF = FALSE, fLast;
+      HB_BOOL  fEOF = HB_FALSE, fLast;
       ULONG ulRec;
 
       if( pArea->dbfarea.lpdbPendingRel && pArea->dbfarea.lpdbPendingRel->isScoped )
          SELF_FORCEREL( ( AREAP ) pArea );
 
-      pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
       if( pTag->UsrUnique )
          fLast = !pTag->UsrAscend;
@@ -6518,22 +6518,22 @@ static HB_ERRCODE hb_cdxSeek( CDXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pKeyItm,
       /* TODO: runtime error if valtype(pKeyItm) != pTag->Type */
       pKey = hb_cdxKeyPutItem( NULL, pKeyItm,
                                fLast ? CDX_MAX_REC_NUM : CDX_IGNORE_REC_NUM,
-                               pTag, TRUE, CDX_CMP_PREFIX );
+                               pTag, HB_TRUE, CDX_CMP_PREFIX );
 
       hb_cdxIndexLockRead( pTag->pIndex );
       hb_cdxTagRefreshScope( pTag );
       ulRec = hb_cdxTagKeyFind( pTag, pKey );
       if( ( ulRec == 0 && ! fSoftSeek ) || pTag->TagEOF )
-         fEOF = TRUE;
+         fEOF = HB_TRUE;
       else /* if( fSoftSeek ) */
       {
          if( ! hb_cdxBottomScope( pTag ) )
-            fEOF = TRUE;
+            fEOF = HB_TRUE;
          else if( ! hb_cdxTopScope( pTag ) )
          {
             hb_cdxTagGoTop( pTag );
             if( pTag->CurKey->rec == 0 )
-               fEOF = TRUE;
+               fEOF = HB_TRUE;
          }
       }
       hb_cdxIndexUnLockRead( pTag->pIndex );
@@ -6550,7 +6550,7 @@ static HB_ERRCODE hb_cdxSeek( CDXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pKeyItm,
                                           pTag->CurKey->val, pTag->CurKey->len,
                                           pKey->mode ) == 0 );
                if( ! pArea->dbfarea.area.fFound && ! fSoftSeek )
-                  fEOF = TRUE;
+                  fEOF = HB_TRUE;
             }
          }
       }
@@ -6560,7 +6560,7 @@ static HB_ERRCODE hb_cdxSeek( CDXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pKeyItm,
       {
          retval = SELF_GOTO( ( AREAP ) pArea, 0 );
       }
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
       hb_cdxKeyFree( pKey );
       return retval;
    }
@@ -6639,7 +6639,7 @@ static HB_ERRCODE hb_cdxSkipRaw( CDXAREAP pArea, LONG lToSkip )
 {
    LPCDXTAG pTag;
    HB_ERRCODE retval;
-   BOOL fOut = FALSE, fForward;
+   HB_BOOL fOut = HB_FALSE, fForward;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxSkipRaw(%p, %ld)", pArea, lToSkip));
 
@@ -6663,14 +6663,14 @@ static HB_ERRCODE hb_cdxSkipRaw( CDXAREAP pArea, LONG lToSkip )
       if( fForward )
       {
          if( pTag->TagEOF || !hb_cdxBottomScope( pTag ) )
-            fOut = TRUE;
+            fOut = HB_TRUE;
          else if( pTag->UsrAscend && hb_cdxTopScope( pTag ) )
             lToSkip--;
       }
       else if( pArea->dbfarea.fPositioned )
       {
          if( pTag->TagEOF || !hb_cdxTopScope( pTag ) )
-            fOut = TRUE;
+            fOut = HB_TRUE;
          else if( !pTag->UsrAscend && hb_cdxBottomScope( pTag ) )
             lToSkip++;
       }
@@ -6684,7 +6684,7 @@ static HB_ERRCODE hb_cdxSkipRaw( CDXAREAP pArea, LONG lToSkip )
             hb_cdxTagSkipNext( pTag );
             if( pTag->TagEOF )
             {
-               fOut = TRUE;
+               fOut = HB_TRUE;
                break;
             }
          }
@@ -6703,7 +6703,7 @@ static HB_ERRCODE hb_cdxSkipRaw( CDXAREAP pArea, LONG lToSkip )
             hb_cdxTagSkipPrev( pTag );
             if( pTag->TagBOF )
             {
-               fOut = TRUE;
+               fOut = HB_TRUE;
                break;
             }
          }
@@ -6715,9 +6715,9 @@ static HB_ERRCODE hb_cdxSkipRaw( CDXAREAP pArea, LONG lToSkip )
    /* Update Bof and Eof flags */
    /*
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
    */
    return retval;
 }
@@ -6756,7 +6756,7 @@ static HB_ERRCODE hb_cdxFlush( CDXAREAP pArea )
          if( pIndex->pFile && pIndex->fFlush )
          {
             hb_fileCommit( pIndex->pFile );
-            pIndex->fFlush = FALSE;
+            pIndex->fFlush = HB_FALSE;
          }
          pIndex = pIndex->pNext;
       }
@@ -6775,8 +6775,8 @@ static HB_ERRCODE hb_cdxFlush( CDXAREAP pArea )
  */
 static HB_ERRCODE hb_cdxGoCold( CDXAREAP pArea )
 {
-   BOOL fRecordChanged = pArea->dbfarea.fRecordChanged;
-   BOOL fAppend = pArea->dbfarea.fAppend;
+   HB_BOOL fRecordChanged = pArea->dbfarea.fRecordChanged;
+   HB_BOOL fAppend = pArea->dbfarea.fAppend;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxGoCold(%p)", pArea));
 
@@ -6787,7 +6787,7 @@ static HB_ERRCODE hb_cdxGoCold( CDXAREAP pArea )
    {
       LPCDXTAG pTag = pArea->lpIndexes->TagList;
       LPCDXKEY pKey = NULL;
-      BOOL fAdd, fDel, fLck = FALSE;
+      HB_BOOL fAdd, fDel, fLck = HB_FALSE;
       LPDBRELINFO lpdbPendingRel;
 
       if( pArea->dbfarea.fShared )
@@ -6796,13 +6796,13 @@ static HB_ERRCODE hb_cdxGoCold( CDXAREAP pArea )
          {
             if( pArea->fCdxAppend )
                hb_cdxErrInternal( "hb_cdxGoCold: multiple appending without GOCOLD." );
-            pArea->fCdxAppend = TRUE;
+            pArea->fCdxAppend = HB_TRUE;
             return HB_SUCCESS;
          }
          else
          {
             fAppend = pArea->fCdxAppend;
-            pArea->fCdxAppend = FALSE;
+            pArea->fCdxAppend = HB_FALSE;
          }
       }
 
@@ -6829,12 +6829,12 @@ static HB_ERRCODE hb_cdxGoCold( CDXAREAP pArea )
             pKey = hb_cdxKeyEval( pKey, pTag );
 
             if( pTag->pForItem != NULL )
-               fAdd = hb_cdxEvalCond( pArea, pTag->pForItem, TRUE );
+               fAdd = hb_cdxEvalCond( pArea, pTag->pForItem, HB_TRUE );
             else
-               fAdd = TRUE;
+               fAdd = HB_TRUE;
 
             if( fAppend )
-               fDel = FALSE;
+               fDel = HB_FALSE;
             else
             {
                if( hb_cdxValCompare( pTag, pKey->val, pKey->len,
@@ -6854,7 +6854,7 @@ static HB_ERRCODE hb_cdxGoCold( CDXAREAP pArea )
                if( !fLck )
                {
                   hb_cdxIndexLockWrite( pTag->pIndex );
-                  fLck = TRUE;
+                  fLck = HB_TRUE;
                }
                if( fDel )
                   hb_cdxTagKeyDel( pTag, pTag->HotKey );
@@ -6876,7 +6876,7 @@ static HB_ERRCODE hb_cdxGoCold( CDXAREAP pArea )
             if( fLck )
             {
                hb_cdxIndexUnLockWrite( pTag->pIndex );
-               fLck = FALSE;
+               fLck = HB_FALSE;
             }
             if( pTag->pIndex->pNext )
                pTag = pTag->pIndex->pNext->TagList;
@@ -6918,7 +6918,7 @@ static HB_ERRCODE hb_cdxGoHot( CDXAREAP pArea )
          if( !pTag->Custom )
          {
             pTag->HotKey = hb_cdxKeyEval( pTag->HotKey, pTag );
-            pTag->HotFor = pTag->pForItem == NULL || hb_cdxEvalCond( pArea, pTag->pForItem, TRUE );
+            pTag->HotFor = pTag->pForItem == NULL || hb_cdxEvalCond( pArea, pTag->pForItem, HB_TRUE );
          }
 
          if( pTag->pNext )
@@ -6968,7 +6968,7 @@ static HB_ERRCODE hb_cdxClose( CDXAREAP pArea )
          pArea->pSort = NULL;
       }
 
-      hb_cdxOrdListClear( pArea, TRUE, NULL );
+      hb_cdxOrdListClear( pArea, HB_TRUE, NULL );
       if( pArea->bCdxSortTab )
       {
          hb_xfree( pArea->bCdxSortTab );
@@ -7040,7 +7040,7 @@ static HB_ERRCODE hb_cdxOpen( CDXAREAP pArea, LPDBOPENINFO pOpenInfo )
    {
       char szFileName[ HB_PATH_MAX ];
 
-      pArea->dbfarea.fHasTags = FALSE;
+      pArea->dbfarea.fHasTags = HB_FALSE;
       hb_cdxCreateFName( pArea, NULL, NULL, szFileName, NULL );
       if( hb_fileExists( szFileName, NULL ) ||
           DBFAREA_DATA( &pArea->dbfarea )->fStrictStruct )
@@ -7066,7 +7066,7 @@ static HB_ERRCODE hb_cdxOpen( CDXAREAP pArea, LPDBOPENINFO pOpenInfo )
    }
    else
    {
-      pArea->dbfarea.fHasTags = FALSE;
+      pArea->dbfarea.fHasTags = HB_FALSE;
    }
 
    return errCode;
@@ -7147,7 +7147,7 @@ static HB_ERRCODE hb_cdxOrderListAdd( CDXAREAP pArea, LPDBORDERINFO pOrderInfo )
    char szBaseName[ CDX_MAXTAGNAMELEN + 1 ];
    char szFileName[ HB_PATH_MAX ];
    LPCDXINDEX pIndex, * pIndexPtr;
-   BOOL fProd, bRetry;
+   HB_BOOL fProd, bRetry;
    PHB_ITEM pError = NULL;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxOrderListAdd(%p, %p)", pArea, pOrderInfo));
@@ -7198,7 +7198,7 @@ static HB_ERRCODE hb_cdxOrderListAdd( CDXAREAP pArea, LPDBORDERINFO pOrderInfo )
             hb_cdxErrorRT( pArea, EG_CORRUPTION, EDBF_CORRUPT,
                            szFileName, hb_fsError(), EF_CANDEFAULT, NULL );
          }
-         bRetry = FALSE;
+         bRetry = HB_FALSE;
       }
 
    } while( bRetry );
@@ -7233,7 +7233,7 @@ static HB_ERRCODE hb_cdxOrderListAdd( CDXAREAP pArea, LPDBORDERINFO pOrderInfo )
    }
 
    if( fProd )
-      pArea->dbfarea.fHasTags = TRUE;
+      pArea->dbfarea.fHasTags = HB_TRUE;
 
    /* dbfcdx specific: If there was no controlling order, set this one.
     * This is the behaviour of Clipper's dbfcdx, although
@@ -7271,7 +7271,7 @@ static HB_ERRCODE hb_cdxOrderListDelete( CDXAREAP pArea, LPDBORDERINFO pOrderInf
    char szTagName[ CDX_MAXTAGNAMELEN + 1 ];
    char szFileName[ HB_PATH_MAX ];
    LPCDXINDEX pIndex, * pIndexPtr;
-   BOOL fProd;
+   HB_BOOL fProd;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_cdxOrderListDelete(%p, %p)", pArea, pOrderInfo));
 
@@ -7386,8 +7386,8 @@ static HB_ERRCODE hb_cdxOrderListRebuild( CDXAREAP pArea )
 static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderInfo )
 {
    ULONG ulRecNo;
-   BOOL fNewFile, fOpenedIndex, fProd, fAscend = TRUE, fNoCase = FALSE,
-        fCustom = FALSE, fTemporary = FALSE, fExclusive = FALSE;
+   HB_BOOL fNewFile, fOpenedIndex, fProd, fAscend = HB_TRUE, fNoCase = HB_FALSE,
+        fCustom = HB_FALSE, fTemporary = HB_FALSE, fExclusive = HB_FALSE;
    PHB_ITEM pKeyExp, pForExp = NULL, pResult;
    char szCpndTagName[ CDX_MAXTAGNAMELEN + 1 ], szTagName[ CDX_MAXTAGNAMELEN + 1 ];
    char szFileName[ HB_PATH_MAX ], szTempFile[ HB_PATH_MAX ];
@@ -7526,12 +7526,12 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    }
 
    if( pArea->dbfarea.fTemporary )
-      fTemporary = TRUE;
+      fTemporary = HB_TRUE;
 
    /* Test conditional expression */
    if( pForExp )
    {
-      BOOL fOK;
+      HB_BOOL fOK;
 
       if( SELF_EVALBLOCK( ( AREAP ) pArea, pForExp ) == HB_FAILURE )
       {
@@ -7569,12 +7569,12 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    if( pOrderInfo->atomBagName && pOrderInfo->atomBagName[0] )
    {
       hb_strncpyUpperTrim( szTagName, ( char * ) pOrderInfo->atomBagName, sizeof( szTagName ) - 1 );
-      fNewFile = FALSE;
+      fNewFile = HB_FALSE;
    }
    else
    {
       hb_strncpy( szTagName, szCpndTagName, sizeof( szTagName ) - 1 );
-      fNewFile = TRUE;
+      fNewFile = HB_TRUE;
    }
 
    if( !pArea->dbfarea.area.lpdbOrdCondInfo ||
@@ -7604,7 +7604,7 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    if( !fOpenedIndex )
    {
       PHB_FILE pFile;
-      BOOL bRetry, fShared = pArea->dbfarea.fShared && !fTemporary && !fExclusive;
+      HB_BOOL bRetry, fShared = pArea->dbfarea.fShared && !fTemporary && !fExclusive;
       PHB_ITEM pError = NULL;
 
       do
@@ -7612,7 +7612,7 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
          if( fTemporary )
          {
             pFile = hb_fileCreateTemp( NULL, NULL, FC_NORMAL, szTempFile );
-            fNewFile = TRUE;
+            fNewFile = HB_TRUE;
          }
          else
          {
@@ -7628,7 +7628,7 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
                                     &pError ) == E_RETRY;
          else
          {
-            bRetry = FALSE;
+            bRetry = HB_FALSE;
             if( !fNewFile )
                fNewFile = ( hb_fileSize( pFile ) == 0 );
          }
@@ -7643,7 +7643,7 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
          pIndex = hb_cdxIndexNew( pArea );
          pIndex->pFile      = pFile;
          pIndex->fShared    = fShared;
-         pIndex->fReadonly  = FALSE;
+         pIndex->fReadonly  = HB_FALSE;
          pIndex->szFileName = hb_strdup( szFileName );
          pIndex->fDelete = fTemporary;
          if( fTemporary )
@@ -7663,7 +7663,7 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
                               szFileName, hb_fsError(), EF_CANDEFAULT, NULL );
                */
                hb_cdxIndexFreeTags( pIndex );
-               fNewFile = TRUE;
+               fNewFile = HB_TRUE;
             }
          }
       }
@@ -7688,7 +7688,7 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    if( fNewFile )
    {
       hb_fileTruncAt( pIndex->pFile, 0 );
-      pIndex->fChanged = TRUE;
+      pIndex->fChanged = HB_TRUE;
       hb_cdxIndexDropAvailPage( pIndex );
       if( pIndex->pCompound != NULL )
          hb_cdxTagFree( pIndex->pCompound );
@@ -7698,7 +7698,7 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
 
    pTag = hb_cdxIndexAddTag( pIndex, szTagName, hb_itemGetCPtr( pOrderInfo->abExpr ),
                              pKeyExp, bType, uiLen, szFor, pForExp,
-                             fAscend , pOrderInfo->fUnique, fNoCase, fCustom, FALSE );
+                             fAscend , pOrderInfo->fUnique, fNoCase, fCustom, HB_FALSE );
 
    if( pArea->dbfarea.area.lpdbOrdCondInfo && ( !pArea->dbfarea.area.lpdbOrdCondInfo->fAll &&
                                    !pArea->dbfarea.area.lpdbOrdCondInfo->fAdditive ) )
@@ -7710,14 +7710,14 @@ static HB_ERRCODE hb_cdxOrderCreate( CDXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    /* Update DBF header */
    if( !pArea->dbfarea.fHasTags && !fOpenedIndex && !pIndex->fDelete && fProd )
    {
-      pArea->dbfarea.fHasTags = TRUE;
+      pArea->dbfarea.fHasTags = HB_TRUE;
       if( !pArea->dbfarea.fReadonly && ( pArea->dbfarea.dbfHeader.bHasTags & 0x01 ) == 0 &&
           ( hb_setGetAutOpen() || DBFAREA_DATA( &pArea->dbfarea )->fStrictStruct ) )
          SELF_WRITEDBHEADER( ( AREAP ) pArea );
    }
    else
    {
-      fProd = FALSE;
+      fProd = HB_FALSE;
    }
 
    if( !fOpenedIndex )
@@ -7777,7 +7777,7 @@ static HB_ERRCODE hb_cdxOrderDestroy( CDXAREAP pArea, LPDBORDERINFO pOrderInfo )
                   pArea->lpIndexes = pIndex->pNext;
                   if( pArea->dbfarea.fHasTags )
                   {
-                     pArea->dbfarea.fHasTags = FALSE;
+                     pArea->dbfarea.fHasTags = HB_FALSE;
                      if( !pArea->dbfarea.fReadonly && ( pArea->dbfarea.dbfHeader.bHasTags & 0x01 ) != 0 &&
                          ( hb_setGetAutOpen() || DBFAREA_DATA( &pArea->dbfarea )->fStrictStruct ) )
                         SELF_WRITEDBHEADER( ( AREAP ) pArea );
@@ -7795,7 +7795,7 @@ static HB_ERRCODE hb_cdxOrderDestroy( CDXAREAP pArea, LPDBORDERINFO pOrderInfo )
                      pIndexTmp->pNext = pIndex->pNext;
                   }
                }
-               pIndex->fDelete = TRUE;
+               pIndex->fDelete = HB_TRUE;
                hb_cdxIndexFree( pIndex );
             }
             if( uiTag < pArea->uiTag )
@@ -7890,7 +7890,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
 
       case DBOI_ISREINDEX:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
-                               pArea->pSort ? pArea->pSort->fReindex : FALSE );
+                               pArea->pSort ? pArea->pSort->fReindex : HB_FALSE );
          return HB_SUCCESS;
 
       case DBOI_LOCKOFFSET:
@@ -8066,11 +8066,11 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
          {
             pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
                hb_cdxDBOIKeyGoto( pArea, pTag,
-                  hb_itemGetNL( pInfo->itmNewVal ), TRUE ) == HB_SUCCESS );
+                  hb_itemGetNL( pInfo->itmNewVal ), HB_TRUE ) == HB_SUCCESS );
          }
          else
             pInfo->itmResult = hb_itemPutNL( pInfo->itmResult,
-                                    hb_cdxDBOIKeyNo( pArea, pTag, TRUE ) );
+                                    hb_cdxDBOIKeyNo( pArea, pTag, HB_TRUE ) );
          break;
 
       /* TODO: is this ok?  DBOI_RECNO == DBOI_KEYNORAW ? No, it isn't. */
@@ -8080,21 +8080,21 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
          {
             pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
                hb_cdxDBOIKeyGoto( pArea, pTag,
-                  hb_itemGetNL( pInfo->itmNewVal ), FALSE ) == HB_SUCCESS );
+                  hb_itemGetNL( pInfo->itmNewVal ), HB_FALSE ) == HB_SUCCESS );
          }
          else
             pInfo->itmResult = hb_itemPutNL( pInfo->itmResult,
-                                    hb_cdxDBOIKeyNo( pArea, pTag, FALSE ) );
+                                    hb_cdxDBOIKeyNo( pArea, pTag, HB_FALSE ) );
          break;
 
       case DBOI_KEYCOUNT:
          pInfo->itmResult = hb_itemPutNL( pInfo->itmResult,
-                                    hb_cdxDBOIKeyCount( pArea, pTag, TRUE ) );
+                                    hb_cdxDBOIKeyCount( pArea, pTag, HB_TRUE ) );
          break;
 
       case DBOI_KEYCOUNTRAW:
          pInfo->itmResult = hb_itemPutNL( pInfo->itmResult,
-                                    hb_cdxDBOIKeyCount( pArea, pTag, FALSE ) );
+                                    hb_cdxDBOIKeyCount( pArea, pTag, HB_FALSE ) );
          break;
 
       case DBOI_RELKEYPOS:
@@ -8109,13 +8109,13 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
       case DBOI_FINDREC:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
                   hb_cdxDBOIFindRec( pArea, pTag,
-                              hb_itemGetNL( pInfo->itmNewVal ), FALSE ) );
+                              hb_itemGetNL( pInfo->itmNewVal ), HB_FALSE ) );
          break;
 
       case DBOI_FINDRECCONT:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
                   hb_cdxDBOIFindRec( pArea, pTag,
-                              hb_itemGetNL( pInfo->itmNewVal ), TRUE ) );
+                              hb_itemGetNL( pInfo->itmNewVal ), HB_TRUE ) );
          break;
 
       case DBOI_SKIPUNIQUE:
@@ -8127,32 +8127,32 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
 
       case DBOI_SKIPEVAL:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
-               hb_cdxDBOISkipEval( pArea, pTag, TRUE, pInfo->itmNewVal ) );
+               hb_cdxDBOISkipEval( pArea, pTag, HB_TRUE, pInfo->itmNewVal ) );
          break;
 
       case DBOI_SKIPEVALBACK:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
-               hb_cdxDBOISkipEval( pArea, pTag, FALSE, pInfo->itmNewVal ) );
+               hb_cdxDBOISkipEval( pArea, pTag, HB_FALSE, pInfo->itmNewVal ) );
          break;
 
       case DBOI_SKIPWILD:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
-               hb_cdxDBOISkipWild( pArea, pTag, TRUE, pInfo->itmNewVal ) );
+               hb_cdxDBOISkipWild( pArea, pTag, HB_TRUE, pInfo->itmNewVal ) );
          break;
 
       case DBOI_SKIPWILDBACK:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
-               hb_cdxDBOISkipWild( pArea, pTag, FALSE, pInfo->itmNewVal ) );
+               hb_cdxDBOISkipWild( pArea, pTag, HB_FALSE, pInfo->itmNewVal ) );
          break;
 
       case DBOI_SKIPREGEX:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
-            hb_cdxDBOISkipRegEx( pArea, pTag, TRUE, pInfo->itmNewVal ) );
+            hb_cdxDBOISkipRegEx( pArea, pTag, HB_TRUE, pInfo->itmNewVal ) );
          break;
 
       case DBOI_SKIPREGEXBACK:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
-            hb_cdxDBOISkipRegEx( pArea, pTag, FALSE, pInfo->itmNewVal ) );
+            hb_cdxDBOISkipRegEx( pArea, pTag, HB_FALSE, pInfo->itmNewVal ) );
          break;
 
       case DBOI_SCOPEEVAL:
@@ -8216,7 +8216,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
          break;
 
       case DBOI_UNIQUE:
-         pInfo->itmResult = hb_itemPutL( pInfo->itmResult, ( pTag ? pTag->UniqueKey || pTag->UsrUnique : FALSE ) );
+         pInfo->itmResult = hb_itemPutL( pInfo->itmResult, ( pTag ? pTag->UniqueKey || pTag->UsrUnique : HB_FALSE ) );
          if( pTag && pInfo->itmNewVal && HB_IS_LOGICAL( pInfo->itmNewVal ) && !pTag->UniqueKey )
          {
             pTag->UsrUnique = hb_itemGetL( pInfo->itmNewVal );
@@ -8261,7 +8261,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
             }
             if( pTag->CurKey->rec == pArea->dbfarea.ulRecNo )
                pInfo->itmResult = hb_cdxKeyGetItem( pTag->CurKey,
-                                           pInfo->itmResult, pTag, TRUE );
+                                           pInfo->itmResult, pTag, HB_TRUE );
          }
          break;
 
@@ -8341,19 +8341,19 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
             {
                if( !pTag->Template )
                {
-                  BOOL fNewVal = hb_itemGetL( pInfo->itmNewVal );
+                  HB_BOOL fNewVal = hb_itemGetL( pInfo->itmNewVal );
                   if( pTag->Custom ? ! fNewVal : fNewVal )
                   {
                      pTag->Custom = fNewVal;
-                     pTag->Partial = TRUE;
-                     pTag->ChgOnly = FALSE;
-                     pTag->TagChanged = TRUE;
+                     pTag->Partial = HB_TRUE;
+                     pTag->ChgOnly = HB_FALSE;
+                     pTag->TagChanged = HB_TRUE;
                      /* This is a hacks to emulate both SIX3 and COMIX behavior
                       * which should be cleaned. I intentionally not used
                       * HB_SIXCDX macro here [druzus]
                       */
                      if( pTag->Custom )
-                        pTag->Template = pTag->MultiKey = TRUE;
+                        pTag->Template = pTag->MultiKey = HB_TRUE;
                   }
                }
                hb_cdxIndexUnLockWrite( pTag->pIndex );
@@ -8383,7 +8383,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
       case DBOI_KEYADD:
          if( !pTag )
          {
-            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, FALSE );
+            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, HB_FALSE );
          }
          else
          {
@@ -8394,9 +8394,9 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
 
                if( !pArea->dbfarea.fPositioned ||
                    ( pTag->pForItem &&
-                     !hb_cdxEvalCond( pArea, pTag->pForItem, TRUE ) ) )
+                     !hb_cdxEvalCond( pArea, pTag->pForItem, HB_TRUE ) ) )
                {
-                  pInfo->itmResult = hb_itemPutL( pInfo->itmResult, FALSE );
+                  pInfo->itmResult = hb_itemPutL( pInfo->itmResult, HB_FALSE );
                }
                else
                {
@@ -8406,7 +8406,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                       pTag->Template )
                      pKey = hb_cdxKeyPutItem( NULL, pInfo->itmNewVal,
                                               pArea->dbfarea.ulRecNo, pTag,
-                                              TRUE, CDX_CMP_EXACT );
+                                              HB_TRUE, CDX_CMP_EXACT );
                   else
                      pKey = hb_cdxKeyEval( NULL, pTag );
                   pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
@@ -8425,7 +8425,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
       case DBOI_KEYDELETE:
          if( !pTag )
          {
-            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, FALSE );
+            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, HB_FALSE );
          }
          else
          {
@@ -8436,9 +8436,9 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
 
                if( !pArea->dbfarea.fPositioned ||
                    ( pTag->pForItem &&
-                     !hb_cdxEvalCond( pArea, pTag->pForItem, TRUE ) ) )
+                     !hb_cdxEvalCond( pArea, pTag->pForItem, HB_TRUE ) ) )
                {
-                  pInfo->itmResult = hb_itemPutL( pInfo->itmResult, FALSE );
+                  pInfo->itmResult = hb_itemPutL( pInfo->itmResult, HB_FALSE );
                }
                else
                {
@@ -8448,7 +8448,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                       pTag->Template )
                      pKey = hb_cdxKeyPutItem( NULL, pInfo->itmNewVal,
                                               pArea->dbfarea.ulRecNo, pTag,
-                                              TRUE, CDX_CMP_EXACT );
+                                              HB_TRUE, CDX_CMP_EXACT );
                   else
                   {
                      if( pTag->CurKey->rec != pArea->dbfarea.ulRecNo )
@@ -8486,7 +8486,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                                                  pTag->pIndex->lockRead > 0 );
          }
          else
-            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, FALSE );
+            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, HB_FALSE );
          break;
 
       case DBOI_WRITELOCK:
@@ -8503,7 +8503,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                                                  pTag->pIndex->lockWrite > 0 );
          }
          else
-            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, FALSE );
+            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, HB_FALSE );
          break;
 
       case DBOI_UPDATECOUNTER:
@@ -8535,7 +8535,7 @@ static HB_ERRCODE hb_cdxOrderInfo( CDXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
          break;
 
       case DBOI_LARGEFILE:
-         pInfo->itmResult = hb_itemPutL( pInfo->itmResult, FALSE );
+         pInfo->itmResult = hb_itemPutL( pInfo->itmResult, HB_FALSE );
          break;
 
       case DBOI_INDEXTYPE:
@@ -8642,12 +8642,12 @@ static HB_ERRCODE hb_cdxRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect
       case RDDI_MULTITAG:
       case RDDI_SORTRECNO:
       case RDDI_STRUCTORD:
-         hb_itemPutL( pItem, TRUE );
+         hb_itemPutL( pItem, HB_TRUE );
          break;
 
       case RDDI_STRICTSTRUCT:
       {
-         BOOL fStrictStruct = pData->fStrictStruct;
+         HB_BOOL fStrictStruct = pData->fStrictStruct;
          if( hb_itemType( pItem ) == HB_IT_LOGICAL )
             pData->fStrictStruct = hb_itemGetL( pItem );
          hb_itemPutL( pItem, fStrictStruct );
@@ -8680,14 +8680,14 @@ static int hb_cdxQuickSortCompare( LPCDXSORTINFO pSort, BYTE * pKey1, BYTE * pKe
    return i;
 }
 
-static BOOL hb_cdxQSort( LPCDXSORTINFO pSort, BYTE * pSrc, BYTE * pBuf, LONG lKeys )
+static HB_BOOL hb_cdxQSort( LPCDXSORTINFO pSort, BYTE * pSrc, BYTE * pBuf, LONG lKeys )
 {
    if( lKeys > 1 )
    {
       int iLen = pSort->keyLen + 4;
       LONG l1, l2;
       BYTE * pPtr1, * pPtr2, *pDst;
-      BOOL f1, f2;
+      HB_BOOL f1, f2;
 
       l1 = lKeys >> 1;
       l2 = lKeys - l1;
@@ -8735,7 +8735,7 @@ static BOOL hb_cdxQSort( LPCDXSORTINFO pSort, BYTE * pSrc, BYTE * pBuf, LONG lKe
       }
       return !f1;
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 static void hb_cdxSortSortPage( LPCDXSORTINFO pSort )
@@ -8756,7 +8756,7 @@ static void hb_cdxSortSortPage( LPCDXSORTINFO pSort )
 static void hb_cdxSortAddNodeKey( LPCDXSORTINFO pSort, int iLevel, BYTE *pKeyVal, ULONG ulRec, ULONG ulPage )
 {
    LPCDXPAGE pPage;
-   BOOL fNew;
+   HB_BOOL fNew;
    int iLen = pSort->keyLen, iDup = 0, iTrl = 0, iTmp, iPos;
    BYTE *pTmp;
 
@@ -8785,7 +8785,7 @@ static void hb_cdxSortAddNodeKey( LPCDXSORTINFO pSort, int iLevel, BYTE *pKeyVal
    }
    if( pPage == NULL )
    {
-      fNew = TRUE;
+      fNew = HB_TRUE;
    }
    else
    {
@@ -8831,7 +8831,7 @@ static void hb_cdxSortAddNodeKey( LPCDXSORTINFO pSort, int iLevel, BYTE *pKeyVal
             pTmp = &pSort->NodeList[ iLevel ]->node.intNode.keyPool[ iPos ];
             hb_cdxSortAddNodeKey( pSort, iLevel + 1, pTmp, HB_GET_BE_UINT32( &pTmp[ iLen ] ), pSort->NodeList[ iLevel ]->Page );
          }
-         hb_cdxPageFree( pSort->NodeList[ iLevel ], TRUE );
+         hb_cdxPageFree( pSort->NodeList[ iLevel ], HB_TRUE );
       }
       pSort->NodeList[ iLevel ] = pPage;
    }
@@ -8953,7 +8953,7 @@ static void hb_cdxSortOrderPages( LPCDXSORTINFO pSort )
    }
 }
 
-static BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, BYTE ** pKeyVal, ULONG *pulRec )
+static HB_BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, BYTE ** pKeyVal, ULONG *pulRec )
 {
    int iLen = pSort->keyLen, i;
    LONG l, r, m;
@@ -9012,14 +9012,14 @@ static BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, BYTE ** pKeyVal, ULONG *pulRe
       pSort->pSwapPage[ ulPage ].ulCurKey++;
       pSort->pSwapPage[ ulPage ].ulKeys--;
       pSort->pSwapPage[ ulPage ].ulKeyBuf--;
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 #else
 
-static BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, BYTE ** pKeyVal, ULONG *pulRec )
+static HB_BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, BYTE ** pKeyVal, ULONG *pulRec )
 {
    int i, iLen = pSort->keyLen;
    ULONG ulPage, ulKeyPage = 0, ulRec = 0, ulRecTmp;
@@ -9057,9 +9057,9 @@ static BOOL hb_cdxSortKeyGet( LPCDXSORTINFO pSort, BYTE ** pKeyVal, ULONG *pulRe
       pSort->pSwapPage[ ulKeyPage ].ulKeyBuf--;
       *pulRec = ulRec;
       *pKeyVal = pKey;
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 #endif
@@ -9198,7 +9198,7 @@ static void hb_cdxSortFree( LPCDXSORTINFO pSort )
 
 static void hb_cdxSortOut( LPCDXSORTINFO pSort )
 {
-   BOOL fUnique = pSort->fUnique, fNext;
+   HB_BOOL fUnique = pSort->fUnique, fNext;
    ULONG ulPage, ulRec, ulKey;
    BYTE * pKeyVal;
    int iLen = pSort->keyLen, iLevel;
@@ -9284,20 +9284,20 @@ static void hb_cdxSortOut( LPCDXSORTINFO pSort )
    }
 
    iLevel = 0;
-   fNext = TRUE;
+   fNext = HB_TRUE;
    do
    {
       if( iLevel + 1 == CDX_STACKSIZE || pSort->NodeList[ iLevel + 1 ] == NULL )
       {
          pSort->NodeList[ iLevel ]->PageType |= CDX_NODE_ROOT;
          pSort->pTag->RootBlock = pSort->NodeList[ iLevel ]->Page;
-         fNext = FALSE;
+         fNext = HB_FALSE;
       }
       else
       {
          hb_cdxSortAddNodeKey( pSort, iLevel + 1, pSort->pLastKey, pSort->ulLastRec, pSort->NodeList[ iLevel ]->Page );
       }
-      hb_cdxPageFree( pSort->NodeList[ iLevel ], TRUE );
+      hb_cdxPageFree( pSort->NodeList[ iLevel ], HB_TRUE );
       iLevel++;
    }
    while( fNext );
@@ -9311,7 +9311,7 @@ static void hb_cdxTagEmptyIndex( LPCDXTAG pTag )
    hb_cdxPageLeafInitSpace( pTag->RootPage );
 }
 
-static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
+static void hb_cdxTagDoIndex( LPCDXTAG pTag, HB_BOOL fReindex )
 {
    LPCDXAREA pArea = pTag->pIndex->pArea;
    LPCDXSORTINFO pSort;
@@ -9343,7 +9343,7 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
    if( ( pTag->OptFlags & CDX_TYPE_STRUCTURE ) == 0 && pEvalItem )
    {
       SELF_GOTO( ( AREAP ) pArea, 0 );
-      if( !hb_cdxEvalCond( pArea, pEvalItem, FALSE ) )
+      if( !hb_cdxEvalCond( pArea, pEvalItem, HB_FALSE ) )
       {
          hb_cdxSortFree( pSort );
          pArea->pSort = NULL;
@@ -9360,7 +9360,7 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
    {
       USHORT uiSaveTag = pArea->uiTag;
       ULONG ulStartRec = 0, ulNextCount = 0;
-      BOOL fDirectRead, fUseFilter = FALSE;
+      HB_BOOL fDirectRead, fUseFilter = HB_FALSE;
       BYTE * pSaveRecBuff = pArea->dbfarea.pRecord, cTemp[8];
       int iRecBuff = 0, iRecBufSize = USHRT_MAX / pArea->dbfarea.uiRecordLen, iRec;
 
@@ -9391,7 +9391,7 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
          }
          else if( pArea->dbfarea.area.lpdbOrdCondInfo->fUseFilter )
          {
-            fUseFilter = TRUE;
+            fUseFilter = HB_TRUE;
          }
          else if( !pArea->dbfarea.area.lpdbOrdCondInfo->fUseCurrent )
          {
@@ -9445,7 +9445,7 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
             pArea->dbfarea.ulRecNo = ulRecNo;
             if( SELF_GETREC( ( AREAP ) pArea, NULL ) == HB_FAILURE )
                break;
-            pArea->dbfarea.fValidBuffer = pArea->dbfarea.fPositioned = TRUE;
+            pArea->dbfarea.fValidBuffer = pArea->dbfarea.fPositioned = HB_TRUE;
             pArea->dbfarea.fDeleted = pArea->dbfarea.pRecord[ 0 ] == '*';
             /* Force relational movement in child WorkAreas */
             if( pArea->dbfarea.area.lpdbRelations )
@@ -9460,18 +9460,18 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
             if( lStep >= pArea->dbfarea.area.lpdbOrdCondInfo->lStep )
             {
                lStep = 0;
-               if( !hb_cdxEvalCond( pArea, pEvalItem, FALSE ) )
+               if( !hb_cdxEvalCond( pArea, pEvalItem, HB_FALSE ) )
                   break;
             }
             ++lStep;
          }
 #endif
 
-         if( pWhileItem && !hb_cdxEvalCond( NULL, pWhileItem, FALSE ) )
+         if( pWhileItem && !hb_cdxEvalCond( NULL, pWhileItem, HB_FALSE ) )
             break;
 
          if( ulRecNo <= ulRecCount &&
-              ( pForItem == NULL || hb_cdxEvalCond( pArea, pForItem, FALSE ) ) )
+              ( pForItem == NULL || hb_cdxEvalCond( pArea, pForItem, HB_FALSE ) ) )
          {
             double d;
 
@@ -9549,7 +9549,7 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
             if( lStep >= pArea->dbfarea.area.lpdbOrdCondInfo->lStep )
             {
                lStep = 0;
-               if( !hb_cdxEvalCond( pArea, pEvalItem, FALSE ) )
+               if( !hb_cdxEvalCond( pArea, pEvalItem, HB_FALSE ) )
                   break;
             }
             ++lStep;
@@ -9582,8 +9582,8 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
 #if !defined( HB_SIXCDX )
       if( pEvalItem && lStep )
       {
-         /* pArea->dbfarea.area.fEof = TRUE; */
-         hb_cdxEvalCond( pArea, pEvalItem, FALSE );
+         /* pArea->dbfarea.area.fEof = HB_TRUE; */
+         hb_cdxEvalCond( pArea, pEvalItem, HB_FALSE );
       }
 #endif
    }
@@ -9592,8 +9592,8 @@ static void hb_cdxTagDoIndex( LPCDXTAG pTag, BOOL fReindex )
    if( pEvalItem )
    {
       SELF_GOTO( ( AREAP ) pArea, 0 );
-      pArea->dbfarea.area.fBof = FALSE;
-      hb_cdxEvalCond( pArea, pEvalItem, FALSE );
+      pArea->dbfarea.area.fBof = HB_FALSE;
+      hb_cdxEvalCond( pArea, pEvalItem, HB_FALSE );
    }
 #endif
 
diff --git a/harbour/src/rdd/dbffpt/dbffpt1.c b/harbour/src/rdd/dbffpt/dbffpt1.c
index 7b32e3c8a9..e56080b0c4 100644
--- a/harbour/src/rdd/dbffpt/dbffpt1.c
+++ b/harbour/src/rdd/dbffpt/dbffpt1.c
@@ -143,13 +143,13 @@ static const char * hb_memoDefaultFileExt( int iType, USHORT uiRdd )
 /*
  * Exclusive lock memo file.
  */
-static BOOL hb_fptFileLockEx( FPTAREAP pArea, BOOL fWait )
+static HB_BOOL hb_fptFileLockEx( FPTAREAP pArea, HB_BOOL fWait )
 {
-   BOOL fRet;
+   HB_BOOL fRet;
 
    if( !pArea->fShared )
    {
-      fRet = TRUE;
+      fRet = HB_TRUE;
    }
    else
    {
@@ -168,13 +168,13 @@ static BOOL hb_fptFileLockEx( FPTAREAP pArea, BOOL fWait )
 /*
  * Shared lock memo file.
  */
-static BOOL hb_fptFileLockSh( FPTAREAP pArea, BOOL fWait )
+static HB_BOOL hb_fptFileLockSh( FPTAREAP pArea, HB_BOOL fWait )
 {
-   BOOL fRet;
+   HB_BOOL fRet;
 
    if( !pArea->fShared )
    {
-      fRet = TRUE;
+      fRet = HB_TRUE;
    }
    else
    {
@@ -193,7 +193,7 @@ static BOOL hb_fptFileLockSh( FPTAREAP pArea, BOOL fWait )
 /*
  * Unlock memo file.
  */
-static BOOL hb_fptFileUnLock( FPTAREAP pArea )
+static HB_BOOL hb_fptFileUnLock( FPTAREAP pArea )
 {
    return !pArea->fShared || hb_fileLock( pArea->pMemoFile, FPT_LOCKPOS, FPT_LOCKSIZE, FL_UNLOCK );
 }
@@ -201,7 +201,7 @@ static BOOL hb_fptFileUnLock( FPTAREAP pArea )
 /*
  * Check if MEMO file has direct access to data
  */
-static BOOL hb_fptHasDirectAccess( FPTAREAP pArea )
+static HB_BOOL hb_fptHasDirectAccess( FPTAREAP pArea )
 {
    return pArea->bMemoType == DB_MEMO_FPT &&
           ( pArea->uiMemoVersion == DB_MEMOVER_FLEX ||
@@ -211,12 +211,12 @@ static BOOL hb_fptHasDirectAccess( FPTAREAP pArea )
 /*
  * Lock root block pointer.
  */
-static BOOL hb_fptRootBlockLock( FPTAREAP pArea )
+static HB_BOOL hb_fptRootBlockLock( FPTAREAP pArea )
 {
-   BOOL fRet;
+   HB_BOOL fRet;
 
    if( !pArea->fShared )
-      fRet = TRUE;
+      fRet = HB_TRUE;
    else
       fRet = hb_fileLock( pArea->pMemoFile, FPT_ROOTBLOCK_OFFSET, 4,
                           FL_LOCK | FLX_EXCLUSIVE );
@@ -226,7 +226,7 @@ static BOOL hb_fptRootBlockLock( FPTAREAP pArea )
 /*
  * Unlock root block pointer.
  */
-static BOOL hb_fptRootBlockUnLock( FPTAREAP pArea )
+static HB_BOOL hb_fptRootBlockUnLock( FPTAREAP pArea )
 {
    return !pArea->fShared ||
           hb_fileLock( pArea->pMemoFile, FPT_ROOTBLOCK_OFFSET, 4, FL_UNLOCK );
@@ -348,7 +348,7 @@ static HB_ERRCODE hb_fptPutRootBlock( FPTAREAP pArea, ULONG ulBlock )
 static void hb_fptSortGCitems( LPMEMOGCTABLE pGCtable )
 {
    ULONG ulOffset, ulSize;
-   BOOL fChanged, fMoved = TRUE;
+   HB_BOOL fChanged, fMoved = HB_TRUE;
    int i, j, l;
 
    /* this table should be allready quite good sorted so this simple
@@ -357,7 +357,7 @@ static void hb_fptSortGCitems( LPMEMOGCTABLE pGCtable )
    l = pGCtable->usItems - 1;
    while( fMoved )
    {
-      fMoved = FALSE;
+      fMoved = HB_FALSE;
       j = l;
       for( i = 0; i < j; i++ )
       {
@@ -372,7 +372,7 @@ static void hb_fptSortGCitems( LPMEMOGCTABLE pGCtable )
             pGCtable->pGCitems[ i ].ulSize   = ulSize;
             pGCtable->pGCitems[ i ].ulOffset = ulOffset;
             pGCtable->pGCitems[ i ].fChanged = fChanged;
-            fMoved = TRUE;
+            fMoved = HB_TRUE;
             pGCtable->bChanged |= 2;
             l = i;
          }
@@ -410,7 +410,7 @@ static void hb_fptPackGCitems( LPMEMOGCTABLE pGCtable )
                if( ulEnd == pGCtable->pGCitems[j].ulOffset )
                {
                   pGCtable->pGCitems[i].ulSize  += pGCtable->pGCitems[j].ulSize;
-                  pGCtable->pGCitems[i].fChanged = TRUE;
+                  pGCtable->pGCitems[i].fChanged = HB_TRUE;
                   pGCtable->pGCitems[j].ulOffset = pGCtable->pGCitems[j].ulSize = 0;
                   pGCtable->bChanged |= 2;
                   i = -1;
@@ -487,9 +487,9 @@ static HB_ERRCODE hb_fptWriteGCitems( FPTAREAP pArea, LPMEMOGCTABLE pGCtable, US
             {
                errCode = EDBF_WRITE;
             }
-            pArea->fMemoFlush = TRUE;
+            pArea->fMemoFlush = HB_TRUE;
          }
-         pGCtable->pGCitems[i].fChanged = FALSE;
+         pGCtable->pGCitems[i].fChanged = HB_FALSE;
       }
    }
    return errCode;
@@ -499,7 +499,7 @@ static HB_ERRCODE hb_fptWriteGCitems( FPTAREAP pArea, LPMEMOGCTABLE pGCtable, US
  * Add new block to GC free memo blocks list.
  */
 static HB_ERRCODE hb_fptGCfreeBlock( FPTAREAP pArea, LPMEMOGCTABLE pGCtable,
-                                     ULONG ulOffset, ULONG ulByteSize, BOOL fRaw )
+                                     ULONG ulOffset, ULONG ulByteSize, HB_BOOL fRaw )
 {
    HB_ERRCODE errCode = HB_SUCCESS;
    ULONG ulSize;
@@ -542,7 +542,7 @@ static HB_ERRCODE hb_fptGCfreeBlock( FPTAREAP pArea, LPMEMOGCTABLE pGCtable,
    }
    else
    {
-      BOOL fChanged = FALSE;
+      HB_BOOL fChanged = HB_FALSE;
       int i;
 
       for( i = 0; i < pGCtable->usItems; i++ )
@@ -551,14 +551,14 @@ static HB_ERRCODE hb_fptGCfreeBlock( FPTAREAP pArea, LPMEMOGCTABLE pGCtable,
          {
             ulOffset = pGCtable->pGCitems[i].ulOffset;
             ulSize   = pGCtable->pGCitems[i].ulSize += ulSize;
-            fChanged = pGCtable->pGCitems[i].fChanged = TRUE;
+            fChanged = pGCtable->pGCitems[i].fChanged = HB_TRUE;
             break;
          }
          if( pGCtable->pGCitems[i].ulOffset == ulOffset + ulSize )
          {
             pGCtable->pGCitems[i].ulOffset = ulOffset;
             ulSize   = pGCtable->pGCitems[i].ulSize += ulSize;
-            fChanged = pGCtable->pGCitems[i].fChanged = TRUE;
+            fChanged = pGCtable->pGCitems[i].fChanged = HB_TRUE;
             break;
          }
       }
@@ -572,7 +572,7 @@ static HB_ERRCODE hb_fptGCfreeBlock( FPTAREAP pArea, LPMEMOGCTABLE pGCtable,
             }
             pGCtable->pGCitems[ pGCtable->usItems ].ulOffset = ulOffset;
             pGCtable->pGCitems[ pGCtable->usItems ].ulSize = ulSize;
-            pGCtable->pGCitems[ pGCtable->usItems ].fChanged = fChanged = TRUE;
+            pGCtable->pGCitems[ pGCtable->usItems ].fChanged = fChanged = HB_TRUE;
             pGCtable->usItems++;
          }
          else if( pGCtable->pGCitems[ 0 ].ulSize < ulSize )
@@ -588,7 +588,7 @@ static HB_ERRCODE hb_fptGCfreeBlock( FPTAREAP pArea, LPMEMOGCTABLE pGCtable,
             }
             pGCtable->pGCitems[ 0 ].ulOffset = ulOffset;
             pGCtable->pGCitems[ 0 ].ulSize = ulSize;
-            pGCtable->pGCitems[ 0 ].fChanged = fChanged = TRUE;
+            pGCtable->pGCitems[ 0 ].fChanged = fChanged = HB_TRUE;
          }
       }
 
@@ -607,10 +607,10 @@ static HB_ERRCODE hb_fptGCfreeBlock( FPTAREAP pArea, LPMEMOGCTABLE pGCtable,
  * Get free memo block from GC free memo blocks list or allocate new one.
  */
 static HB_ERRCODE hb_fptGCgetFreeBlock( FPTAREAP pArea, LPMEMOGCTABLE pGCtable,
-                                     ULONG * ulOffset, ULONG ulByteSize,
-                                     BOOL fRaw )
+                                        ULONG * ulOffset, ULONG ulByteSize,
+                                        HB_BOOL fRaw )
 {
-   BOOL fAlloc = FALSE;
+   HB_BOOL fAlloc = HB_FALSE;
    ULONG ulSize;
    int i;
 
@@ -654,11 +654,11 @@ static HB_ERRCODE hb_fptGCgetFreeBlock( FPTAREAP pArea, LPMEMOGCTABLE pGCtable,
          }
          else
          {
-            pGCtable->pGCitems[i].fChanged = TRUE;
+            pGCtable->pGCitems[i].fChanged = HB_TRUE;
             hb_fptSortGCitems( pGCtable );
          }
          pGCtable->bChanged |= 2;
-         fAlloc = TRUE;
+         fAlloc = HB_TRUE;
          break;
       }
    }
@@ -729,7 +729,7 @@ static HB_ERRCODE hb_fptReadGCdata( FPTAREAP pArea, LPMEMOGCTABLE pGCtable )
          {
             pGCtable->pGCitems[i].ulSize = HB_GET_LE_UINT16( &pGCtable->fptHeader.reserved2[ i * 6 ] );
             pGCtable->pGCitems[i].ulOffset = HB_GET_LE_UINT32( &pGCtable->fptHeader.reserved2[ i * 6 + 2 ] );
-            pGCtable->pGCitems[i].fChanged = FALSE;
+            pGCtable->pGCitems[i].fChanged = HB_FALSE;
          }
       }
       else if( pArea->bMemoType == DB_MEMO_FPT &&
@@ -775,7 +775,7 @@ static HB_ERRCODE hb_fptReadGCdata( FPTAREAP pArea, LPMEMOGCTABLE pGCtable )
                                                       pArea->ulMemoBlockSize;
                pGCtable->pGCitems[i].ulSize = HB_GET_LE_UINT32( &bPageBuf[ i * 8 + 6 ] ) /
                                                       pArea->ulMemoBlockSize;
-               pGCtable->pGCitems[i].fChanged = FALSE;
+               pGCtable->pGCitems[i].fChanged = HB_FALSE;
             }
             hb_xfree( bPageBuf );
          }
@@ -844,12 +844,12 @@ static HB_ERRCODE hb_fptWriteGCdata( FPTAREAP pArea, LPMEMOGCTABLE pGCtable )
          {
             pGCtable->ulSize = FLEXGCPAGE_SIZE;
             errCode = hb_fptGCgetFreeBlock( pArea, pGCtable,
-                                &pGCtable->ulDirPage, pGCtable->ulSize, FALSE );
+                                &pGCtable->ulDirPage, pGCtable->ulSize, HB_FALSE );
             if( errCode == HB_SUCCESS )
             {
                pGCtable->ulDirPage *= pArea->ulMemoBlockSize;
                errCode = hb_fptGCgetFreeBlock( pArea, pGCtable,
-                                &pGCtable->ulRevPage, pGCtable->ulSize, FALSE );
+                                &pGCtable->ulRevPage, pGCtable->ulSize, HB_FALSE );
                pGCtable->ulRevPage *= pArea->ulMemoBlockSize;
             }
             pGCtable->bChanged |= 2;
@@ -929,7 +929,7 @@ static HB_ERRCODE hb_fptWriteGCdata( FPTAREAP pArea, LPMEMOGCTABLE pGCtable )
             hb_fileTruncAt( pArea->pMemoFile, FPT_BLOCK_OFFSET( pGCtable->ulNextBlock ) );
          }
       }
-      pArea->fMemoFlush = TRUE;
+      pArea->fMemoFlush = HB_TRUE;
       pGCtable->bChanged = 0;
    }
    return errCode;
@@ -1090,7 +1090,7 @@ static const char * hb_fptGetMemoType( FPTAREAP pArea, USHORT uiIndex )
  * Calculate the size of SMT memo item
  */
 static ULONG hb_fptCountSMTItemLength( FPTAREAP pArea, PHB_ITEM pItem,
-                                       ULONG * pulArrayCount, BOOL fTrans )
+                                       ULONG * pulArrayCount, HB_BOOL fTrans )
 {
    ULONG ulLen, u, ulSize;
 
@@ -1210,7 +1210,7 @@ static HB_ERRCODE hb_fptCountSMTDataLength( FPTAREAP pArea, HB_FOFFSET * pfOffse
 /*
  * Write VM item as SMT memos.
  */
-static ULONG hb_fptStoreSMTItem( FPTAREAP pArea, PHB_ITEM pItem, BYTE ** bBufPtr, BOOL fTrans )
+static ULONG hb_fptStoreSMTItem( FPTAREAP pArea, PHB_ITEM pItem, BYTE ** bBufPtr, HB_BOOL fTrans )
 {
    ULONG ulLen, u, ulSize = 0;
    HB_LONG iVal;
@@ -1305,7 +1305,7 @@ static ULONG hb_fptStoreSMTItem( FPTAREAP pArea, PHB_ITEM pItem, BYTE ** bBufPtr
 /*
  * Read SMT item from file
  */
-static HB_ERRCODE hb_fptReadRawSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_FOFFSET *pfOffset, BOOL fTrans )
+static HB_ERRCODE hb_fptReadRawSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_FOFFSET *pfOffset, HB_BOOL fTrans )
 {
    ULONG ulLen, u;
    BYTE buffer[ 10 ];
@@ -1402,7 +1402,7 @@ static HB_ERRCODE hb_fptReadRawSMTItem( FPTAREAP pArea, PHB_ITEM pItem, HB_FOFFS
 /*
  * Read SMT item from memory buffer.
  */
-static HB_ERRCODE hb_fptReadSMTItem( FPTAREAP pArea, BYTE ** pbMemoBuf, BYTE * bBufEnd, PHB_ITEM pItem, BOOL fTrans )
+static HB_ERRCODE hb_fptReadSMTItem( FPTAREAP pArea, BYTE ** pbMemoBuf, BYTE * bBufEnd, PHB_ITEM pItem, HB_BOOL fTrans )
 {
    ULONG ulLen, u;
    HB_ERRCODE errCode = HB_SUCCESS;
@@ -1526,7 +1526,7 @@ static HB_ERRCODE hb_fptReadSMTItem( FPTAREAP pArea, BYTE ** pbMemoBuf, BYTE * b
  * Calculate the size of SIX memo item
  */
 static ULONG hb_fptCountSixItemLength( FPTAREAP pArea, PHB_ITEM pItem,
-                                       ULONG * pulArrayCount, BOOL fTrans )
+                                       ULONG * pulArrayCount, HB_BOOL fTrans )
 {
    ULONG ulLen, u, ulSize;
 
@@ -1579,7 +1579,7 @@ static ULONG hb_fptCountSixItemLength( FPTAREAP pArea, PHB_ITEM pItem,
 /*
  * Write fpt vartype as SIX memos.
  */
-static ULONG hb_fptStoreSixItem( FPTAREAP pArea, PHB_ITEM pItem, BYTE ** bBufPtr, BOOL fTrans )
+static ULONG hb_fptStoreSixItem( FPTAREAP pArea, PHB_ITEM pItem, BYTE ** bBufPtr, HB_BOOL fTrans )
 {
    ULONG ulLen, u, ulSize;
    HB_LONG iVal;
@@ -1689,7 +1689,7 @@ static ULONG hb_fptStoreSixItem( FPTAREAP pArea, PHB_ITEM pItem, BYTE ** bBufPtr
 /*
  * Read SIX item from memo.
  */
-static HB_ERRCODE hb_fptReadSixItem( FPTAREAP pArea, BYTE ** pbMemoBuf, BYTE * bBufEnd, PHB_ITEM pItem, BOOL fTrans )
+static HB_ERRCODE hb_fptReadSixItem( FPTAREAP pArea, BYTE ** pbMemoBuf, BYTE * bBufEnd, PHB_ITEM pItem, HB_BOOL fTrans )
 {
    USHORT usType;
    ULONG ulLen, u;
@@ -1791,7 +1791,7 @@ static HB_ERRCODE hb_fptReadSixItem( FPTAREAP pArea, BYTE ** pbMemoBuf, BYTE * b
  * Calculate the size of FLEX memo item
  */
 static ULONG hb_fptCountFlexItemLength( FPTAREAP pArea, PHB_ITEM pItem,
-                                        ULONG * pulArrayCount, BOOL fTrans )
+                                        ULONG * pulArrayCount, HB_BOOL fTrans )
 {
    ULONG ulLen, u, ulSize = 1;
    HB_LONG iVal;
@@ -1844,7 +1844,7 @@ static ULONG hb_fptCountFlexItemLength( FPTAREAP pArea, PHB_ITEM pItem,
 /*
  * Store in buffer fpt vartype as FLEX memos.
  */
-static void hb_fptStoreFlexItem( FPTAREAP pArea, PHB_ITEM pItem, BYTE ** bBufPtr, BOOL fTrans )
+static void hb_fptStoreFlexItem( FPTAREAP pArea, PHB_ITEM pItem, BYTE ** bBufPtr, HB_BOOL fTrans )
 {
    ULONG ulLen, u;
    HB_LONG iVal;
@@ -1956,7 +1956,7 @@ static void hb_fptStoreFlexItem( FPTAREAP pArea, PHB_ITEM pItem, BYTE ** bBufPtr
 /*
  * Read FLEX item from memo.
  */
-static HB_ERRCODE hb_fptReadFlexItem( FPTAREAP pArea, BYTE ** pbMemoBuf, BYTE * bBufEnd, PHB_ITEM pItem, BOOL bRoot, BOOL fTrans )
+static HB_ERRCODE hb_fptReadFlexItem( FPTAREAP pArea, BYTE ** pbMemoBuf, BYTE * bBufEnd, PHB_ITEM pItem, HB_BOOL bRoot, HB_BOOL fTrans )
 {
    BYTE usType;
    ULONG ulLen, i;
@@ -1980,10 +1980,10 @@ static HB_ERRCODE hb_fptReadFlexItem( FPTAREAP pArea, BYTE ** pbMemoBuf, BYTE *
          hb_itemClear( pItem );
          break;
       case FPTIT_FLEXAR_TRUE:
-         hb_itemPutL( pItem, TRUE );
+         hb_itemPutL( pItem, HB_TRUE );
          break;
       case FPTIT_FLEXAR_FALSE:
-         hb_itemPutL( pItem, FALSE );
+         hb_itemPutL( pItem, HB_FALSE );
          break;
       case FPTIT_FLEXAR_LOGIC:
          if( bBufEnd - (*pbMemoBuf) >= 1 )
@@ -2319,7 +2319,7 @@ static HB_ERRCODE hb_fptReadFlexItem( FPTAREAP pArea, BYTE ** pbMemoBuf, BYTE *
                for( i = 1; i <= ulLen; i++ )
                {
                   errCode = hb_fptReadFlexItem( pArea, pbMemoBuf, bBufEnd,
-                                    hb_arrayGetItemPtr( pItem, i ), FALSE, fTrans );
+                                    hb_arrayGetItemPtr( pItem, i ), HB_FALSE, fTrans );
                   if( errCode != HB_SUCCESS )
                   {
                      break;
@@ -2481,7 +2481,7 @@ static HB_ERRCODE hb_fptReadBlobBlock( FPTAREAP pArea, PHB_ITEM pItem,
 }
 
 static HB_ERRCODE hb_fptReadSMTBlock( FPTAREAP pArea, PHB_ITEM pItem,
-                                      ULONG ulBlock, ULONG ulSize, BOOL fTrans )
+                                      ULONG ulBlock, ULONG ulSize, HB_BOOL fTrans )
 {
    if( ulBlock == 0 )
       return EDBF_CORRUPT;
@@ -2522,7 +2522,7 @@ static HB_ERRCODE hb_fptReadSMTBlock( FPTAREAP pArea, PHB_ITEM pItem,
  */
 static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, USHORT uiIndex, PHB_ITEM pItem,
                                  HB_FHANDLE hFile, ULONG ulBlock, ULONG ulStart,
-                                 ULONG ulCount, BOOL fTrans )
+                                 ULONG ulCount, HB_BOOL fTrans )
 {
    HB_ERRCODE errCode;
    ULONG ulSize = 0, ulType = 0;
@@ -2681,16 +2681,16 @@ static HB_ERRCODE hb_fptGetMemo( FPTAREAP pArea, USHORT uiIndex, PHB_ITEM pItem,
                break;
             case FPTIT_FLEX_ARRAY:
                bMemoBuf = ( BYTE * ) pBuffer;
-               errCode = hb_fptReadFlexItem( pArea, &bMemoBuf, bMemoBuf + ulSize, pItem, TRUE, fTrans );
+               errCode = hb_fptReadFlexItem( pArea, &bMemoBuf, bMemoBuf + ulSize, pItem, HB_TRUE, fTrans );
                break;
             case FPTIT_FLEX_NIL:
                hb_itemClear( pItem );
                break;
             case FPTIT_FLEX_TRUE:
-               hb_itemPutL( pItem, TRUE );
+               hb_itemPutL( pItem, HB_TRUE );
                break;
             case FPTIT_FLEX_FALSE:
-               hb_itemPutL( pItem, FALSE );
+               hb_itemPutL( pItem, HB_FALSE );
                break;
             case FPTIT_FLEX_LDATE:
                hb_itemPutDL( pItem, ( long ) HB_GET_LE_UINT32( pBuffer ) );
@@ -2762,7 +2762,7 @@ static HB_ERRCODE hb_fptWriteMemo( FPTAREAP pArea, ULONG ulBlock, ULONG ulSize,
 {
    MEMOGCTABLE fptGCtable;
    HB_ERRCODE errCode;
-   BOOL bWrite;
+   HB_BOOL bWrite;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_fptWriteMemo(%p, %lu, %lu, %p, %p, %lu, %lu, %p)",
          pArea, ulBlock, ulSize, bBufPtr, ( void * ) ( HB_PTRDIFF ) hFile, ulType, ulLen, pulStoredBlock));
@@ -2874,7 +2874,7 @@ static HB_ERRCODE hb_fptWriteMemo( FPTAREAP pArea, ULONG ulBlock, ULONG ulSize,
                             FPT_BLOCK_OFFSET( *pulStoredBlock + ulBlocks ) - 1 );
          }
       }
-      pArea->fMemoFlush = TRUE;
+      pArea->fMemoFlush = HB_TRUE;
    }
    else
    {
@@ -2894,7 +2894,7 @@ static HB_ERRCODE hb_fptWriteMemo( FPTAREAP pArea, ULONG ulBlock, ULONG ulSize,
  * Assign a value to the specified memo field.
  */
 static HB_ERRCODE hb_fptPutMemo( FPTAREAP pArea, USHORT uiIndex, PHB_ITEM pItem,
-                                 ULONG * pulBlock, BOOL fTrans )
+                                 ULONG * pulBlock, HB_BOOL fTrans )
 {
    ULONG ulBlock = 0, ulSize, ulType, ulOldSize = 0, ulOldType = 0, ulArrayCount = 0;
    BYTE itmBuffer[FLEX_ITEM_BUFSIZE];
@@ -3077,7 +3077,7 @@ static HB_ERRCODE hb_fptPutMemo( FPTAREAP pArea, USHORT uiIndex, PHB_ITEM pItem,
 /*
  * Check if memo field has any data
  */
-static BOOL hb_fptHasMemoData( FPTAREAP pArea, USHORT uiIndex )
+static HB_BOOL hb_fptHasMemoData( FPTAREAP pArea, USHORT uiIndex )
 {
    if( --uiIndex < pArea->area.uiFieldCount )
    {
@@ -3096,7 +3096,7 @@ static BOOL hb_fptHasMemoData( FPTAREAP pArea, USHORT uiIndex )
                case HB_VF_BLOB:
                case HB_VF_BLOBCOMPRESS:
                case HB_VF_BLOBENCRYPT:
-                  return TRUE;
+                  return HB_TRUE;
                case HB_VF_DNUM:
                   return pField->uiLen <= 12;
                default:
@@ -3121,23 +3121,23 @@ static BOOL hb_fptHasMemoData( FPTAREAP pArea, USHORT uiIndex )
             do
             {
                if( *pFieldBuf >= '1' && *pFieldBuf <= '9' )
-                  return TRUE;
+                  return HB_TRUE;
                ++pFieldBuf;
             }
             while( --uiLen );
          }
       }
    }
-   return FALSE;
+   return HB_FALSE;
 }
 #endif
 
-static HB_ERRCODE hb_fptLockForRead( FPTAREAP pArea, USHORT uiIndex, BOOL *fUnLock )
+static HB_ERRCODE hb_fptLockForRead( FPTAREAP pArea, USHORT uiIndex, HB_BOOL *fUnLock )
 {
    HB_ERRCODE errCode;
-   BOOL fLocked;
+   HB_BOOL fLocked;
 
-   *fUnLock = FALSE;
+   *fUnLock = HB_FALSE;
 #ifdef HB_MEMO_SAFELOCK
    if( pArea->lpdbPendingRel )
    {
@@ -3151,7 +3151,7 @@ static HB_ERRCODE hb_fptLockForRead( FPTAREAP pArea, USHORT uiIndex, BOOL *fUnLo
        !pArea->fPositioned || !pArea->fShared ||
        pArea->fFLocked || pArea->fRecordChanged )
    {
-      fLocked = TRUE;
+      fLocked = HB_TRUE;
    }
    else
    {
@@ -3170,11 +3170,11 @@ static HB_ERRCODE hb_fptLockForRead( FPTAREAP pArea, USHORT uiIndex, BOOL *fUnLo
       if( !pArea->fValidBuffer || uiIndex == 0 ||
           hb_fptHasMemoData( pArea, uiIndex ) )
       {
-         if( !hb_fptFileLockSh( pArea, TRUE ) )
+         if( !hb_fptFileLockSh( pArea, HB_TRUE ) )
             return HB_FAILURE;
 
-         *fUnLock = TRUE;
-         pArea->fValidBuffer = FALSE;
+         *fUnLock = HB_TRUE;
+         pArea->fValidBuffer = HB_FALSE;
       }
    }
 #else
@@ -3191,7 +3191,7 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, USHORT uiIndex, PHB_ITEM pI
    LPFIELD pField;
    HB_ERRCODE errCode;
    BYTE * pFieldBuf;
-   BOOL fUnLock = FALSE;
+   HB_BOOL fUnLock = HB_FALSE;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_fptGetVarField(%p, %hu, %p, %p)", pArea, uiIndex, pItem, ( void * ) ( HB_PTRDIFF ) hFile));
 
@@ -3367,7 +3367,7 @@ static HB_ERRCODE hb_fptGetVarField( FPTAREAP pArea, USHORT uiIndex, PHB_ITEM pI
    return errCode;
 }
 
-static HB_ERRCODE hb_fptGetVarFile( FPTAREAP pArea, ULONG ulBlock, const char * szFile, USHORT uiMode, BOOL fTrans )
+static HB_ERRCODE hb_fptGetVarFile( FPTAREAP pArea, ULONG ulBlock, const char * szFile, USHORT uiMode, HB_BOOL fTrans )
 {
    HB_ERRCODE errCode;
    HB_FHANDLE hFile;
@@ -3429,7 +3429,7 @@ static ULONG hb_fptPutVarFile( FPTAREAP pArea, ULONG ulBlock, const char * szFil
       else
          ulSize = ( ULONG ) HB_MIN( size, ( HB_FOFFSET ) ( 0xFFFFFFFFUL - sizeof( FPTBLOCK ) ) );
 
-      if( hb_fptFileLockEx( pArea, TRUE ) )
+      if( hb_fptFileLockEx( pArea, HB_TRUE ) )
       {
          errCode = hb_fptWriteMemo( pArea, ulBlock, 0, NULL, hFile,
                                     0, ulSize, &ulBlock );
@@ -3469,7 +3469,7 @@ static HB_ERRCODE hb_fptPutVarField( FPTAREAP pArea, USHORT uiIndex, PHB_ITEM pI
    {
       BYTE * pFieldBuf = pArea->pRecord + pArea->pFieldOffset[ uiIndex - 1 ];
       HB_ERRCODE errCode;
-      BOOL bDeleted;
+      HB_BOOL bDeleted;
 
       /* update any pending relations and reread record if necessary */
       errCode = SELF_DELETED( ( AREAP ) pArea, &bDeleted );
@@ -3489,7 +3489,7 @@ static HB_ERRCODE hb_fptPutVarField( FPTAREAP pArea, USHORT uiIndex, PHB_ITEM pI
 
       if( pField->uiType != HB_FT_ANY )
       {
-         if( !hb_fptFileLockEx( pArea, TRUE ) )
+         if( !hb_fptFileLockEx( pArea, HB_TRUE ) )
             return EDBF_LOCK;
          errCode = hb_fptPutMemo( pArea, uiIndex, pItem, NULL,
                                   ( pField->uiFlags & HB_FF_BINARY ) == 0 &&
@@ -3640,7 +3640,7 @@ static HB_ERRCODE hb_fptPutVarField( FPTAREAP pArea, USHORT uiIndex, PHB_ITEM pI
          else if( HB_IS_ARRAY( pItem ) )
          {
             ULONG ulArrayCount = 0;
-            BOOL fTrans = ( pField->uiFlags & HB_FF_BINARY ) == 0 &&
+            HB_BOOL fTrans = ( pField->uiFlags & HB_FF_BINARY ) == 0 &&
                           hb_vmCDP() != pArea->area.cdPage;
             ulNewSize = hb_fptCountSMTItemLength( pArea, pItem, &ulArrayCount, fTrans );
             pBlock = pAlloc = ( BYTE * ) hb_xgrab( ulNewSize );
@@ -3658,7 +3658,7 @@ static HB_ERRCODE hb_fptPutVarField( FPTAREAP pArea, USHORT uiIndex, PHB_ITEM pI
             HB_PUT_LE_UINT32( pFieldBuf + pField->uiLen - 6, 0 );
          if( ulOldBlock != 0 || ulNewSize != 0 )
          {
-            if( !hb_fptFileLockEx( pArea, TRUE ) )
+            if( !hb_fptFileLockEx( pArea, HB_TRUE ) )
             {
                errCode = EDBF_LOCK;
             }
@@ -3725,7 +3725,7 @@ static HB_ERRCODE hb_fptGetVarLen( FPTAREAP pArea, USHORT uiIndex, ULONG * pLeng
          pArea->area.lpFields[ uiIndex - 1 ].uiType == HB_FT_OLE ) )
    {
       HB_ERRCODE errCode;
-      BOOL fUnLock;
+      HB_BOOL fUnLock;
 
       errCode = hb_fptLockForRead( pArea, uiIndex, &fUnLock );
       if( errCode == HB_SUCCESS )
@@ -3807,7 +3807,7 @@ static HB_ERRCODE hb_fptCreateMemFile( FPTAREAP pArea, LPDBOPENINFO pCreateInfo
       char szFileName[ HB_PATH_MAX ];
       PHB_FNAME pFileName;
       PHB_ITEM pError = NULL, pItem = NULL;
-      BOOL bRetry;
+      HB_BOOL bRetry;
 
       if( !pArea->bMemoType )
       {
@@ -3911,7 +3911,7 @@ static HB_ERRCODE hb_fptCreateMemFile( FPTAREAP pArea, LPDBOPENINFO pCreateInfo
             bRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
          }
          else
-            bRetry = FALSE;
+            bRetry = HB_FALSE;
       } while( bRetry );
 
       if( pError )
@@ -3974,7 +3974,7 @@ static HB_ERRCODE hb_fptCreateMemFile( FPTAREAP pArea, LPDBOPENINFO pCreateInfo
    }
    /* trunc file */
    hb_fileTruncAt( pArea->pMemoFile, ulSize );
-   pArea->fMemoFlush = TRUE;
+   pArea->fMemoFlush = HB_TRUE;
    return HB_SUCCESS;
 }
 
@@ -4044,7 +4044,7 @@ static HB_ERRCODE hb_fptOpenMemFile( FPTAREAP pArea, LPDBOPENINFO pOpenInfo )
    PHB_FNAME pFileName;
    PHB_ITEM pError;
    USHORT uiFlags;
-   BOOL bRetry;
+   HB_BOOL bRetry;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_fptOpenMemFile(%p, %p)", pArea, pOpenInfo));
 
@@ -4103,7 +4103,7 @@ static HB_ERRCODE hb_fptOpenMemFile( FPTAREAP pArea, LPDBOPENINFO pOpenInfo )
          bRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
       }
       else
-         bRetry = FALSE;
+         bRetry = HB_FALSE;
    } while( bRetry );
 
    if( pError )
@@ -4122,7 +4122,7 @@ static HB_ERRCODE hb_fptOpenMemFile( FPTAREAP pArea, LPDBOPENINFO pOpenInfo )
    {
       FPTHEADER fptHeader;
       memset( &fptHeader, 0, sizeof( FPTHEADER ) );
-      if( hb_fptFileLockSh( pArea, TRUE ) )
+      if( hb_fptFileLockSh( pArea, HB_TRUE ) )
       {
          if( hb_fileReadAt( pArea->pMemoFile, &fptHeader,
                             sizeof( FPTHEADER ), 0 ) >= 512 )
@@ -4198,7 +4198,7 @@ static HB_ERRCODE hb_fptPutValueFile( FPTAREAP pArea, USHORT uiIndex, const char
          ( pField->uiType == HB_FT_ANY && pField->uiLen >= 6 ) ) )
    {
       HB_ERRCODE errCode;
-      BOOL bDeleted;
+      HB_BOOL bDeleted;
       HB_FHANDLE hFile;
 
       /* update any pending relations and reread record if necessary */
@@ -4245,7 +4245,7 @@ static HB_ERRCODE hb_fptPutValueFile( FPTAREAP pArea, USHORT uiIndex, const char
             hb_itemRelease( pItem );
          }
       }
-      else if( !hb_fptFileLockEx( pArea, TRUE ) )
+      else if( !hb_fptFileLockEx( pArea, HB_TRUE ) )
       {
          hb_fsClose( hFile );
          errCode = EDBF_LOCK;
@@ -4466,13 +4466,13 @@ static HB_ERRCODE hb_fptDoPack( FPTAREAP pArea, USHORT uiBlockSize,
                if( pEvalBlock )
                {
                   SELF_GOTO( ( AREAP ) pArea, 0 );
-                  pArea->area.fEof = FALSE;
+                  pArea->area.fEof = HB_FALSE;
                   hb_vmEvalBlock( pEvalBlock );
                }
 
                for( ulRecNo = 1; ulRecNo <= ulRecords; ++ulRecNo )
                {
-                  BOOL fDeleted;
+                  HB_BOOL fDeleted;
 
                   errCode = SELF_GOTO( ( AREAP ) pArea, ulRecNo );
                   if( errCode != HB_SUCCESS )
@@ -4501,7 +4501,7 @@ static HB_ERRCODE hb_fptDoPack( FPTAREAP pArea, USHORT uiBlockSize,
                if( errCode == HB_SUCCESS && pEvalBlock )
                {
                   SELF_GOTO( ( AREAP ) pArea, 0 );
-                  pArea->area.fBof = FALSE;
+                  pArea->area.fBof = HB_FALSE;
                   hb_vmEvalBlock( pEvalBlock );
                }
             }
@@ -4549,7 +4549,7 @@ static HB_ERRCODE hb_fptDoPack( FPTAREAP pArea, USHORT uiBlockSize,
  * Pack helper function called for each packed record
  * ( DBENTRYP_LSP )   hb_fptPackRec,
  */
-static HB_ERRCODE hb_fptPackRec( FPTAREAP pArea, ULONG ulRecNo, BOOL *pfWritten )
+static HB_ERRCODE hb_fptPackRec( FPTAREAP pArea, ULONG ulRecNo, HB_BOOL *pfWritten )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_fptPackRec(%p, %lu, %p)", pArea, ulRecNo, pfWritten));
 
@@ -4601,9 +4601,9 @@ static HB_ERRCODE hb_fptPack( FPTAREAP pArea )
 
          if( errCode == HB_SUCCESS )
          {
-            pArea->fPackMemo = TRUE;
+            pArea->fPackMemo = HB_TRUE;
             errCode = SUPER_PACK( ( AREAP ) pArea );
-            pArea->fPackMemo = FALSE;
+            pArea->fPackMemo = HB_FALSE;
             if( errCode == HB_SUCCESS )
             {
                HB_FOFFSET size = hb_fileSize( pArea->pMemoTmpFile );
@@ -4790,7 +4790,7 @@ static HB_ERRCODE hb_fptInfo( FPTAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
             ulBlock = hb_arrayGetNL( pItem, 1 );
             if( pValue )
             {
-               if( hb_fptFileLockEx( pArea, TRUE ) )
+               if( hb_fptFileLockEx( pArea, HB_TRUE ) )
                {
                   errCode = hb_fptPutMemo( pArea, 0, pValue, &ulBlock, FPT_DIRECT_TRANS( pArea ) );
                   hb_fptFileUnLock( pArea );
@@ -4835,7 +4835,7 @@ static HB_ERRCODE hb_fptInfo( FPTAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
          errCode = hb_fptGetRootBlock( pArea, &ulBlock );
          if( errCode == HB_SUCCESS )
          {
-            if( hb_fptFileLockEx( pArea, TRUE ) )
+            if( hb_fptFileLockEx( pArea, HB_TRUE ) )
             {
                errCode = hb_fptPutMemo( pArea, 0, pItem, &ulBlock, FPT_DIRECT_TRANS( pArea ) );
                hb_fptFileUnLock( pArea );
@@ -4849,10 +4849,10 @@ static HB_ERRCODE hb_fptInfo( FPTAREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
          {
             if( errCode != HB_FAILURE )
                hb_memoErrorRT( pArea, 0, errCode, pArea->szMemoFileName, 0, 0 );
-            hb_itemPutL( pItem, FALSE );
+            hb_itemPutL( pItem, HB_FALSE );
             return HB_FAILURE;
          }
-         hb_itemPutL( pItem, TRUE );
+         hb_itemPutL( pItem, HB_TRUE );
          break;
       }
       case DBI_BLOB_ROOT_LOCK:      /* BLOBRootLock() */
@@ -4896,7 +4896,7 @@ static HB_ERRCODE hb_fptFieldInfo( FPTAREAP pArea, USHORT uiIndex, USHORT uiType
          pArea->area.lpFields[ uiIndex - 1 ].uiType == HB_FT_OLE ) )
    {
       ULONG ulBlock, ulSize, ulType;
-      BOOL bDeleted;
+      HB_BOOL bDeleted;
 
       SELF_DELETED( ( AREAP ) pArea, &bDeleted );
       switch( uiType )
@@ -4906,7 +4906,7 @@ static HB_ERRCODE hb_fptFieldInfo( FPTAREAP pArea, USHORT uiIndex, USHORT uiType
             /* pItem := { <nStart>, <nCount> } */
             ULONG ulStart, ulCount;
             HB_ERRCODE errCode;
-            BOOL fTrans = FPT_DIRECT_TRANS( pArea );
+            HB_BOOL fTrans = FPT_DIRECT_TRANS( pArea );
 
             if( HB_IS_ARRAY( pItem ) )
             {
@@ -4920,7 +4920,7 @@ static HB_ERRCODE hb_fptFieldInfo( FPTAREAP pArea, USHORT uiIndex, USHORT uiType
                ulStart = ulCount = 0;
             }
             if( ulStart || ulCount )
-               fTrans = FALSE;
+               fTrans = HB_FALSE;
             errCode = hb_fptGetMemo( pArea, uiIndex, pItem, FS_ERROR, 0, ulStart, ulCount, fTrans );
             if( errCode != HB_SUCCESS )
             {
@@ -5056,11 +5056,11 @@ static HB_ERRCODE hb_fptRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect
 #if defined( HB_MEMO_SAFELOCK )
          hb_itemPutL( pItem, pRDD->rddID != s_uiRddIdBLOB );
 #else
-         hb_itemPutL( pItem, FALSE );
+         hb_itemPutL( pItem, HB_FALSE );
 #endif
          break;
       case RDDI_MEMOREUSE:
-         hb_itemPutL( pItem, TRUE );
+         hb_itemPutL( pItem, HB_TRUE );
          break;
 
       case RDDI_BLOB_SUPPORT:
diff --git a/harbour/src/rdd/dbfnsx/dbfnsx1.c b/harbour/src/rdd/dbfnsx/dbfnsx1.c
index 89fa3ae16d..c61593c89a 100644
--- a/harbour/src/rdd/dbfnsx/dbfnsx1.c
+++ b/harbour/src/rdd/dbfnsx/dbfnsx1.c
@@ -640,7 +640,7 @@ static USHORT hb_nsxKeyTypeRaw( UCHAR ucType )
  *       for scope key evaluation
  */
 static LPKEYINFO hb_nsxKeyPutItem( LPKEYINFO pKey, PHB_ITEM pItem, ULONG ulRecNo,
-                                   LPTAGINFO pTag, BOOL fTrans, USHORT *puiLen )
+                                   LPTAGINFO pTag, HB_BOOL fTrans, USHORT *puiLen )
 {
    double d;
    ULONG len;
@@ -713,7 +713,7 @@ static LPKEYINFO hb_nsxKeyPutItem( LPKEYINFO pKey, PHB_ITEM pItem, ULONG ulRecNo
  * get Item from index key
  */
 static PHB_ITEM hb_nsxKeyGetItem( PHB_ITEM pItem, LPKEYINFO pKey,
-                                  LPTAGINFO pTag, BOOL fTrans )
+                                  LPTAGINFO pTag, HB_BOOL fTrans )
 {
    double d;
 
@@ -777,7 +777,7 @@ static LPKEYINFO hb_nsxEvalKey( LPKEYINFO pKey, LPTAGINFO pTag )
    {
       pItem = hb_itemNew( NULL );
       SELF_GETVALUE( ( AREAP ) pArea, pTag->nField, pItem );
-      pKey = hb_nsxKeyPutItem( pKey, pItem, pArea->dbfarea.ulRecNo, pTag, FALSE, NULL );
+      pKey = hb_nsxKeyPutItem( pKey, pItem, pArea->dbfarea.ulRecNo, pTag, HB_FALSE, NULL );
       hb_itemRelease( pItem );
    }
    else
@@ -790,7 +790,7 @@ static LPKEYINFO hb_nsxEvalKey( LPKEYINFO pKey, LPTAGINFO pTag )
          iCurrArea = 0;
 
       pItem = hb_vmEvalBlockOrMacro( pTag->pKeyItem );
-      pKey = hb_nsxKeyPutItem( pKey, pItem, pArea->dbfarea.ulRecNo, pTag, FALSE, NULL );
+      pKey = hb_nsxKeyPutItem( pKey, pItem, pArea->dbfarea.ulRecNo, pTag, HB_FALSE, NULL );
 
       if( iCurrArea )
          hb_rddSelectWorkAreaNumber( iCurrArea );
@@ -804,10 +804,10 @@ static LPKEYINFO hb_nsxEvalKey( LPKEYINFO pKey, LPTAGINFO pTag )
 /*
  * evaluate conditional expression and return the logical result
  */
-static BOOL hb_nsxEvalCond( NSXAREAP pArea, PHB_ITEM pCondItem, BOOL fSetWA )
+static HB_BOOL hb_nsxEvalCond( NSXAREAP pArea, PHB_ITEM pCondItem, HB_BOOL fSetWA )
 {
    int iCurrArea = 0;
-   BOOL fRet;
+   HB_BOOL fRet;
 
    if( fSetWA )
    {
@@ -829,12 +829,12 @@ static BOOL hb_nsxEvalCond( NSXAREAP pArea, PHB_ITEM pCondItem, BOOL fSetWA )
 /*
  * evaluate seek/skip block: {|key, rec| ... }
  */
-static BOOL hb_nsxEvalSeekCond( LPTAGINFO pTag, PHB_ITEM pCondItem )
+static HB_BOOL hb_nsxEvalSeekCond( LPTAGINFO pTag, PHB_ITEM pCondItem )
 {
-   BOOL fRet;
+   HB_BOOL fRet;
    PHB_ITEM pKeyVal, pKeyRec;
 
-   pKeyVal = hb_nsxKeyGetItem( NULL, pTag->CurKeyInfo, pTag, TRUE );
+   pKeyVal = hb_nsxKeyGetItem( NULL, pTag->CurKeyInfo, pTag, HB_TRUE );
    pKeyRec = hb_itemPutNInt( NULL, pTag->CurKeyInfo->rec );
 
    fRet = hb_itemGetL( hb_vmEvalBlockV( pCondItem, 2, pKeyVal, pKeyRec ) );
@@ -904,7 +904,7 @@ static int hb_nsxValCompare( LPTAGINFO pTag, UCHAR * val1, int len1,
 /*
  * check if a given key is in top scope
  */
-static BOOL hb_nsxInTopScope( LPTAGINFO pTag, UCHAR * key )
+static HB_BOOL hb_nsxInTopScope( LPTAGINFO pTag, UCHAR * key )
 {
    PHB_NSXSCOPE pScope = pTag->fUsrDescend ? &pTag->bottom : &pTag->top;
 
@@ -915,13 +915,13 @@ static BOOL hb_nsxInTopScope( LPTAGINFO pTag, UCHAR * key )
       return pTag->fUsrDescend ? i >= 0 : i <= 0;
    }
    else
-      return TRUE;
+      return HB_TRUE;
 }
 
 /*
  * check if a given key is in bottom scope
  */
-static BOOL hb_nsxInBottomScope( LPTAGINFO pTag, UCHAR * key )
+static HB_BOOL hb_nsxInBottomScope( LPTAGINFO pTag, UCHAR * key )
 {
    PHB_NSXSCOPE pScope = pTag->fUsrDescend ? &pTag->top : &pTag->bottom;
 
@@ -932,13 +932,13 @@ static BOOL hb_nsxInBottomScope( LPTAGINFO pTag, UCHAR * key )
       return pTag->fUsrDescend ? i <= 0 : i >= 0;
    }
    else
-      return TRUE;
+      return HB_TRUE;
 }
 
 /*
  * check if a given key is in current scope
  */
-static BOOL hb_nsxKeyInScope( LPTAGINFO pTag, LPKEYINFO pKey )
+static HB_BOOL hb_nsxKeyInScope( LPTAGINFO pTag, LPKEYINFO pKey )
 {
    return hb_nsxInTopScope( pTag, pKey->val ) &&
           hb_nsxInBottomScope( pTag, pKey->val );
@@ -994,7 +994,7 @@ static void hb_nsxTagSetScope( LPTAGINFO pTag, USHORT nScope, PHB_ITEM pItem )
    if( hb_nsxKeyTypeCmp( pTag->KeyType ) == hb_nsxKeyTypeCmp( hb_nsxItemType( pScopeVal ) ) )
    {
       PHB_NSXSCOPE pScope;
-      BOOL fTop = ( nScope == 0 );
+      HB_BOOL fTop = ( nScope == 0 );
 
       if( pTag->fUsrDescend )
          fTop = !fTop;
@@ -1003,7 +1003,7 @@ static void hb_nsxTagSetScope( LPTAGINFO pTag, USHORT nScope, PHB_ITEM pItem )
 
       pScope->scopeKey = hb_nsxKeyPutItem( pScope->scopeKey, pScopeVal,
                fTop ? NSX_IGNORE_REC_NUM : NSX_MAX_REC_NUM,
-               pTag, TRUE, &pScope->scopeKeyLen );
+               pTag, HB_TRUE, &pScope->scopeKeyLen );
 
       if( pScope->scopeItem == NULL )
          pScope->scopeItem = hb_itemNew( NULL );
@@ -1056,28 +1056,28 @@ static void hb_nsxTagRefreshScope( LPTAGINFO pTag )
    {
       pItem = hb_vmEvalBlock( pTag->top.scopeItem );
       pTag->top.scopeKey = hb_nsxKeyPutItem( pTag->top.scopeKey, pItem,
-               pTag->top.scopeKey->rec, pTag, TRUE, &pTag->top.scopeKeyLen );
+               pTag->top.scopeKey->rec, pTag, HB_TRUE, &pTag->top.scopeKeyLen );
    }
    if( hb_itemType( pTag->bottom.scopeItem ) == HB_IT_BLOCK )
    {
       pItem = hb_vmEvalBlock( pTag->bottom.scopeItem );
       pTag->bottom.scopeKey = hb_nsxKeyPutItem( pTag->bottom.scopeKey, pItem,
-         pTag->bottom.scopeKey->rec, pTag, TRUE, &pTag->bottom.scopeKeyLen );
+         pTag->bottom.scopeKey->rec, pTag, HB_TRUE, &pTag->bottom.scopeKeyLen );
    }
 }
 
 /*
  * an interface for fast check record number in record filter
  */
-static BOOL hb_nsxCheckRecordScope( NSXAREAP pArea, ULONG ulRec )
+static HB_BOOL hb_nsxCheckRecordScope( NSXAREAP pArea, ULONG ulRec )
 {
    LONG lRecNo = ( LONG ) ulRec;
 
    if( SELF_COUNTSCOPE( ( AREAP ) pArea, NULL, &lRecNo ) == HB_SUCCESS && lRecNo == 0 )
    {
-      return FALSE;
+      return HB_FALSE;
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 #ifdef HB_NSX_DEBUG
@@ -1175,7 +1175,7 @@ static void hb_nsxPageCheckKeys( LPPAGEINFO pPage, LPTAGINFO pTag, int iPos, int
 /*
  * read a given block from index file
  */
-static BOOL hb_nsxBlockRead( LPNSXINDEX pIndex, ULONG ulBlock, BYTE *buffer, int iSize )
+static HB_BOOL hb_nsxBlockRead( LPNSXINDEX pIndex, ULONG ulBlock, BYTE *buffer, int iSize )
 {
    if( !pIndex->lockRead && !pIndex->lockWrite )
       hb_errInternal( 9103, "hb_nsxBlockRead on not locked index file.", NULL, NULL );
@@ -1185,15 +1185,15 @@ static BOOL hb_nsxBlockRead( LPNSXINDEX pIndex, ULONG ulBlock, BYTE *buffer, int
    {
       hb_nsxErrorRT( pIndex->pArea, EG_READ, EDBF_READ,
                      pIndex->IndexName, hb_fsError(), 0, NULL );
-      return FALSE;
+      return HB_FALSE;
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * write a given block into index file
  */
-static BOOL hb_nsxBlockWrite( LPNSXINDEX pIndex, ULONG ulBlock, BYTE *buffer, int iSize )
+static HB_BOOL hb_nsxBlockWrite( LPNSXINDEX pIndex, ULONG ulBlock, BYTE *buffer, int iSize )
 {
    if( !pIndex->lockWrite )
       hb_errInternal( 9102, "hb_nsxBlockWrite on not locked index file.", NULL, NULL );
@@ -1203,15 +1203,15 @@ static BOOL hb_nsxBlockWrite( LPNSXINDEX pIndex, ULONG ulBlock, BYTE *buffer, in
    {
       hb_nsxErrorRT( pIndex->pArea, EG_WRITE, EDBF_WRITE,
                      pIndex->IndexName, hb_fsError(), 0, NULL );
-      return FALSE;
+      return HB_FALSE;
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * write a given tag page to file
  */
-static BOOL hb_nsxPageSave( LPNSXINDEX pIndex, LPPAGEINFO pPage )
+static HB_BOOL hb_nsxPageSave( LPNSXINDEX pIndex, LPPAGEINFO pPage )
 {
    hb_nsxSetKeyCount( pPage, pPage->uiKeys );
    if( hb_nsxIsLeaf( pPage ) )
@@ -1220,15 +1220,15 @@ static BOOL hb_nsxPageSave( LPNSXINDEX pIndex, LPPAGEINFO pPage )
    }
    if( !hb_nsxBlockWrite( pIndex, pPage->Page,
                           (BYTE *) hb_nsxPageBuffer( pPage ), NSX_PAGELEN ) )
-      return FALSE;
-   pPage->Changed = FALSE;
-   pIndex->fFlush = TRUE;
+      return HB_FALSE;
+   pPage->Changed = HB_FALSE;
+   pIndex->fFlush = HB_TRUE;
    /* In shared mode we have to update counter in version field of
       NSXHEADER to signal for other stations that their index buffers
       have to be discarded */
    if( pIndex->fShared )
-      pIndex->Changed = TRUE;
-   return TRUE;
+      pIndex->Changed = HB_TRUE;
+   return HB_TRUE;
 }
 
 /*
@@ -1263,7 +1263,7 @@ static void hb_nsxTagUpdateFlags( LPTAGINFO pTag )
 /*
  * check tag header in compound index
  */
-static BOOL hb_nsxTagHeaderCheck( LPTAGINFO pTag )
+static HB_BOOL hb_nsxTagHeaderCheck( LPTAGINFO pTag )
 {
    if( !pTag->RootBlock )
    {
@@ -1336,7 +1336,7 @@ static void hb_nsxIndexTrunc( LPNSXINDEX pIndex )
       hb_errInternal( 9102, "hb_nsxIndexTrunc on not locked index file.", NULL, NULL );
 
    hb_nsxFreePageBuffer( pIndex );
-   pIndex->Update = pIndex->Changed = pIndex->fFlush = TRUE;
+   pIndex->Update = pIndex->Changed = pIndex->fFlush = HB_TRUE;
    pIndex->Version = 0;
    pIndex->FileSize = 0;
    pIndex->NextAvail = NSX_DUMMYNODE;
@@ -1522,7 +1522,7 @@ static LPPAGEINFO hb_nsxPageLoad( LPTAGINFO pTag, ULONG ulPage )
    else
    {
       pPage = hb_nsxPageGetBuffer( pTag, ulPage );
-      pPage->Changed = FALSE;
+      pPage->Changed = HB_FALSE;
       if( !hb_nsxBlockRead( pTag->pIndex, ulPage,
                             (BYTE *) hb_nsxPageBuffer( pPage ), NSX_PAGELEN ) )
       {
@@ -1570,7 +1570,7 @@ static void hb_nsxPageFree( LPTAGINFO pTag, LPPAGEINFO pPage )
       HB_PUT_LE_UINT32( pHeader->FreePage, pTag->pIndex->NextAvail );
    }
    pTag->pIndex->NextAvail = pPage->Page;
-   pTag->pIndex->Changed = pPage->Changed = TRUE;
+   pTag->pIndex->Changed = pPage->Changed = HB_TRUE;
 }
 
 /*
@@ -1579,7 +1579,7 @@ static void hb_nsxPageFree( LPTAGINFO pTag, LPPAGEINFO pPage )
 static void hb_nsxPageAddFree( LPTAGINFO pTag, ULONG ulPage )
 {
    LPPAGEINFO pPage = hb_nsxPageGetBuffer( pTag, ulPage );
-   pPage->Changed = TRUE;
+   pPage->Changed = HB_TRUE;
    hb_nsxPageInit( pPage );
    hb_nsxPageFree( pTag, pPage );
    hb_nsxPageSave( pTag->pIndex, pPage );
@@ -1607,7 +1607,7 @@ static ULONG hb_nsxPageAlloc( LPNSXINDEX pIndex )
 /*
  * allocate new page in index file - reuse freed one or increase file
  */
-static LPPAGEINFO hb_nsxPageNew( LPTAGINFO pTag, BOOL fNull )
+static LPPAGEINFO hb_nsxPageNew( LPTAGINFO pTag, HB_BOOL fNull )
 {
    LPPAGEINFO pPage;
 
@@ -1627,7 +1627,7 @@ static LPPAGEINFO hb_nsxPageNew( LPTAGINFO pTag, BOOL fNull )
       pPage = hb_nsxPageGetBuffer( pTag, fNull ? 0 : hb_nsxPageAlloc( pTag->pIndex ) );
    }
    hb_nsxPageInit( pPage );
-   pTag->pIndex->Changed = pPage->Changed = TRUE;
+   pTag->pIndex->Changed = pPage->Changed = HB_TRUE;
 
    return pPage;
 }
@@ -1637,13 +1637,13 @@ static LPPAGEINFO hb_nsxPageNew( LPTAGINFO pTag, BOOL fNull )
  */
 static ULONG hb_nsxPageGetFree( LPTAGINFO pTag )
 {
-   LPPAGEINFO pPage = hb_nsxPageNew( pTag, FALSE );
+   LPPAGEINFO pPage = hb_nsxPageNew( pTag, HB_FALSE );
    ULONG ulPage = 0;
 
    if( pPage )
    {
       ulPage = pPage->Page;
-      pPage->Changed = FALSE;
+      pPage->Changed = HB_FALSE;
       hb_nsxPageRelease( pTag, pPage );
    }
    return ulPage;
@@ -1656,7 +1656,7 @@ static LPTAGINFO hb_nsxTagNew( LPNSXINDEX pIndex, const char * szTagName,
                                const char *szKeyExpr, PHB_ITEM pKeyExpr,
                                UCHAR ucKeyType, USHORT uiKeyLen, BYTE bTrail,
                                const char *szForExpr, PHB_ITEM pForExpr,
-                               BOOL fAscendKey, BOOL fUnique, BOOL fCustom )
+                               HB_BOOL fAscendKey, HB_BOOL fUnique, HB_BOOL fCustom )
 {
    LPTAGINFO pTag;
 
@@ -1744,7 +1744,7 @@ static void hb_nsxTagDelete( LPTAGINFO pTag )
       }
    }
    hb_nsxTagFree( pTag );
-   pIndex->pArea->fSetTagNumbers = TRUE;
+   pIndex->pArea->fSetTagNumbers = HB_TRUE;
    return;
 }
 
@@ -1763,7 +1763,7 @@ static HB_ERRCODE hb_nsxTagAdd( LPNSXINDEX pIndex, LPTAGINFO pTag )
       pIndex->lpTags = ( LPTAGINFO * ) hb_xgrab( sizeof( LPTAGINFO ) );
 
    pIndex->lpTags[ pIndex->iTags++ ] = pTag;
-   pIndex->pArea->fSetTagNumbers = TRUE;
+   pIndex->pArea->fSetTagNumbers = HB_TRUE;
    return HB_SUCCESS;
 }
 
@@ -1838,7 +1838,7 @@ static void hb_nsxIndexTagAdd( LPNSXINDEX pIndex, LPTAGINFO pTag )
       hb_strncpy( ( char * ) pTagItem->TagName, pTag->TagName, NSX_TAGNAME );
    }
    HB_PUT_LE_UINT32( pTagItem->TagOffset, pTag->HeadBlock );
-   pIndex->Update = TRUE;
+   pIndex->Update = HB_TRUE;
 }
 
 /*
@@ -1857,7 +1857,7 @@ static void hb_nsxIndexTagDel( LPNSXINDEX pIndex, const char * szTagName )
          memset( pTagItem + iTags - 1, 0, sizeof( NSXTAGITEM ) );
          --iTags;
          HB_PUT_LE_UINT16( pIndex->HeaderBuff.TagCount, iTags );
-         pIndex->Update = TRUE;
+         pIndex->Update = HB_TRUE;
          break;
       }
    }
@@ -1934,8 +1934,8 @@ static HB_ERRCODE hb_nsxTagHeaderSave( LPTAGINFO pTag )
    if( !hb_nsxBlockWrite( pIndex, pTag->HeadBlock, ( BYTE * ) &Header, iSize ) )
       return HB_FAILURE;
 
-   pTag->HdrChanged = FALSE;
-   pIndex->Changed = pIndex->fFlush = TRUE;
+   pTag->HdrChanged = HB_FALSE;
+   pIndex->Changed = pIndex->fFlush = HB_TRUE;
 
    return HB_SUCCESS;
 }
@@ -2003,7 +2003,7 @@ static HB_ERRCODE hb_nsxIndexHeaderSave( LPNSXINDEX pIndex )
    if( !hb_nsxBlockWrite( pIndex, 0, ( BYTE * ) &pIndex->HeaderBuff, iSize ) )
       return HB_FAILURE;
 
-   pIndex->Changed = pIndex->Update = FALSE;
+   pIndex->Changed = pIndex->Update = HB_FALSE;
 
    return HB_SUCCESS;
 }
@@ -2020,7 +2020,7 @@ static HB_ERRCODE hb_nsxIndexLoad( LPNSXINDEX pIndex )
    {
       if( !hb_nsxBlockRead( pIndex, 0, ( BYTE * ) &pIndex->HeaderBuff, NSX_PAGELEN ) )
          return HB_FAILURE;
-      pIndex->fValidHeader = TRUE;
+      pIndex->fValidHeader = HB_TRUE;
    }
 
    signature = pIndex->HeaderBuff.Signature[0];
@@ -2138,14 +2138,14 @@ static void hb_nsxIndexFlush( LPNSXINDEX pIndex )
 /*
  * lock index for reading (shared lock)
  */
-static BOOL hb_nsxIndexLockRead( LPNSXINDEX pIndex )
+static HB_BOOL hb_nsxIndexLockRead( LPNSXINDEX pIndex )
 {
-   BOOL fOK;
+   HB_BOOL fOK;
 
    if( pIndex->lockRead > 0 || pIndex->lockWrite > 0 || !pIndex->fShared ||
        HB_DIRTYREAD( &pIndex->pArea->dbfarea) )
    {
-      fOK = TRUE;
+      fOK = HB_TRUE;
       pIndex->lockRead++;
    }
    else
@@ -2163,7 +2163,7 @@ static BOOL hb_nsxIndexLockRead( LPNSXINDEX pIndex )
             pIndex->lockRead--;
             hb_dbfLockIdxFile( pIndex->pFile, pIndex->pArea->dbfarea.bLockType,
                                FL_UNLOCK, &pIndex->ulLockPos );
-            return FALSE;
+            return HB_FALSE;
          }
       }
    }
@@ -2176,9 +2176,9 @@ static BOOL hb_nsxIndexLockRead( LPNSXINDEX pIndex )
 /*
  * lock index for writing (exclusive lock)
  */
-static BOOL hb_nsxIndexLockWrite( LPNSXINDEX pIndex, BOOL fCheck )
+static HB_BOOL hb_nsxIndexLockWrite( LPNSXINDEX pIndex, HB_BOOL fCheck )
 {
-   BOOL fOK;
+   HB_BOOL fOK;
 
    if( pIndex->fReadonly )
       hb_errInternal( 9101, "hb_nsxIndexLockWrite: readonly index.", NULL, NULL );
@@ -2188,7 +2188,7 @@ static BOOL hb_nsxIndexLockWrite( LPNSXINDEX pIndex, BOOL fCheck )
 
    if( pIndex->lockWrite > 0 || !pIndex->fShared )
    {
-      fOK = TRUE;
+      fOK = HB_TRUE;
       pIndex->lockWrite++;
    }
    else
@@ -2206,7 +2206,7 @@ static BOOL hb_nsxIndexLockWrite( LPNSXINDEX pIndex, BOOL fCheck )
             pIndex->lockWrite--;
             hb_dbfLockIdxFile( pIndex->pFile, pIndex->pArea->dbfarea.bLockType,
                                FL_UNLOCK, &pIndex->ulLockPos );
-            return FALSE;
+            return HB_FALSE;
          }
       }
    }
@@ -2219,9 +2219,9 @@ static BOOL hb_nsxIndexLockWrite( LPNSXINDEX pIndex, BOOL fCheck )
 /*
  * remove index read lock (shared lock)
  */
-static BOOL hb_nsxIndexUnLockRead( LPNSXINDEX pIndex )
+static HB_BOOL hb_nsxIndexUnLockRead( LPNSXINDEX pIndex )
 {
-   BOOL fOK;
+   HB_BOOL fOK;
 
 #ifdef HB_NSX_DEBUG
    int i;
@@ -2236,11 +2236,11 @@ static BOOL hb_nsxIndexUnLockRead( LPNSXINDEX pIndex )
    if( pIndex->lockRead || pIndex->lockWrite || !pIndex->fShared ||
        HB_DIRTYREAD( &pIndex->pArea->dbfarea ) )
    {
-      fOK = TRUE;
+      fOK = HB_TRUE;
    }
    else
    {
-      pIndex->fValidHeader = FALSE;
+      pIndex->fValidHeader = HB_FALSE;
       fOK = hb_dbfLockIdxFile( pIndex->pFile, pIndex->pArea->dbfarea.bLockType,
                                FL_UNLOCK, &pIndex->ulLockPos );
    }
@@ -2253,9 +2253,9 @@ static BOOL hb_nsxIndexUnLockRead( LPNSXINDEX pIndex )
 /*
  * remove index write lock (exclusive lock)
  */
-static BOOL hb_nsxIndexUnLockWrite( LPNSXINDEX pIndex )
+static HB_BOOL hb_nsxIndexUnLockWrite( LPNSXINDEX pIndex )
 {
-   BOOL fOK;
+   HB_BOOL fOK;
 
 #ifdef HB_NSX_DEBUG
    int i;
@@ -2273,11 +2273,11 @@ static BOOL hb_nsxIndexUnLockWrite( LPNSXINDEX pIndex )
 
    if( pIndex->lockWrite || !pIndex->fShared )
    {
-      fOK = TRUE;
+      fOK = HB_TRUE;
    }
    else
    {
-      pIndex->fValidHeader = FALSE;
+      pIndex->fValidHeader = HB_FALSE;
       fOK = hb_dbfLockIdxFile( pIndex->pFile, pIndex->pArea->dbfarea.bLockType,
                                FL_UNLOCK, &pIndex->ulLockPos );
    }
@@ -2290,9 +2290,9 @@ static BOOL hb_nsxIndexUnLockWrite( LPNSXINDEX pIndex )
 /*
  * lock tag for reading (shared lock)
  */
-static BOOL hb_nsxTagLockRead( LPTAGINFO pTag )
+static HB_BOOL hb_nsxTagLockRead( LPTAGINFO pTag )
 {
-   BOOL fOK = FALSE;
+   HB_BOOL fOK = HB_FALSE;
 
    if( hb_nsxIndexLockRead( pTag->pIndex ) )
    {
@@ -2309,11 +2309,11 @@ static BOOL hb_nsxTagLockRead( LPTAGINFO pTag )
 /*
  * lock tag for writing (exclusive lock)
  */
-static BOOL hb_nsxTagLockWrite( LPTAGINFO pTag )
+static HB_BOOL hb_nsxTagLockWrite( LPTAGINFO pTag )
 {
-   BOOL fOK = FALSE;
+   HB_BOOL fOK = HB_FALSE;
 
-   if( hb_nsxIndexLockWrite( pTag->pIndex, TRUE ) )
+   if( hb_nsxIndexLockWrite( pTag->pIndex, HB_TRUE ) )
    {
       fOK = hb_nsxTagHeaderCheck( pTag );
       if( !fOK )
@@ -2328,7 +2328,7 @@ static BOOL hb_nsxTagLockWrite( LPTAGINFO pTag )
 /*
  * remove tag read lock (shared lock)
  */
-static BOOL hb_nsxTagUnLockRead( LPTAGINFO pTag )
+static HB_BOOL hb_nsxTagUnLockRead( LPTAGINFO pTag )
 {
    return hb_nsxIndexUnLockRead( pTag->pIndex );
 }
@@ -2336,7 +2336,7 @@ static BOOL hb_nsxTagUnLockRead( LPTAGINFO pTag )
 /*
  * remove tag write lock (exclusive lock)
  */
-static BOOL hb_nsxTagUnLockWrite( LPTAGINFO pTag )
+static HB_BOOL hb_nsxTagUnLockWrite( LPTAGINFO pTag )
 {
    return hb_nsxIndexUnLockWrite( pTag->pIndex );
 }
@@ -2344,24 +2344,24 @@ static BOOL hb_nsxTagUnLockWrite( LPTAGINFO pTag )
 /*
  * retrieve previous key value from upper branch page
  */
-static BOOL hb_nsxTagGetPrevKey( LPTAGINFO pTag, UCHAR * pKeyVal, int iLevel )
+static HB_BOOL hb_nsxTagGetPrevKey( LPTAGINFO pTag, UCHAR * pKeyVal, int iLevel )
 {
    while( --iLevel >= 0 )
    {
       if( pTag->stack[ iLevel ].ikey != 0 )
       {
          memcpy( pKeyVal, pTag->stack[ iLevel ].value, pTag->KeyLength );
-         return TRUE;
+         return HB_TRUE;
       }
    }
    /* memset( pKeyVal, pTag->TrailChar, pTag->KeyLength ); */
-   return FALSE;
+   return HB_FALSE;
 }
 
 /*
  * decode key from leaf page into given buffer
  */
-static BOOL hb_nsxPageGetLeafKey( LPTAGINFO pTag, LPPAGEINFO pPage, USHORT uiKey,
+static HB_BOOL hb_nsxPageGetLeafKey( LPTAGINFO pTag, LPPAGEINFO pPage, USHORT uiKey,
                                   UCHAR * pKeyVal, ULONG * pulRecNo )
 {
    USHORT uiOffset = NSX_LEAFKEYOFFSET;
@@ -2375,18 +2375,18 @@ static BOOL hb_nsxPageGetLeafKey( LPTAGINFO pTag, LPPAGEINFO pPage, USHORT uiKey
       {
          hb_nsxCorruptError( pTag->pIndex );
          *pulRecNo = 0;
-         return FALSE;
+         return HB_FALSE;
       }
    }
    while( uiKey-- );
 
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * retrieve key from page
  */
-static BOOL hb_nsxTagGetCurKey( LPTAGINFO pTag, LPPAGEINFO pPage, USHORT uiKey )
+static HB_BOOL hb_nsxTagGetCurKey( LPTAGINFO pTag, LPPAGEINFO pPage, USHORT uiKey )
 {
    if( hb_nsxIsLeaf( pPage ) )
    {
@@ -2416,7 +2416,7 @@ static BOOL hb_nsxTagGetCurKey( LPTAGINFO pTag, LPPAGEINFO pPage, USHORT uiKey )
             {
                hb_nsxCorruptError( pTag->pIndex );
                pTag->CurKeyInfo->rec = 0;
-               return FALSE;
+               return HB_FALSE;
             }
             pTag->CurKeyNo++;
          }
@@ -2433,7 +2433,7 @@ static BOOL hb_nsxTagGetCurKey( LPTAGINFO pTag, LPPAGEINFO pPage, USHORT uiKey )
    else
       pTag->CurKeyInfo->rec = pTag->CurKeyInfo->page = 0;
 
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
@@ -2538,15 +2538,15 @@ static LPPAGEINFO hb_nsxPageBottomMove( LPTAGINFO pTag, ULONG ulPage )
 /*
  * set page path to the first key in tag
  */
-static BOOL hb_nsxTagTopKey( LPTAGINFO pTag )
+static HB_BOOL hb_nsxTagTopKey( LPTAGINFO pTag )
 {
    LPPAGEINFO pPage;
-   BOOL fFound;
+   HB_BOOL fFound;
 
    pTag->stackLevel = 0;
    pPage = hb_nsxPageTopMove( pTag, hb_nsxTagRootBlock( pTag ) );
    if( ! pPage )
-      return FALSE;
+      return HB_FALSE;
    fFound = hb_nsxTagGetCurKey( pTag, pPage, 0 ) && pPage->uiKeys != 0;
    hb_nsxPageRelease( pTag, pPage );
    return fFound;
@@ -2555,15 +2555,15 @@ static BOOL hb_nsxTagTopKey( LPTAGINFO pTag )
 /*
  * set page path to the last key in tag
  */
-static BOOL hb_nsxTagBottomKey( LPTAGINFO pTag )
+static HB_BOOL hb_nsxTagBottomKey( LPTAGINFO pTag )
 {
    LPPAGEINFO pPage;
-   BOOL fFound;
+   HB_BOOL fFound;
 
    pTag->stackLevel = 0;
    pPage = hb_nsxPageBottomMove( pTag, hb_nsxTagRootBlock( pTag ) );
    if( ! pPage )
-      return FALSE;
+      return HB_FALSE;
    fFound = hb_nsxTagGetCurKey( pTag, pPage,
                                 pTag->stack[ pTag->stackLevel - 1 ].ikey ) &&
             pPage->uiKeys != 0;
@@ -2574,18 +2574,18 @@ static BOOL hb_nsxTagBottomKey( LPTAGINFO pTag )
 /*
  * update page path to the next key in tag
  */
-static BOOL hb_nsxTagNextKey( LPTAGINFO pTag )
+static HB_BOOL hb_nsxTagNextKey( LPTAGINFO pTag )
 {
    int iLevel = pTag->stackLevel - 1;
    LPPAGEINFO pPage;
    ULONG ulPage;
-   BOOL fFound;
+   HB_BOOL fFound;
 
    if( iLevel >= 0 )
    {
       pPage = hb_nsxPageLoad( pTag, pTag->stack[ iLevel ].page );
       if( ! pPage )
-         return FALSE;
+         return HB_FALSE;
       if( !hb_nsxIsLeaf( pPage ) )
       {
          ulPage = pTag->stack[ iLevel ].ikey == 0 ? 0 :
@@ -2593,7 +2593,7 @@ static BOOL hb_nsxTagNextKey( LPTAGINFO pTag )
          hb_nsxPageRelease( pTag, pPage );
          pPage = hb_nsxPageTopMove( pTag, ulPage );
          if( ! pPage )
-            return FALSE;
+            return HB_FALSE;
       }
       else if( pTag->stack[ iLevel ].ikey + 1 < pPage->uiKeys )
          pTag->stack[ iLevel ].ikey++;
@@ -2603,10 +2603,10 @@ static BOOL hb_nsxTagNextKey( LPTAGINFO pTag )
          {
             hb_nsxPageRelease( pTag, pPage );
             if( --iLevel < 0 )
-               return FALSE;
+               return HB_FALSE;
             pPage = hb_nsxPageLoad( pTag, pTag->stack[ iLevel ].page );
             if( ! pPage )
-               return FALSE;
+               return HB_FALSE;
             if( pPage->uiKeys && pTag->stack[ iLevel ].ikey < pPage->uiKeys )
             {
                if( !pTag->stack[ iLevel ].value )
@@ -2626,24 +2626,24 @@ static BOOL hb_nsxTagNextKey( LPTAGINFO pTag )
       hb_nsxPageRelease( pTag, pPage );
       return fFound;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 /*
  * update page path to the previous key in tag
  */
-static BOOL hb_nsxTagPrevKey( LPTAGINFO pTag )
+static HB_BOOL hb_nsxTagPrevKey( LPTAGINFO pTag )
 {
    int iLevel = pTag->stackLevel - 1;
    LPPAGEINFO pPage;
    ULONG ulPage;
-   BOOL fFound;
+   HB_BOOL fFound;
 
    if( iLevel >= 0 )
    {
       pPage = hb_nsxPageLoad( pTag, pTag->stack[ iLevel ].page );
       if( ! pPage )
-         return FALSE;
+         return HB_FALSE;
 
       if( !hb_nsxIsLeaf( pPage ) )
       {
@@ -2662,7 +2662,7 @@ static BOOL hb_nsxTagPrevKey( LPTAGINFO pTag )
          }
          pPage = hb_nsxPageBottomMove( pTag, ulPage );
          if( ! pPage )
-            return FALSE;
+            return HB_FALSE;
       }
       else if( pTag->stack[ iLevel ].ikey )
          pTag->stack[ iLevel ].ikey--;
@@ -2672,10 +2672,10 @@ static BOOL hb_nsxTagPrevKey( LPTAGINFO pTag )
          {
             hb_nsxPageRelease( pTag, pPage );
             if( --iLevel < 0 )
-               return FALSE;
+               return HB_FALSE;
             pPage = hb_nsxPageLoad( pTag, pTag->stack[ iLevel ].page );
             if( ! pPage )
-               return FALSE;
+               return HB_FALSE;
             if( pTag->stack[ iLevel ].ikey )
                break;
          }
@@ -2687,7 +2687,7 @@ static BOOL hb_nsxTagPrevKey( LPTAGINFO pTag )
       hb_nsxPageRelease( pTag, pPage );
       return fFound;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 /*
@@ -2695,12 +2695,12 @@ static BOOL hb_nsxTagPrevKey( LPTAGINFO pTag )
  */
 static int hb_nsxPageKeyFind( LPTAGINFO pTag, LPPAGEINFO pPage,
                               UCHAR * key, SHORT keylen, int mode,
-                              BOOL fLast, ULONG ulRecNo, BOOL *fStop )
+                              HB_BOOL fLast, ULONG ulRecNo, HB_BOOL *fStop )
 {
    int iBegin, iEnd, iLast, k, i;
    ULONG ulRec;
 
-   *fStop = FALSE;
+   *fStop = HB_FALSE;
 
    if( pPage->uiKeys == 0 )
       return 0;
@@ -2731,7 +2731,7 @@ static int hb_nsxPageKeyFind( LPTAGINFO pTag, LPPAGEINFO pPage,
                   k = 1;
                else
                {
-                  *fStop = TRUE;
+                  *fStop = HB_TRUE;
                   return u;
                }
             }
@@ -2741,7 +2741,7 @@ static int hb_nsxPageKeyFind( LPTAGINFO pTag, LPPAGEINFO pPage,
             break;
          else if( k==0 && !fLast )
          {
-            *fStop = TRUE;
+            *fStop = HB_TRUE;
             break;
          }
       }
@@ -2770,7 +2770,7 @@ static int hb_nsxPageKeyFind( LPTAGINFO pTag, LPPAGEINFO pPage,
                   k = 1;
                else
                {
-                  *fStop = TRUE;
+                  *fStop = HB_TRUE;
                   return i + 1;
                }
             }
@@ -2781,7 +2781,7 @@ static int hb_nsxPageKeyFind( LPTAGINFO pTag, LPPAGEINFO pPage,
          else
          {
             if( k == 0 )
-               *fStop = TRUE;
+               *fStop = HB_TRUE;
             iLast = i;
             iEnd = i - 1;
          }
@@ -2793,15 +2793,15 @@ static int hb_nsxPageKeyFind( LPTAGINFO pTag, LPPAGEINFO pPage,
 /*
  * set page path to given key in tag
  */
-static BOOL hb_nsxTagKeyFind( LPTAGINFO pTag, LPKEYINFO pKey, USHORT uiLen )
+static HB_BOOL hb_nsxTagKeyFind( LPTAGINFO pTag, LPKEYINFO pKey, USHORT uiLen )
 {
    LPPAGEINFO pPage;
    ULONG ulPage, ulRecNo = 0;
    int iKey;
-   BOOL fStop = FALSE, fLast = FALSE, fOut;
+   HB_BOOL fStop = HB_FALSE, fLast = HB_FALSE, fOut;
 
    if( pKey->rec == NSX_MAX_REC_NUM )     /* for seek last */
-      fLast = TRUE;
+      fLast = HB_TRUE;
    else if( pKey->rec != NSX_IGNORE_REC_NUM ) /* for key del, add and current key */
       ulRecNo = pKey->rec;
    /* else -> normal seek */
@@ -2811,16 +2811,16 @@ static BOOL hb_nsxTagKeyFind( LPTAGINFO pTag, LPKEYINFO pKey, USHORT uiLen )
    ulPage = hb_nsxTagRootBlock( pTag );
    if( !ulPage )
    {
-      pTag->TagBOF = pTag->TagEOF = TRUE;
+      pTag->TagBOF = pTag->TagEOF = HB_TRUE;
       pTag->CurKeyInfo->rec = 0;
-      return FALSE;
+      return HB_FALSE;
    }
 
    for( ;; )
    {
       pPage = hb_nsxPageLoad( pTag, ulPage );
       if( ! pPage )
-         return FALSE;
+         return HB_FALSE;
 
       iKey = hb_nsxPageKeyFind( pTag, pPage, pKey->val, uiLen, pKey->mode,
                                 fLast, ulRecNo, &fStop );
@@ -2836,7 +2836,7 @@ static BOOL hb_nsxTagKeyFind( LPTAGINFO pTag, LPKEYINFO pKey, USHORT uiLen )
    fOut = !hb_nsxTagGetCurKey( pTag, pPage, iKey );
    hb_nsxPageRelease( pTag, pPage );
    if( fOut )
-      return FALSE;
+      return HB_FALSE;
 
    if( ulRecNo == 0 )
    {
@@ -2844,8 +2844,8 @@ static BOOL hb_nsxTagKeyFind( LPTAGINFO pTag, LPKEYINFO pKey, USHORT uiLen )
       {
          if( !hb_nsxTagPrevKey( pTag ) )
          {
-            fOut = TRUE;
-            fStop = FALSE;
+            fOut = HB_TRUE;
+            fStop = HB_FALSE;
          }
          else
          {
@@ -2857,8 +2857,8 @@ static BOOL hb_nsxTagKeyFind( LPTAGINFO pTag, LPKEYINFO pKey, USHORT uiLen )
       {
          if( !hb_nsxTagNextKey( pTag ) )  /* Tag EOF */
          {
-            fOut = TRUE;
-            fStop = FALSE;
+            fOut = HB_TRUE;
+            fStop = HB_FALSE;
          }
          else
          {
@@ -2897,7 +2897,7 @@ static void hb_nsxPageKeyAdd( LPTAGINFO pTag, LPPAGEINFO pPage, USHORT uiPos,
    hb_nsxBranchKeySetPage( ptr, pKey->page );
    hb_nsxBranchKeySetRec( ptr, pKey->rec );
    memcpy( hb_nsxBranchKeyVal( ptr ), pKey->val, pTag->KeyLength );
-   pPage->Changed = TRUE;
+   pPage->Changed = HB_TRUE;
    pPage->uiKeys++;
 }
 
@@ -2910,7 +2910,7 @@ static LPKEYINFO hb_nsxPageSplit( LPTAGINFO pTag, LPPAGEINFO pPage,
    LPPAGEINFO pNewPage;
    USHORT n, uiKeys, uiHalf, uiLen;
 
-   pNewPage = hb_nsxPageNew( pTag, FALSE );
+   pNewPage = hb_nsxPageNew( pTag, HB_FALSE );
    if( ! pNewPage )
    {
       hb_nsxKeyFree( pKey );
@@ -2966,7 +2966,7 @@ static LPKEYINFO hb_nsxPageSplit( LPTAGINFO pTag, LPPAGEINFO pPage,
    hb_nsxSetLowerPage( pNewPage, pKey->page );
    pKey->page = pNewPage->Page;
 
-   pPage->Changed = pNewPage->Changed = TRUE;
+   pPage->Changed = pNewPage->Changed = HB_TRUE;
 #ifdef HB_NSX_DEBUG
    hb_nsxPageCheckKeys( pNewPage, pTag, uiPos, 1 );
    hb_nsxPageCheckKeys( pPage, pTag, uiPos - pNewPage->uiKeys, 2 );
@@ -2980,7 +2980,7 @@ static LPKEYINFO hb_nsxPageSplit( LPTAGINFO pTag, LPPAGEINFO pPage,
 /*
  * insert key into current stack page
  */
-static BOOL hb_nsxTagInsertKey( LPTAGINFO pTag, LPPAGEINFO pPage,
+static HB_BOOL hb_nsxTagInsertKey( LPTAGINFO pTag, LPPAGEINFO pPage,
                                 LPKEYINFO pKey, UCHAR * pKeyPrev )
 {
    USHORT uiOffset = NSX_LEAFKEYOFFSET, uiKeyOffset = 0,
@@ -3025,7 +3025,7 @@ static BOOL hb_nsxTagInsertKey( LPTAGINFO pTag, LPPAGEINFO pPage,
             pTag->stackLevel = 0;
             hb_nsxPageRelease( pTag, pPage );
             hb_nsxCorruptError( pTag->pIndex );
-            return FALSE;
+            return HB_FALSE;
          }
          HB_PUT_LE_UINT32( ptr, ulRecNo );
          ptr += 4;
@@ -3054,7 +3054,7 @@ static BOOL hb_nsxTagInsertKey( LPTAGINFO pTag, LPPAGEINFO pPage,
    else
       pKeyPrev = ptr - iLen;
 
-   pPage->Changed = TRUE;
+   pPage->Changed = HB_TRUE;
    for( ; uiKey <= uiKeys; ++uiKey )
    {
       if( uiHalfOffset == 0 && pPage->uiOffset >= NSX_LEAFSPLITOFFSET )
@@ -3079,13 +3079,13 @@ static BOOL hb_nsxTagInsertKey( LPTAGINFO pTag, LPPAGEINFO pPage,
          hb_nsxPageCheckKeys( pPage, pTag, uiKey, 41 );
 #endif
          hb_nsxPageRelease( pTag, pPage );
-         pPage = hb_nsxPageNew( pTag, FALSE );
+         pPage = hb_nsxPageNew( pTag, HB_FALSE );
          if( ! pPage )
          {
             hb_xfree( pKeyBuff );
             pTag->CurKeyOffset = 0;
             pTag->stackLevel = 0;
-            return FALSE;
+            return HB_FALSE;
          }
          pNewKey = hb_nsxKeyNew( iLen );
          pNewKey->page = pPage->Page;
@@ -3094,7 +3094,7 @@ static BOOL hb_nsxTagInsertKey( LPTAGINFO pTag, LPPAGEINFO pPage,
          hb_nsxSetPageType( pPage, NSX_LEAFPAGE );
          hb_nsxSetKeyRecSize( pPage, ucRecSize );
          pPage->uiKeys = uiKeys - uiKey;
-         pPage->Changed = TRUE;
+         pPage->Changed = HB_TRUE;
          uiOffset = NSX_LEAFKEYOFFSET;
       }
       pPage->uiOffset = uiOffset;
@@ -3119,7 +3119,7 @@ static BOOL hb_nsxTagInsertKey( LPTAGINFO pTag, LPPAGEINFO pPage,
             hb_nsxKeyFree( pNewKey );
             pTag->CurKeyOffset = 0;
             pTag->stackLevel = 0;
-            return FALSE;
+            return HB_FALSE;
          }
          iKey = pTag->stack[ iLevel ].ikey;
          if( pPage->uiKeys < pTag->MaxKeys )
@@ -3139,23 +3139,23 @@ static BOOL hb_nsxTagInsertKey( LPTAGINFO pTag, LPPAGEINFO pPage,
          if( hb_nsxIsRoot( pPage ) )
          {
             hb_nsxPageType( pPage ) &= ~NSX_ROOTPAGE;
-            pPage->Changed = TRUE;
+            pPage->Changed = HB_TRUE;
          }
          hb_nsxPageRelease( pTag, pPage );
-         pPage = hb_nsxPageNew( pTag, FALSE );
+         pPage = hb_nsxPageNew( pTag, HB_FALSE );
          if( ! pPage )
          {
             hb_nsxKeyFree( pNewKey );
             pTag->CurKeyOffset = 0;
             pTag->stackLevel = 0;
-            return FALSE;
+            return HB_FALSE;
          }
          hb_nsxSetPageType( pPage, NSX_ROOTPAGE );
          hb_nsxSetKeyRecSize( pPage, 4 );
          hb_nsxSetLowerPage( pPage, pTag->RootBlock );
          hb_nsxPageKeyAdd( pTag, pPage, 0, pNewKey );
          pTag->RootBlock = pPage->Page;
-         pTag->HdrChanged = TRUE;
+         pTag->HdrChanged = HB_TRUE;
          pTag->CurKeyOffset = 0;
          pTag->stackLevel = 0;
          hb_nsxKeyFree( pNewKey );
@@ -3164,17 +3164,17 @@ static BOOL hb_nsxTagInsertKey( LPTAGINFO pTag, LPPAGEINFO pPage,
    hb_nsxPageRelease( pTag, pPage );
    pTag->CurKeyOffset = 0;
    pTag->stackLevel = 0;
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * add key to the index at the curret page path
  */
-static BOOL hb_nsxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey )
+static HB_BOOL hb_nsxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey )
 {
    LPPAGEINFO pPage;
    ULONG ulPage;
-   BOOL fFound, fBottom = FALSE;
+   HB_BOOL fFound, fBottom = HB_FALSE;
 
    if( pTag->UniqueKey )
    {
@@ -3184,8 +3184,8 @@ static BOOL hb_nsxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey )
       fFound = hb_nsxTagKeyFind( pTag, pKey, pTag->KeyLength );
       pKey->rec = ulRecNo;
       if( fFound )
-         return FALSE;
-      fBottom = TRUE;
+         return HB_FALSE;
+      fBottom = HB_TRUE;
    }
    else
    {
@@ -3195,17 +3195,17 @@ static BOOL hb_nsxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey )
       if( fFound )
       {
          if( pTag->MultiKey )
-            fBottom = TRUE;
+            fBottom = HB_TRUE;
          else
-            return FALSE;
+            return HB_FALSE;
       }
    }
 
    if( pTag->stackLevel == 0 )
-      return FALSE;
+      return HB_FALSE;
    pPage = hb_nsxPageLoad( pTag, pTag->stack[ pTag->stackLevel - 1 ].page );
    if( ! pPage )
-      return FALSE;
+      return HB_FALSE;
    if( fBottom && !hb_nsxIsLeaf( pPage ) )
    {
       ulPage = pTag->stack[ pTag->stackLevel - 1 ].ikey == 0 ?
@@ -3214,7 +3214,7 @@ static BOOL hb_nsxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey )
       hb_nsxPageRelease( pTag, pPage );
       pPage = hb_nsxPageBottomMove( pTag, ulPage );
       if( ! pPage )
-         return FALSE;
+         return HB_FALSE;
       if( pTag->stack[ pTag->stackLevel - 1 ].ikey < pPage->uiKeys )
          pTag->stack[ pTag->stackLevel - 1 ].ikey++;
    }
@@ -3230,7 +3230,7 @@ static void hb_nsxPageLeafKeyDel( LPTAGINFO pTag, LPPAGEINFO pPage, USHORT uiKey
    UCHAR pKeyVal[ NSX_MAXKEYLEN ], pKeyVal2[ NSX_MAXKEYLEN ], * pPrevVal = NULL;
    ULONG ulRecNo;
    USHORT uiOffset = NSX_LEAFKEYOFFSET, u;
-   BOOL fPrev;
+   HB_BOOL fPrev;
 
    fPrev = hb_nsxTagGetPrevKey( pTag, pKeyVal, pTag->stackLevel - 1 );
    for( u = 0; u < uiKey; ++u )
@@ -3270,32 +3270,32 @@ static void hb_nsxPageLeafKeyDel( LPTAGINFO pTag, LPPAGEINFO pPage, USHORT uiKey
       uiOffset += pPage->uiOffset - u;
    }
    pPage->uiOffset = uiOffset;
-   pPage->Changed = TRUE;
+   pPage->Changed = HB_TRUE;
 }
 
 /*
  * del key at the curret page path from the index
  */
-static BOOL hb_nsxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
+static HB_BOOL hb_nsxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
 {
    int iLevel, iKey, iBaseLevel, iBaseKey;
    LPPAGEINFO pBasePage, pPage;
    ULONG ulPage, ulRecNo;
-   BOOL fResult = TRUE;
+   HB_BOOL fResult = HB_TRUE;
 
    pKey->page = 0;
    if( pTag->stackLevel == 0 || pTag->CurKeyInfo->rec != pKey->rec ||
        memcmp( pTag->CurKeyInfo->val, pKey->val, pTag->KeyLength ) != 0 )
    {
       if( ! hb_nsxTagKeyFind( pTag, pKey, pTag->KeyLength ) )
-         return FALSE;
+         return HB_FALSE;
    }
 
    iLevel = pTag->stackLevel - 1;
    iKey = pTag->stack[ iLevel ].ikey;
    pPage = hb_nsxPageLoad( pTag, pTag->stack[ iLevel ].page );
    if( ! pPage )
-      return FALSE;
+      return HB_FALSE;
 
    if( !hb_nsxIsLeaf( pPage ) )
    {
@@ -3307,7 +3307,7 @@ static BOOL hb_nsxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
       if( ! pPage )
       {
          hb_nsxPageRelease( pTag, pBasePage );
-         return FALSE;
+         return HB_FALSE;
       }
       iLevel = pTag->stackLevel - 1;
       iKey = pTag->stack[ iLevel ].ikey;  /* iKey = 0 */
@@ -3318,7 +3318,7 @@ static BOOL hb_nsxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
          hb_nsxPageRelease( pTag, pBasePage );
          hb_nsxPageRelease( pTag, pPage );
          pTag->stackLevel = 0;
-         return FALSE;
+         return HB_FALSE;
       }
       hb_nsxSetKeyRec( pBasePage, pTag->KeyLength, iBaseKey, ulRecNo );
       if( !pTag->stack[ iBaseLevel ].value )
@@ -3326,7 +3326,7 @@ static BOOL hb_nsxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
       memcpy( pTag->stack[ iBaseLevel ].value,
               hb_nsxGetKeyVal( pBasePage, pTag->KeyLength, iBaseKey ),
               pTag->KeyLength );
-      pBasePage->Changed = TRUE;
+      pBasePage->Changed = HB_TRUE;
 #ifdef HB_NSX_DEBUG
       hb_nsxPageCheckKeys( pBasePage, pTag, iBaseKey, 61 );
 #endif
@@ -3357,7 +3357,7 @@ static BOOL hb_nsxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
          hb_nsxSetKeyRecSize( pPage, hb_nsxGetRecSize( 0 ) );
          pPage->uiOffset = NSX_LEAFKEYOFFSET;
          pPage->uiKeys = 0;
-         pPage->Changed = TRUE;
+         pPage->Changed = HB_TRUE;
          hb_nsxPageRelease( pTag, pPage );
       }
       else
@@ -3387,7 +3387,7 @@ static BOOL hb_nsxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
                      hb_nsxBranchKeySize( pPage, pTag->KeyLength ) *
                      ( pPage->uiKeys - iKey ) );
          }
-         pPage->Changed = TRUE;
+         pPage->Changed = HB_TRUE;
          pTag->stackLevel = iLevel;
          hb_nsxTagSetPageStack( pTag, pPage, iKey );
          hb_nsxPageRelease( pTag, pPage );
@@ -3418,7 +3418,7 @@ static BOOL hb_nsxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
 /*
  * refresh CurKey value and set proper path from RootPage to LeafPage
  */
-static BOOL hb_nsxCurKeyRefresh( LPTAGINFO pTag )
+static HB_BOOL hb_nsxCurKeyRefresh( LPTAGINFO pTag )
 {
    NSXAREAP pArea = pTag->pIndex->pArea;
 
@@ -3428,20 +3428,20 @@ static BOOL hb_nsxCurKeyRefresh( LPTAGINFO pTag )
    if( !pArea->dbfarea.fPositioned )
    {
       pTag->stackLevel = 0;
-      pTag->TagBOF = pTag->TagEOF = TRUE;
+      pTag->TagBOF = pTag->TagEOF = HB_TRUE;
       pTag->CurKeyInfo->rec = 0;
-      return FALSE;
+      return HB_FALSE;
    }
    else if( pTag->stackLevel == 0 || pTag->CurKeyInfo->rec != pArea->dbfarea.ulRecNo )
    {
-      BOOL fValidBuf = pArea->dbfarea.fValidBuffer;
+      HB_BOOL fValidBuf = pArea->dbfarea.fValidBuffer;
       BYTE buf[ NSX_MAXKEYLEN ];
-      BOOL fBuf = FALSE;
+      HB_BOOL fBuf = HB_FALSE;
       LPKEYINFO pKey = NULL;
       /* Try to find previous if it's key for the same record */
       if( pTag->CurKeyInfo->rec == pArea->dbfarea.ulRecNo )
       {
-         fBuf = TRUE;
+         fBuf = HB_TRUE;
          memcpy( buf, pTag->CurKeyInfo->val, pTag->KeyLength );
          pKey = hb_nsxKeyCopy( pKey, pTag->CurKeyInfo, pTag->KeyLength );
          hb_nsxTagKeyFind( pTag, pKey, pTag->KeyLength );
@@ -3466,16 +3466,16 @@ static BOOL hb_nsxCurKeyRefresh( LPTAGINFO pTag )
       hb_nsxKeyFree( pKey );
       return pTag->CurKeyInfo->rec != 0 && pTag->CurKeyInfo->rec == pArea->dbfarea.ulRecNo;
    }
-   pTag->TagBOF = pTag->TagEOF = FALSE;
-   return TRUE;
+   pTag->TagBOF = pTag->TagEOF = HB_FALSE;
+   return HB_TRUE;
 }
 
 /*
  * Skip in tag respecting record filter only
  */
-static void hb_nsxTagSkipFilter( LPTAGINFO pTag, BOOL fForward )
+static void hb_nsxTagSkipFilter( LPTAGINFO pTag, HB_BOOL fForward )
 {
-   BOOL fBack, fEof = fForward ? pTag->TagEOF : pTag->TagBOF;
+   HB_BOOL fBack, fEof = fForward ? pTag->TagEOF : pTag->TagBOF;
 
    fBack = pTag->fUsrDescend ? fForward : !fForward;
 
@@ -3489,15 +3489,15 @@ static void hb_nsxTagSkipFilter( LPTAGINFO pTag, BOOL fForward )
 
       if( !fEof && !hb_nsxKeyInScope( pTag, pTag->CurKeyInfo ) )
       {
-         fEof = TRUE;
+         fEof = HB_TRUE;
       }
    }
    if( fEof )
    {
       if( fForward )
-         pTag->TagEOF = TRUE;
+         pTag->TagEOF = HB_TRUE;
       else
-         pTag->TagBOF = TRUE;
+         pTag->TagBOF = HB_TRUE;
    }
 }
 
@@ -3519,7 +3519,7 @@ static void hb_nsxTagGoTop( LPTAGINFO pTag )
                   !hb_nsxKeyInScope( pTag, pTag->CurKeyInfo );
 
    if( ! pTag->TagEOF && pTag->pIndex->pArea->dbfarea.area.dbfi.fFilter )
-      hb_nsxTagSkipFilter( pTag, TRUE );
+      hb_nsxTagSkipFilter( pTag, HB_TRUE );
 
    pTag->TagBOF = pTag->TagEOF;
 }
@@ -3542,7 +3542,7 @@ static void hb_nsxTagGoBottom( LPTAGINFO pTag )
                   !hb_nsxKeyInScope( pTag, pTag->CurKeyInfo );
 
    if( ! pTag->TagBOF && pTag->pIndex->pArea->dbfarea.area.dbfi.fFilter )
-      hb_nsxTagSkipFilter( pTag, FALSE );
+      hb_nsxTagSkipFilter( pTag, HB_FALSE );
 
    pTag->TagEOF = pTag->TagBOF;
 }
@@ -3552,10 +3552,10 @@ static void hb_nsxTagGoBottom( LPTAGINFO pTag )
  */
 static void hb_nsxTagSkipNext( LPTAGINFO pTag )
 {
-   pTag->TagBOF = FALSE;
+   pTag->TagBOF = HB_FALSE;
 
    if( pTag->stackLevel == 0 )
-      pTag->TagEOF = TRUE;
+      pTag->TagEOF = HB_TRUE;
    else if( ! hb_nsxInTopScope( pTag, pTag->CurKeyInfo->val ) )
       hb_nsxTagGoTop( pTag );
    else if( pTag->fUsrDescend )
@@ -3564,10 +3564,10 @@ static void hb_nsxTagSkipNext( LPTAGINFO pTag )
       pTag->TagEOF = !hb_nsxTagNextKey( pTag );
 
    if( ! pTag->TagEOF && ! hb_nsxKeyInScope( pTag, pTag->CurKeyInfo ) )
-      pTag->TagEOF = TRUE;
+      pTag->TagEOF = HB_TRUE;
 
    if( ! pTag->TagEOF && pTag->pIndex->pArea->dbfarea.area.dbfi.fFilter )
-      hb_nsxTagSkipFilter( pTag, TRUE );
+      hb_nsxTagSkipFilter( pTag, HB_TRUE );
 }
 
 /*
@@ -3575,7 +3575,7 @@ static void hb_nsxTagSkipNext( LPTAGINFO pTag )
  */
 static void hb_nsxTagSkipPrev( LPTAGINFO pTag )
 {
-   pTag->TagEOF = FALSE;
+   pTag->TagEOF = HB_FALSE;
 
    if( pTag->stackLevel == 0 )
       hb_nsxTagGoBottom( pTag );
@@ -3585,10 +3585,10 @@ static void hb_nsxTagSkipPrev( LPTAGINFO pTag )
       pTag->TagBOF = !hb_nsxTagPrevKey( pTag );
 
    if( ! pTag->TagBOF && ! hb_nsxKeyInScope( pTag, pTag->CurKeyInfo ) )
-      pTag->TagBOF = TRUE;
+      pTag->TagBOF = HB_TRUE;
 
    if( ! pTag->TagBOF && pTag->pIndex->pArea->dbfarea.area.dbfi.fFilter )
-      hb_nsxTagSkipFilter( pTag, FALSE );
+      hb_nsxTagSkipFilter( pTag, HB_FALSE );
 }
 
 /*
@@ -3710,10 +3710,10 @@ static void hb_nsxTagGoToRelKeyPos( LPTAGINFO pTag, double dPos )
 /*
  * free pages allocated by tag
  */
-static BOOL hb_nsxTagPagesFree( LPTAGINFO pTag, ULONG ulPage )
+static HB_BOOL hb_nsxTagPagesFree( LPTAGINFO pTag, ULONG ulPage )
 {
    LPPAGEINFO pPage = hb_nsxPageLoad( pTag, ulPage );
-   BOOL fOK = pPage != NULL;
+   HB_BOOL fOK = pPage != NULL;
 
    if( fOK )
    {
@@ -3754,7 +3754,7 @@ static HB_ERRCODE hb_nsxTagSpaceFree( LPTAGINFO pTag )
       }
       hb_nsxPageAddFree( pTag, pTag->HeadBlock );
       hb_nsxIndexTagDel( pTag->pIndex, pTag->TagName );
-      pTag->pIndex->Changed = TRUE;
+      pTag->pIndex->Changed = HB_TRUE;
    }
    hb_nsxTagDelete( pTag );
    return HB_SUCCESS;
@@ -3763,12 +3763,12 @@ static HB_ERRCODE hb_nsxTagSpaceFree( LPTAGINFO pTag )
 /*
  * create index file name
  */
-static void hb_nsxCreateFName( NSXAREAP pArea, const char * szBagName, BOOL * fProd,
+static void hb_nsxCreateFName( NSXAREAP pArea, const char * szBagName, HB_BOOL * fProd,
                                char * szFileName, char * szTagName )
 {
    PHB_FNAME pFileName;
    PHB_ITEM pExt = NULL;
-   BOOL fName = szBagName && *szBagName;
+   HB_BOOL fName = szBagName && *szBagName;
 
    pFileName = hb_fsFNameSplit( fName ? szBagName : pArea->dbfarea.szDataFileName );
 
@@ -3796,9 +3796,9 @@ static void hb_nsxCreateFName( NSXAREAP pArea, const char * szBagName, BOOL * fP
    if( fProd )
    {
       if( ! pFileName->szName )
-         *fProd = FALSE;
+         *fProd = HB_FALSE;
       else if( !fName )
-         *fProd = TRUE;
+         *fProd = HB_TRUE;
       else
       {
          PHB_FNAME pTableFileName = hb_fsFNameSplit( pArea->dbfarea.szDataFileName );
@@ -3831,7 +3831,7 @@ static LPNSXINDEX hb_nsxFindBag( NSXAREAP pArea, const char * szBagName )
 {
    LPNSXINDEX pIndex;
    PHB_FNAME pSeek, pName;
-   BOOL fFound;
+   HB_BOOL fFound;
 
    pSeek = hb_fsFNameSplit( szBagName );
    if( ! pSeek->szName )
@@ -3880,7 +3880,7 @@ static LPTAGINFO hb_nsxFindTag( NSXAREAP pArea, PHB_ITEM pTagItem,
                                 PHB_ITEM pBagItem )
 {
    LPNSXINDEX pIndex;
-   BOOL fBag;
+   HB_BOOL fBag;
 
    if( ! pTagItem ||
        ( hb_itemType( pTagItem ) & ( HB_IT_STRING | HB_IT_NUMERIC ) ) == 0 )
@@ -3901,7 +3901,7 @@ static LPTAGINFO hb_nsxFindTag( NSXAREAP pArea, PHB_ITEM pTagItem,
       pIndex = pArea->lpIndexes;
       if( iBag > 0 )
       {
-         fBag = TRUE;
+         fBag = HB_TRUE;
          while( pIndex )
          {
             if( --iBag == 0 )
@@ -3983,7 +3983,7 @@ static int hb_nsxFindTagNum( NSXAREAP pArea, LPTAGINFO pTag )
          }
          pIndex = pIndex->pNext;
       }
-      pArea->fSetTagNumbers = FALSE;
+      pArea->fSetTagNumbers = HB_FALSE;
    }
    return pTag->uiNumber;
 }
@@ -4070,7 +4070,7 @@ static ULONG hb_nsxOrdKeyNo( LPTAGINFO pTag )
          else
          {
             int iLevel = pTag->stackLevel, iKey;
-            BOOL fBack = pTag->fUsrDescend, fFirst = TRUE;
+            HB_BOOL fBack = pTag->fUsrDescend, fFirst = HB_TRUE;
             LPPAGEINFO pPage;
 
             while( --iLevel >= 0 )
@@ -4094,7 +4094,7 @@ static ULONG hb_nsxOrdKeyNo( LPTAGINFO pTag )
                            hb_nsxGetKeyPage( pPage, pTag->KeyLength, iKey - 1 ) );
                      }
                   }
-                  fFirst = FALSE;
+                  fFirst = HB_FALSE;
                }
                else
                {
@@ -4123,12 +4123,12 @@ static ULONG hb_nsxOrdKeyNo( LPTAGINFO pTag )
 /*
  * set logical key position in given tag
  */
-static BOOL hb_nsxOrdKeyGoto( LPTAGINFO pTag, ULONG ulKeyNo )
+static HB_BOOL hb_nsxOrdKeyGoto( LPTAGINFO pTag, ULONG ulKeyNo )
 {
    NSXAREAP pArea = pTag->pIndex->pArea;
 
    if( ! ulKeyNo || ! hb_nsxTagLockRead( pTag ) )
-      return FALSE;
+      return HB_FALSE;
 
    hb_nsxTagRefreshScope( pTag );
    hb_nsxTagGoTop( pTag );
@@ -4141,7 +4141,7 @@ static BOOL hb_nsxOrdKeyGoto( LPTAGINFO pTag, ULONG ulKeyNo )
    else
    {
       int iLevel = pTag->stackLevel - 1, iKey;
-      BOOL fBack = pTag->fUsrDescend, fFirst = TRUE;
+      HB_BOOL fBack = pTag->fUsrDescend, fFirst = HB_TRUE;
       LPPAGEINFO pPage;
       ULONG ulPage;
 
@@ -4185,7 +4185,7 @@ static BOOL hb_nsxOrdKeyGoto( LPTAGINFO pTag, ULONG ulKeyNo )
                   --ulKeyNo;
                }
             }
-            fFirst = FALSE;
+            fFirst = HB_FALSE;
          }
          else
          {
@@ -4228,7 +4228,7 @@ static BOOL hb_nsxOrdKeyGoto( LPTAGINFO pTag, ULONG ulKeyNo )
          if( ulKeyNo == 0 )
          {
             if( !hb_nsxTagGetCurKey( pTag, pPage, pTag->stack[ iLevel ].ikey ) )
-               pTag->TagEOF = TRUE;
+               pTag->TagEOF = HB_TRUE;
          }
          hb_nsxPageRelease( pTag, pPage );
       }
@@ -4248,7 +4248,7 @@ static BOOL hb_nsxOrdKeyGoto( LPTAGINFO pTag, ULONG ulKeyNo )
       pArea->lpCurTag = pSavedTag;
    }
    hb_nsxTagUnLockRead( pTag );
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
@@ -4257,19 +4257,19 @@ static BOOL hb_nsxOrdKeyGoto( LPTAGINFO pTag, ULONG ulKeyNo )
 static double hb_nsxOrdGetRelKeyPos( LPTAGINFO pTag )
 {
    double dPos = 0.0, dStart = 0.0, dStop = 1.0, dFact = 0.0000000000001;
-   BOOL fOK = TRUE, fFilter = pTag->pIndex->pArea->dbfarea.area.dbfi.fFilter;
+   HB_BOOL fOK = HB_TRUE, fFilter = pTag->pIndex->pArea->dbfarea.area.dbfi.fFilter;
 
    if( ! hb_nsxTagLockRead( pTag ) )
-      return FALSE;
+      return HB_FALSE;
 
    hb_nsxTagRefreshScope( pTag );
 
-   pTag->pIndex->pArea->dbfarea.area.dbfi.fFilter = FALSE;
+   pTag->pIndex->pArea->dbfarea.area.dbfi.fFilter = HB_FALSE;
    if( pTag->fUsrDescend ? pTag->bottom.scopeKeyLen : pTag->top.scopeKeyLen )
    {
       hb_nsxTagGoTop( pTag );
       if( pTag->TagEOF )
-         fOK = FALSE;
+         fOK = HB_FALSE;
       else
          dStart = hb_nsxTagCountRelKeyPos( pTag );
    }
@@ -4277,7 +4277,7 @@ static double hb_nsxOrdGetRelKeyPos( LPTAGINFO pTag )
    {
       hb_nsxTagGoBottom( pTag );
       if( pTag->TagBOF )
-         fOK = FALSE;
+         fOK = HB_FALSE;
       else
          dStop = hb_nsxTagCountRelKeyPos( pTag );
    }
@@ -4316,23 +4316,23 @@ static void hb_nsxOrdSetRelKeyPos( LPTAGINFO pTag, double dPos )
    {
       NSXAREAP pArea = pTag->pIndex->pArea;
       double dStart = 0.0, dStop = 1.0, dFact = 0.0000000000001;
-      BOOL fOK = TRUE, fFilter = pArea->dbfarea.area.dbfi.fFilter;
-      BOOL fForward = TRUE, fTop = FALSE;
+      HB_BOOL fOK = HB_TRUE, fFilter = pArea->dbfarea.area.dbfi.fFilter;
+      HB_BOOL fForward = HB_TRUE, fTop = HB_FALSE;
 
       hb_nsxTagRefreshScope( pTag );
 
       if( dPos >= 1.0 )
-         fForward = FALSE;
+         fForward = HB_FALSE;
       else if( dPos <= 0.0 )
-         fTop = TRUE;
+         fTop = HB_TRUE;
       else
       {
-         pArea->dbfarea.area.dbfi.fFilter = FALSE;
+         pArea->dbfarea.area.dbfi.fFilter = HB_FALSE;
          if( pTag->fUsrDescend ? pTag->bottom.scopeKeyLen : pTag->top.scopeKeyLen )
          {
             hb_nsxTagGoTop( pTag );
             if( pTag->TagEOF )
-               fOK = FALSE;
+               fOK = HB_FALSE;
             else
                dStart = hb_nsxTagCountRelKeyPos( pTag );
          }
@@ -4340,7 +4340,7 @@ static void hb_nsxOrdSetRelKeyPos( LPTAGINFO pTag, double dPos )
          {
             hb_nsxTagGoBottom( pTag );
             if( pTag->TagBOF )
-               fOK = FALSE;
+               fOK = HB_FALSE;
             else
                dStop = hb_nsxTagCountRelKeyPos( pTag );
          }
@@ -4350,18 +4350,18 @@ static void hb_nsxOrdSetRelKeyPos( LPTAGINFO pTag, double dPos )
          {
             if( dStart >= dStop - dFact )
             {
-               fTop = TRUE;
+               fTop = HB_TRUE;
             }
             else
             {
                dPos = dPos * ( dStop - dStart ) + dStart;
                hb_nsxTagGoToRelKeyPos( pTag, dPos );
                if( pTag->CurKeyInfo->rec == 0 )
-                  fForward = FALSE;
+                  fForward = HB_FALSE;
                else if( !hb_nsxInTopScope( pTag, pTag->CurKeyInfo->val ) )
-                  fTop = TRUE;
+                  fTop = HB_TRUE;
                else if( !hb_nsxInBottomScope( pTag, pTag->CurKeyInfo->val ) )
-                  fForward = FALSE;
+                  fForward = HB_FALSE;
             }
          }
       }
@@ -4374,7 +4374,7 @@ static void hb_nsxOrdSetRelKeyPos( LPTAGINFO pTag, double dPos )
          LPTAGINFO pSavedTag = pArea->lpCurTag;
          pArea->lpCurTag = pTag;
 
-         pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+         pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
          if( fForward )
          {
@@ -4386,13 +4386,13 @@ static void hb_nsxOrdSetRelKeyPos( LPTAGINFO pTag, double dPos )
                {
                   SELF_SKIPFILTER( ( AREAP ) pArea, 1 );
                   if( pArea->dbfarea.area.fEof && !fTop )
-                     fForward = FALSE;
+                     fForward = HB_FALSE;
                }
             }
             else if( fTop )
                SELF_GOTO( ( AREAP ) pArea, 0 );
             else
-               fForward = FALSE;
+               fForward = HB_FALSE;
          }
          if( !fForward )
          {
@@ -4400,7 +4400,7 @@ static void hb_nsxOrdSetRelKeyPos( LPTAGINFO pTag, double dPos )
             if( SELF_GOTO( ( AREAP ) pArea, pTag->CurKeyInfo->rec ) == HB_SUCCESS &&
                 pTag->CurKeyInfo->rec != 0 )
             {
-               pArea->dbfarea.area.fBottom = TRUE;
+               pArea->dbfarea.area.fBottom = HB_TRUE;
                SELF_SKIPFILTER( ( AREAP ) pArea, -1 );
             }
          }
@@ -4413,15 +4413,15 @@ static void hb_nsxOrdSetRelKeyPos( LPTAGINFO pTag, double dPos )
 /*
  * skip to next/previous unique key
  */
-static BOOL hb_nsxOrdSkipUnique( LPTAGINFO pTag, LONG lToSkip )
+static HB_BOOL hb_nsxOrdSkipUnique( LPTAGINFO pTag, LONG lToSkip )
 {
    NSXAREAP pArea = pTag->pIndex->pArea;
-   BOOL fOut = FALSE, fEof = FALSE, fForward = ( lToSkip >= 0 );
+   HB_BOOL fOut = HB_FALSE, fEof = HB_FALSE, fForward = ( lToSkip >= 0 );
 
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
-   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
    if( hb_nsxTagLockRead( pTag ) )
    {
@@ -4454,12 +4454,12 @@ static BOOL hb_nsxOrdSkipUnique( LPTAGINFO pTag, LONG lToSkip )
       }
       else
       {
-         fOut = TRUE;
+         fOut = HB_TRUE;
       }
       if( fOut )
       {
          if( fForward )
-            fEof = TRUE;
+            fEof = HB_TRUE;
          else
          {
             hb_nsxTagGoTop( pTag );
@@ -4473,42 +4473,42 @@ static BOOL hb_nsxOrdSkipUnique( LPTAGINFO pTag, LONG lToSkip )
       {
          SELF_SKIPFILTER( ( AREAP ) pArea, ( fForward || fOut ) ? 1 : -1 );
          if( ! fForward && fOut )
-            pArea->dbfarea.area.fBof = TRUE;
+            pArea->dbfarea.area.fBof = HB_TRUE;
       }
 
       /* Update Bof and Eof flags */
       if( fForward )
-         pArea->dbfarea.area.fBof = FALSE;
+         pArea->dbfarea.area.fBof = HB_FALSE;
       else
-         pArea->dbfarea.area.fEof = FALSE;
+         pArea->dbfarea.area.fEof = HB_FALSE;
 
       pArea->lpCurTag = pSavedTag;
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 /*
- * skip while code block doesn't return TRUE
+ * skip while code block doesn't return HB_TRUE
  */
-static BOOL hb_nsxOrdSkipEval( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pEval )
+static HB_BOOL hb_nsxOrdSkipEval( LPTAGINFO pTag, HB_BOOL fForward, PHB_ITEM pEval )
 {
    NSXAREAP pArea = pTag->pIndex->pArea;
-   BOOL fFound = FALSE;
+   HB_BOOL fFound = HB_FALSE;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_nsxOrdSkipEval(%p, %d, %p)", pTag, fForward, pEval));
 
    if( hb_itemType( pEval ) != HB_IT_BLOCK )
    {
       if( SELF_SKIP( ( AREAP ) pArea, fForward ? 1 : -1 ) != HB_SUCCESS )
-         return FALSE;
+         return HB_FALSE;
       return fForward ? !pArea->dbfarea.area.fEof : !pArea->dbfarea.area.fBof;
    }
 
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
-   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
    if( hb_nsxTagLockRead( pTag ) )
    {
@@ -4533,7 +4533,7 @@ static BOOL hb_nsxOrdSkipEval( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pEval )
                if( SELF_SKIPFILTER( ( AREAP ) pArea, fForward ? 1 : -1 ) != HB_SUCCESS ||
                    pArea->dbfarea.ulRecNo == ulRecNo || hb_nsxEvalSeekCond( pTag, pEval ) )
                {
-                  fFound = TRUE;
+                  fFound = HB_TRUE;
                   break;
                }
             }
@@ -4549,7 +4549,7 @@ static BOOL hb_nsxOrdSkipEval( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pEval )
             else
             {
                SELF_GOTOP( ( AREAP ) pArea );
-               pArea->dbfarea.area.fBof = TRUE;
+               pArea->dbfarea.area.fBof = HB_TRUE;
             }
          }
       }
@@ -4559,22 +4559,22 @@ static BOOL hb_nsxOrdSkipEval( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pEval )
 
    /* Update Bof and Eof flags */
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
    return fFound;
 }
 
 /*
- * skip while code block doesn't return TRUE
+ * skip while code block doesn't return HB_TRUE
  */
-static BOOL hb_nsxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm )
+static HB_BOOL hb_nsxOrdSkipWild( LPTAGINFO pTag, HB_BOOL fForward, PHB_ITEM pWildItm )
 {
    NSXAREAP pArea = pTag->pIndex->pArea;
    const char *szPattern;
    char *szFree = NULL;
-   BOOL fFound = FALSE;
+   HB_BOOL fFound = HB_FALSE;
    int iFixed = 0;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_nsxOrdSkipWild(%p, %d, %p)", pTag, fForward, pWildItm));
@@ -4584,7 +4584,7 @@ static BOOL hb_nsxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm
    if( pTag->KeyType != 'C' || !szPattern || !*szPattern )
    {
       if( SELF_SKIP( ( AREAP ) pArea, fForward ? 1 : -1 ) != HB_SUCCESS )
-         return FALSE;
+         return HB_FALSE;
       return fForward ? !pArea->dbfarea.area.fEof : !pArea->dbfarea.area.fBof;
    }
 
@@ -4601,7 +4601,7 @@ static BOOL hb_nsxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
-   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
    if( hb_nsxTagLockRead( pTag ) )
    {
@@ -4628,9 +4628,9 @@ static BOOL hb_nsxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm
             if( !hb_nsxTagKeyFind( pTag, pKey, iFixed ) )
             {
                if( fForward )
-                  pTag->TagEOF = TRUE;
+                  pTag->TagEOF = HB_TRUE;
                else
-                  pTag->TagBOF = TRUE;
+                  pTag->TagBOF = HB_TRUE;
             }
             hb_nsxKeyFree( pKey );
          }
@@ -4650,7 +4650,7 @@ static BOOL hb_nsxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm
                    pArea->dbfarea.ulRecNo == ulRecNo ||
                    hb_strMatchWild( ( const char * ) pTag->CurKeyInfo->val, szPattern ) )
                {
-                  fFound = TRUE;
+                  fFound = HB_TRUE;
                   break;
                }
             }
@@ -4671,7 +4671,7 @@ static BOOL hb_nsxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm
             else
             {
                SELF_GOTOP( ( AREAP ) pArea );
-               pArea->dbfarea.area.fBof = TRUE;
+               pArea->dbfarea.area.fBof = HB_TRUE;
             }
          }
       }
@@ -4681,9 +4681,9 @@ static BOOL hb_nsxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm
 
    /* Update Bof and Eof flags */
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
    if( szFree )
       hb_xfree( szFree );
@@ -4691,7 +4691,7 @@ static BOOL hb_nsxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm
    return fFound;
 }
 
-static BOOL hb_nsxRegexMatch( LPTAGINFO pTag, PHB_REGEX pRegEx, const char * szKey )
+static HB_BOOL hb_nsxRegexMatch( LPTAGINFO pTag, PHB_REGEX pRegEx, const char * szKey )
 {
    ULONG ulLen = pTag->KeyLength;
    char szBuff[ NSX_MAXKEYLEN + 1 ];
@@ -4704,16 +4704,16 @@ static BOOL hb_nsxRegexMatch( LPTAGINFO pTag, PHB_REGEX pRegEx, const char * szK
       szBuff[ ulLen ] = '\0';
       szKey = szBuff;
    }
-   return hb_regexMatch( pRegEx, szKey, ulLen, FALSE );
+   return hb_regexMatch( pRegEx, szKey, ulLen, HB_FALSE );
 }
 
 /*
- * skip while regular expression on index key val doesn't return TRUE
+ * skip while regular expression on index key val doesn't return HB_TRUE
  */
-static BOOL hb_nsxOrdSkipRegEx( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pRegExItm )
+static HB_BOOL hb_nsxOrdSkipRegEx( LPTAGINFO pTag, HB_BOOL fForward, PHB_ITEM pRegExItm )
 {
    NSXAREAP pArea = pTag->pIndex->pArea;
-   BOOL fFound = FALSE;
+   HB_BOOL fFound = HB_FALSE;
    PHB_REGEX pRegEx;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_nsxOrdSkipRegEx(%p, %d, %p)", pTag, fForward, pRegExItm));
@@ -4721,14 +4721,14 @@ static BOOL hb_nsxOrdSkipRegEx( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pRegExIt
    if( pTag->KeyType != 'C' || ( pRegEx = hb_regexGet( pRegExItm, 0 ) ) == NULL )
    {
       if( SELF_SKIP( ( AREAP ) pArea, fForward ? 1 : -1 ) != HB_SUCCESS )
-         return FALSE;
+         return HB_FALSE;
       return fForward ? !pArea->dbfarea.area.fEof : !pArea->dbfarea.area.fBof;
    }
 
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
-   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
    if( hb_nsxTagLockRead( pTag ) )
    {
@@ -4755,7 +4755,7 @@ static BOOL hb_nsxOrdSkipRegEx( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pRegExIt
                    pArea->dbfarea.ulRecNo == ulRecNo ||
                    hb_nsxRegexMatch( pTag, pRegEx, ( const char * ) pTag->CurKeyInfo->val ) )
                {
-                  fFound = TRUE;
+                  fFound = HB_TRUE;
                   break;
                }
             }
@@ -4771,7 +4771,7 @@ static BOOL hb_nsxOrdSkipRegEx( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pRegExIt
             else
             {
                SELF_GOTOP( ( AREAP ) pArea );
-               pArea->dbfarea.area.fBof = TRUE;
+               pArea->dbfarea.area.fBof = HB_TRUE;
             }
          }
       }
@@ -4781,9 +4781,9 @@ static BOOL hb_nsxOrdSkipRegEx( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pRegExIt
 
    /* Update Bof and Eof flags */
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
    hb_regexFree( pRegEx );
 
@@ -4794,24 +4794,24 @@ static BOOL hb_nsxOrdSkipRegEx( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pRegExIt
  * add key to custom tag (ordKeyAdd())
  * user key value is not implemented
  */
-static BOOL hb_nsxOrdKeyAdd( LPTAGINFO pTag, PHB_ITEM pItem )
+static HB_BOOL hb_nsxOrdKeyAdd( LPTAGINFO pTag, PHB_ITEM pItem )
 {
    NSXAREAP pArea = pTag->pIndex->pArea;
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
    LPKEYINFO pKey;
 
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
    if( !pArea->dbfarea.fPositioned )
-      return FALSE;
+      return HB_FALSE;
 
-   if( pTag->pForItem && !hb_nsxEvalCond( pArea, pTag->pForItem, TRUE ) )
-      return FALSE;
+   if( pTag->pForItem && !hb_nsxEvalCond( pArea, pTag->pForItem, HB_TRUE ) )
+      return HB_FALSE;
 
    if( pTag->Template && pItem && hb_itemType( pItem ) != HB_IT_NIL )
    {
-      pKey = hb_nsxKeyPutItem( NULL, pItem, pArea->dbfarea.ulRecNo, pTag, TRUE, NULL );
+      pKey = hb_nsxKeyPutItem( NULL, pItem, pArea->dbfarea.ulRecNo, pTag, HB_TRUE, NULL );
    }
    else
    {
@@ -4822,7 +4822,7 @@ static BOOL hb_nsxOrdKeyAdd( LPTAGINFO pTag, PHB_ITEM pItem )
    {
       if( hb_nsxTagKeyAdd( pTag, pKey ) )
       {
-         fResult = TRUE;
+         fResult = HB_TRUE;
          if( !pTag->pIndex->fShared && pTag->keyCount &&
              hb_nsxKeyInScope( pTag, pKey ) )
             pTag->keyCount++;
@@ -4837,24 +4837,24 @@ static BOOL hb_nsxOrdKeyAdd( LPTAGINFO pTag, PHB_ITEM pItem )
  * del key from custom tag (ordKeyDel())
  * user key value is not implemented
  */
-static BOOL hb_nsxOrdKeyDel( LPTAGINFO pTag, PHB_ITEM pItem )
+static HB_BOOL hb_nsxOrdKeyDel( LPTAGINFO pTag, PHB_ITEM pItem )
 {
    NSXAREAP pArea = pTag->pIndex->pArea;
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
    LPKEYINFO pKey = NULL;
 
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
    if( !pArea->dbfarea.fPositioned )
-      return FALSE;
+      return HB_FALSE;
 
-   if( pTag->pForItem && !hb_nsxEvalCond( pArea, pTag->pForItem, TRUE ) )
-      return FALSE;
+   if( pTag->pForItem && !hb_nsxEvalCond( pArea, pTag->pForItem, HB_TRUE ) )
+      return HB_FALSE;
 
    if( pTag->Template && pItem && hb_itemType( pItem ) != HB_IT_NIL )
    {
-      pKey = hb_nsxKeyPutItem( NULL, pItem, pArea->dbfarea.ulRecNo, pTag, TRUE, NULL );
+      pKey = hb_nsxKeyPutItem( NULL, pItem, pArea->dbfarea.ulRecNo, pTag, HB_TRUE, NULL );
    }
 
    if( hb_nsxTagLockWrite( pTag ) )
@@ -4868,7 +4868,7 @@ static BOOL hb_nsxOrdKeyDel( LPTAGINFO pTag, PHB_ITEM pItem )
       }
       if( hb_nsxTagKeyDel( pTag, pKey ) )
       {
-         fResult = TRUE;
+         fResult = HB_TRUE;
          if( !pTag->pIndex->fShared && pTag->keyCount &&
              hb_nsxKeyInScope( pTag, pKey ) )
             pTag->keyCount--;
@@ -4884,10 +4884,10 @@ static BOOL hb_nsxOrdKeyDel( LPTAGINFO pTag, PHB_ITEM pItem )
  * custom indexes when the same record can be stored more then once
  * or when the used index key is unknown
  */
-static BOOL hb_nsxOrdFindRec( LPTAGINFO pTag, ULONG ulRecNo, BOOL fCont )
+static HB_BOOL hb_nsxOrdFindRec( LPTAGINFO pTag, ULONG ulRecNo, HB_BOOL fCont )
 {
    NSXAREAP pArea = pTag->pIndex->pArea;
-   BOOL fFound = FALSE;
+   HB_BOOL fFound = HB_FALSE;
 
    if( pTag && ulRecNo )
    {
@@ -4914,7 +4914,7 @@ static BOOL hb_nsxOrdFindRec( LPTAGINFO pTag, ULONG ulRecNo, BOOL fCont )
             {
                if( pTag->CurKeyInfo->rec == ulRecNo )
                {
-                  fFound = TRUE;
+                  fFound = HB_TRUE;
                   break;
                }
                hb_nsxTagSkipNext( pTag );
@@ -4936,14 +4936,14 @@ static ULONG hb_nsxOrdScopeEval( LPTAGINFO pTag,
 {
    ULONG ulCount = 0, ulLen = ( ULONG ) pTag->KeyLength;
    PHB_ITEM pItemTop = hb_itemNew( NULL ), pItemBottom = hb_itemNew( NULL );
-   BOOL fDescend = pTag->fUsrDescend;
+   HB_BOOL fDescend = pTag->fUsrDescend;
 
    if( fDescend )
    {
       PHB_ITEM pTemp = pItemLo;
       pItemLo = pItemHi;
       pItemHi = pTemp;
-      pTag->fUsrDescend = FALSE;
+      pTag->fUsrDescend = HB_FALSE;
    }
    hb_nsxTagGetScope( pTag, 0, pItemTop );
    hb_nsxTagGetScope( pTag, 1, pItemBottom );
@@ -4987,14 +4987,14 @@ static int hb_nsxQuickSortCompare( LPNSXSORTINFO pSort, UCHAR * pKey1, UCHAR * p
    return i;
 }
 
-static BOOL hb_nsxQSort( LPNSXSORTINFO pSort, UCHAR * pSrc, UCHAR * pBuf, LONG lKeys )
+static HB_BOOL hb_nsxQSort( LPNSXSORTINFO pSort, UCHAR * pSrc, UCHAR * pBuf, LONG lKeys )
 {
    if( lKeys > 1 )
    {
       int iLen = pSort->keyLen + 4;
       LONG l1, l2;
       UCHAR * pPtr1, * pPtr2, *pDst;
-      BOOL f1, f2;
+      HB_BOOL f1, f2;
 
       l1 = lKeys >> 1;
       l2 = lKeys - l1;
@@ -5038,7 +5038,7 @@ static BOOL hb_nsxQSort( LPNSXSORTINFO pSort, UCHAR * pSrc, UCHAR * pBuf, LONG l
          memcpy( pDst, pPtr2, iLen * l2 );
       return !f1;
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 static void hb_nsxSortSortPage( LPNSXSORTINFO pSort )
@@ -5068,9 +5068,9 @@ static void hb_nsxSortBufferFlush( LPNSXSORTINFO pSort )
                         pIndex->IndexName, hb_fsError(), 0, NULL );
       }
       pSort->ulPagesIO = 0;
-      pIndex->fFlush = TRUE;
+      pIndex->fFlush = HB_TRUE;
       if( pIndex->fShared )
-         pIndex->Changed = TRUE;
+         pIndex->Changed = HB_TRUE;
    }
 }
 
@@ -5096,7 +5096,7 @@ static void hb_nsxSortStorePage( LPNSXSORTINFO pSort, LPPAGEINFO pPage )
             pSort->ulLastIO = pPage->Page;
             if( !pSort->ulPagesIO++ )
                pSort->ulFirstIO = pPage->Page;
-            pPage->Changed = FALSE;
+            pPage->Changed = HB_FALSE;
             return;
          }
       }
@@ -5117,7 +5117,7 @@ static void hb_nsxSortAddNodeKey( LPNSXSORTINFO pSort, UCHAR *pKeyVal, ULONG ulR
       pPage = pSort->NodeList[ iLevel ];
       if( pPage == NULL )
       {
-         pPage = pSort->NodeList[ iLevel ] = hb_nsxPageNew( pSort->pTag, TRUE );
+         pPage = pSort->NodeList[ iLevel ] = hb_nsxPageNew( pSort->pTag, HB_TRUE );
          if( iLevel == 0 )
          {
             /* executed once for first key only */
@@ -5165,7 +5165,7 @@ static void hb_nsxSortAddNodeKey( LPNSXSORTINFO pSort, UCHAR *pKeyVal, ULONG ulR
       hb_nsxSortStorePage( pSort, pPage );
       ulPage = pPage->Page;
       hb_nsxPageRelease( pSort->pTag, pPage );
-      pSort->NodeList[ iLevel ] = hb_nsxPageNew( pSort->pTag, TRUE );
+      pSort->NodeList[ iLevel ] = hb_nsxPageNew( pSort->pTag, HB_TRUE );
       if( iLevel == 0 )
       {
          pSort->ulLastLeaf = ulPage;
@@ -5281,7 +5281,7 @@ static void hb_nsxSortOrderPages( LPNSXSORTINFO pSort )
    }
 }
 
-static BOOL hb_nsxSortKeyGet( LPNSXSORTINFO pSort, UCHAR ** pKeyVal, ULONG *pulRec )
+static HB_BOOL hb_nsxSortKeyGet( LPNSXSORTINFO pSort, UCHAR ** pKeyVal, ULONG *pulRec )
 {
    int iLen = pSort->keyLen, i;
    LONG l, r, m;
@@ -5339,13 +5339,13 @@ static BOOL hb_nsxSortKeyGet( LPNSXSORTINFO pSort, UCHAR ** pKeyVal, ULONG *pulR
       pSort->pSwapPage[ ulPage ].ulCurKey++;
       pSort->pSwapPage[ ulPage ].ulKeys--;
       pSort->pSwapPage[ ulPage ].ulKeyBuf--;
-      return TRUE;
+      return HB_TRUE;
    }
 
    *pKeyVal = NULL;
    *pulRec = 0;
 
-   return FALSE;
+   return HB_FALSE;
 }
 
 static void hb_nsxSortKeyAdd( LPNSXSORTINFO pSort, ULONG ulRec, const char * pKeyVal, int iKeyLen )
@@ -5460,7 +5460,7 @@ static LPNSXSORTINFO hb_nsxSortNew( LPTAGINFO pTag, ULONG ulRecCount )
    return pSort;
 }
 
-static void hb_nsxSortFree( LPNSXSORTINFO pSort, BOOL fFull )
+static void hb_nsxSortFree( LPNSXSORTINFO pSort, HB_BOOL fFull )
 {
    if( pSort->hTempFile != FS_ERROR )
    {
@@ -5501,7 +5501,7 @@ static void hb_nsxSortFree( LPNSXSORTINFO pSort, BOOL fFull )
 
 static void hb_nsxSortOut( LPNSXSORTINFO pSort )
 {
-   BOOL fUnique = pSort->fUnique, fNext;
+   HB_BOOL fUnique = pSort->fUnique, fNext;
    LPTAGINFO pTag = pSort->pTag;
    ULONG ulLastPage = 0, ulPage, ulRec, ulKey;
    UCHAR * pKeyVal = NULL;
@@ -5596,7 +5596,7 @@ static void hb_nsxSortOut( LPNSXSORTINFO pSort )
 
    if( pSort->NodeList[ 0 ] == NULL )
    {
-      pSort->NodeList[ 0 ] = hb_nsxPageNew( pTag, TRUE );
+      pSort->NodeList[ 0 ] = hb_nsxPageNew( pTag, HB_TRUE );
       hb_nsxSetPageType( pSort->NodeList[ 0 ], NSX_LEAFPAGE );
       hb_nsxSetKeyRecSize( pSort->NodeList[ 0 ], pSort->recSize );
       pSort->NodeList[ 0 ]->uiOffset = NSX_LEAFKEYOFFSET;
@@ -5604,7 +5604,7 @@ static void hb_nsxSortOut( LPNSXSORTINFO pSort )
 
    iLevel = 0;
    ulPage = 0;
-   fNext = TRUE;
+   fNext = HB_TRUE;
    do
    {
       if( iLevel + 1 == NSX_STACKSIZE || pSort->NodeList[ iLevel + 1 ] == NULL )
@@ -5614,7 +5614,7 @@ static void hb_nsxSortOut( LPNSXSORTINFO pSort )
          if( ulPage && !ulLastPage && pSort->NodeList[ iLevel ]->uiKeys != 0 )
             ulLastPage = pSort->NodeList[ iLevel ]->Page;
          pTag->RootBlock = pSort->NodeList[ iLevel ]->Page;
-         fNext = FALSE;
+         fNext = HB_FALSE;
       }
       else
       {
@@ -5652,7 +5652,7 @@ static void hb_nsxSortOut( LPNSXSORTINFO pSort )
                                pKeyVal, iLen, NSX_CMP_EXACT ) == 0;
 
    hb_nsxSortBufferFlush( pSort );
-   hb_nsxSortFree( pSort, FALSE );
+   hb_nsxSortFree( pSort, HB_FALSE );
 
    if( ulLastPage && hb_vmRequestQuery() == 0 )
    {
@@ -5714,7 +5714,7 @@ static void hb_nsxSortOut( LPNSXSORTINFO pSort )
                memcpy( pKeyVal, pSort->pLastKey, pTag->KeyLength );
 
                /* mark pages as modified */
-               pPage->Changed = pLastPage->Changed = pLastLeaf->Changed = TRUE;
+               pPage->Changed = pLastPage->Changed = pLastLeaf->Changed = HB_TRUE;
 
                hb_nsxPageRelease( pTag, pLastPage );
             }
@@ -5728,7 +5728,7 @@ static void hb_nsxSortOut( LPNSXSORTINFO pSort )
 /*
  * create tag in index file
  */
-static HB_ERRCODE hb_nsxTagCreate( LPTAGINFO pTag, BOOL fReindex )
+static HB_ERRCODE hb_nsxTagCreate( LPTAGINFO pTag, HB_BOOL fReindex )
 {
    LPNSXAREA pArea = pTag->pIndex->pArea;
    PHB_ITEM pForItem, pWhileItem = NULL, pEvalItem = NULL, pItem = NULL;
@@ -5769,7 +5769,7 @@ static HB_ERRCODE hb_nsxTagCreate( LPTAGINFO pTag, BOOL fReindex )
       }
 #endif
 
-      pPage = hb_nsxPageNew( pTag, FALSE );
+      pPage = hb_nsxPageNew( pTag, HB_FALSE );
       if( pPage )
       {
          pTag->RootBlock = pPage->Page;
@@ -5787,7 +5787,7 @@ static HB_ERRCODE hb_nsxTagCreate( LPTAGINFO pTag, BOOL fReindex )
    {
       LPTAGINFO pSaveTag = pArea->lpCurTag;
       ULONG ulStartRec = 0, ulNextCount = 0;
-      BOOL fDirectRead, fUseFilter = FALSE;
+      HB_BOOL fDirectRead, fUseFilter = HB_FALSE;
       BYTE * pSaveRecBuff = pArea->dbfarea.pRecord;
       char szBuffer[ NSX_MAXKEYLEN ];
       int iRecBuff = 0, iRecBufSize, iRec;
@@ -5821,7 +5821,7 @@ static HB_ERRCODE hb_nsxTagCreate( LPTAGINFO pTag, BOOL fReindex )
          }
          else if( pArea->dbfarea.area.lpdbOrdCondInfo->fUseFilter )
          {
-            fUseFilter = TRUE;
+            fUseFilter = HB_TRUE;
          }
          else if( !pArea->dbfarea.area.lpdbOrdCondInfo->fUseCurrent )
          {
@@ -5883,7 +5883,7 @@ static HB_ERRCODE hb_nsxTagCreate( LPTAGINFO pTag, BOOL fReindex )
             pArea->dbfarea.ulRecNo = ulRecNo;
             if( SELF_GETREC( ( AREAP ) pArea, NULL ) == HB_FAILURE )
                break;
-            pArea->dbfarea.fValidBuffer = pArea->dbfarea.fPositioned = TRUE;
+            pArea->dbfarea.fValidBuffer = pArea->dbfarea.fPositioned = HB_TRUE;
             pArea->dbfarea.fDeleted = pArea->dbfarea.pRecord[ 0 ] == '*';
             /* Force relational movement in child WorkAreas */
             if( pArea->dbfarea.area.lpdbRelations )
@@ -5895,11 +5895,11 @@ static HB_ERRCODE hb_nsxTagCreate( LPTAGINFO pTag, BOOL fReindex )
             iRecBuff++;
          }
 
-         if( pWhileItem && !hb_nsxEvalCond( NULL, pWhileItem, FALSE ) )
+         if( pWhileItem && !hb_nsxEvalCond( NULL, pWhileItem, HB_FALSE ) )
             break;
 
          if( ulRecNo <= ulRecCount &&
-             ( pForItem == NULL || hb_nsxEvalCond( pArea, pForItem, FALSE ) ) )
+             ( pForItem == NULL || hb_nsxEvalCond( pArea, pForItem, HB_FALSE ) ) )
          {
             if( pTag->nField )
                errCode = SELF_GETVALUE( ( AREAP ) pArea, pTag->nField, pItem );
@@ -5942,7 +5942,7 @@ static HB_ERRCODE hb_nsxTagCreate( LPTAGINFO pTag, BOOL fReindex )
                   hb_nsxErrorRT( pArea, EG_DATATYPE, EDBF_INVALIDKEY,
                                  pTag->pIndex->IndexName, 0, 0, NULL );
                   errCode = HB_FAILURE;
-                  pTag->Partial = TRUE;
+                  pTag->Partial = HB_TRUE;
                   pEvalItem = NULL;
                   ulNextCount = 1;
                   break;
@@ -5960,9 +5960,9 @@ static HB_ERRCODE hb_nsxTagCreate( LPTAGINFO pTag, BOOL fReindex )
             if( lStep >= pArea->dbfarea.area.lpdbOrdCondInfo->lStep )
             {
                lStep = 0;
-               if( !hb_nsxEvalCond( pArea, pEvalItem, FALSE ) )
+               if( !hb_nsxEvalCond( pArea, pEvalItem, HB_FALSE ) )
                {
-                  pTag->Partial = TRUE;
+                  pTag->Partial = HB_TRUE;
                   break;
                }
             }
@@ -5983,7 +5983,7 @@ static HB_ERRCODE hb_nsxTagCreate( LPTAGINFO pTag, BOOL fReindex )
       if( fDirectRead )
       {
          pArea->dbfarea.pRecord = pSaveRecBuff;
-         pArea->dbfarea.fValidBuffer = FALSE;
+         pArea->dbfarea.fValidBuffer = HB_FALSE;
          if( errCode == HB_SUCCESS )
             errCode = SELF_GOTO( ( AREAP ) pArea, ulRecNo );
       }
@@ -5998,7 +5998,7 @@ static HB_ERRCODE hb_nsxTagCreate( LPTAGINFO pTag, BOOL fReindex )
       hb_cdpSelect( cdpTmp );
    }
 
-   hb_nsxSortFree( pSort, TRUE );
+   hb_nsxSortFree( pSort, HB_TRUE );
    pArea->pSort = NULL;
 
    return errCode;
@@ -6012,7 +6012,7 @@ static HB_ERRCODE hb_nsxReIndex( LPNSXINDEX pIndex )
    HB_ERRCODE errCode = HB_FAILURE;
    int i;
 
-   if( hb_nsxIndexLockWrite( pIndex, FALSE ) )
+   if( hb_nsxIndexLockWrite( pIndex, HB_FALSE ) )
    {
       errCode = HB_SUCCESS;
       hb_nsxIndexTrunc( pIndex );
@@ -6021,8 +6021,8 @@ static HB_ERRCODE hb_nsxReIndex( LPNSXINDEX pIndex )
       {
          LPTAGINFO pTag = pIndex->lpTags[ i ];
          pTag->HeadBlock = pTag->RootBlock = pTag->keyCount = 0;
-         pTag->HdrChanged = TRUE;
-         errCode = hb_nsxTagCreate( pTag, TRUE );
+         pTag->HdrChanged = HB_TRUE;
+         errCode = hb_nsxTagCreate( pTag, HB_TRUE );
          if( errCode != HB_SUCCESS )
             break;
       }
@@ -6057,8 +6057,8 @@ static HB_ERRCODE hb_nsxGoBottom( NSXAREAP pArea )
 
    hb_nsxTagGoBottom( pArea->lpCurTag );
 
-   pArea->dbfarea.area.fTop = FALSE;
-   pArea->dbfarea.area.fBottom = TRUE;
+   pArea->dbfarea.area.fTop = HB_FALSE;
+   pArea->dbfarea.area.fBottom = HB_TRUE;
 
    if( pArea->lpCurTag->TagEOF )
       retval = SELF_GOTO( ( AREAP ) pArea, 0 );
@@ -6094,8 +6094,8 @@ static HB_ERRCODE hb_nsxTop( NSXAREAP pArea )
 
    hb_nsxTagGoTop( pArea->lpCurTag );
 
-   pArea->dbfarea.area.fTop = TRUE;
-   pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = HB_TRUE;
+   pArea->dbfarea.area.fBottom = HB_FALSE;
 
    if( pArea->lpCurTag->TagEOF )
       retval = SELF_GOTO( ( AREAP ) pArea, 0 );
@@ -6110,7 +6110,7 @@ static HB_ERRCODE hb_nsxTop( NSXAREAP pArea )
    return retval;
 }
 
-static HB_ERRCODE hb_nsxSeek( NSXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pItem, BOOL fFindLast )
+static HB_ERRCODE hb_nsxSeek( NSXAREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pItem, HB_BOOL fFindLast )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_nsxSeek(%p, %d, %p, %d)", pArea, fSoftSeek, pItem, fFindLast));
 
@@ -6126,21 +6126,21 @@ static HB_ERRCODE hb_nsxSeek( NSXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pItem, BO
    {
       LPKEYINFO pKey;
       HB_ERRCODE retval = HB_SUCCESS;
-      BOOL  fEOF = FALSE, fLast;
+      HB_BOOL  fEOF = HB_FALSE, fLast;
       USHORT uiLen;
       ULONG ulRec;
 
       if( pArea->dbfarea.lpdbPendingRel && pArea->dbfarea.lpdbPendingRel->isScoped )
          SELF_FORCEREL( ( AREAP ) pArea );
 
-      pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
       fLast = pArea->lpCurTag->fUsrDescend ? !fFindLast : fFindLast;
 
       pKey = hb_nsxKeyPutItem( NULL, pItem,
                                fLast ? NSX_MAX_REC_NUM : NSX_IGNORE_REC_NUM,
-                               pArea->lpCurTag, TRUE, &uiLen );
+                               pArea->lpCurTag, HB_TRUE, &uiLen );
 
       if( ! hb_nsxTagLockRead( pArea->lpCurTag ) )
       {
@@ -6155,17 +6155,17 @@ static HB_ERRCODE hb_nsxSeek( NSXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pItem, BO
          ulRec = 0;
 
       if( ( ulRec == 0 && ! fSoftSeek ) || pArea->lpCurTag->TagEOF )
-         fEOF = TRUE;
+         fEOF = HB_TRUE;
       else
       {
          if( ! hb_nsxInBottomScope( pArea->lpCurTag, pArea->lpCurTag->CurKeyInfo->val ) )
-            fEOF = TRUE;
+            fEOF = HB_TRUE;
          else if( ! hb_nsxInTopScope( pArea->lpCurTag, pArea->lpCurTag->CurKeyInfo->val ) )
          {
             hb_nsxTagGoTop( pArea->lpCurTag );
             if( pArea->lpCurTag->CurKeyInfo->rec == 0 ||
                 pArea->lpCurTag->TagEOF )
-               fEOF = TRUE;
+               fEOF = HB_TRUE;
          }
       }
       hb_nsxTagUnLockRead( pArea->lpCurTag );
@@ -6183,7 +6183,7 @@ static HB_ERRCODE hb_nsxSeek( NSXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pItem, BO
                                        pArea->lpCurTag->KeyLength,
                                        NSX_CMP_PREFIX ) == 0 );
                if( ! pArea->dbfarea.area.fFound && ! fSoftSeek )
-                  fEOF = TRUE;
+                  fEOF = HB_TRUE;
             }
          }
       }
@@ -6193,7 +6193,7 @@ static HB_ERRCODE hb_nsxSeek( NSXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pItem, BO
          retval = SELF_GOTO( ( AREAP ) pArea, 0 );
       }
       if( pArea->dbfarea.fPositioned || pArea->dbfarea.ulRecNo != 1 )
-         pArea->dbfarea.area.fBof = FALSE;
+         pArea->dbfarea.area.fBof = HB_FALSE;
       hb_nsxKeyFree( pKey );
       return retval;
    }
@@ -6202,7 +6202,7 @@ static HB_ERRCODE hb_nsxSeek( NSXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pItem, BO
 static HB_ERRCODE hb_nsxSkipRaw( NSXAREAP pArea, LONG lToSkip )
 {
    HB_ERRCODE retval;
-   BOOL fOut = FALSE, fForward;
+   HB_BOOL fOut = HB_FALSE, fForward;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_nsxSkipRaw(%p, %ld)", pArea, lToSkip));
 
@@ -6221,7 +6221,7 @@ static HB_ERRCODE hb_nsxSkipRaw( NSXAREAP pArea, LONG lToSkip )
    if( ! hb_nsxCurKeyRefresh( pArea->lpCurTag ) )
    {
       if( fForward || pArea->dbfarea.fPositioned )
-         fOut = TRUE;
+         fOut = HB_TRUE;
       else
       {
          hb_nsxTagGoBottom( pArea->lpCurTag );
@@ -6249,7 +6249,7 @@ static HB_ERRCODE hb_nsxSkipRaw( NSXAREAP pArea, LONG lToSkip )
       if( fOut || pArea->lpCurTag->TagBOF )
       {
          hb_nsxTagGoTop( pArea->lpCurTag );
-         fOut = TRUE;
+         fOut = HB_TRUE;
       }
       retval = SELF_GOTO( ( AREAP ) pArea, pArea->lpCurTag->TagEOF ? 0 :
                                           pArea->lpCurTag->CurKeyInfo->rec );
@@ -6260,9 +6260,9 @@ static HB_ERRCODE hb_nsxSkipRaw( NSXAREAP pArea, LONG lToSkip )
    /* Update Bof and Eof flags */
    /*
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
    */
    return retval;
 }
@@ -6289,7 +6289,7 @@ static HB_ERRCODE hb_nsxFlush( NSXAREAP pArea )
             if( pIndex->fFlush && !pIndex->fDelete )
             {
                hb_fileCommit( pIndex->pFile );
-               pIndex->fFlush = FALSE;
+               pIndex->fFlush = HB_FALSE;
             }
             pIndex = pIndex->pNext;
          }
@@ -6304,8 +6304,8 @@ static HB_ERRCODE hb_nsxFlush( NSXAREAP pArea )
  */
 static HB_ERRCODE hb_nsxGoCold( NSXAREAP pArea )
 {
-   BOOL fRecordChanged = pArea->dbfarea.fRecordChanged;
-   BOOL fAppend = pArea->dbfarea.fAppend;
+   HB_BOOL fRecordChanged = pArea->dbfarea.fRecordChanged;
+   HB_BOOL fAppend = pArea->dbfarea.fAppend;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_nsxGoCold(%p)", pArea));
 
@@ -6317,14 +6317,14 @@ static HB_ERRCODE hb_nsxGoCold( NSXAREAP pArea )
          {
             if( pArea->fIdxAppend )
                hb_errInternal( 9999, "hb_nsxGoCold: multiple appending without GOCOLD.", NULL, NULL );
-            pArea->fIdxAppend = TRUE;
+            pArea->fIdxAppend = HB_TRUE;
          }
          else
          {
             LPNSXINDEX pIndex = pArea->lpIndexes;
             LPTAGINFO pTag;
             LPKEYINFO pKey;
-            BOOL fAdd, fDel, fLck = FALSE;
+            HB_BOOL fAdd, fDel, fLck = HB_FALSE;
             int i;
 
             /* The pending relation may move the record pointer so we should
@@ -6335,7 +6335,7 @@ static HB_ERRCODE hb_nsxGoCold( NSXAREAP pArea )
             if( pArea->dbfarea.fShared )
             {
                fAppend = pArea->fIdxAppend;
-               pArea->fIdxAppend = FALSE;
+               pArea->fIdxAppend = HB_FALSE;
             }
 
             while( pIndex )
@@ -6350,10 +6350,10 @@ static HB_ERRCODE hb_nsxGoCold( NSXAREAP pArea )
                   pKey = hb_nsxEvalKey( NULL, pTag );
 
                   fAdd = ( pTag->pForItem == NULL ||
-                           hb_nsxEvalCond( pArea, pTag->pForItem, TRUE ) );
+                           hb_nsxEvalCond( pArea, pTag->pForItem, HB_TRUE ) );
                   if( fAppend )
                   {
-                     fDel = FALSE;
+                     fDel = HB_FALSE;
                   }
                   else
                   {
@@ -6362,7 +6362,7 @@ static HB_ERRCODE hb_nsxGoCold( NSXAREAP pArea )
                                            NSX_CMP_EXACT ) == 0 )
                      {
                         if( pTag->HotFor ? fAdd : !fAdd )
-                           fAdd = fDel = FALSE;
+                           fAdd = fDel = HB_FALSE;
                         else
                            fDel = !fAdd;
                      }
@@ -6375,14 +6375,14 @@ static HB_ERRCODE hb_nsxGoCold( NSXAREAP pArea )
                   {
                      if( !fLck )
                      {
-                        if( !hb_nsxIndexLockWrite( pIndex, TRUE ) )
+                        if( !hb_nsxIndexLockWrite( pIndex, HB_TRUE ) )
                         {
                            hb_nsxKeyFree( pKey );
                            break;
                         }
-                        fLck = TRUE;
+                        fLck = HB_TRUE;
                         if( !pTag->HeadBlock || !pTag->RootBlock )
-                           fAdd = fDel = FALSE;
+                           fAdd = fDel = HB_FALSE;
                      }
                      if( fDel )
                      {
@@ -6395,7 +6395,7 @@ static HB_ERRCODE hb_nsxGoCold( NSXAREAP pArea )
                         else
                         {
                            if( pTag->ChgOnly )
-                              fAdd = FALSE;
+                              fAdd = HB_FALSE;
                            else if( !pTag->Partial && !pTag->UniqueKey )
                               hb_nsxCorruptError( pTag->pIndex );
                         }
@@ -6415,7 +6415,7 @@ static HB_ERRCODE hb_nsxGoCold( NSXAREAP pArea )
                if( fLck )
                {
                   hb_nsxIndexUnLockWrite( pIndex );
-                  fLck = FALSE;
+                  fLck = HB_FALSE;
                }
                pIndex = pIndex->pNext;
             }
@@ -6458,7 +6458,7 @@ static HB_ERRCODE hb_nsxGoHot( NSXAREAP pArea )
                   {
                      pTag->HotKeyInfo = hb_nsxEvalKey( pTag->HotKeyInfo, pTag );
                      pTag->HotFor = ( pTag->pForItem == NULL ||
-                                 hb_nsxEvalCond( pArea, pTag->pForItem, TRUE ) );
+                                 hb_nsxEvalCond( pArea, pTag->pForItem, HB_TRUE ) );
                   }
                }
             }
@@ -6488,7 +6488,7 @@ static HB_ERRCODE hb_nsxClose( NSXAREAP pArea )
    {
       if( pArea->pSort )
       {
-         hb_nsxSortFree( pArea->pSort, TRUE );
+         hb_nsxSortFree( pArea->pSort, HB_TRUE );
          pArea->pSort = NULL;
       }
 
@@ -6612,8 +6612,8 @@ static HB_ERRCODE hb_nsxOrderCreate( NSXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    LPTAGINFO pTag = NULL;
    HB_ERRCODE errCode;
    ULONG ulRecNo;
-   BOOL fNewFile, fProd, fLocked = FALSE, fAscend = TRUE, fCustom = FALSE,
-        fTemporary = FALSE, fExclusive = FALSE;
+   HB_BOOL fNewFile, fProd, fLocked = HB_FALSE, fAscend = HB_TRUE, fCustom = HB_FALSE,
+        fTemporary = HB_FALSE, fExclusive = HB_FALSE;
    BYTE bType, bTrail;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_nsxOrderCreate(%p, %p)", pArea, pOrderInfo));
@@ -6719,12 +6719,12 @@ static HB_ERRCODE hb_nsxOrderCreate( NSXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    }
 
    if( pArea->dbfarea.fTemporary )
-      fTemporary = TRUE;
+      fTemporary = HB_TRUE;
 
    /* Test conditional expression */
    if( pForExp )
    {
-      BOOL fOK;
+      HB_BOOL fOK;
 
       errCode = SELF_EVALBLOCK( ( AREAP ) pArea, pForExp );
       if( errCode != HB_SUCCESS )
@@ -6787,7 +6787,7 @@ static HB_ERRCODE hb_nsxOrderCreate( NSXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    else
    {
       PHB_FILE pFile;
-      BOOL bRetry, fShared = pArea->dbfarea.fShared && !fTemporary && !fExclusive;
+      HB_BOOL bRetry, fShared = pArea->dbfarea.fShared && !fTemporary && !fExclusive;
       USHORT uiFlags = FO_READWRITE | ( fShared ? FO_DENYNONE : FO_EXCLUSIVE );
       PHB_ITEM pError = NULL;
 
@@ -6796,7 +6796,7 @@ static HB_ERRCODE hb_nsxOrderCreate( NSXAREAP pArea, LPDBORDERCREATEINFO pOrderI
          if( fTemporary )
          {
             pFile = hb_fileCreateTemp( NULL, NULL, FC_NORMAL, szSpFile );
-            fNewFile = TRUE;
+            fNewFile = HB_TRUE;
          }
          else
          {
@@ -6811,7 +6811,7 @@ static HB_ERRCODE hb_nsxOrderCreate( NSXAREAP pArea, LPDBORDERCREATEINFO pOrderI
                                     &pError ) == E_RETRY;
          else
          {
-            bRetry = FALSE;
+            bRetry = HB_FALSE;
             if( !fNewFile )
                fNewFile = ( hb_fileSize( pFile ) == 0 );
          }
@@ -6832,7 +6832,7 @@ static HB_ERRCODE hb_nsxOrderCreate( NSXAREAP pArea, LPDBORDERCREATEINFO pOrderI
 
       pIndex = hb_nsxIndexNew( pArea );
       pIndex->IndexName = hb_strdup( szFileName );
-      pIndex->fReadonly = FALSE;
+      pIndex->fReadonly = HB_FALSE;
       pIndex->fShared = fShared;
       pIndex->pFile = pFile;
       pIndex->fDelete = fTemporary;
@@ -6843,7 +6843,7 @@ static HB_ERRCODE hb_nsxOrderCreate( NSXAREAP pArea, LPDBORDERCREATEINFO pOrderI
 
       if( !fNewFile )
       {
-         if( !hb_nsxIndexLockWrite( pIndex, TRUE ) )
+         if( !hb_nsxIndexLockWrite( pIndex, HB_TRUE ) )
             errCode = HB_FAILURE;
          else
          {
@@ -6851,7 +6851,7 @@ static HB_ERRCODE hb_nsxOrderCreate( NSXAREAP pArea, LPDBORDERCREATEINFO pOrderI
             if( errCode != HB_SUCCESS )
                hb_nsxIndexUnLockWrite( pIndex );
             else
-               fLocked = TRUE;
+               fLocked = HB_TRUE;
          }
          if( errCode != HB_SUCCESS )
          {
@@ -6931,8 +6931,8 @@ static HB_ERRCODE hb_nsxOrderCreate( NSXAREAP pArea, LPDBORDERCREATEINFO pOrderI
 
       if( errCode == HB_SUCCESS )
       {
-         pIndex->Update = pIndex->Changed = pTag->HdrChanged = TRUE;
-         errCode = hb_nsxTagCreate( pTag, FALSE );
+         pIndex->Update = pIndex->Changed = pTag->HdrChanged = HB_TRUE;
+         errCode = hb_nsxTagCreate( pTag, HB_FALSE );
       }
       hb_nsxIndexUnLockWrite( pIndex );
    }
@@ -6967,7 +6967,7 @@ static HB_ERRCODE hb_nsxOrderCreate( NSXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    if( pIndex->Production && !pArea->dbfarea.fHasTags &&
        ( DBFAREA_DATA( &pArea->dbfarea )->fStrictStruct || hb_setGetAutOpen() ) )
    {
-      pArea->dbfarea.fHasTags = TRUE;
+      pArea->dbfarea.fHasTags = HB_TRUE;
       if( !pArea->dbfarea.fReadonly && ( pArea->dbfarea.dbfHeader.bHasTags & 0x01 ) == 0 )
          SELF_WRITEDBHEADER( ( AREAP ) pArea );
    }
@@ -7004,17 +7004,17 @@ static HB_ERRCODE hb_nsxOrderDestroy( NSXAREAP pArea, LPDBORDERINFO pOrderInfo )
 
          if( pIndex->iTags == 1 )
          {
-            BOOL fProd = pIndex->Production;
+            HB_BOOL fProd = pIndex->Production;
             pIndexPtr = &pArea->lpIndexes;
             while( *pIndexPtr != pIndex )
                pIndexPtr = &(*pIndexPtr)->pNext;
             *pIndexPtr = pIndex->pNext;
-            pIndex->fDelete = TRUE;
+            pIndex->fDelete = HB_TRUE;
             hb_nsxIndexFree( pIndex );
             if( fProd && pArea->dbfarea.fHasTags &&
                 ( DBFAREA_DATA( &pArea->dbfarea )->fStrictStruct || hb_setGetAutOpen() ) )
             {
-               pArea->dbfarea.fHasTags = FALSE;
+               pArea->dbfarea.fHasTags = HB_FALSE;
                if( !pArea->dbfarea.fReadonly && ( pArea->dbfarea.dbfHeader.bHasTags & 0x01 ) != 0 )
                   SELF_WRITEDBHEADER( ( AREAP ) pArea );
             }
@@ -7031,7 +7031,7 @@ static HB_ERRCODE hb_nsxOrderDestroy( NSXAREAP pArea, LPDBORDERINFO pOrderInfo )
             return HB_FAILURE;
          }
 #endif
-         else if( !hb_nsxIndexLockWrite( pIndex, TRUE ) )
+         else if( !hb_nsxIndexLockWrite( pIndex, HB_TRUE ) )
          {
             return HB_FAILURE;
          }
@@ -7108,7 +7108,7 @@ static HB_ERRCODE hb_nsxOrderInfo( NSXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
          return HB_SUCCESS;
       case DBOI_ISREINDEX:
          pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
-                      pArea->pSort ? pArea->pSort->fReindex : FALSE );
+                      pArea->pSort ? pArea->pSort->fReindex : HB_FALSE );
          return HB_SUCCESS;
       case DBOI_LOCKOFFSET:
       case DBOI_HPLOCKING:
@@ -7221,7 +7221,7 @@ static HB_ERRCODE hb_nsxOrderInfo( NSXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                    *szForExpr )
                {
                   PHB_ITEM pForItem = NULL;
-                  BOOL fOK = *szForExpr == 0;
+                  HB_BOOL fOK = *szForExpr == 0;
                   if( !fOK )
                   {
                      if( SELF_COMPILE( ( AREAP ) pArea, szForExpr ) == HB_SUCCESS )
@@ -7253,9 +7253,9 @@ static HB_ERRCODE hb_nsxOrderInfo( NSXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                         pTag->ForExpr = NULL;
                         pTag->pForItem = NULL;
                      }
-                     pTag->Partial = TRUE;
-                     pTag->HdrChanged = TRUE;
-                     pTag->pIndex->Update = TRUE;
+                     pTag->Partial = HB_TRUE;
+                     pTag->HdrChanged = HB_TRUE;
+                     pTag->pIndex->Update = HB_TRUE;
                      hb_nsxTagUnLockWrite( pTag );
                   }
                   if( pForItem )
@@ -7323,13 +7323,13 @@ static HB_ERRCODE hb_nsxOrderInfo( NSXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                {
                   if( !pTag->Template )
                   {
-                     BOOL fNewVal = hb_itemGetL( pInfo->itmNewVal );
+                     HB_BOOL fNewVal = hb_itemGetL( pInfo->itmNewVal );
                      if( pTag->Custom ? ! fNewVal : fNewVal )
                      {
                         pTag->Custom = fNewVal;
-                        pTag->Partial = TRUE;
-                        pTag->ChgOnly = FALSE;
-                        pTag->HdrChanged = TRUE;
+                        pTag->Partial = HB_TRUE;
+                        pTag->ChgOnly = HB_FALSE;
+                        pTag->HdrChanged = HB_TRUE;
                      }
                   }
                   hb_nsxTagUnLockWrite( pTag );
@@ -7344,12 +7344,12 @@ static HB_ERRCODE hb_nsxOrderInfo( NSXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                {
                   if( !pTag->Custom )
                   {
-                     BOOL fNewVal = hb_itemGetL( pInfo->itmNewVal );
+                     HB_BOOL fNewVal = hb_itemGetL( pInfo->itmNewVal );
                      if( pTag->ChgOnly ? ! fNewVal : fNewVal )
                      {
                         pTag->ChgOnly = fNewVal;
-                        pTag->Partial = TRUE;
-                        pTag->HdrChanged = TRUE;
+                        pTag->Partial = HB_TRUE;
+                        pTag->HdrChanged = HB_TRUE;
                      }
                   }
                   hb_nsxTagUnLockWrite( pTag );
@@ -7365,8 +7365,8 @@ static HB_ERRCODE hb_nsxOrderInfo( NSXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                {
                   if( pTag->Custom && !pTag->Template )
                   {
-                     pTag->Template = TRUE;
-                     pTag->HdrChanged = TRUE;
+                     pTag->Template = HB_TRUE;
+                     pTag->HdrChanged = HB_TRUE;
                   }
                   hb_nsxTagUnLockWrite( pTag );
                }
@@ -7380,8 +7380,8 @@ static HB_ERRCODE hb_nsxOrderInfo( NSXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                {
                   if( pTag->Custom && !pTag->MultiKey )
                   {
-                     pTag->MultiKey = TRUE;
-                     pTag->HdrChanged = TRUE;
+                     pTag->MultiKey = HB_TRUE;
+                     pTag->HdrChanged = HB_TRUE;
                   }
                   hb_nsxTagUnLockWrite( pTag );
                }
@@ -7483,7 +7483,7 @@ static HB_ERRCODE hb_nsxOrderInfo( NSXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
             {
                if( hb_nsxCurKeyRefresh( pTag ) )
                   pInfo->itmResult = hb_nsxKeyGetItem( pInfo->itmResult,
-                                       pTag->CurKeyInfo, pTag, TRUE );
+                                       pTag->CurKeyInfo, pTag, HB_TRUE );
                else if( pInfo->itmResult )
                   hb_itemClear( pInfo->itmResult );
                hb_nsxTagUnLockRead( pTag );
@@ -7550,14 +7550,14 @@ static HB_ERRCODE hb_nsxOrderInfo( NSXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
             if( hb_itemType( pInfo->itmNewVal ) == HB_IT_LOGICAL )
                pInfo->itmResult = hb_itemPutL( pInfo->itmResult,
                             hb_itemGetL( pInfo->itmNewVal ) ?
-                                 hb_nsxIndexLockWrite( pTag->pIndex, TRUE ) :
+                                 hb_nsxIndexLockWrite( pTag->pIndex, HB_TRUE ) :
                                  hb_nsxIndexUnLockWrite( pTag->pIndex ) );
             else
                pInfo->itmResult = hb_itemPutL( pInfo->itmResult, pTag->pIndex->lockWrite > 0 );
             break;
          case DBOI_ISSORTRECNO:
          case DBOI_ISMULTITAG:
-            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, TRUE );
+            pInfo->itmResult = hb_itemPutL( pInfo->itmResult, HB_TRUE );
             break;
          case DBOI_LARGEFILE:
             pInfo->itmResult = hb_itemPutL( pInfo->itmResult, pTag->pIndex->LargeFile );
@@ -7661,7 +7661,7 @@ static HB_ERRCODE hb_nsxOrderInfo( NSXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
          case DBOI_FINDREC:
          case DBOI_FINDRECCONT:
             SELF_GOTO( ( AREAP ) pArea, 0 );
-            hb_itemPutL( pInfo->itmResult, FALSE );
+            hb_itemPutL( pInfo->itmResult, HB_FALSE );
             break;
          case DBOI_ISCOND:
          case DBOI_ISDESC:
@@ -7681,7 +7681,7 @@ static HB_ERRCODE hb_nsxOrderInfo( NSXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
          case DBOI_ISREADONLY:
          case DBOI_WRITELOCK:
          case DBOI_READLOCK:
-            hb_itemPutL( pInfo->itmResult, FALSE );
+            hb_itemPutL( pInfo->itmResult, HB_FALSE );
             break;
          case DBOI_KEYVAL:
          case DBOI_SCOPETOP:
@@ -7738,7 +7738,7 @@ static HB_ERRCODE hb_nsxOrderListAdd( NSXAREAP pArea, LPDBORDERINFO pOrderInfo )
    char szFileName[ HB_PATH_MAX ];
    LPNSXINDEX pIndex, *pIndexPtr;
    HB_ERRCODE errCode;
-   BOOL fRetry, fReadonly, fShared, fProd;
+   HB_BOOL fRetry, fReadonly, fShared, fProd;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_nsxOrderListAdd(%p, %p)", pArea, pOrderInfo));
 
@@ -7763,7 +7763,7 @@ static HB_ERRCODE hb_nsxOrderListAdd( NSXAREAP pArea, LPDBORDERINFO pOrderInfo )
                 ( fShared ? FO_DENYNONE : FO_EXCLUSIVE );
       do
       {
-         fRetry = FALSE;
+         fRetry = HB_FALSE;
          pFile = hb_fileExtOpen( szFileName, NULL, uiFlags |
                                  FXO_DEFAULTS | FXO_SHARELOCK | FXO_COPYNAME,
                                  NULL, pError );
@@ -7853,7 +7853,7 @@ static HB_ERRCODE hb_nsxOrderListDelete( NSXAREAP pArea, LPDBORDERINFO pOrderInf
    char szTagName[ NSX_TAGNAME + 1 ];
    char szFileName[ HB_PATH_MAX ];
    LPNSXINDEX pIndex, * pIndexPtr;
-   BOOL fProd;
+   HB_BOOL fProd;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_nsxOrderListDelete(%p, %p)", pArea, pOrderInfo));
 
@@ -7990,12 +7990,12 @@ static HB_ERRCODE hb_nsxRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect
       case RDDI_MULTITAG:
       case RDDI_SORTRECNO:
       case RDDI_STRUCTORD:
-         hb_itemPutL( pItem, TRUE );
+         hb_itemPutL( pItem, HB_TRUE );
          break;
 
       case RDDI_STRICTSTRUCT:
       {
-         BOOL fStrictStruct = pData->fStrictStruct;
+         HB_BOOL fStrictStruct = pData->fStrictStruct;
          if( hb_itemType( pItem ) == HB_IT_LOGICAL )
             pData->fStrictStruct = hb_itemGetL( pItem );
          hb_itemPutL( pItem, fStrictStruct );
@@ -8004,7 +8004,7 @@ static HB_ERRCODE hb_nsxRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect
 
       case RDDI_MULTIKEY:
       {
-         BOOL fMultiKey = pData->fMultiKey;
+         HB_BOOL fMultiKey = pData->fMultiKey;
          if( hb_itemType( pItem ) == HB_IT_LOGICAL )
             pData->fMultiKey = hb_itemGetL( pItem );
          hb_itemPutL( pItem, fMultiKey );
diff --git a/harbour/src/rdd/dbfntx/dbfntx1.c b/harbour/src/rdd/dbfntx/dbfntx1.c
index 56ce4e2b30..40c4e23317 100644
--- a/harbour/src/rdd/dbfntx/dbfntx1.c
+++ b/harbour/src/rdd/dbfntx/dbfntx1.c
@@ -425,7 +425,7 @@ static BYTE hb_ntxItemTypeCmp( BYTE bType )
  *       for scope key evaluation
  */
 static LPKEYINFO hb_ntxKeyPutItem( LPKEYINFO pKey, PHB_ITEM pItem, ULONG ulRecNo,
-                                   LPTAGINFO pTag, BOOL fTrans, USHORT *puiLen )
+                                   LPTAGINFO pTag, HB_BOOL fTrans, USHORT *puiLen )
 {
    ULONG len;
 
@@ -507,7 +507,7 @@ static LPKEYINFO hb_ntxKeyPutItem( LPKEYINFO pKey, PHB_ITEM pItem, ULONG ulRecNo
  * get Item from index key
  */
 static PHB_ITEM hb_ntxKeyGetItem( PHB_ITEM pItem, LPKEYINFO pKey,
-                                  LPTAGINFO pTag, BOOL fTrans )
+                                  LPTAGINFO pTag, HB_BOOL fTrans )
 {
    if( pKey )
    {
@@ -556,10 +556,10 @@ static PHB_ITEM hb_ntxKeyGetItem( PHB_ITEM pItem, LPKEYINFO pKey,
 /*
  * evaluate conditional expression and return the logical result
  */
-static BOOL hb_ntxEvalCond( NTXAREAP pArea, PHB_ITEM pCondItem, BOOL fSetWA )
+static HB_BOOL hb_ntxEvalCond( NTXAREAP pArea, PHB_ITEM pCondItem, HB_BOOL fSetWA )
 {
    int iCurrArea = 0;
-   BOOL fRet;
+   HB_BOOL fRet;
 
    if( fSetWA )
    {
@@ -581,12 +581,12 @@ static BOOL hb_ntxEvalCond( NTXAREAP pArea, PHB_ITEM pCondItem, BOOL fSetWA )
 /*
  * evaluate seek/skip block: {|key, rec| ... }
  */
-static BOOL hb_ntxEvalSeekCond( LPTAGINFO pTag, PHB_ITEM pCondItem )
+static HB_BOOL hb_ntxEvalSeekCond( LPTAGINFO pTag, PHB_ITEM pCondItem )
 {
-   BOOL fRet;
+   HB_BOOL fRet;
    PHB_ITEM pKeyVal, pKeyRec;
 
-   pKeyVal = hb_ntxKeyGetItem( NULL, pTag->CurKeyInfo, pTag, TRUE );
+   pKeyVal = hb_ntxKeyGetItem( NULL, pTag->CurKeyInfo, pTag, HB_TRUE );
    pKeyRec = hb_itemPutNInt( NULL, pTag->CurKeyInfo->Xtra );
 
    fRet = hb_itemGetL( hb_vmEvalBlockV( pCondItem, 2, pKeyVal, pKeyRec ) );
@@ -641,7 +641,7 @@ static LPKEYINFO hb_ntxEvalKey( LPKEYINFO pKey, LPTAGINFO pTag )
    {
       pItem = hb_itemNew( NULL );
       SELF_GETVALUE( ( AREAP ) pArea, pTag->nField, pItem );
-      pKey = hb_ntxKeyPutItem( pKey, pItem, pArea->dbfarea.ulRecNo, pTag, FALSE, NULL );
+      pKey = hb_ntxKeyPutItem( pKey, pItem, pArea->dbfarea.ulRecNo, pTag, HB_FALSE, NULL );
       hb_itemRelease( pItem );
    }
    else
@@ -654,7 +654,7 @@ static LPKEYINFO hb_ntxEvalKey( LPKEYINFO pKey, LPTAGINFO pTag )
          iCurrArea = 0;
 
       pItem = hb_vmEvalBlockOrMacro( pTag->pKeyItem );
-      pKey = hb_ntxKeyPutItem( pKey, pItem, pArea->dbfarea.ulRecNo, pTag, FALSE, NULL );
+      pKey = hb_ntxKeyPutItem( pKey, pItem, pArea->dbfarea.ulRecNo, pTag, HB_FALSE, NULL );
 
       if( iCurrArea )
          hb_rddSelectWorkAreaNumber( iCurrArea );
@@ -669,7 +669,7 @@ static LPKEYINFO hb_ntxEvalKey( LPKEYINFO pKey, LPTAGINFO pTag )
  * compare two values using Tag conditions (len & type)
  */
 static int hb_ntxValCompare( LPTAGINFO pTag, const char* val1, int len1,
-                             const char* val2, int len2, BOOL fExact )
+                             const char* val2, int len2, HB_BOOL fExact )
 {
    int iLimit, iResult = 0;
 
@@ -709,41 +709,41 @@ static int hb_ntxValCompare( LPTAGINFO pTag, const char* val1, int len1,
 /*
  * check if a given key is in top scope
  */
-static BOOL hb_ntxInTopScope( LPTAGINFO pTag, char* key )
+static HB_BOOL hb_ntxInTopScope( LPTAGINFO pTag, char* key )
 {
    PHB_NTXSCOPE pScope = pTag->fUsrDescend ? &pTag->bottom : &pTag->top;
 
    if( pScope->scopeKeyLen )
    {
       int i = hb_ntxValCompare( pTag, pScope->scopeKey->key, pScope->scopeKeyLen,
-                                 key, pTag->KeyLength, FALSE );
+                                 key, pTag->KeyLength, HB_FALSE );
       return pTag->fUsrDescend ? i >= 0 : i <= 0;
    }
    else
-      return TRUE;
+      return HB_TRUE;
 }
 
 /*
  * check if a given key is in bottom scope
  */
-static BOOL hb_ntxInBottomScope( LPTAGINFO pTag, char* key )
+static HB_BOOL hb_ntxInBottomScope( LPTAGINFO pTag, char* key )
 {
    PHB_NTXSCOPE pScope = pTag->fUsrDescend ? &pTag->top : &pTag->bottom;
 
    if( pScope->scopeKeyLen )
    {
       int i = hb_ntxValCompare( pTag, pScope->scopeKey->key, pScope->scopeKeyLen,
-                                key, pTag->KeyLength, FALSE );
+                                key, pTag->KeyLength, HB_FALSE );
       return pTag->fUsrDescend ? i <= 0 : i >= 0;
    }
    else
-      return TRUE;
+      return HB_TRUE;
 }
 
 /*
  * check if a given key is in current scope
  */
-static BOOL hb_ntxKeyInScope( LPTAGINFO pTag, LPKEYINFO pKey )
+static HB_BOOL hb_ntxKeyInScope( LPTAGINFO pTag, LPKEYINFO pKey )
 {
    return hb_ntxInTopScope( pTag, pKey->key ) &&
           hb_ntxInBottomScope( pTag, pKey->key );
@@ -799,7 +799,7 @@ static void hb_ntxTagSetScope( LPTAGINFO pTag, USHORT nScope, PHB_ITEM pItem )
    if( hb_ntxItemTypeCmp( pTag->KeyType ) == hb_ntxItemTypeCmp( hb_ntxItemType( pScopeVal ) ) )
    {
       PHB_NTXSCOPE pScope;
-      BOOL fTop = ( nScope == 0 );
+      HB_BOOL fTop = ( nScope == 0 );
 
       if( pTag->fUsrDescend )
          fTop = !fTop;
@@ -808,7 +808,7 @@ static void hb_ntxTagSetScope( LPTAGINFO pTag, USHORT nScope, PHB_ITEM pItem )
 
       pScope->scopeKey = hb_ntxKeyPutItem( pScope->scopeKey, pScopeVal,
                ( fTop == pTag->AscendKey ) ? NTX_IGNORE_REC_NUM : NTX_MAX_REC_NUM,
-               pTag, TRUE, &pScope->scopeKeyLen );
+               pTag, HB_TRUE, &pScope->scopeKeyLen );
 
       if( pScope->scopeItem == NULL )
          pScope->scopeItem = hb_itemNew( NULL );
@@ -861,28 +861,28 @@ static void hb_ntxTagRefreshScope( LPTAGINFO pTag )
    {
       pItem = hb_vmEvalBlock( pTag->top.scopeItem );
       pTag->top.scopeKey = hb_ntxKeyPutItem( pTag->top.scopeKey, pItem,
-               pTag->top.scopeKey->Xtra, pTag, TRUE, &pTag->top.scopeKeyLen );
+               pTag->top.scopeKey->Xtra, pTag, HB_TRUE, &pTag->top.scopeKeyLen );
    }
    if( hb_itemType( pTag->bottom.scopeItem ) == HB_IT_BLOCK )
    {
       pItem = hb_vmEvalBlock( pTag->bottom.scopeItem );
       pTag->bottom.scopeKey = hb_ntxKeyPutItem( pTag->bottom.scopeKey, pItem,
-         pTag->bottom.scopeKey->Xtra, pTag, TRUE, &pTag->bottom.scopeKeyLen );
+         pTag->bottom.scopeKey->Xtra, pTag, HB_TRUE, &pTag->bottom.scopeKeyLen );
    }
 }
 
 /*
  * an interface for fast check record number in record filter
  */
-static BOOL hb_ntxCheckRecordScope( NTXAREAP pArea, ULONG ulRec )
+static HB_BOOL hb_ntxCheckRecordScope( NTXAREAP pArea, ULONG ulRec )
 {
    LONG lRecNo = ( LONG ) ulRec;
 
    if( SELF_COUNTSCOPE( ( AREAP ) pArea, NULL, &lRecNo ) == HB_SUCCESS && lRecNo == 0 )
    {
-      return FALSE;
+      return HB_FALSE;
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 #ifdef HB_NTX_DEBUG
@@ -913,7 +913,7 @@ static void hb_ntxPageCheckKeys( LPPAGEINFO pPage, LPTAGINFO pTag, int iPos, int
    {
       i = hb_ntxValCompare( pTag,
                             hb_ntxGetKeyVal( pPage, u - 1 ), pTag->KeyLength,
-                            hb_ntxGetKeyVal( pPage, u ), pTag->KeyLength, TRUE );
+                            hb_ntxGetKeyVal( pPage, u ), pTag->KeyLength, HB_TRUE );
       if( !pTag->AscendKey )
          i = -i;
       if( i > 0 )
@@ -931,7 +931,7 @@ static void hb_ntxPageCheckKeys( LPPAGEINFO pPage, LPTAGINFO pTag, int iPos, int
 /*
  * read a given block from index file
  */
-static BOOL hb_ntxBlockRead( LPNTXINDEX pIndex, ULONG ulBlock, BYTE *buffer, int iSize )
+static HB_BOOL hb_ntxBlockRead( LPNTXINDEX pIndex, ULONG ulBlock, BYTE *buffer, int iSize )
 {
    if( !pIndex->lockRead && !pIndex->lockWrite )
       hb_errInternal( 9103, "hb_ntxBlockRead on not locked index file.", NULL, NULL );
@@ -944,15 +944,15 @@ static BOOL hb_ntxBlockRead( LPNTXINDEX pIndex, ULONG ulBlock, BYTE *buffer, int
    {
       hb_ntxErrorRT( pIndex->Owner, EG_READ, EDBF_READ,
                      pIndex->IndexName, hb_fsError(), 0, NULL );
-      return FALSE;
+      return HB_FALSE;
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * write a given block into index file
  */
-static BOOL hb_ntxBlockWrite( LPNTXINDEX pIndex, ULONG ulBlock, BYTE *buffer, int iSize )
+static HB_BOOL hb_ntxBlockWrite( LPNTXINDEX pIndex, ULONG ulBlock, BYTE *buffer, int iSize )
 {
    if( !pIndex->lockWrite )
       hb_errInternal( 9102, "hb_ntxBlockWrite on not locked index file.", NULL, NULL );
@@ -965,28 +965,28 @@ static BOOL hb_ntxBlockWrite( LPNTXINDEX pIndex, ULONG ulBlock, BYTE *buffer, in
    {
       hb_ntxErrorRT( pIndex->Owner, EG_WRITE, EDBF_WRITE,
                      pIndex->IndexName, hb_fsError(), 0, NULL );
-      return FALSE;
+      return HB_FALSE;
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * write a given tag page to file
  */
-static BOOL hb_ntxPageSave( LPNTXINDEX pIndex, LPPAGEINFO pPage )
+static HB_BOOL hb_ntxPageSave( LPNTXINDEX pIndex, LPPAGEINFO pPage )
 {
    hb_ntxSetKeyCount( pPage, pPage->uiKeys );
    if( !hb_ntxBlockWrite( pIndex, pPage->Page,
                           (BYTE *) hb_ntxPageBuffer( pPage ), NTXBLOCKSIZE ) )
-      return FALSE;
-   pPage->Changed = FALSE;
-   pIndex->fFlush = TRUE;
+      return HB_FALSE;
+   pPage->Changed = HB_FALSE;
+   pIndex->fFlush = HB_TRUE;
    /* In shared mode we have to update counter in version field of
       NTXHEADER to signal for other stations that their index buffers
       has to be discarded */
    if( pIndex->fShared )
-      pIndex->Changed = TRUE;
-   return TRUE;
+      pIndex->Changed = HB_TRUE;
+   return HB_TRUE;
 }
 
 /*
@@ -1032,7 +1032,7 @@ static void hb_ntxTagUpdateFlags( LPTAGINFO pTag )
 /*
  * check tag header in compound index
  */
-static BOOL hb_ntxTagHeaderCheck( LPTAGINFO pTag )
+static HB_BOOL hb_ntxTagHeaderCheck( LPTAGINFO pTag )
 {
    if( !pTag->RootBlock )
    {
@@ -1088,7 +1088,7 @@ static void hb_ntxIndexTrunc( LPNTXINDEX pIndex )
       hb_errInternal( 9102, "hb_ntxIndexTrunc on not locked index file.", NULL, NULL );
 
    hb_ntxFreePageBuffer( pIndex );
-   pIndex->Update = pIndex->Changed = pIndex->fFlush = TRUE;
+   pIndex->Update = pIndex->Changed = pIndex->fFlush = HB_TRUE;
    pIndex->TagBlock = pIndex->NextAvail = 0;
    pIndex->Version = 0;
    hb_fileTruncAt( pIndex->DiskFile, NTXBLOCKSIZE );
@@ -1205,7 +1205,7 @@ static void hb_ntxPageFree( LPTAGINFO pTag, LPPAGEINFO pPage )
 {
    hb_ntxSetKeyPage( pPage, 0, pTag->Owner->NextAvail );
    pTag->Owner->NextAvail = pPage->Page;
-   pTag->Owner->Changed = pPage->Changed = TRUE;
+   pTag->Owner->Changed = pPage->Changed = HB_TRUE;
 }
 
 /*
@@ -1283,7 +1283,7 @@ static LPPAGEINFO hb_ntxPageLoad( LPTAGINFO pTag, ULONG ulPage )
    else
    {
       pPage = hb_ntxPageGetBuffer( pTag, ulPage );
-      pPage->Changed = FALSE;
+      pPage->Changed = HB_FALSE;
       if( !hb_ntxBlockRead( pTag->Owner, ulPage,
                             (BYTE *) hb_ntxPageBuffer( pPage ), NTXBLOCKSIZE ) )
       {
@@ -1329,7 +1329,7 @@ static ULONG hb_ntxPageAlloc( LPNTXINDEX pIndex )
 /*
  * allocate new page in index file - reuse freed one or increase file
  */
-static LPPAGEINFO hb_ntxPageNew( LPTAGINFO pTag, BOOL fNull )
+static LPPAGEINFO hb_ntxPageNew( LPTAGINFO pTag, HB_BOOL fNull )
 {
    LPPAGEINFO pPage;
 
@@ -1374,7 +1374,7 @@ static LPPAGEINFO hb_ntxPageNew( LPTAGINFO pTag, BOOL fNull )
       pPage = hb_ntxPageGetBuffer( pTag, fNull ? 0 : hb_ntxPageAlloc( pTag->Owner ) );
       hb_ntxPageInit( pTag, pPage );
    }
-   pTag->Owner->Changed = pPage->Changed = TRUE;
+   pTag->Owner->Changed = pPage->Changed = HB_TRUE;
 
    return pPage;
 }
@@ -1385,7 +1385,7 @@ static LPPAGEINFO hb_ntxPageNew( LPTAGINFO pTag, BOOL fNull )
 static void hb_ntxPageAddFree( LPTAGINFO pTag, ULONG ulPage )
 {
    LPPAGEINFO pPage = hb_ntxPageGetBuffer( pTag, ulPage );
-   pPage->Changed = TRUE;
+   pPage->Changed = HB_TRUE;
    hb_ntxPageInit( pTag, pPage );
    hb_ntxPageFree( pTag, pPage );
    hb_ntxPageSave( pTag->Owner, pPage );
@@ -1397,13 +1397,13 @@ static void hb_ntxPageAddFree( LPTAGINFO pTag, ULONG ulPage )
  */
 static ULONG hb_ntxPageGetFree( LPTAGINFO pTag )
 {
-   LPPAGEINFO pPage = hb_ntxPageNew( pTag, FALSE );
+   LPPAGEINFO pPage = hb_ntxPageNew( pTag, HB_FALSE );
    ULONG ulPage = 0;
 
    if( pPage )
    {
       ulPage = pPage->Page;
-      pPage->Changed = FALSE;
+      pPage->Changed = HB_FALSE;
       hb_ntxPageRelease( pTag, pPage );
    }
    return ulPage;
@@ -1413,12 +1413,12 @@ static ULONG hb_ntxPageGetFree( LPTAGINFO pTag )
  * create the new tag structure
  */
 static LPTAGINFO hb_ntxTagNew( LPNTXINDEX pIndex,
-                               const char * szTagName, BOOL fTagName,
+                               const char * szTagName, HB_BOOL fTagName,
                                const char *szKeyExpr, PHB_ITEM pKeyExpr,
                                BYTE bKeyType, USHORT uiKeyLen, USHORT uiKeyDec,
                                const char *szForExpr, PHB_ITEM pForExpr,
-                               BOOL fAscendKey, BOOL fUnique, BOOL fCustom,
-                               BOOL fSortRec )
+                               HB_BOOL fAscendKey, HB_BOOL fUnique, HB_BOOL fCustom,
+                               HB_BOOL fSortRec )
 {
    LPTAGINFO pTag;
 
@@ -1512,7 +1512,7 @@ static void hb_ntxTagDelete( LPTAGINFO pTag )
       }
    }
    hb_ntxTagFree( pTag );
-   pIndex->Owner->fSetTagNumbers = TRUE;
+   pIndex->Owner->fSetTagNumbers = HB_TRUE;
    return;
 }
 
@@ -1531,7 +1531,7 @@ static HB_ERRCODE hb_ntxTagAdd( LPNTXINDEX pIndex, LPTAGINFO pTag )
       pIndex->lpTags = ( LPTAGINFO * ) hb_xgrab( sizeof( LPTAGINFO ) );
 
    pIndex->lpTags[ pIndex->iTags++ ] = pTag;
-   pIndex->Owner->fSetTagNumbers = TRUE;
+   pIndex->Owner->fSetTagNumbers = HB_TRUE;
    return HB_SUCCESS;
 }
 
@@ -1545,7 +1545,7 @@ static LPTAGINFO hb_ntxTagLoad( LPNTXINDEX pIndex, ULONG ulBlock,
    LPTAGINFO pTag;
    PHB_ITEM pKeyExp, pForExp = NULL;
    USHORT usType;
-   BOOL fName;
+   HB_BOOL fName;
 
    usType = HB_GET_LE_UINT16( lpNTX->type );
 
@@ -1640,7 +1640,7 @@ static void hb_ntxIndexTagAdd( LPNTXINDEX pIndex, LPTAGINFO pTag )
       memset( pTagItem->tag_name + iLen, 0, sizeof( pTagItem->tag_name ) - iLen );
    }
    HB_PUT_LE_UINT32( pTagItem->tag_header, pTag->HeadBlock );
-   pIndex->Update = TRUE;
+   pIndex->Update = HB_TRUE;
 }
 
 /*
@@ -1660,7 +1660,7 @@ static void hb_ntxIndexTagDel( LPNTXINDEX pIndex, char * szTagName )
          memset( pTagItem + iTags - 1, 0, NTX_TAGITEMSIZE );
          --iTags;
          HB_PUT_LE_UINT16( lpCTX->ntags, iTags );
-         pIndex->Update = TRUE;
+         pIndex->Update = HB_TRUE;
          break;
       }
    }
@@ -1708,7 +1708,7 @@ static HB_ERRCODE hb_ntxTagHeaderSave( LPTAGINFO pTag )
       {
          hb_ntxPageAddFree( pTag, pTag->HeadBlock );
          pTag->HeadBlock = 0;
-         pIndex->Update = TRUE;
+         pIndex->Update = HB_TRUE;
       }
       pIndex->Version++;
       version = pIndex->Version &= 0xffff;
@@ -1769,9 +1769,9 @@ static HB_ERRCODE hb_ntxTagHeaderSave( LPTAGINFO pTag )
 
    if( !hb_ntxBlockWrite( pIndex, pTag->HeadBlock, ( BYTE * ) &Header, iSize ) )
       return HB_FAILURE;
-   pTag->HdrChanged = FALSE;
+   pTag->HdrChanged = HB_FALSE;
    pIndex->Changed = pIndex->Compound;
-   pIndex->fFlush = TRUE;
+   pIndex->fFlush = HB_TRUE;
    return HB_SUCCESS;
 }
 
@@ -1843,7 +1843,7 @@ static HB_ERRCODE hb_ntxIndexHeaderSave( LPNTXINDEX pIndex )
       if( !hb_ntxBlockWrite( pIndex, 0, ( BYTE * ) lpCTX, iSize ) )
          return HB_FAILURE;
    }
-   pIndex->Changed = pIndex->Update = FALSE;
+   pIndex->Changed = pIndex->Update = HB_FALSE;
    return HB_SUCCESS;
 }
 
@@ -1861,7 +1861,7 @@ static HB_ERRCODE hb_ntxIndexLoad( LPNTXINDEX pIndex, char * szTagName )
          pIndex->HeaderBuff = ( BYTE * ) hb_xgrab( NTXBLOCKSIZE );
       if( !hb_ntxBlockRead( pIndex, 0, pIndex->HeaderBuff, NTXBLOCKSIZE ) )
          return HB_FAILURE;
-      pIndex->fValidHeader = TRUE;
+      pIndex->fValidHeader = HB_TRUE;
    }
 
    type = HB_GET_LE_UINT16( pIndex->HeaderBuff );
@@ -1944,7 +1944,7 @@ static HB_ERRCODE hb_ntxIndexHeaderRead( LPNTXINDEX pIndex )
          hb_ntxDiscardBuffers( pIndex );
          pIndex->Version = ulVersion;
          pIndex->NextAvail = ulNext;
-         pIndex->Compound = TRUE;
+         pIndex->Compound = HB_TRUE;
          for( i = 1; i < pIndex->iTags; i++ )
          {
             pIndex->lpTags[ i ]->HeadBlock =
@@ -2028,14 +2028,14 @@ static void hb_ntxIndexFlush( LPNTXINDEX pIndex )
 /*
  * lock index for reading (shared lock)
  */
-static BOOL hb_ntxIndexLockRead( LPNTXINDEX pIndex )
+static HB_BOOL hb_ntxIndexLockRead( LPNTXINDEX pIndex )
 {
-   BOOL fOK;
+   HB_BOOL fOK;
 
    if( pIndex->lockRead > 0 || pIndex->lockWrite > 0 || !pIndex->fShared ||
        HB_DIRTYREAD( &pIndex->Owner->dbfarea ) )
    {
-      fOK = TRUE;
+      fOK = HB_TRUE;
       pIndex->lockRead++;
    }
    else
@@ -2053,7 +2053,7 @@ static BOOL hb_ntxIndexLockRead( LPNTXINDEX pIndex )
             pIndex->lockRead--;
             hb_dbfLockIdxFile( pIndex->DiskFile, pIndex->Owner->dbfarea.bLockType,
                                FL_UNLOCK, &pIndex->ulLockPos );
-            return FALSE;
+            return HB_FALSE;
          }
       }
    }
@@ -2067,9 +2067,9 @@ static BOOL hb_ntxIndexLockRead( LPNTXINDEX pIndex )
 /*
  * lock index for writing (exclusive lock)
  */
-static BOOL hb_ntxIndexLockWrite( LPNTXINDEX pIndex, BOOL fCheck )
+static HB_BOOL hb_ntxIndexLockWrite( LPNTXINDEX pIndex, HB_BOOL fCheck )
 {
-   BOOL fOK;
+   HB_BOOL fOK;
 
    if( pIndex->fReadonly )
       hb_errInternal( 9101, "hb_ntxIndexLockWrite: readonly index.", NULL, NULL );
@@ -2079,7 +2079,7 @@ static BOOL hb_ntxIndexLockWrite( LPNTXINDEX pIndex, BOOL fCheck )
 
    if( pIndex->lockWrite > 0 || !pIndex->fShared )
    {
-      fOK = TRUE;
+      fOK = HB_TRUE;
       pIndex->lockWrite++;
    }
    else
@@ -2097,7 +2097,7 @@ static BOOL hb_ntxIndexLockWrite( LPNTXINDEX pIndex, BOOL fCheck )
             pIndex->lockWrite--;
             hb_dbfLockIdxFile( pIndex->DiskFile, pIndex->Owner->dbfarea.bLockType,
                                FL_UNLOCK, &pIndex->ulLockPos );
-            return FALSE;
+            return HB_FALSE;
          }
       }
    }
@@ -2111,9 +2111,9 @@ static BOOL hb_ntxIndexLockWrite( LPNTXINDEX pIndex, BOOL fCheck )
 /*
  * remove index read lock (shared lock)
  */
-static BOOL hb_ntxIndexUnLockRead( LPNTXINDEX pIndex )
+static HB_BOOL hb_ntxIndexUnLockRead( LPNTXINDEX pIndex )
 {
-   BOOL fOK;
+   HB_BOOL fOK;
 
 #ifdef HB_NTX_DEBUG
    int i;
@@ -2128,11 +2128,11 @@ static BOOL hb_ntxIndexUnLockRead( LPNTXINDEX pIndex )
    if( pIndex->lockRead || pIndex->lockWrite || !pIndex->fShared ||
        HB_DIRTYREAD( &pIndex->Owner->dbfarea ) )
    {
-      fOK = TRUE;
+      fOK = HB_TRUE;
    }
    else
    {
-      pIndex->fValidHeader = FALSE;
+      pIndex->fValidHeader = HB_FALSE;
       fOK = hb_dbfLockIdxFile( pIndex->DiskFile, pIndex->Owner->dbfarea.bLockType,
                                FL_UNLOCK, &pIndex->ulLockPos );
    }
@@ -2145,9 +2145,9 @@ static BOOL hb_ntxIndexUnLockRead( LPNTXINDEX pIndex )
 /*
  * remove index write lock (exclusive lock)
  */
-static BOOL hb_ntxIndexUnLockWrite( LPNTXINDEX pIndex )
+static HB_BOOL hb_ntxIndexUnLockWrite( LPNTXINDEX pIndex )
 {
-   BOOL fOK;
+   HB_BOOL fOK;
 
 #ifdef HB_NTX_DEBUG
    int i;
@@ -2165,11 +2165,11 @@ static BOOL hb_ntxIndexUnLockWrite( LPNTXINDEX pIndex )
 
    if( pIndex->lockWrite || !pIndex->fShared )
    {
-      fOK = TRUE;
+      fOK = HB_TRUE;
    }
    else
    {
-      pIndex->fValidHeader = FALSE;
+      pIndex->fValidHeader = HB_FALSE;
       fOK = hb_dbfLockIdxFile( pIndex->DiskFile, pIndex->Owner->dbfarea.bLockType,
                                FL_UNLOCK, &pIndex->ulLockPos );
    }
@@ -2182,9 +2182,9 @@ static BOOL hb_ntxIndexUnLockWrite( LPNTXINDEX pIndex )
 /*
  * lock tag for reading (shared lock)
  */
-static BOOL hb_ntxTagLockRead( LPTAGINFO pTag )
+static HB_BOOL hb_ntxTagLockRead( LPTAGINFO pTag )
 {
-   BOOL fOK = FALSE;
+   HB_BOOL fOK = HB_FALSE;
 
    if( hb_ntxIndexLockRead( pTag->Owner ) )
    {
@@ -2202,11 +2202,11 @@ static BOOL hb_ntxTagLockRead( LPTAGINFO pTag )
 /*
  * lock tag for writing (exclusive lock)
  */
-static BOOL hb_ntxTagLockWrite( LPTAGINFO pTag )
+static HB_BOOL hb_ntxTagLockWrite( LPTAGINFO pTag )
 {
-   BOOL fOK = FALSE;
+   HB_BOOL fOK = HB_FALSE;
 
-   if( hb_ntxIndexLockWrite( pTag->Owner, TRUE ) )
+   if( hb_ntxIndexLockWrite( pTag->Owner, HB_TRUE ) )
    {
       fOK = hb_ntxTagHeaderCheck( pTag );
       if( !fOK )
@@ -2222,7 +2222,7 @@ static BOOL hb_ntxTagLockWrite( LPTAGINFO pTag )
 /*
  * remove tag read lock (shared lock)
  */
-static BOOL hb_ntxTagUnLockRead( LPTAGINFO pTag )
+static HB_BOOL hb_ntxTagUnLockRead( LPTAGINFO pTag )
 {
    return hb_ntxIndexUnLockRead( pTag->Owner );
 }
@@ -2230,7 +2230,7 @@ static BOOL hb_ntxTagUnLockRead( LPTAGINFO pTag )
 /*
  * remove tag write lock (exclusive lock)
  */
-static BOOL hb_ntxTagUnLockWrite( LPTAGINFO pTag )
+static HB_BOOL hb_ntxTagUnLockWrite( LPTAGINFO pTag )
 {
    return hb_ntxIndexUnLockWrite( pTag->Owner );
 }
@@ -2331,7 +2331,7 @@ static LPPAGEINFO hb_ntxPageBottomMove( LPTAGINFO pTag, ULONG ulPage )
 /*
  * set page path to the first key in tag
  */
-static BOOL hb_ntxTagTopKey( LPTAGINFO pTag )
+static HB_BOOL hb_ntxTagTopKey( LPTAGINFO pTag )
 {
    LPPAGEINFO pPage;
    int iKeys;
@@ -2339,7 +2339,7 @@ static BOOL hb_ntxTagTopKey( LPTAGINFO pTag )
    pTag->stackLevel = 0;
    pPage = hb_ntxPageTopMove( pTag, 0 );
    if( ! pPage )
-      return FALSE;
+      return HB_FALSE;
    hb_ntxPageGetKey( pPage, 0, pTag->CurKeyInfo, pTag->KeyLength );
    iKeys = pPage->uiKeys;
    hb_ntxPageRelease( pTag, pPage );
@@ -2349,7 +2349,7 @@ static BOOL hb_ntxTagTopKey( LPTAGINFO pTag )
 /*
  * set page path to the last key in tag
  */
-static BOOL hb_ntxTagBottomKey( LPTAGINFO pTag )
+static HB_BOOL hb_ntxTagBottomKey( LPTAGINFO pTag )
 {
    LPPAGEINFO pPage;
    int iKeys;
@@ -2357,7 +2357,7 @@ static BOOL hb_ntxTagBottomKey( LPTAGINFO pTag )
    pTag->stackLevel = 0;
    pPage = hb_ntxPageBottomMove( pTag, 0 );
    if( ! pPage )
-      return FALSE;
+      return HB_FALSE;
    hb_ntxPageGetKey( pPage, pTag->stack[ pTag->stackLevel - 1 ].ikey,
                      pTag->CurKeyInfo, pTag->KeyLength );
    iKeys = pPage->uiKeys;
@@ -2368,7 +2368,7 @@ static BOOL hb_ntxTagBottomKey( LPTAGINFO pTag )
 /*
  * update page path to the next key in tag
  */
-static BOOL hb_ntxTagNextKey( LPTAGINFO pTag )
+static HB_BOOL hb_ntxTagNextKey( LPTAGINFO pTag )
 {
    int iLevel = pTag->stackLevel - 1;
    LPPAGEINFO pPage;
@@ -2378,7 +2378,7 @@ static BOOL hb_ntxTagNextKey( LPTAGINFO pTag )
    {
       pPage = hb_ntxPageLoad( pTag, pTag->stack[ iLevel ].page );
       if( ! pPage )
-         return FALSE;
+         return HB_FALSE;
       if( pTag->stack[ iLevel ].ikey < pPage->uiKeys )
          ulPage = hb_ntxGetKeyPage( pPage, pTag->stack[ iLevel ].ikey + 1 );
       if( ulPage || pTag->stack[ iLevel ].ikey + 1 < pPage->uiKeys )
@@ -2389,7 +2389,7 @@ static BOOL hb_ntxTagNextKey( LPTAGINFO pTag )
             hb_ntxPageRelease( pTag, pPage );
             pPage = hb_ntxPageTopMove( pTag, ulPage );
             if( ! pPage )
-               return FALSE;
+               return HB_FALSE;
          }
       }
       else
@@ -2399,29 +2399,29 @@ static BOOL hb_ntxTagNextKey( LPTAGINFO pTag )
             hb_ntxPageRelease( pTag, pPage );
             pPage = hb_ntxPageLoad( pTag, pTag->stack[ iLevel ].page );
             if( ! pPage )
-               return FALSE;
+               return HB_FALSE;
             if( pTag->stack[ iLevel ].ikey < pPage->uiKeys )
                break;
          }
          if( iLevel < 0 )
          {
             hb_ntxPageRelease( pTag, pPage );
-            return FALSE;
+            return HB_FALSE;
          }
          pTag->stackLevel = iLevel + 1;
       }
       hb_ntxPageGetKey( pPage, pTag->stack[ pTag->stackLevel - 1 ].ikey,
                         pTag->CurKeyInfo, pTag->KeyLength );
       hb_ntxPageRelease( pTag, pPage );
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 /*
  * update page path to the previous key in tag
  */
-static BOOL hb_ntxTagPrevKey( LPTAGINFO pTag )
+static HB_BOOL hb_ntxTagPrevKey( LPTAGINFO pTag )
 {
    int iLevel = pTag->stackLevel - 1;
    LPPAGEINFO pPage;
@@ -2431,14 +2431,14 @@ static BOOL hb_ntxTagPrevKey( LPTAGINFO pTag )
    {
       pPage = hb_ntxPageLoad( pTag, pTag->stack[ iLevel ].page );
       if( ! pPage )
-         return FALSE;
+         return HB_FALSE;
       ulPage = hb_ntxGetKeyPage( pPage, pTag->stack[ iLevel ].ikey );
       if( ulPage )
       {
          hb_ntxPageRelease( pTag, pPage );
          pPage = hb_ntxPageBottomMove( pTag, ulPage );
          if( ! pPage )
-            return FALSE;
+            return HB_FALSE;
       }
       else if( pTag->stack[ iLevel ].ikey )
       {
@@ -2451,7 +2451,7 @@ static BOOL hb_ntxTagPrevKey( LPTAGINFO pTag )
             hb_ntxPageRelease( pTag, pPage );
             pPage = hb_ntxPageLoad( pTag, pTag->stack[ iLevel ].page );
             if( ! pPage )
-               return FALSE;
+               return HB_FALSE;
             if( pTag->stack[ iLevel ].ikey )
             {
                pTag->stack[ iLevel ].ikey--;
@@ -2461,33 +2461,33 @@ static BOOL hb_ntxTagPrevKey( LPTAGINFO pTag )
          if( iLevel < 0 )
          {
             hb_ntxPageRelease( pTag, pPage );
-            return FALSE;
+            return HB_FALSE;
          }
          pTag->stackLevel = iLevel + 1;
       }
       hb_ntxPageGetKey( pPage, pTag->stack[ pTag->stackLevel - 1 ].ikey,
                         pTag->CurKeyInfo, pTag->KeyLength );
       hb_ntxPageRelease( pTag, pPage );
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 /*
  * find a key value in page
  */
 static int hb_ntxPageKeyFind( LPTAGINFO pTag, LPPAGEINFO pPage,
-                              char* key, SHORT keylen, BOOL fNext,
-                              ULONG ulRecNo, BOOL *fStop )
+                              char* key, SHORT keylen, HB_BOOL fNext,
+                              ULONG ulRecNo, HB_BOOL *fStop )
 {
    SHORT iLast = -1, iBegin = 0, iEnd = pPage->uiKeys - 1, k, i;
 
-   *fStop = FALSE;
+   *fStop = HB_FALSE;
    while( iBegin <= iEnd )
    {
       i = ( iBegin + iEnd ) >> 1;
       k = hb_ntxValCompare( pTag, key, keylen, hb_ntxGetKeyVal( pPage, i ),
-                            pTag->KeyLength, FALSE );
+                            pTag->KeyLength, HB_FALSE );
       if( k == 0 )
       {
          if( ulRecNo != 0 && pTag->fSortRec )
@@ -2499,7 +2499,7 @@ static int hb_ntxPageKeyFind( LPTAGINFO pTag, LPPAGEINFO pPage,
                k = 1;
             else
             {
-               *fStop = TRUE;
+               *fStop = HB_TRUE;
                return i;
             }
          }
@@ -2511,7 +2511,7 @@ static int hb_ntxPageKeyFind( LPTAGINFO pTag, LPPAGEINFO pPage,
       else
       {
          if( k == 0 && !ulRecNo )
-            *fStop = TRUE;
+            *fStop = HB_TRUE;
          iLast = i;
          iEnd = i - 1;
       }
@@ -2522,7 +2522,7 @@ static int hb_ntxPageKeyFind( LPTAGINFO pTag, LPPAGEINFO pPage,
 /*
  * find a record in page starting from given key
  */
-static BOOL hb_ntxPageFindRecNo( LPPAGEINFO pPage, int * iStart, ULONG ulRecno )
+static HB_BOOL hb_ntxPageFindRecNo( LPPAGEINFO pPage, int * iStart, ULONG ulRecno )
 {
    int iKey = *iStart;
    while( iKey < pPage->uiKeys )
@@ -2530,32 +2530,32 @@ static BOOL hb_ntxPageFindRecNo( LPPAGEINFO pPage, int * iStart, ULONG ulRecno )
       if( hb_ntxGetKeyRec( pPage, iKey ) == ulRecno )
       {
          *iStart = iKey;
-         return TRUE;
+         return HB_TRUE;
       }
       iKey++;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 /*
  * set page path to given key in tag
  */
-static BOOL hb_ntxTagKeyFind( LPTAGINFO pTag, LPKEYINFO pKey, USHORT uiLen )
+static HB_BOOL hb_ntxTagKeyFind( LPTAGINFO pTag, LPKEYINFO pKey, USHORT uiLen )
 {
    LPPAGEINFO pPage = NULL;
    ULONG ulPage = 0, ulRecNo = 0;
    int iKey;
-   BOOL fStop = FALSE, fNext = FALSE, fPrev = FALSE, fOut = FALSE;
+   HB_BOOL fStop = HB_FALSE, fNext = HB_FALSE, fPrev = HB_FALSE, fOut = HB_FALSE;
 
    if( pKey->Tag == NTX_MAX_REC_NUM )          /* for key add */
    {
       if( pTag->fSortRec )
          ulRecNo = pKey->Xtra;
       else
-         fNext = TRUE;
+         fNext = HB_TRUE;
    }
    else if( pKey->Xtra == NTX_MAX_REC_NUM )    /* for seek last */
-      fNext = fPrev = TRUE;
+      fNext = fPrev = HB_TRUE;
    else if( pKey->Xtra != NTX_IGNORE_REC_NUM ) /* for key del and current key */
       ulRecNo = pKey->Xtra;
    /* else -> normal seek */
@@ -2567,7 +2567,7 @@ static BOOL hb_ntxTagKeyFind( LPTAGINFO pTag, LPKEYINFO pKey, USHORT uiLen )
          hb_ntxPageRelease( pTag, pPage );
       pPage = hb_ntxPageLoad( pTag, ulPage );
       if( ! pPage )
-         return FALSE;
+         return HB_FALSE;
       iKey = hb_ntxPageKeyFind( pTag, pPage, pKey->key, uiLen, fNext, ulRecNo, &fStop );
       hb_ntxTagSetPageStack( pTag, pPage->Page, iKey );
       if( fStop && ulRecNo && pTag->fSortRec )
@@ -2588,19 +2588,19 @@ static BOOL hb_ntxTagKeyFind( LPTAGINFO pTag, LPKEYINFO pKey, USHORT uiLen )
    {
       if( !pTag->fSortRec )
       {
-         fStop = TRUE;
+         fStop = HB_TRUE;
          while( fStop && ulRecNo != pTag->CurKeyInfo->Xtra )
          {
             if( ! hb_ntxTagNextKey( pTag ) ) /* Tag EOF */
             {
-               fOut = TRUE;
-               fStop = FALSE;
+               fOut = HB_TRUE;
+               fStop = HB_FALSE;
             }
             else
             {
                fStop = hb_ntxValCompare( pTag, pKey->key, uiLen,
                                          pTag->CurKeyInfo->key, pTag->KeyLength,
-                                         FALSE ) == 0;
+                                         HB_FALSE ) == 0;
             }
          }
       }
@@ -2609,27 +2609,27 @@ static BOOL hb_ntxTagKeyFind( LPTAGINFO pTag, LPKEYINFO pKey, USHORT uiLen )
    {
       if( !hb_ntxTagPrevKey( pTag ) )
       {
-         fOut = TRUE;
-         fStop = FALSE;
+         fOut = HB_TRUE;
+         fStop = HB_FALSE;
       }
       else
       {
          fStop = hb_ntxValCompare( pTag, pKey->key, uiLen, pTag->CurKeyInfo->key,
-                                   pTag->KeyLength, FALSE ) == 0;
+                                   pTag->KeyLength, HB_FALSE ) == 0;
       }
    }
    else if( !fNext && !fStop && pTag->CurKeyInfo->Xtra == 0 )
    {
       if( ! hb_ntxTagNextKey( pTag ) ) /* Tag EOF */
       {
-         fOut = TRUE;
-         fStop = FALSE;
+         fOut = HB_TRUE;
+         fStop = HB_FALSE;
       }
       else
       {
          fStop = hb_ntxValCompare( pTag, pKey->key, uiLen,
                                    pTag->CurKeyInfo->key, pTag->KeyLength,
-                                   FALSE ) == 0;
+                                   HB_FALSE ) == 0;
       }
    }
 
@@ -2647,7 +2647,7 @@ static void hb_ntxPageKeySet( LPTAGINFO pTag, LPPAGEINFO pPage, USHORT uiPos,
    hb_ntxSetKeyPage( pPage, uiPos, ulPage );
    hb_ntxSetKeyRec( pPage, uiPos, ulRec );
    memcpy( hb_ntxGetKeyVal( pPage, uiPos ), keyVal, pTag->KeyLength );
-   pPage->Changed = TRUE;
+   pPage->Changed = HB_TRUE;
 }
 
 /*
@@ -2685,7 +2685,7 @@ static void hb_ntxPageKeyDel( LPPAGEINFO pPage, USHORT uiPos )
    hb_ntxSetKeyOffset( pPage, pPage->uiKeys, ntmp );
 
    pPage->uiKeys--;
-   pPage->Changed = TRUE;
+   pPage->Changed = HB_TRUE;
 }
 
 /*
@@ -2694,7 +2694,7 @@ static void hb_ntxPageKeyDel( LPPAGEINFO pPage, USHORT uiPos )
 static LPKEYINFO hb_ntxPageSplit( LPTAGINFO pTag, LPPAGEINFO pPage,
                                   LPKEYINFO pKey, USHORT uiPos )
 {
-   LPPAGEINFO pNewPage = hb_ntxPageNew( pTag, FALSE );
+   LPPAGEINFO pNewPage = hb_ntxPageNew( pTag, HB_FALSE );
    LPKEYINFO pKeyNew;
    USHORT uiKeys = pPage->uiKeys + 1, uiLen = pTag->KeyLength + 8,
           i, j, u, uiHalf;
@@ -2762,7 +2762,7 @@ static LPKEYINFO hb_ntxPageSplit( LPTAGINFO pTag, LPPAGEINFO pPage,
    hb_ntxSetKeyPage( pPage, i, ulPage );
    pPage->uiKeys = i;
 
-   pPage->Changed = pNewPage->Changed = TRUE;
+   pPage->Changed = pNewPage->Changed = HB_TRUE;
 #ifdef HB_NTX_DEBUG
    hb_ntxPageCheckKeys( pNewPage, pTag, uiPos, 1 );
    hb_ntxPageCheckKeys( pPage, pTag, uiPos - pNewPage->uiKeys, 2 );
@@ -2795,7 +2795,7 @@ static void hb_ntxPageJoin( LPTAGINFO pTag, LPPAGEINFO pBasePage, USHORT uiPos,
    hb_ntxSetKeyPage( pFirst, pFirst->uiKeys, hb_ntxGetKeyPage( pLast, pLast->uiKeys ) );
    pLast->uiKeys = 0;
    hb_ntxPageFree( pTag, pLast );
-   pFirst->Changed = pLast->Changed = TRUE;
+   pFirst->Changed = pLast->Changed = HB_TRUE;
 #ifdef HB_NTX_DEBUG
    hb_ntxPageCheckKeys( pBasePage, pTag, uiPos, 11 );
    hb_ntxPageCheckKeys( pFirst, pTag, 0, 12 );
@@ -2879,7 +2879,7 @@ static void hb_ntxBalancePages( LPTAGINFO pTag, LPPAGEINFO pBasePage, USHORT uiP
       memcpy( hb_ntxGetKeyVal( pBasePage, uiPos ),
               hb_ntxGetKeyVal( pFirst, pFirst->uiKeys ), pTag->KeyLength );
    }
-   pFirst->Changed = pLast->Changed = pBasePage->Changed = TRUE;
+   pFirst->Changed = pLast->Changed = pBasePage->Changed = HB_TRUE;
 #ifdef HB_NTX_DEBUG
    hb_ntxPageCheckKeys( pBasePage, pTag, uiPos, 21 );
    hb_ntxPageCheckKeys( pFirst, pTag, iMove, 22 );
@@ -2890,13 +2890,13 @@ static void hb_ntxBalancePages( LPTAGINFO pTag, LPPAGEINFO pBasePage, USHORT uiP
 /*
  * add key to the index at the curret page path
  */
-static BOOL hb_ntxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey )
+static HB_BOOL hb_ntxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey )
 {
    int iLevel, iKey;
    LPPAGEINFO pPage = NULL;
    LPKEYINFO pNewKey = NULL;
    ULONG ulPage;
-   BOOL fFound, fBottom = FALSE;
+   HB_BOOL fFound, fBottom = HB_FALSE;
 
    if( pTag->UniqueKey )
    {
@@ -2906,8 +2906,8 @@ static BOOL hb_ntxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey )
       fFound = hb_ntxTagKeyFind( pTag, pKey, pTag->KeyLength );
       pKey->Xtra = ulRecNo;
       if( fFound )
-         return FALSE;
-      fBottom = TRUE;
+         return HB_FALSE;
+      fBottom = HB_TRUE;
    }
    else
    {
@@ -2917,9 +2917,9 @@ static BOOL hb_ntxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey )
       if( fFound )
       {
          if( pTag->MultiKey )
-            fBottom = TRUE;
+            fBottom = HB_TRUE;
          else
-            return FALSE;
+            return HB_FALSE;
       }
    }
 
@@ -2928,14 +2928,14 @@ static BOOL hb_ntxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey )
    {
       pPage = hb_ntxPageLoad( pTag, pTag->stack[ iLevel ].page );
       if( ! pPage )
-         return FALSE;
+         return HB_FALSE;
       ulPage = hb_ntxGetKeyPage( pPage, pTag->stack[ iLevel ].ikey );
       if( ulPage )
       {
          hb_ntxPageRelease( pTag, pPage );
          pPage = hb_ntxPageBottomMove( pTag, ulPage );
          if( ! pPage )
-            return FALSE;
+            return HB_FALSE;
          iLevel = pTag->stackLevel - 1;
          if( pTag->stack[ iLevel ].ikey < pPage->uiKeys )
             pTag->stack[ iLevel ].ikey++;
@@ -2954,7 +2954,7 @@ static BOOL hb_ntxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey )
          if( pNewKey )
             hb_ntxKeyFree( pNewKey );
          pTag->stackLevel = 0;
-         return FALSE;
+         return HB_FALSE;
       }
       iKey = pTag->stack[ iLevel ].ikey;
       if( pPage->uiKeys < pTag->MaxKeys )
@@ -2976,7 +2976,7 @@ static BOOL hb_ntxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey )
                hb_ntxPageRelease( pTag, pPage );
                if( pNewKey )
                   hb_ntxKeyFree( pNewKey );
-               return FALSE;
+               return HB_FALSE;
             }
             uiFirst = uiLast = uiBaseKey = pTag->stack[ iLevel -1 ].ikey;
             if( uiLast < pBasePage->uiKeys && hb_ntxGetKeyPage( pBasePage, uiLast + 1 ) != 0 )
@@ -2997,7 +2997,7 @@ static BOOL hb_ntxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey )
                      hb_ntxPageRelease( pTag, pBasePage );
                      if( pNewKey )
                         hb_ntxKeyFree( pNewKey );
-                     return FALSE;
+                     return HB_FALSE;
                   }
                   uiBaseKey = iKey;
                }
@@ -3011,7 +3011,7 @@ static BOOL hb_ntxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey )
                      hb_ntxPageRelease( pTag, pBasePage );
                      if( pNewKey )
                         hb_ntxKeyFree( pNewKey );
-                     return FALSE;
+                     return HB_FALSE;
                   }
                   uiBaseKey = pFirst->uiKeys + iKey + 1;
                }
@@ -3044,25 +3044,25 @@ static BOOL hb_ntxTagKeyAdd( LPTAGINFO pTag, LPKEYINFO pKey )
    hb_ntxPageRelease( pTag, pPage );
    if( pKey )
    {
-      pPage = hb_ntxPageNew( pTag, FALSE );
+      pPage = hb_ntxPageNew( pTag, HB_FALSE );
       if( ! pPage )
-         return FALSE;
+         return HB_FALSE;
       hb_ntxPageKeyAdd( pTag, pPage, 0, pKey->Tag, pKey->Xtra, pKey->key );
       hb_ntxSetKeyPage( pPage, 1, pTag->RootBlock );
       pTag->RootBlock = pPage->Page;
-      pTag->HdrChanged = TRUE;
+      pTag->HdrChanged = HB_TRUE;
       hb_ntxPageRelease( pTag, pPage );
       pTag->stackLevel = 0;
    }
    if( pNewKey )
       hb_ntxKeyFree( pNewKey );
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * del key at the curret page path from the index
  */
-static BOOL hb_ntxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
+static HB_BOOL hb_ntxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
 {
    int iLevel, iBaseKey, iKey;
    LPPAGEINFO pBasePage, pPage;
@@ -3073,14 +3073,14 @@ static BOOL hb_ntxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
        memcmp( pTag->CurKeyInfo->key, pKey->key, pTag->KeyLength ) != 0 )
    {
       if( ! hb_ntxTagKeyFind( pTag, pKey, pTag->KeyLength ) )
-         return FALSE;
+         return HB_FALSE;
    }
 
    iLevel = pTag->stackLevel - 1;
 
    pPage = hb_ntxPageLoad( pTag, pTag->stack[ iLevel ].page );
    if( ! pPage )
-      return FALSE;
+      return HB_FALSE;
    iKey = pTag->stack[ iLevel ].ikey;
    ulPage = hb_ntxGetKeyPage( pPage, iKey );
 
@@ -3092,7 +3092,7 @@ static BOOL hb_ntxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
       if( ! pPage )
       {
          hb_ntxPageRelease( pTag, pBasePage );
-         return FALSE;
+         return HB_FALSE;
       }
       iLevel = pTag->stackLevel - 1;
       iKey = pTag->stack[ iLevel ].ikey;
@@ -3100,7 +3100,7 @@ static BOOL hb_ntxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
       hb_ntxSetKeyRec( pBasePage, iBaseKey, hb_ntxGetKeyRec( pPage, iKey ) );
       memcpy( hb_ntxGetKeyVal( pBasePage, iBaseKey ),
               hb_ntxGetKeyVal( pPage, iKey ), pTag->KeyLength );
-      pBasePage->Changed = TRUE;
+      pBasePage->Changed = HB_TRUE;
 #ifdef HB_NTX_DEBUG
       hb_ntxPageCheckKeys( pBasePage, pTag, iBaseKey, 61 );
 #endif
@@ -3118,7 +3118,7 @@ static BOOL hb_ntxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
          if( ! pBasePage )
          {
             hb_ntxPageRelease( pTag, pPage );
-            return FALSE;
+            return HB_FALSE;
          }
          uiFirst = uiLast = uiBaseKey = pTag->stack[ iLevel -1 ].ikey;
          if( uiLast < pBasePage->uiKeys && hb_ntxGetKeyPage( pBasePage, uiLast + 1 ) != 0 )
@@ -3148,7 +3148,7 @@ static BOOL hb_ntxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
                   hb_ntxPageRelease( pTag, pPage );
                   hb_ntxPageRelease( pTag, pBasePage );
                   pTag->stackLevel = 0;
-                  return FALSE;
+                  return HB_FALSE;
                }
             }
             else
@@ -3160,7 +3160,7 @@ static BOOL hb_ntxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
                   hb_ntxPageRelease( pTag, pPage );
                   hb_ntxPageRelease( pTag, pBasePage );
                   pTag->stackLevel = 0;
-                  return FALSE;
+                  return HB_FALSE;
                }
             }
             if( pFirst->uiKeys + pLast->uiKeys < pTag->MaxKeys )
@@ -3183,19 +3183,19 @@ static BOOL hb_ntxTagKeyDel( LPTAGINFO pTag, LPKEYINFO pKey )
       if( ulPage != 0 )
       {
          pTag->RootBlock = ulPage;
-         pTag->HdrChanged = TRUE;
+         pTag->HdrChanged = HB_TRUE;
          hb_ntxPageFree( pTag, pPage );
       }
    }
    hb_ntxPageRelease( pTag, pPage );
    pTag->stackLevel = 0;
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
  * refresh CurKey value and set proper path from RootPage to LeafPage
  */
-static BOOL hb_ntxCurKeyRefresh( LPTAGINFO pTag )
+static HB_BOOL hb_ntxCurKeyRefresh( LPTAGINFO pTag )
 {
    NTXAREAP pArea = pTag->Owner->Owner;
 
@@ -3205,26 +3205,26 @@ static BOOL hb_ntxCurKeyRefresh( LPTAGINFO pTag )
    if( !pArea->dbfarea.fPositioned )
    {
       pTag->stackLevel = 0;
-      pTag->TagBOF = pTag->TagEOF = TRUE;
+      pTag->TagBOF = pTag->TagEOF = HB_TRUE;
       pTag->CurKeyInfo->Xtra = 0;
-      return FALSE;
+      return HB_FALSE;
    }
    else if( pTag->stackLevel == 0 || pTag->CurKeyInfo->Xtra != pArea->dbfarea.ulRecNo )
    {
       BYTE buf[ NTX_MAX_KEY ];
-      BOOL fBuf = FALSE;
+      HB_BOOL fBuf = HB_FALSE;
       LPKEYINFO pKey = NULL;
       /* Try to find previous if it's key for the same record */
       if( pTag->CurKeyInfo->Xtra == pArea->dbfarea.ulRecNo )
       {
-         fBuf = TRUE;
+         fBuf = HB_TRUE;
          memcpy( buf, pTag->CurKeyInfo->key, pTag->KeyLength );
          pKey = hb_ntxKeyCopy( pKey, pTag->CurKeyInfo, pTag->KeyLength );
          hb_ntxTagKeyFind( pTag, pKey, pTag->KeyLength );
       }
       if( pTag->CurKeyInfo->Xtra != pArea->dbfarea.ulRecNo )
       {
-         BOOL fValidBuf = pArea->dbfarea.fValidBuffer;
+         HB_BOOL fValidBuf = pArea->dbfarea.fValidBuffer;
          /* not found, create new key from DBF and if differs seek again */
          pKey = hb_ntxEvalKey( pKey, pTag );
          if( !fBuf || memcmp( buf, pKey->key, pTag->KeyLength ) != 0 )
@@ -3245,16 +3245,16 @@ static BOOL hb_ntxCurKeyRefresh( LPTAGINFO pTag )
       hb_ntxKeyFree( pKey );
       return pTag->CurKeyInfo->Xtra != 0 && pTag->CurKeyInfo->Xtra == pArea->dbfarea.ulRecNo;
    }
-   pTag->TagBOF = pTag->TagEOF = FALSE;
-   return TRUE;
+   pTag->TagBOF = pTag->TagEOF = HB_FALSE;
+   return HB_TRUE;
 }
 
 /*
  * Skip in tag respecting record filter only
  */
-static void hb_ntxTagSkipFilter( LPTAGINFO pTag, BOOL fForward )
+static void hb_ntxTagSkipFilter( LPTAGINFO pTag, HB_BOOL fForward )
 {
-   BOOL fBack, fEof = fForward ? pTag->TagEOF : pTag->TagBOF;
+   HB_BOOL fBack, fEof = fForward ? pTag->TagEOF : pTag->TagBOF;
 
    fBack = pTag->fUsrDescend == pTag->AscendKey ? fForward : !fForward;
 
@@ -3268,15 +3268,15 @@ static void hb_ntxTagSkipFilter( LPTAGINFO pTag, BOOL fForward )
 
       if( !fEof && !hb_ntxKeyInScope( pTag, pTag->CurKeyInfo ) )
       {
-         fEof = TRUE;
+         fEof = HB_TRUE;
       }
    }
    if( fEof )
    {
       if( fForward )
-         pTag->TagEOF = TRUE;
+         pTag->TagEOF = HB_TRUE;
       else
-         pTag->TagBOF = TRUE;
+         pTag->TagBOF = HB_TRUE;
    }
 }
 
@@ -3298,7 +3298,7 @@ static void hb_ntxTagGoTop( LPTAGINFO pTag )
                   !hb_ntxKeyInScope( pTag, pTag->CurKeyInfo );
 
    if( ! pTag->TagEOF && pTag->Owner->Owner->dbfarea.area.dbfi.fFilter )
-      hb_ntxTagSkipFilter( pTag, TRUE );
+      hb_ntxTagSkipFilter( pTag, HB_TRUE );
 
    pTag->TagBOF = pTag->TagEOF;
 }
@@ -3321,7 +3321,7 @@ static void hb_ntxTagGoBottom( LPTAGINFO pTag )
                   !hb_ntxKeyInScope( pTag, pTag->CurKeyInfo );
 
    if( ! pTag->TagBOF && pTag->Owner->Owner->dbfarea.area.dbfi.fFilter )
-      hb_ntxTagSkipFilter( pTag, FALSE );
+      hb_ntxTagSkipFilter( pTag, HB_FALSE );
 
    pTag->TagEOF = pTag->TagBOF;
 }
@@ -3331,10 +3331,10 @@ static void hb_ntxTagGoBottom( LPTAGINFO pTag )
  */
 static void hb_ntxTagSkipNext( LPTAGINFO pTag )
 {
-   pTag->TagBOF = FALSE;
+   pTag->TagBOF = HB_FALSE;
 
    if( pTag->stackLevel == 0 )
-      pTag->TagEOF = TRUE;
+      pTag->TagEOF = HB_TRUE;
    else if( ! hb_ntxInTopScope( pTag, pTag->CurKeyInfo->key ) )
       hb_ntxTagGoTop( pTag );
    else if( pTag->fUsrDescend == pTag->AscendKey )
@@ -3343,10 +3343,10 @@ static void hb_ntxTagSkipNext( LPTAGINFO pTag )
       pTag->TagEOF = !hb_ntxTagNextKey( pTag );
 
    if( ! pTag->TagEOF && ! hb_ntxKeyInScope( pTag, pTag->CurKeyInfo ) )
-      pTag->TagEOF = TRUE;
+      pTag->TagEOF = HB_TRUE;
 
    if( ! pTag->TagEOF && pTag->Owner->Owner->dbfarea.area.dbfi.fFilter )
-      hb_ntxTagSkipFilter( pTag, TRUE );
+      hb_ntxTagSkipFilter( pTag, HB_TRUE );
 }
 
 /*
@@ -3354,7 +3354,7 @@ static void hb_ntxTagSkipNext( LPTAGINFO pTag )
  */
 static void hb_ntxTagSkipPrev( LPTAGINFO pTag )
 {
-   pTag->TagEOF = FALSE;
+   pTag->TagEOF = HB_FALSE;
 
    if( pTag->stackLevel == 0 )
       /* TODO?: check if this is NTX behavior,
@@ -3366,10 +3366,10 @@ static void hb_ntxTagSkipPrev( LPTAGINFO pTag )
       pTag->TagBOF = !hb_ntxTagPrevKey( pTag );
 
    if( ! pTag->TagBOF && ! hb_ntxKeyInScope( pTag, pTag->CurKeyInfo ) )
-      pTag->TagBOF = TRUE;
+      pTag->TagBOF = HB_TRUE;
 
    if( ! pTag->TagBOF && pTag->Owner->Owner->dbfarea.area.dbfi.fFilter )
-      hb_ntxTagSkipFilter( pTag, FALSE );
+      hb_ntxTagSkipFilter( pTag, HB_FALSE );
 }
 
 /*
@@ -3475,10 +3475,10 @@ static void hb_ntxTagGoToRelKeyPos( LPTAGINFO pTag, double dPos )
 /*
  * free pages allocated by tag
  */
-static BOOL hb_ntxTagPagesFree( LPTAGINFO pTag, ULONG ulPage )
+static HB_BOOL hb_ntxTagPagesFree( LPTAGINFO pTag, ULONG ulPage )
 {
    LPPAGEINFO pPage = hb_ntxPageLoad( pTag, ulPage );
-   BOOL fOK = pPage != NULL;
+   HB_BOOL fOK = pPage != NULL;
    USHORT u;
 
    for( u = 0; fOK && u <= pPage->uiKeys; u++ )
@@ -3514,7 +3514,7 @@ static HB_ERRCODE hb_ntxTagSpaceFree( LPTAGINFO pTag )
       }
       hb_ntxPageAddFree( pTag, pTag->HeadBlock );
       hb_ntxIndexTagDel( pTag->Owner, pTag->TagName );
-      pTag->Owner->Changed = TRUE;
+      pTag->Owner->Changed = HB_TRUE;
    }
    hb_ntxTagDelete( pTag );
    return HB_SUCCESS;
@@ -3523,12 +3523,12 @@ static HB_ERRCODE hb_ntxTagSpaceFree( LPTAGINFO pTag )
 /*
  * create index file name
  */
-static void hb_ntxCreateFName( NTXAREAP pArea, const char * szBagName, BOOL * fProd,
+static void hb_ntxCreateFName( NTXAREAP pArea, const char * szBagName, HB_BOOL * fProd,
                                char * szFileName, char * szTagName )
 {
    PHB_FNAME pFileName;
    PHB_ITEM pExt = NULL;
-   BOOL fName = szBagName && *szBagName;
+   HB_BOOL fName = szBagName && *szBagName;
 
    pFileName = hb_fsFNameSplit( fName ? szBagName : pArea->dbfarea.szDataFileName );
 
@@ -3556,9 +3556,9 @@ static void hb_ntxCreateFName( NTXAREAP pArea, const char * szBagName, BOOL * fP
    if( fProd )
    {
       if( ! pFileName->szName )
-         *fProd = FALSE;
+         *fProd = HB_FALSE;
       else if( !fName )
-         *fProd = TRUE;
+         *fProd = HB_TRUE;
       else
       {
          PHB_FNAME pTableFileName = hb_fsFNameSplit( pArea->dbfarea.szDataFileName );
@@ -3591,7 +3591,7 @@ static LPNTXINDEX hb_ntxFindBag( NTXAREAP pArea, const char * szBagName )
 {
    LPNTXINDEX pIndex;
    PHB_FNAME pSeek, pName;
-   BOOL fFound;
+   HB_BOOL fFound;
 
    pSeek = hb_fsFNameSplit( szBagName );
    if( ! pSeek->szName )
@@ -3640,7 +3640,7 @@ static LPTAGINFO hb_ntxFindTag( NTXAREAP pArea, PHB_ITEM pTagItem,
                                 PHB_ITEM pBagItem )
 {
    LPNTXINDEX pIndex;
-   BOOL fBag;
+   HB_BOOL fBag;
 
    if( ! pTagItem ||
        ( hb_itemType( pTagItem ) & ( HB_IT_STRING | HB_IT_NUMERIC ) ) == 0 )
@@ -3661,7 +3661,7 @@ static LPTAGINFO hb_ntxFindTag( NTXAREAP pArea, PHB_ITEM pTagItem,
       pIndex = pArea->lpIndexes;
       if( iBag > 0 )
       {
-         fBag = TRUE;
+         fBag = HB_TRUE;
          while( pIndex )
          {
             if( --iBag == 0 )
@@ -3743,7 +3743,7 @@ static int hb_ntxFindTagNum( NTXAREAP pArea, LPTAGINFO pTag )
          }
          pIndex = pIndex->pNext;
       }
-      pArea->fSetTagNumbers = FALSE;
+      pArea->fSetTagNumbers = HB_FALSE;
    }
    return pTag->uiNumber;
 }
@@ -3812,7 +3812,7 @@ static ULONG hb_ntxOrdKeyNo( LPTAGINFO pTag )
          else
          {
             int iLevel = pTag->stackLevel, iKey, iFirst = 1;
-            BOOL fBack = pTag->fUsrDescend == pTag->AscendKey;
+            HB_BOOL fBack = pTag->fUsrDescend == pTag->AscendKey;
             LPPAGEINFO pPage;
             ULONG ulPage;
 
@@ -3855,12 +3855,12 @@ static ULONG hb_ntxOrdKeyNo( LPTAGINFO pTag )
 /*
  * set logical key position in given tag
  */
-static BOOL hb_ntxOrdKeyGoto( LPTAGINFO pTag, ULONG ulKeyNo )
+static HB_BOOL hb_ntxOrdKeyGoto( LPTAGINFO pTag, ULONG ulKeyNo )
 {
    NTXAREAP pArea = pTag->Owner->Owner;
 
    if( ! ulKeyNo || ! hb_ntxTagLockRead( pTag ) )
-      return FALSE;
+      return HB_FALSE;
 
    hb_ntxTagRefreshScope( pTag );
    hb_ntxTagGoTop( pTag );
@@ -3882,7 +3882,7 @@ static BOOL hb_ntxOrdKeyGoto( LPTAGINFO pTag, ULONG ulKeyNo )
       pArea->lpCurTag = pSavedTag;
    }
    hb_ntxTagUnLockRead( pTag );
-   return TRUE;
+   return HB_TRUE;
 }
 
 /*
@@ -3891,19 +3891,19 @@ static BOOL hb_ntxOrdKeyGoto( LPTAGINFO pTag, ULONG ulKeyNo )
 static double hb_ntxOrdGetRelKeyPos( LPTAGINFO pTag )
 {
    double dPos = 0.0, dStart = 0.0, dStop = 1.0, dFact = 0.0000000000001;
-   BOOL fOK = TRUE, fFilter = pTag->Owner->Owner->dbfarea.area.dbfi.fFilter;
+   HB_BOOL fOK = HB_TRUE, fFilter = pTag->Owner->Owner->dbfarea.area.dbfi.fFilter;
 
    if( ! hb_ntxTagLockRead( pTag ) )
-      return FALSE;
+      return HB_FALSE;
 
    hb_ntxTagRefreshScope( pTag );
 
-   pTag->Owner->Owner->dbfarea.area.dbfi.fFilter = FALSE;
+   pTag->Owner->Owner->dbfarea.area.dbfi.fFilter = HB_FALSE;
    if( pTag->fUsrDescend ? pTag->bottom.scopeKeyLen : pTag->top.scopeKeyLen )
    {
       hb_ntxTagGoTop( pTag );
       if( pTag->TagEOF )
-         fOK = FALSE;
+         fOK = HB_FALSE;
       else
          dStart = hb_ntxTagCountRelKeyPos( pTag );
    }
@@ -3911,7 +3911,7 @@ static double hb_ntxOrdGetRelKeyPos( LPTAGINFO pTag )
    {
       hb_ntxTagGoBottom( pTag );
       if( pTag->TagBOF )
-         fOK = FALSE;
+         fOK = HB_FALSE;
       else
          dStop = hb_ntxTagCountRelKeyPos( pTag );
    }
@@ -3950,23 +3950,23 @@ static void hb_ntxOrdSetRelKeyPos( LPTAGINFO pTag, double dPos )
    {
       NTXAREAP pArea = pTag->Owner->Owner;
       double dStart = 0.0, dStop = 1.0, dFact = 0.0000000000001;
-      BOOL fOK = TRUE, fFilter = pArea->dbfarea.area.dbfi.fFilter;
-      BOOL fForward = TRUE, fTop = FALSE;
+      HB_BOOL fOK = HB_TRUE, fFilter = pArea->dbfarea.area.dbfi.fFilter;
+      HB_BOOL fForward = HB_TRUE, fTop = HB_FALSE;
 
       hb_ntxTagRefreshScope( pTag );
 
       if( dPos >= 1.0 )
-         fForward = FALSE;
+         fForward = HB_FALSE;
       else if( dPos <= 0.0 )
-         fTop = TRUE;
+         fTop = HB_TRUE;
       else
       {
-         pArea->dbfarea.area.dbfi.fFilter = FALSE;
+         pArea->dbfarea.area.dbfi.fFilter = HB_FALSE;
          if( pTag->fUsrDescend ? pTag->bottom.scopeKeyLen : pTag->top.scopeKeyLen )
          {
             hb_ntxTagGoTop( pTag );
             if( pTag->TagEOF )
-               fOK = FALSE;
+               fOK = HB_FALSE;
             else
                dStart = hb_ntxTagCountRelKeyPos( pTag );
          }
@@ -3974,7 +3974,7 @@ static void hb_ntxOrdSetRelKeyPos( LPTAGINFO pTag, double dPos )
          {
             hb_ntxTagGoBottom( pTag );
             if( pTag->TagBOF )
-               fOK = FALSE;
+               fOK = HB_FALSE;
             else
                dStop = hb_ntxTagCountRelKeyPos( pTag );
          }
@@ -3984,18 +3984,18 @@ static void hb_ntxOrdSetRelKeyPos( LPTAGINFO pTag, double dPos )
          {
             if( dStart >= dStop - dFact )
             {
-               fTop = TRUE;
+               fTop = HB_TRUE;
             }
             else
             {
                dPos = dPos * ( dStop - dStart ) + dStart;
                hb_ntxTagGoToRelKeyPos( pTag, dPos );
                if( pTag->CurKeyInfo->Xtra == 0 )
-                  fForward = FALSE;
+                  fForward = HB_FALSE;
                else if( !hb_ntxInTopScope( pTag, pTag->CurKeyInfo->key ) )
-                  fTop = TRUE;
+                  fTop = HB_TRUE;
                else if( !hb_ntxInBottomScope( pTag, pTag->CurKeyInfo->key ) )
-                  fForward = FALSE;
+                  fForward = HB_FALSE;
             }
          }
       }
@@ -4008,7 +4008,7 @@ static void hb_ntxOrdSetRelKeyPos( LPTAGINFO pTag, double dPos )
          LPTAGINFO pSavedTag = pArea->lpCurTag;
          pArea->lpCurTag = pTag;
 
-         pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+         pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
          if( fForward )
          {
@@ -4020,13 +4020,13 @@ static void hb_ntxOrdSetRelKeyPos( LPTAGINFO pTag, double dPos )
                {
                   SELF_SKIPFILTER( ( AREAP ) pArea, 1 );
                   if( pArea->dbfarea.area.fEof && !fTop )
-                     fForward = FALSE;
+                     fForward = HB_FALSE;
                }
             }
             else if( fTop )
                SELF_GOTO( ( AREAP ) pArea, 0 );
             else
-               fForward = FALSE;
+               fForward = HB_FALSE;
          }
          if( !fForward )
          {
@@ -4034,7 +4034,7 @@ static void hb_ntxOrdSetRelKeyPos( LPTAGINFO pTag, double dPos )
             if( SELF_GOTO( ( AREAP ) pArea, pTag->CurKeyInfo->Xtra ) == HB_SUCCESS &&
                 pTag->CurKeyInfo->Xtra != 0 )
             {
-               pArea->dbfarea.area.fBottom = TRUE;
+               pArea->dbfarea.area.fBottom = HB_TRUE;
                SELF_SKIPFILTER( ( AREAP ) pArea, -1 );
             }
          }
@@ -4047,15 +4047,15 @@ static void hb_ntxOrdSetRelKeyPos( LPTAGINFO pTag, double dPos )
 /*
  * skip to next/previous unique key
  */
-static BOOL hb_ntxOrdSkipUnique( LPTAGINFO pTag, LONG lToSkip )
+static HB_BOOL hb_ntxOrdSkipUnique( LPTAGINFO pTag, LONG lToSkip )
 {
    NTXAREAP pArea = pTag->Owner->Owner;
-   BOOL fOut = FALSE, fEof = FALSE, fForward = ( lToSkip >= 0 );
+   HB_BOOL fOut = HB_FALSE, fEof = HB_FALSE, fForward = ( lToSkip >= 0 );
 
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
-   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
    if( hb_ntxTagLockRead( pTag ) )
    {
@@ -4078,7 +4078,7 @@ static BOOL hb_ntxOrdSkipUnique( LPTAGINFO pTag, LONG lToSkip )
          }
          while( !fOut && hb_ntxValCompare( pTag,
                                        pTag->CurKeyInfo->key, pTag->KeyLength,
-                                       keyVal, pTag->KeyLength, TRUE ) == 0 );
+                                       keyVal, pTag->KeyLength, HB_TRUE ) == 0 );
       }
       else if( !fForward && !pArea->dbfarea.fPositioned )
       {
@@ -4087,12 +4087,12 @@ static BOOL hb_ntxOrdSkipUnique( LPTAGINFO pTag, LONG lToSkip )
       }
       else
       {
-         fOut = TRUE;
+         fOut = HB_TRUE;
       }
       if( fOut )
       {
          if( fForward )
-            fEof = TRUE;
+            fEof = HB_TRUE;
          else
          {
             hb_ntxTagGoTop( pTag );
@@ -4106,42 +4106,42 @@ static BOOL hb_ntxOrdSkipUnique( LPTAGINFO pTag, LONG lToSkip )
       {
          SELF_SKIPFILTER( ( AREAP ) pArea, ( fForward || fOut ) ? 1 : -1 );
          if( ! fForward && fOut )
-            pArea->dbfarea.area.fBof = TRUE;
+            pArea->dbfarea.area.fBof = HB_TRUE;
       }
 
       /* Update Bof and Eof flags */
       if( fForward )
-         pArea->dbfarea.area.fBof = FALSE;
+         pArea->dbfarea.area.fBof = HB_FALSE;
       else
-         pArea->dbfarea.area.fEof = FALSE;
+         pArea->dbfarea.area.fEof = HB_FALSE;
 
       pArea->lpCurTag = pSavedTag;
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 /*
- * skip while code block doesn't return TRUE
+ * skip while code block doesn't return HB_TRUE
  */
-static BOOL hb_ntxOrdSkipEval( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pEval )
+static HB_BOOL hb_ntxOrdSkipEval( LPTAGINFO pTag, HB_BOOL fForward, PHB_ITEM pEval )
 {
    NTXAREAP pArea = pTag->Owner->Owner;
-   BOOL fFound = FALSE;
+   HB_BOOL fFound = HB_FALSE;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_ntxOrdSkipEval(%p, %d, %p)", pTag, fForward, pEval));
 
    if( hb_itemType( pEval ) != HB_IT_BLOCK )
    {
       if( SELF_SKIP( ( AREAP ) pArea, fForward ? 1 : -1 ) != HB_SUCCESS )
-         return FALSE;
+         return HB_FALSE;
       return fForward ? !pArea->dbfarea.area.fEof : !pArea->dbfarea.area.fBof;
    }
 
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
-   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
    if( hb_ntxTagLockRead( pTag ) )
    {
@@ -4166,7 +4166,7 @@ static BOOL hb_ntxOrdSkipEval( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pEval )
                if( SELF_SKIPFILTER( ( AREAP ) pArea, fForward ? 1 : -1 ) != HB_SUCCESS ||
                    pArea->dbfarea.ulRecNo == ulRecNo || hb_ntxEvalSeekCond( pTag, pEval ) )
                {
-                  fFound = TRUE;
+                  fFound = HB_TRUE;
                   break;
                }
             }
@@ -4182,7 +4182,7 @@ static BOOL hb_ntxOrdSkipEval( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pEval )
             else
             {
                SELF_GOTOP( ( AREAP ) pArea );
-               pArea->dbfarea.area.fBof = TRUE;
+               pArea->dbfarea.area.fBof = HB_TRUE;
             }
          }
       }
@@ -4192,22 +4192,22 @@ static BOOL hb_ntxOrdSkipEval( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pEval )
 
    /* Update Bof and Eof flags */
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
    return fFound;
 }
 
 /*
- * skip while code block doesn't return TRUE
+ * skip while code block doesn't return HB_TRUE
  */
-static BOOL hb_ntxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm )
+static HB_BOOL hb_ntxOrdSkipWild( LPTAGINFO pTag, HB_BOOL fForward, PHB_ITEM pWildItm )
 {
    NTXAREAP pArea = pTag->Owner->Owner;
    const char * szPattern;
    char * szFree = NULL;
-   BOOL fFound = FALSE;
+   HB_BOOL fFound = HB_FALSE;
    int iFixed = 0;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_ntxOrdSkipWild(%p, %d, %p)", pTag, fForward, pWildItm));
@@ -4217,7 +4217,7 @@ static BOOL hb_ntxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm
    if( pTag->KeyType != 'C' || !szPattern || !*szPattern )
    {
       if( SELF_SKIP( ( AREAP ) pArea, fForward ? 1 : -1 ) != HB_SUCCESS )
-         return FALSE;
+         return HB_FALSE;
       return fForward ? !pArea->dbfarea.area.fEof : !pArea->dbfarea.area.fBof;
    }
 
@@ -4235,7 +4235,7 @@ static BOOL hb_ntxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
-   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
    if( hb_ntxTagLockRead( pTag ) )
    {
@@ -4249,7 +4249,7 @@ static BOOL hb_ntxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm
          if( pTag->fUsrDescend )
             iStop = -iStop;
          if( iFixed && hb_ntxValCompare( pTag, szPattern, iFixed,
-                             pTag->CurKeyInfo->key, iFixed, FALSE ) == -iStop )
+                             pTag->CurKeyInfo->key, iFixed, HB_FALSE ) == -iStop )
          {
             LPKEYINFO pKey;
             pKey = hb_ntxKeyNew( NULL, pTag->KeyLength );
@@ -4261,9 +4261,9 @@ static BOOL hb_ntxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm
             if( !hb_ntxTagKeyFind( pTag, pKey, iFixed ) )
             {
                if( fForward )
-                  pTag->TagEOF = TRUE;
+                  pTag->TagEOF = HB_TRUE;
                else
-                  pTag->TagBOF = TRUE;
+                  pTag->TagBOF = HB_TRUE;
             }
             hb_ntxKeyFree( pKey );
          }
@@ -4283,12 +4283,12 @@ static BOOL hb_ntxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm
                    pArea->dbfarea.ulRecNo == ulRecNo ||
                    hb_strMatchWild( pTag->CurKeyInfo->key, szPattern ) )
                {
-                  fFound = TRUE;
+                  fFound = HB_TRUE;
                   break;
                }
             }
             if( iFixed && hb_ntxValCompare( pTag, szPattern, iFixed,
-                             pTag->CurKeyInfo->key, iFixed, FALSE ) == iStop )
+                             pTag->CurKeyInfo->key, iFixed, HB_FALSE ) == iStop )
             {
                break;
             }
@@ -4304,7 +4304,7 @@ static BOOL hb_ntxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm
             else
             {
                SELF_GOTOP( ( AREAP ) pArea );
-               pArea->dbfarea.area.fBof = TRUE;
+               pArea->dbfarea.area.fBof = HB_TRUE;
             }
          }
       }
@@ -4314,9 +4314,9 @@ static BOOL hb_ntxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm
 
    /* Update Bof and Eof flags */
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
    if( szFree )
       hb_xfree( szFree );
@@ -4324,7 +4324,7 @@ static BOOL hb_ntxOrdSkipWild( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pWildItm
    return fFound;
 }
 
-static BOOL hb_ntxRegexMatch( LPTAGINFO pTag, PHB_REGEX pRegEx, char * szKey )
+static HB_BOOL hb_ntxRegexMatch( LPTAGINFO pTag, PHB_REGEX pRegEx, char * szKey )
 {
    ULONG ulLen = pTag->KeyLength;
    char szBuff[ NTX_MAX_KEY + 1 ];
@@ -4338,16 +4338,16 @@ static BOOL hb_ntxRegexMatch( LPTAGINFO pTag, PHB_REGEX pRegEx, char * szKey )
       szKey = szBuff;
    }
 
-   return hb_regexMatch( pRegEx, szKey, ulLen, FALSE );
+   return hb_regexMatch( pRegEx, szKey, ulLen, HB_FALSE );
 }
 
 /*
- * skip while regular expression on index key val doesn't return TRUE
+ * skip while regular expression on index key val doesn't return HB_TRUE
  */
-static BOOL hb_ntxOrdSkipRegEx( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pRegExItm )
+static HB_BOOL hb_ntxOrdSkipRegEx( LPTAGINFO pTag, HB_BOOL fForward, PHB_ITEM pRegExItm )
 {
    NTXAREAP pArea = pTag->Owner->Owner;
-   BOOL fFound = FALSE;
+   HB_BOOL fFound = HB_FALSE;
    PHB_REGEX pRegEx;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_ntxOrdSkipRegEx(%p, %d, %p)", pTag, fForward, pRegExItm));
@@ -4355,14 +4355,14 @@ static BOOL hb_ntxOrdSkipRegEx( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pRegExIt
    if( pTag->KeyType != 'C' || ( pRegEx = hb_regexGet( pRegExItm, 0 ) ) == NULL )
    {
       if( SELF_SKIP( ( AREAP ) pArea, fForward ? 1 : -1 ) != HB_SUCCESS )
-         return FALSE;
+         return HB_FALSE;
       return fForward ? !pArea->dbfarea.area.fEof : !pArea->dbfarea.area.fBof;
    }
 
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
-   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
 
    if( hb_ntxTagLockRead( pTag ) )
    {
@@ -4389,7 +4389,7 @@ static BOOL hb_ntxOrdSkipRegEx( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pRegExIt
                    pArea->dbfarea.ulRecNo == ulRecNo ||
                    hb_ntxRegexMatch( pTag, pRegEx, ( char * ) pTag->CurKeyInfo->key ) )
                {
-                  fFound = TRUE;
+                  fFound = HB_TRUE;
                   break;
                }
             }
@@ -4405,7 +4405,7 @@ static BOOL hb_ntxOrdSkipRegEx( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pRegExIt
             else
             {
                SELF_GOTOP( ( AREAP ) pArea );
-               pArea->dbfarea.area.fBof = TRUE;
+               pArea->dbfarea.area.fBof = HB_TRUE;
             }
          }
       }
@@ -4415,9 +4415,9 @@ static BOOL hb_ntxOrdSkipRegEx( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pRegExIt
 
    /* Update Bof and Eof flags */
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
    hb_regexFree( pRegEx );
 
@@ -4428,24 +4428,24 @@ static BOOL hb_ntxOrdSkipRegEx( LPTAGINFO pTag, BOOL fForward, PHB_ITEM pRegExIt
  * add key to custom tag (ordKeyAdd())
  * user key value is not implemented
  */
-static BOOL hb_ntxOrdKeyAdd( LPTAGINFO pTag, PHB_ITEM pItem )
+static HB_BOOL hb_ntxOrdKeyAdd( LPTAGINFO pTag, PHB_ITEM pItem )
 {
    NTXAREAP pArea = pTag->Owner->Owner;
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
    LPKEYINFO pKey;
 
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
    if( !pArea->dbfarea.fPositioned )
-      return FALSE;
+      return HB_FALSE;
 
-   if( pTag->pForItem && !hb_ntxEvalCond( pArea, pTag->pForItem, TRUE ) )
-      return FALSE;
+   if( pTag->pForItem && !hb_ntxEvalCond( pArea, pTag->pForItem, HB_TRUE ) )
+      return HB_FALSE;
 
    if( pTag->Template && pItem && hb_itemType( pItem ) != HB_IT_NIL )
    {
-      pKey = hb_ntxKeyPutItem( NULL, pItem, pArea->dbfarea.ulRecNo, pTag, TRUE, NULL );
+      pKey = hb_ntxKeyPutItem( NULL, pItem, pArea->dbfarea.ulRecNo, pTag, HB_TRUE, NULL );
    }
    else
    {
@@ -4456,7 +4456,7 @@ static BOOL hb_ntxOrdKeyAdd( LPTAGINFO pTag, PHB_ITEM pItem )
    {
       if( hb_ntxTagKeyAdd( pTag, pKey ) )
       {
-         fResult = TRUE;
+         fResult = HB_TRUE;
          if( !pTag->Owner->fShared && pTag->keyCount &&
              hb_ntxKeyInScope( pTag, pKey ) )
             pTag->keyCount++;
@@ -4471,24 +4471,24 @@ static BOOL hb_ntxOrdKeyAdd( LPTAGINFO pTag, PHB_ITEM pItem )
  * del key from custom tag (ordKeyDel())
  * user key value is not implemented
  */
-static BOOL hb_ntxOrdKeyDel( LPTAGINFO pTag, PHB_ITEM pItem )
+static HB_BOOL hb_ntxOrdKeyDel( LPTAGINFO pTag, PHB_ITEM pItem )
 {
    NTXAREAP pArea = pTag->Owner->Owner;
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
    LPKEYINFO pKey = NULL;
 
    if( pArea->dbfarea.lpdbPendingRel )
       SELF_FORCEREL( ( AREAP ) pArea );
 
    if( !pArea->dbfarea.fPositioned )
-      return FALSE;
+      return HB_FALSE;
 
-   if( pTag->pForItem && !hb_ntxEvalCond( pArea, pTag->pForItem, TRUE ) )
-      return FALSE;
+   if( pTag->pForItem && !hb_ntxEvalCond( pArea, pTag->pForItem, HB_TRUE ) )
+      return HB_FALSE;
 
    if( pTag->Template && pItem && hb_itemType( pItem ) != HB_IT_NIL )
    {
-      pKey = hb_ntxKeyPutItem( NULL, pItem, pArea->dbfarea.ulRecNo, pTag, TRUE, NULL );
+      pKey = hb_ntxKeyPutItem( NULL, pItem, pArea->dbfarea.ulRecNo, pTag, HB_TRUE, NULL );
    }
 
    if( hb_ntxTagLockWrite( pTag ) )
@@ -4502,7 +4502,7 @@ static BOOL hb_ntxOrdKeyDel( LPTAGINFO pTag, PHB_ITEM pItem )
       }
       if( hb_ntxTagKeyDel( pTag, pKey ) )
       {
-         fResult = TRUE;
+         fResult = HB_TRUE;
          if( !pTag->Owner->fShared && pTag->keyCount &&
              hb_ntxKeyInScope( pTag, pKey ) )
             pTag->keyCount--;
@@ -4518,10 +4518,10 @@ static BOOL hb_ntxOrdKeyDel( LPTAGINFO pTag, PHB_ITEM pItem )
  * custom indexes when the same record can be stored more then once
  * or when the used index key is unknown
  */
-static BOOL hb_ntxOrdFindRec( LPTAGINFO pTag, ULONG ulRecNo, BOOL fCont )
+static HB_BOOL hb_ntxOrdFindRec( LPTAGINFO pTag, ULONG ulRecNo, HB_BOOL fCont )
 {
    NTXAREAP pArea = pTag->Owner->Owner;
-   BOOL fFound = FALSE;
+   HB_BOOL fFound = HB_FALSE;
 
    if( pTag && ulRecNo )
    {
@@ -4548,7 +4548,7 @@ static BOOL hb_ntxOrdFindRec( LPTAGINFO pTag, ULONG ulRecNo, BOOL fCont )
             {
                if( pTag->CurKeyInfo->Xtra == ulRecNo )
                {
-                  fFound = TRUE;
+                  fFound = HB_TRUE;
                   break;
                }
                hb_ntxTagSkipNext( pTag );
@@ -4604,7 +4604,7 @@ static int hb_ntxQuickSortCompare( LPNTXSORTINFO pSort, BYTE * pKey1, BYTE * pKe
 {
    int iLen = pSort->keyLen, i;
 
-   i = hb_ntxValCompare( pSort->pTag, (char *) pKey1, iLen, (char *) pKey2, iLen, TRUE );
+   i = hb_ntxValCompare( pSort->pTag, (char *) pKey1, iLen, (char *) pKey2, iLen, HB_TRUE );
    if( i == 0 )
    {
       if( pSort->pTag->fSortRec )
@@ -4618,14 +4618,14 @@ static int hb_ntxQuickSortCompare( LPNTXSORTINFO pSort, BYTE * pKey1, BYTE * pKe
    return i;
 }
 
-static BOOL hb_ntxQSort( LPNTXSORTINFO pSort, BYTE * pSrc, BYTE * pBuf, LONG lKeys )
+static HB_BOOL hb_ntxQSort( LPNTXSORTINFO pSort, BYTE * pSrc, BYTE * pBuf, LONG lKeys )
 {
    if( lKeys > 1 )
    {
       int iLen = pSort->keyLen + 4;
       LONG l1, l2;
       BYTE * pPtr1, * pPtr2, *pDst;
-      BOOL f1, f2;
+      HB_BOOL f1, f2;
 
       l1 = lKeys >> 1;
       l2 = lKeys - l1;
@@ -4673,7 +4673,7 @@ static BOOL hb_ntxQSort( LPNTXSORTINFO pSort, BYTE * pSrc, BYTE * pBuf, LONG lKe
       }
       return !f1;
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 static void hb_ntxSortSortPage( LPNTXSORTINFO pSort )
@@ -4703,9 +4703,9 @@ static void hb_ntxSortBufferFlush( LPNTXSORTINFO pSort )
                         pIndex->IndexName, hb_fsError(), 0, NULL );
       }
       pSort->ulPagesIO = 0;
-      pIndex->fFlush = TRUE;
+      pIndex->fFlush = HB_TRUE;
       if( pIndex->fShared )
-         pIndex->Changed = TRUE;
+         pIndex->Changed = HB_TRUE;
    }
 }
 
@@ -4729,7 +4729,7 @@ static void hb_ntxSortStorePage( LPNTXSORTINFO pSort, LPPAGEINFO pPage )
             pSort->ulLastIO = pPage->Page;
             if( !pSort->ulPagesIO++ )
                pSort->ulFirstIO = pPage->Page;
-            pPage->Changed = FALSE;
+            pPage->Changed = HB_FALSE;
             return;
          }
       }
@@ -4749,7 +4749,7 @@ static void hb_ntxSortAddNodeKey( LPNTXSORTINFO pSort, BYTE *pKeyVal, ULONG ulRe
       pPage = pSort->NodeList[ iLevel ];
       if( pPage == NULL )
       {
-         pPage = pSort->NodeList[ iLevel ] = hb_ntxPageNew( pSort->pTag, TRUE );
+         pPage = pSort->NodeList[ iLevel ] = hb_ntxPageNew( pSort->pTag, HB_TRUE );
          break;
       }
       else if( pPage->uiKeys >= pSort->pTag->MaxKeys )
@@ -4758,7 +4758,7 @@ static void hb_ntxSortAddNodeKey( LPNTXSORTINFO pSort, BYTE *pKeyVal, ULONG ulRe
          hb_ntxSortStorePage( pSort, pPage );
          ulPage = pPage->Page;
          hb_ntxPageRelease( pSort->pTag, pPage );
-         pSort->NodeList[ iLevel++ ] = hb_ntxPageNew( pSort->pTag, TRUE );
+         pSort->NodeList[ iLevel++ ] = hb_ntxPageNew( pSort->pTag, HB_TRUE );
       }
       else
          break;
@@ -4849,7 +4849,7 @@ static void hb_ntxSortOrderPages( LPNTXSORTINFO pSort )
             m = ( l + r ) >> 1;
             ulPage = pSort->pSortedPages[ m ];
             pTmp = &pSort->pSwapPage[ ulPage ].pKeyPool[ pSort->pSwapPage[ ulPage ].ulCurKey * ( iLen + 4 ) ];
-            i = hb_ntxValCompare( pSort->pTag, (char *) pKey, iLen, (char *) pTmp, iLen, TRUE );
+            i = hb_ntxValCompare( pSort->pTag, (char *) pKey, iLen, (char *) pTmp, iLen, HB_TRUE );
             if( i == 0 )
             {
                if( pSort->pTag->fSortRec )
@@ -4869,7 +4869,7 @@ static void hb_ntxSortOrderPages( LPNTXSORTINFO pSort )
    }
 }
 
-static BOOL hb_ntxSortKeyGet( LPNTXSORTINFO pSort, BYTE ** pKeyVal, ULONG *pulRec )
+static HB_BOOL hb_ntxSortKeyGet( LPNTXSORTINFO pSort, BYTE ** pKeyVal, ULONG *pulRec )
 {
    int iLen = pSort->keyLen, i;
    LONG l, r, m;
@@ -4900,7 +4900,7 @@ static BOOL hb_ntxSortKeyGet( LPNTXSORTINFO pSort, BYTE ** pKeyVal, ULONG *pulRe
          m = ( l + r ) >> 1;
          ulPg = pSort->pSortedPages[ m ];
          pTmp = &pSort->pSwapPage[ ulPg ].pKeyPool[ pSort->pSwapPage[ ulPg ].ulCurKey * ( iLen + 4 ) ];
-         i = hb_ntxValCompare( pSort->pTag, (char *) pKey, iLen, (char *) pTmp, iLen, TRUE );
+         i = hb_ntxValCompare( pSort->pTag, (char *) pKey, iLen, (char *) pTmp, iLen, HB_TRUE );
          if( i == 0 )
          {
             if( pSort->pTag->fSortRec )
@@ -4934,13 +4934,13 @@ static BOOL hb_ntxSortKeyGet( LPNTXSORTINFO pSort, BYTE ** pKeyVal, ULONG *pulRe
       pSort->pSwapPage[ ulPage ].ulCurKey++;
       pSort->pSwapPage[ ulPage ].ulKeys--;
       pSort->pSwapPage[ ulPage ].ulKeyBuf--;
-      return TRUE;
+      return HB_TRUE;
    }
 
    *pKeyVal = NULL;
    *pulRec = 0;
 
-   return FALSE;
+   return HB_FALSE;
 }
 
 static void hb_ntxSortKeyAdd( LPNTXSORTINFO pSort, ULONG ulRec, const char * pKeyVal, int iKeyLen )
@@ -5053,7 +5053,7 @@ static LPNTXSORTINFO hb_ntxSortNew( LPTAGINFO pTag, ULONG ulRecCount )
    return pSort;
 }
 
-static void hb_ntxSortFree( LPNTXSORTINFO pSort, BOOL fFull )
+static void hb_ntxSortFree( LPNTXSORTINFO pSort, HB_BOOL fFull )
 {
    if( pSort->hTempFile != FS_ERROR )
    {
@@ -5094,7 +5094,7 @@ static void hb_ntxSortFree( LPNTXSORTINFO pSort, BOOL fFull )
 
 static void hb_ntxSortOut( LPNTXSORTINFO pSort )
 {
-   BOOL fUnique = pSort->fUnique, fBalance, fNext;
+   HB_BOOL fUnique = pSort->fUnique, fBalance, fNext;
    LPTAGINFO pTag = pSort->pTag;
    ULONG ulPage, ulRec, ulKey;
    USHORT uiHalf;
@@ -5140,7 +5140,7 @@ static void hb_ntxSortOut( LPNTXSORTINFO pSort )
       }
       if( fUnique )
       {
-         if( ulKey != 0 && hb_ntxValCompare( pTag, (char *) pSort->pLastKey, iLen, (char *) pKeyVal, iLen, TRUE ) == 0 )
+         if( ulKey != 0 && hb_ntxValCompare( pTag, (char *) pSort->pLastKey, iLen, (char *) pKeyVal, iLen, HB_TRUE ) == 0 )
          {
             continue;
          }
@@ -5154,7 +5154,7 @@ static void hb_ntxSortOut( LPNTXSORTINFO pSort )
 #ifdef HB_NTX_DEBUG_EXT
       if( ulKey != 0 )
       {
-         int i = hb_ntxValCompare( pTag, (char *) pSort->pLastKey, iLen, (char *) pKeyVal, iLen, TRUE );
+         int i = hb_ntxValCompare( pTag, (char *) pSort->pLastKey, iLen, (char *) pKeyVal, iLen, HB_TRUE );
          if( ! pTag->AscendKey )
             i = -i;
          if( i == 0 )
@@ -5185,13 +5185,13 @@ static void hb_ntxSortOut( LPNTXSORTINFO pSort )
 
    if( pSort->NodeList[ 0 ] == NULL )
    {
-      pSort->NodeList[ 0 ] = hb_ntxPageNew( pTag, TRUE );
+      pSort->NodeList[ 0 ] = hb_ntxPageNew( pTag, HB_TRUE );
    }
    hb_ntxSetKeyPage( pSort->NodeList[ 0 ], pSort->NodeList[ 0 ]->uiKeys, 0 );
 
    iLevel = 0;
-   fNext = TRUE;
-   fBalance = FALSE;
+   fNext = HB_TRUE;
+   fBalance = HB_FALSE;
    uiHalf = pTag->MaxKeys >> 1;
    do
    {
@@ -5199,7 +5199,7 @@ static void hb_ntxSortOut( LPNTXSORTINFO pSort )
       if( iLevel + 1 == NTX_STACKSIZE || pSort->NodeList[ iLevel + 1 ] == NULL )
       {
          pTag->RootBlock = pSort->NodeList[ iLevel ]->Page;
-         fNext = FALSE;
+         fNext = HB_FALSE;
       }
       else
       {
@@ -5208,7 +5208,7 @@ static void hb_ntxSortOut( LPNTXSORTINFO pSort )
                            pSort->NodeList[ iLevel ]->Page );
          if( pSort->NodeList[ iLevel ]->uiKeys < uiHalf )
          {
-            fBalance = TRUE;
+            fBalance = HB_TRUE;
          }
       }
       hb_ntxPageRelease( pTag, pSort->NodeList[ iLevel ] );
@@ -5217,7 +5217,7 @@ static void hb_ntxSortOut( LPNTXSORTINFO pSort )
    while( fNext );
 
    hb_ntxSortBufferFlush( pSort );
-   hb_ntxSortFree( pSort, FALSE );
+   hb_ntxSortFree( pSort, HB_FALSE );
 
    if( fBalance )
    {
@@ -5261,7 +5261,7 @@ static void hb_ntxSortOut( LPNTXSORTINFO pSort )
 /*
  * create tag in index file
  */
-static HB_ERRCODE hb_ntxTagCreate( LPTAGINFO pTag, BOOL fReindex )
+static HB_ERRCODE hb_ntxTagCreate( LPTAGINFO pTag, HB_BOOL fReindex )
 {
    LPNTXAREA pArea = pTag->Owner->Owner;
    PHB_ITEM pForItem, pWhileItem = NULL, pEvalItem = NULL, pItem = NULL;
@@ -5292,7 +5292,7 @@ static HB_ERRCODE hb_ntxTagCreate( LPTAGINFO pTag, BOOL fReindex )
 
    if( ulRecCount == 0 )
    {
-      LPPAGEINFO pPage = hb_ntxPageNew( pTag, FALSE );
+      LPPAGEINFO pPage = hb_ntxPageNew( pTag, HB_FALSE );
 
       if( pPage )
       {
@@ -5308,7 +5308,7 @@ static HB_ERRCODE hb_ntxTagCreate( LPTAGINFO pTag, BOOL fReindex )
    {
       LPTAGINFO pSaveTag = pArea->lpCurTag;
       ULONG ulStartRec = 0, ulNextCount = 0;
-      BOOL fDirectRead, fUseFilter = FALSE;
+      HB_BOOL fDirectRead, fUseFilter = HB_FALSE;
       BYTE * pSaveRecBuff = pArea->dbfarea.pRecord;
       char szBuffer[ NTX_MAX_KEY ];
       int iRecBuff = 0, iRecBufSize, iRec;
@@ -5341,7 +5341,7 @@ static HB_ERRCODE hb_ntxTagCreate( LPTAGINFO pTag, BOOL fReindex )
          }
          else if( pArea->dbfarea.area.lpdbOrdCondInfo->fUseFilter )
          {
-            fUseFilter = TRUE;
+            fUseFilter = HB_TRUE;
          }
          else if( !pArea->dbfarea.area.lpdbOrdCondInfo->fUseCurrent )
          {
@@ -5403,7 +5403,7 @@ static HB_ERRCODE hb_ntxTagCreate( LPTAGINFO pTag, BOOL fReindex )
             pArea->dbfarea.ulRecNo = ulRecNo;
             if( SELF_GETREC( ( AREAP ) pArea, NULL ) == HB_FAILURE )
                break;
-            pArea->dbfarea.fValidBuffer = pArea->dbfarea.fPositioned = TRUE;
+            pArea->dbfarea.fValidBuffer = pArea->dbfarea.fPositioned = HB_TRUE;
             pArea->dbfarea.fDeleted = pArea->dbfarea.pRecord[ 0 ] == '*';
             /* Force relational movement in child WorkAreas */
             if( pArea->dbfarea.area.lpdbRelations )
@@ -5415,11 +5415,11 @@ static HB_ERRCODE hb_ntxTagCreate( LPTAGINFO pTag, BOOL fReindex )
             iRecBuff++;
          }
 
-         if( pWhileItem && !hb_ntxEvalCond( NULL, pWhileItem, FALSE ) )
+         if( pWhileItem && !hb_ntxEvalCond( NULL, pWhileItem, HB_FALSE ) )
             break;
 
          if( ulRecNo <= ulRecCount &&
-             ( pForItem == NULL || hb_ntxEvalCond( pArea, pForItem, FALSE ) ) )
+             ( pForItem == NULL || hb_ntxEvalCond( pArea, pForItem, HB_FALSE ) ) )
          {
             if( pTag->nField )
                errCode = SELF_GETVALUE( ( AREAP ) pArea, pTag->nField, pItem );
@@ -5463,7 +5463,7 @@ static HB_ERRCODE hb_ntxTagCreate( LPTAGINFO pTag, BOOL fReindex )
                   hb_ntxErrorRT( pArea, EG_DATATYPE, EDBF_INVALIDKEY,
                                  pTag->Owner->IndexName, 0, 0, NULL );
                   errCode = HB_FAILURE;
-                  pTag->Partial = TRUE;
+                  pTag->Partial = HB_TRUE;
                   pEvalItem = NULL;
                   ulNextCount = 1;
                   break;
@@ -5481,9 +5481,9 @@ static HB_ERRCODE hb_ntxTagCreate( LPTAGINFO pTag, BOOL fReindex )
             if( lStep >= pArea->dbfarea.area.lpdbOrdCondInfo->lStep )
             {
                lStep = 0;
-               if( !hb_ntxEvalCond( pArea, pEvalItem, FALSE ) )
+               if( !hb_ntxEvalCond( pArea, pEvalItem, HB_FALSE ) )
                {
-                  pTag->Partial = TRUE;
+                  pTag->Partial = HB_TRUE;
                   break;
                }
             }
@@ -5504,7 +5504,7 @@ static HB_ERRCODE hb_ntxTagCreate( LPTAGINFO pTag, BOOL fReindex )
       if( fDirectRead )
       {
          pArea->dbfarea.pRecord = pSaveRecBuff;
-         pArea->dbfarea.fValidBuffer = FALSE;
+         pArea->dbfarea.fValidBuffer = HB_FALSE;
          if( errCode == HB_SUCCESS )
             errCode = SELF_GOTO( ( AREAP ) pArea, ulRecNo );
       }
@@ -5519,7 +5519,7 @@ static HB_ERRCODE hb_ntxTagCreate( LPTAGINFO pTag, BOOL fReindex )
       hb_cdpSelect( cdpTmp );
    }
 
-   hb_ntxSortFree( pSort, TRUE );
+   hb_ntxSortFree( pSort, HB_TRUE );
    pArea->pSort = NULL;
 
    return errCode;
@@ -5533,7 +5533,7 @@ static HB_ERRCODE hb_ntxReIndex( LPNTXINDEX pIndex )
    HB_ERRCODE errCode = HB_FAILURE;
    int i;
 
-   if( hb_ntxIndexLockWrite( pIndex, FALSE ) )
+   if( hb_ntxIndexLockWrite( pIndex, HB_FALSE ) )
    {
       errCode = HB_SUCCESS;
       hb_ntxIndexTrunc( pIndex );
@@ -5542,8 +5542,8 @@ static HB_ERRCODE hb_ntxReIndex( LPNTXINDEX pIndex )
       {
          LPTAGINFO pTag = pIndex->lpTags[ i ];
          pTag->HeadBlock = pTag->RootBlock = pTag->keyCount = 0;
-         pTag->HdrChanged = TRUE;
-         errCode = hb_ntxTagCreate( pTag, TRUE );
+         pTag->HdrChanged = HB_TRUE;
+         errCode = hb_ntxTagCreate( pTag, HB_TRUE );
          if( errCode != HB_SUCCESS )
             break;
       }
@@ -5582,8 +5582,8 @@ static HB_ERRCODE hb_ntxGoBottom( NTXAREAP pArea )
 
    hb_ntxTagGoBottom( pArea->lpCurTag );
 
-   pArea->dbfarea.area.fTop = FALSE;
-   pArea->dbfarea.area.fBottom = TRUE;
+   pArea->dbfarea.area.fTop = HB_FALSE;
+   pArea->dbfarea.area.fBottom = HB_TRUE;
 
    if( pArea->lpCurTag->TagEOF )
       retval = SELF_GOTO( ( AREAP ) pArea, 0 );
@@ -5622,8 +5622,8 @@ static HB_ERRCODE hb_ntxGoTop( NTXAREAP pArea )
 
    hb_ntxTagGoTop( pArea->lpCurTag );
 
-   pArea->dbfarea.area.fTop = TRUE;
-   pArea->dbfarea.area.fBottom = FALSE;
+   pArea->dbfarea.area.fTop = HB_TRUE;
+   pArea->dbfarea.area.fBottom = HB_FALSE;
 
    if( pArea->lpCurTag->TagEOF )
       retval = SELF_GOTO( ( AREAP ) pArea, 0 );
@@ -5638,7 +5638,7 @@ static HB_ERRCODE hb_ntxGoTop( NTXAREAP pArea )
    return retval;
 }
 
-static HB_ERRCODE hb_ntxSeek( NTXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pItem, BOOL fFindLast )
+static HB_ERRCODE hb_ntxSeek( NTXAREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pItem, HB_BOOL fFindLast )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_ntxSeek(%p, %d, %p, %d)", pArea, fSoftSeek, pItem, fFindLast));
 
@@ -5654,21 +5654,21 @@ static HB_ERRCODE hb_ntxSeek( NTXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pItem, BO
    {
       LPKEYINFO pKey;
       HB_ERRCODE retval = HB_SUCCESS;
-      BOOL  fEOF = FALSE, fLast;
+      HB_BOOL  fEOF = HB_FALSE, fLast;
       USHORT uiLen;
       ULONG ulRec;
 
       if( pArea->dbfarea.lpdbPendingRel && pArea->dbfarea.lpdbPendingRel->isScoped )
          SELF_FORCEREL( ( AREAP ) pArea );
 
-      pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = FALSE;
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fTop = pArea->dbfarea.area.fBottom = HB_FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
 
       fLast = pArea->lpCurTag->fUsrDescend == pArea->lpCurTag->AscendKey ?
               !fFindLast : fFindLast;
 
       pKey = hb_ntxKeyPutItem( NULL, pItem, fLast ? NTX_MAX_REC_NUM :
-                         NTX_IGNORE_REC_NUM, pArea->lpCurTag, TRUE, &uiLen );
+                         NTX_IGNORE_REC_NUM, pArea->lpCurTag, HB_TRUE, &uiLen );
 
       if( ! hb_ntxTagLockRead( pArea->lpCurTag ) )
       {
@@ -5683,17 +5683,17 @@ static HB_ERRCODE hb_ntxSeek( NTXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pItem, BO
          ulRec = 0;
 
       if( ( ulRec == 0 && ! fSoftSeek ) || pArea->lpCurTag->TagEOF )
-         fEOF = TRUE;
+         fEOF = HB_TRUE;
       else
       {
          if( ! hb_ntxInBottomScope( pArea->lpCurTag, pArea->lpCurTag->CurKeyInfo->key ) )
-            fEOF = TRUE;
+            fEOF = HB_TRUE;
          else if( ! hb_ntxInTopScope( pArea->lpCurTag, pArea->lpCurTag->CurKeyInfo->key ) )
          {
             hb_ntxTagGoTop( pArea->lpCurTag );
             if( pArea->lpCurTag->CurKeyInfo->Xtra == 0 ||
                 pArea->lpCurTag->TagEOF )
-               fEOF = TRUE;
+               fEOF = HB_TRUE;
          }
       }
       hb_ntxTagUnLockRead( pArea->lpCurTag );
@@ -5708,9 +5708,9 @@ static HB_ERRCODE hb_ntxSeek( NTXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pItem, BO
                pArea->dbfarea.area.fFound = ( ulRec == pArea->dbfarea.ulRecNo ||
                      hb_ntxValCompare( pArea->lpCurTag, pKey->key, uiLen,
                                        pArea->lpCurTag->CurKeyInfo->key,
-                                       pArea->lpCurTag->KeyLength, FALSE ) == 0 );
+                                       pArea->lpCurTag->KeyLength, HB_FALSE ) == 0 );
                if( ! pArea->dbfarea.area.fFound && ! fSoftSeek )
-                  fEOF = TRUE;
+                  fEOF = HB_TRUE;
             }
          }
       }
@@ -5720,7 +5720,7 @@ static HB_ERRCODE hb_ntxSeek( NTXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pItem, BO
          retval = SELF_GOTO( ( AREAP ) pArea, 0 );
       }
       if( pArea->dbfarea.fPositioned || pArea->dbfarea.ulRecNo != 1 )
-         pArea->dbfarea.area.fBof = FALSE;
+         pArea->dbfarea.area.fBof = HB_FALSE;
       hb_ntxKeyFree( pKey );
       return retval;
    }
@@ -5732,7 +5732,7 @@ static HB_ERRCODE hb_ntxSeek( NTXAREAP pArea, BOOL fSoftSeek, PHB_ITEM pItem, BO
 static HB_ERRCODE hb_ntxSkipRaw( NTXAREAP pArea, LONG lToSkip )
 {
    HB_ERRCODE retval;
-   BOOL fOut = FALSE, fForward;
+   HB_BOOL fOut = HB_FALSE, fForward;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_ntxSkipRaw(%p, %ld)", pArea, lToSkip));
 
@@ -5751,7 +5751,7 @@ static HB_ERRCODE hb_ntxSkipRaw( NTXAREAP pArea, LONG lToSkip )
    if( ! hb_ntxCurKeyRefresh( pArea->lpCurTag ) )
    {
       if( fForward || pArea->dbfarea.fPositioned )
-         fOut = TRUE;
+         fOut = HB_TRUE;
       else
       {
          hb_ntxTagGoBottom( pArea->lpCurTag );
@@ -5779,7 +5779,7 @@ static HB_ERRCODE hb_ntxSkipRaw( NTXAREAP pArea, LONG lToSkip )
       if( fOut || pArea->lpCurTag->TagBOF )
       {
          hb_ntxTagGoTop( pArea->lpCurTag );
-         fOut = TRUE;
+         fOut = HB_TRUE;
       }
       retval = SELF_GOTO( ( AREAP ) pArea, pArea->lpCurTag->TagEOF ? 0 :
                                           pArea->lpCurTag->CurKeyInfo->Xtra );
@@ -5790,9 +5790,9 @@ static HB_ERRCODE hb_ntxSkipRaw( NTXAREAP pArea, LONG lToSkip )
    /* Update Bof and Eof flags */
    /*
    if( fForward )
-      pArea->dbfarea.area.fBof = FALSE;
+      pArea->dbfarea.area.fBof = HB_FALSE;
    else
-      pArea->dbfarea.area.fEof = FALSE;
+      pArea->dbfarea.area.fEof = HB_FALSE;
    */
    return retval;
 }
@@ -5829,7 +5829,7 @@ static HB_ERRCODE hb_ntxFlush( NTXAREAP pArea )
             if( pIndex->fFlush /* && !pIndex->Temporary */ )
             {
                hb_fileCommit( pIndex->DiskFile );
-               pIndex->fFlush = FALSE;
+               pIndex->fFlush = HB_FALSE;
             }
             pIndex = pIndex->pNext;
          }
@@ -5848,8 +5848,8 @@ static HB_ERRCODE hb_ntxFlush( NTXAREAP pArea )
  */
 static HB_ERRCODE hb_ntxGoCold( NTXAREAP pArea )
 {
-   BOOL fRecordChanged = pArea->dbfarea.fRecordChanged;
-   BOOL fAppend = pArea->dbfarea.fAppend;
+   HB_BOOL fRecordChanged = pArea->dbfarea.fRecordChanged;
+   HB_BOOL fAppend = pArea->dbfarea.fAppend;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_ntxGoCold(%p)", pArea));
 
@@ -5861,14 +5861,14 @@ static HB_ERRCODE hb_ntxGoCold( NTXAREAP pArea )
          {
             if( pArea->fNtxAppend )
                hb_errInternal( 9312, "hb_ntxGoCold: multiple appending without GOCOLD.", NULL, NULL );
-            pArea->fNtxAppend = TRUE;
+            pArea->fNtxAppend = HB_TRUE;
          }
          else
          {
             LPNTXINDEX pIndex = pArea->lpIndexes;
             LPTAGINFO pTag;
             LPKEYINFO pKey;
-            BOOL fAdd, fDel, fLck = FALSE;
+            HB_BOOL fAdd, fDel, fLck = HB_FALSE;
             int i;
 
             /* The pending relation may move the record pointer so we should
@@ -5879,7 +5879,7 @@ static HB_ERRCODE hb_ntxGoCold( NTXAREAP pArea )
             if( pArea->dbfarea.fShared )
             {
                fAppend = pArea->fNtxAppend;
-               pArea->fNtxAppend = FALSE;
+               pArea->fNtxAppend = HB_FALSE;
             }
 
             while( pIndex )
@@ -5895,18 +5895,18 @@ static HB_ERRCODE hb_ntxGoCold( NTXAREAP pArea )
                   pKey = hb_ntxEvalKey( NULL, pTag );
 
                   fAdd = ( pTag->pForItem == NULL ||
-                           hb_ntxEvalCond( pArea, pTag->pForItem, TRUE ) );
+                           hb_ntxEvalCond( pArea, pTag->pForItem, HB_TRUE ) );
                   if( fAppend )
                   {
-                     fDel = FALSE;
+                     fDel = HB_FALSE;
                   }
                   else
                   {
                      if( hb_ntxValCompare( pTag, pKey->key, pTag->KeyLength,
-                          pTag->HotKeyInfo->key, pTag->KeyLength, TRUE ) == 0 )
+                          pTag->HotKeyInfo->key, pTag->KeyLength, HB_TRUE ) == 0 )
                      {
                         if( pTag->HotFor ? fAdd : !fAdd )
-                           fAdd = fDel = FALSE;
+                           fAdd = fDel = HB_FALSE;
                         else
                            fDel = !fAdd;
                      }
@@ -5919,15 +5919,15 @@ static HB_ERRCODE hb_ntxGoCold( NTXAREAP pArea )
                   {
                      if( !fLck )
                      {
-                        if( !hb_ntxIndexLockWrite( pIndex, TRUE ) )
+                        if( !hb_ntxIndexLockWrite( pIndex, HB_TRUE ) )
                         {
                            hb_ntxKeyFree( pKey );
                            break;
                         }
-                        fLck = TRUE;
+                        fLck = HB_TRUE;
                         if( ( pTag->Owner->Compound && !pTag->HeadBlock ) ||
                             !pTag->RootBlock )
-                           fAdd = fDel = FALSE;
+                           fAdd = fDel = HB_FALSE;
                      }
                      if( fDel )
                      {
@@ -5940,7 +5940,7 @@ static HB_ERRCODE hb_ntxGoCold( NTXAREAP pArea )
                         else
                         {
                            if( pTag->ChgOnly )
-                              fAdd = FALSE;
+                              fAdd = HB_FALSE;
                            else if( !pTag->Partial && !pTag->UniqueKey )
                               hb_ntxErrorRT( pTag->Owner->Owner,
                                              EG_CORRUPTION, EDBF_CORRUPT,
@@ -5962,7 +5962,7 @@ static HB_ERRCODE hb_ntxGoCold( NTXAREAP pArea )
                if( fLck )
                {
                   hb_ntxIndexUnLockWrite( pIndex );
-                  fLck = FALSE;
+                  fLck = HB_FALSE;
                }
                pIndex = pIndex->pNext;
             }
@@ -6005,7 +6005,7 @@ static HB_ERRCODE hb_ntxGoHot( NTXAREAP pArea )
                   {
                      pTag->HotKeyInfo = hb_ntxEvalKey( pTag->HotKeyInfo, pTag );
                      pTag->HotFor = ( pTag->pForItem == NULL ||
-                                 hb_ntxEvalCond( pArea, pTag->pForItem, TRUE ) );
+                                 hb_ntxEvalCond( pArea, pTag->pForItem, HB_TRUE ) );
                   }
                }
             }
@@ -6045,7 +6045,7 @@ static HB_ERRCODE hb_ntxClose( NTXAREAP pArea )
    {
       if( pArea->pSort )
       {
-         hb_ntxSortFree( pArea->pSort, TRUE );
+         hb_ntxSortFree( pArea->pSort, HB_TRUE );
          pArea->pSort = NULL;
       }
 
@@ -6187,8 +6187,8 @@ static HB_ERRCODE hb_ntxOrderCreate( NTXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    LPDBFDATA pData;
    HB_ERRCODE errCode;
    ULONG ulRecNo;
-   BOOL fCompound, fTagName, fBagName, fProd, fLocked = FALSE,
-        fAscend = TRUE, fCustom = FALSE, fTemporary = FALSE, fExclusive = FALSE;
+   HB_BOOL fCompound, fTagName, fBagName, fProd, fLocked = HB_FALSE,
+        fAscend = HB_TRUE, fCustom = HB_FALSE, fTemporary = HB_FALSE, fExclusive = HB_FALSE;
    BYTE bType;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_ntxOrderCreate(%p, %p)", pArea, pOrderInfo));
@@ -6298,12 +6298,12 @@ static HB_ERRCODE hb_ntxOrderCreate( NTXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    }
 
    if( pArea->dbfarea.fTemporary )
-      fTemporary = TRUE;
+      fTemporary = HB_TRUE;
 
    /* Test conditional expression */
    if( pForExp )
    {
-      BOOL fOK;
+      HB_BOOL fOK;
 
       errCode = SELF_EVALBLOCK( ( AREAP ) pArea, pForExp );
       if( errCode != HB_SUCCESS )
@@ -6341,7 +6341,7 @@ static HB_ERRCODE hb_ntxOrderCreate( NTXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    fTagName = pOrderInfo->atomBagName && pOrderInfo->atomBagName[0];
    fBagName = pOrderInfo->abBagName && pOrderInfo->abBagName[0];
 #if defined( HB_NTX_NOMULTITAG )
-   fCompound = FALSE;
+   fCompound = HB_FALSE;
 #else
    fCompound = fTagName && pData->fMultiTag;
 #endif
@@ -6392,7 +6392,7 @@ static HB_ERRCODE hb_ntxOrderCreate( NTXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    else
    {
       PHB_FILE pFile;
-      BOOL bRetry, fOld, fShared = pArea->dbfarea.fShared && !fTemporary && !fExclusive;
+      HB_BOOL bRetry, fOld, fShared = pArea->dbfarea.fShared && !fTemporary && !fExclusive;
       USHORT uiFlags = FO_READWRITE | ( fShared ? FO_DENYNONE : FO_EXCLUSIVE );
       PHB_ITEM pError = NULL;
 
@@ -6402,7 +6402,7 @@ static HB_ERRCODE hb_ntxOrderCreate( NTXAREAP pArea, LPDBORDERCREATEINFO pOrderI
          if( fTemporary )
          {
             pFile = hb_fileCreateTemp( NULL, NULL, FC_NORMAL, szSpFile );
-            fOld = FALSE;
+            fOld = HB_FALSE;
          }
          else
          {
@@ -6417,7 +6417,7 @@ static HB_ERRCODE hb_ntxOrderCreate( NTXAREAP pArea, LPDBORDERCREATEINFO pOrderI
                                     &pError ) == E_RETRY;
          else
          {
-            bRetry = FALSE;
+            bRetry = HB_FALSE;
             if( fOld )
                fOld = hb_fileSize( pFile ) != 0;
          }
@@ -6438,7 +6438,7 @@ static HB_ERRCODE hb_ntxOrderCreate( NTXAREAP pArea, LPDBORDERCREATEINFO pOrderI
 
       pIndex = hb_ntxIndexNew( pArea );
       pIndex->IndexName = hb_strdup( szFileName );
-      pIndex->fReadonly = FALSE;
+      pIndex->fReadonly = HB_FALSE;
       pIndex->fShared = fShared;
       pIndex->DiskFile = pFile;
       pIndex->fDelete = fTemporary;
@@ -6453,7 +6453,7 @@ static HB_ERRCODE hb_ntxOrderCreate( NTXAREAP pArea, LPDBORDERCREATEINFO pOrderI
       *pIndexPtr = pIndex;
       if( fOld )
       {
-         if( !hb_ntxIndexLockWrite( pIndex, TRUE ) )
+         if( !hb_ntxIndexLockWrite( pIndex, HB_TRUE ) )
             errCode = HB_FAILURE;
          else
          {
@@ -6461,7 +6461,7 @@ static HB_ERRCODE hb_ntxOrderCreate( NTXAREAP pArea, LPDBORDERCREATEINFO pOrderI
             if( errCode != HB_SUCCESS )
                hb_ntxIndexUnLockWrite( pIndex );
             else
-               fLocked = TRUE;
+               fLocked = HB_TRUE;
          }
          if( errCode != HB_SUCCESS )
          {
@@ -6510,11 +6510,11 @@ static HB_ERRCODE hb_ntxOrderCreate( NTXAREAP pArea, LPDBORDERCREATEINFO pOrderI
             if( !pIndex->HeaderBuff )
                pIndex->HeaderBuff = ( BYTE * ) hb_xgrab( NTXBLOCKSIZE );
             memset( pIndex->HeaderBuff, 0, NTXBLOCKSIZE );
-            pIndex->fValidHeader = TRUE;
+            pIndex->fValidHeader = HB_TRUE;
          }
          for( i = 0; i < pIndex->iTags; i++ )
          {
-            pIndex->lpTags[ i ]->HdrChanged = TRUE;
+            pIndex->lpTags[ i ]->HdrChanged = HB_TRUE;
             pIndex->lpTags[ i ]->HeadBlock = 0;
             if( fCompound )
                hb_ntxIndexTagAdd( pIndex, pIndex->lpTags[ i ] );
@@ -6558,8 +6558,8 @@ static HB_ERRCODE hb_ntxOrderCreate( NTXAREAP pArea, LPDBORDERCREATEINFO pOrderI
 
       if( errCode == HB_SUCCESS )
       {
-         pIndex->Update = pIndex->Changed = pTag->HdrChanged = TRUE;
-         errCode = hb_ntxTagCreate( pTag, FALSE );
+         pIndex->Update = pIndex->Changed = pTag->HdrChanged = HB_TRUE;
+         errCode = hb_ntxTagCreate( pTag, HB_FALSE );
       }
       hb_ntxIndexUnLockWrite( pIndex );
    }
@@ -6593,7 +6593,7 @@ static HB_ERRCODE hb_ntxOrderCreate( NTXAREAP pArea, LPDBORDERCREATEINFO pOrderI
    if( pIndex->Production && !pArea->dbfarea.fHasTags &&
        pData->fStruct && ( pData->fStrictStruct || hb_setGetAutOpen() ) )
    {
-      pArea->dbfarea.fHasTags = TRUE;
+      pArea->dbfarea.fHasTags = HB_TRUE;
       if( !pArea->dbfarea.fReadonly && ( pArea->dbfarea.dbfHeader.bHasTags & 0x01 ) == 0 )
          SELF_WRITEDBHEADER( ( AREAP ) pArea );
    }
@@ -6630,18 +6630,18 @@ static HB_ERRCODE hb_ntxOrderDestroy( NTXAREAP pArea, LPDBORDERINFO pOrderInfo )
 
          if( pIndex->iTags == 1 )
          {
-            BOOL fProd = pIndex->Production;
+            HB_BOOL fProd = pIndex->Production;
             pIndexPtr = &pArea->lpIndexes;
             while( *pIndexPtr != pIndex )
                pIndexPtr = &(*pIndexPtr)->pNext;
             *pIndexPtr = pIndex->pNext;
-            pIndex->fDelete = TRUE;
+            pIndex->fDelete = HB_TRUE;
             hb_ntxIndexFree( pIndex );
             if( fProd && pArea->dbfarea.fHasTags &&
                 DBFAREA_DATA( &pArea->dbfarea )->fStruct &&
                 ( DBFAREA_DATA( &pArea->dbfarea )->fStrictStruct || hb_setGetAutOpen() ) )
             {
-               pArea->dbfarea.fHasTags = FALSE;
+               pArea->dbfarea.fHasTags = HB_FALSE;
                if( !pArea->dbfarea.fReadonly && ( pArea->dbfarea.dbfHeader.bHasTags & 0x01 ) != 0 )
                   SELF_WRITEDBHEADER( ( AREAP ) pArea );
             }
@@ -6658,7 +6658,7 @@ static HB_ERRCODE hb_ntxOrderDestroy( NTXAREAP pArea, LPDBORDERINFO pOrderInfo )
             return HB_FAILURE;
          }
 #endif
-         else if( !hb_ntxIndexLockWrite( pIndex, TRUE ) )
+         else if( !hb_ntxIndexLockWrite( pIndex, HB_TRUE ) )
          {
             return HB_FAILURE;
          }
@@ -6717,7 +6717,7 @@ static HB_ERRCODE hb_ntxOrderInfo( NTXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
          return HB_SUCCESS;
       case DBOI_ISREINDEX:
          hb_itemPutL( pInfo->itmResult,
-                      pArea->pSort ? pArea->pSort->fReindex : FALSE );
+                      pArea->pSort ? pArea->pSort->fReindex : HB_FALSE );
          return HB_SUCCESS;
       case DBOI_LOCKOFFSET:
       case DBOI_HPLOCKING:
@@ -6733,7 +6733,7 @@ static HB_ERRCODE hb_ntxOrderInfo( NTXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
       case DBOI_ORDERCOUNT:
       {
          int i = 0;
-         BOOL fBag = hb_itemGetCLen( pInfo->atomBagName ) > 0;
+         HB_BOOL fBag = hb_itemGetCLen( pInfo->atomBagName ) > 0;
          LPNTXINDEX pIndex = fBag ?
                hb_ntxFindBag( pArea, hb_itemGetCPtr( pInfo->atomBagName ) ) :
                pArea->lpIndexes;
@@ -6831,7 +6831,7 @@ static HB_ERRCODE hb_ntxOrderInfo( NTXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                    *szForExpr )
                {
                   PHB_ITEM pForItem = NULL;
-                  BOOL fOK = *szForExpr == 0;
+                  HB_BOOL fOK = *szForExpr == 0;
                   if( !fOK )
                   {
                      if( SELF_COMPILE( ( AREAP ) pArea, szForExpr ) == HB_SUCCESS )
@@ -6863,9 +6863,9 @@ static HB_ERRCODE hb_ntxOrderInfo( NTXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                         pTag->ForExpr = NULL;
                         pTag->pForItem = NULL;
                      }
-                     pTag->Partial = TRUE;
-                     pTag->HdrChanged = TRUE;
-                     pTag->Owner->Update = TRUE;
+                     pTag->Partial = HB_TRUE;
+                     pTag->HdrChanged = HB_TRUE;
+                     pTag->Owner->Update = HB_TRUE;
                      hb_ntxTagUnLockWrite( pTag );
                   }
                   if( pForItem )
@@ -6933,13 +6933,13 @@ static HB_ERRCODE hb_ntxOrderInfo( NTXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                {
                   if( !pTag->Template )
                   {
-                     BOOL fNewVal = hb_itemGetL( pInfo->itmNewVal );
+                     HB_BOOL fNewVal = hb_itemGetL( pInfo->itmNewVal );
                      if( pTag->Custom ? ! fNewVal : fNewVal )
                      {
                         pTag->Custom = fNewVal;
-                        pTag->Partial = TRUE;
-                        pTag->ChgOnly = FALSE;
-                        pTag->HdrChanged = TRUE;
+                        pTag->Partial = HB_TRUE;
+                        pTag->ChgOnly = HB_FALSE;
+                        pTag->HdrChanged = HB_TRUE;
                      }
                   }
                   hb_ntxTagUnLockWrite( pTag );
@@ -6954,12 +6954,12 @@ static HB_ERRCODE hb_ntxOrderInfo( NTXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                {
                   if( !pTag->Custom )
                   {
-                     BOOL fNewVal = hb_itemGetL( pInfo->itmNewVal );
+                     HB_BOOL fNewVal = hb_itemGetL( pInfo->itmNewVal );
                      if( pTag->ChgOnly ? ! fNewVal : fNewVal )
                      {
                         pTag->ChgOnly = fNewVal;
-                        pTag->Partial = TRUE;
-                        pTag->HdrChanged = TRUE;
+                        pTag->Partial = HB_TRUE;
+                        pTag->HdrChanged = HB_TRUE;
                      }
                   }
                   hb_ntxTagUnLockWrite( pTag );
@@ -6975,8 +6975,8 @@ static HB_ERRCODE hb_ntxOrderInfo( NTXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                {
                   if( pTag->Custom && !pTag->Template )
                   {
-                     pTag->Template = TRUE;
-                     pTag->HdrChanged = TRUE;
+                     pTag->Template = HB_TRUE;
+                     pTag->HdrChanged = HB_TRUE;
                   }
                   hb_ntxTagUnLockWrite( pTag );
                }
@@ -6990,8 +6990,8 @@ static HB_ERRCODE hb_ntxOrderInfo( NTXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
                {
                   if( pTag->Custom && !pTag->MultiKey )
                   {
-                     pTag->MultiKey = TRUE;
-                     pTag->HdrChanged = TRUE;
+                     pTag->MultiKey = HB_TRUE;
+                     pTag->HdrChanged = HB_TRUE;
                   }
                   hb_ntxTagUnLockWrite( pTag );
                }
@@ -7092,7 +7092,7 @@ static HB_ERRCODE hb_ntxOrderInfo( NTXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
             if( hb_ntxTagLockRead( pTag ) )
             {
                if( hb_ntxCurKeyRefresh( pTag ) )
-                  hb_ntxKeyGetItem( pInfo->itmResult, pTag->CurKeyInfo, pTag, TRUE );
+                  hb_ntxKeyGetItem( pInfo->itmResult, pTag->CurKeyInfo, pTag, HB_TRUE );
                else
                   hb_itemClear( pInfo->itmResult );
                hb_ntxTagUnLockRead( pTag );
@@ -7165,7 +7165,7 @@ static HB_ERRCODE hb_ntxOrderInfo( NTXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
             {
                hb_itemPutL( pInfo->itmResult,
                             hb_itemGetL( pInfo->itmNewVal ) ?
-                                 hb_ntxIndexLockWrite( pTag->Owner, TRUE ) :
+                                 hb_ntxIndexLockWrite( pTag->Owner, HB_TRUE ) :
                                  hb_ntxIndexUnLockWrite( pTag->Owner ) );
             }
             else
@@ -7178,7 +7178,7 @@ static HB_ERRCODE hb_ntxOrderInfo( NTXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
             break;
          case DBOI_ISMULTITAG:
 #if defined( HB_NTX_NOMULTITAG )
-            hb_itemPutL( pInfo->itmResult, FALSE );
+            hb_itemPutL( pInfo->itmResult, HB_FALSE );
 #else
             hb_itemPutL( pInfo->itmResult, pTag->Owner->Compound );
 #endif
@@ -7289,7 +7289,7 @@ static HB_ERRCODE hb_ntxOrderInfo( NTXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
          case DBOI_FINDREC:
          case DBOI_FINDRECCONT:
             SELF_GOTO( ( AREAP ) pArea, 0 );
-            hb_itemPutL( pInfo->itmResult, FALSE );
+            hb_itemPutL( pInfo->itmResult, HB_FALSE );
             break;
          case DBOI_ISCOND:
          case DBOI_ISDESC:
@@ -7309,7 +7309,7 @@ static HB_ERRCODE hb_ntxOrderInfo( NTXAREAP pArea, USHORT uiIndex, LPDBORDERINFO
          case DBOI_ISREADONLY:
          case DBOI_WRITELOCK:
          case DBOI_READLOCK:
-            hb_itemPutL( pInfo->itmResult, FALSE );
+            hb_itemPutL( pInfo->itmResult, HB_FALSE );
             break;
          case DBOI_KEYVAL:
          case DBOI_SCOPETOP:
@@ -7356,7 +7356,7 @@ static HB_ERRCODE hb_ntxOrderListAdd( NTXAREAP pArea, LPDBORDERINFO pOrderInfo )
    char szFileName[ HB_PATH_MAX ], szTagName[ NTX_MAX_TAGNAME + 1 ];
    LPNTXINDEX pIndex, *pIndexPtr;
    HB_ERRCODE errCode;
-   BOOL fRetry, fReadonly, fShared, fProd;
+   HB_BOOL fRetry, fReadonly, fShared, fProd;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_ntxOrderListAdd(%p, %p)", pArea, pOrderInfo));
 
@@ -7387,7 +7387,7 @@ static HB_ERRCODE hb_ntxOrderListAdd( NTXAREAP pArea, LPDBORDERINFO pOrderInfo )
                 ( fShared ? FO_DENYNONE : FO_EXCLUSIVE );
       do
       {
-         fRetry = FALSE;
+         fRetry = HB_FALSE;
          pFile = hb_fileExtOpen( szFileName, NULL, uiFlags |
                                  FXO_DEFAULTS | FXO_SHARELOCK | FXO_COPYNAME,
                                  NULL, pError );
@@ -7479,7 +7479,7 @@ static HB_ERRCODE hb_ntxOrderListDelete( NTXAREAP pArea, LPDBORDERINFO pOrderInf
    char szTagName[ NTX_MAX_TAGNAME + 1 ];
    char szFileName[ HB_PATH_MAX ];
    LPNTXINDEX pIndex, * pIndexPtr;
-   BOOL fProd;
+   HB_BOOL fProd;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_ntxOrderListDelete(%p, %p)", pArea, pOrderInfo));
 
@@ -7633,7 +7633,7 @@ static HB_ERRCODE hb_ntxInit( LPRDDNODE pRDD )
       SELF_RDDINFO( pRDD, RDDI_MEMOTYPE, 0, pItem );
       hb_itemRelease( pItem );
 #if !defined( HB_NTX_NOMULTITAG )
-      DBFNODE_DATA( pRDD )->fMultiTag = TRUE;
+      DBFNODE_DATA( pRDD )->fMultiTag = HB_TRUE;
 #endif
    }
    return errCode;
@@ -7674,9 +7674,9 @@ static HB_ERRCODE hb_ntxRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect
       case RDDI_MULTITAG:
       {
 #if defined( HB_NTX_NOMULTITAG )
-         hb_itemPutL( pItem, FALSE );
+         hb_itemPutL( pItem, HB_FALSE );
 #else
-         BOOL fMultiTag = pData->fMultiTag;
+         HB_BOOL fMultiTag = pData->fMultiTag;
          if( hb_itemType( pItem ) == HB_IT_LOGICAL )
             pData->fMultiTag = hb_itemGetL( pItem );
          hb_itemPutL( pItem, fMultiTag );
@@ -7686,7 +7686,7 @@ static HB_ERRCODE hb_ntxRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect
 
       case RDDI_SORTRECNO:
       {
-         BOOL fSortRecNo = pData->fSortRecNo;
+         HB_BOOL fSortRecNo = pData->fSortRecNo;
          if( hb_itemType( pItem ) == HB_IT_LOGICAL )
             pData->fSortRecNo = hb_itemGetL( pItem );
          hb_itemPutL( pItem, fSortRecNo );
@@ -7695,7 +7695,7 @@ static HB_ERRCODE hb_ntxRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect
 
       case RDDI_STRUCTORD:
       {
-         BOOL fStruct = pData->fStruct;
+         HB_BOOL fStruct = pData->fStruct;
          if( hb_itemType( pItem ) == HB_IT_LOGICAL )
             pData->fStruct = hb_itemGetL( pItem );
          hb_itemPutL( pItem, fStruct );
@@ -7704,7 +7704,7 @@ static HB_ERRCODE hb_ntxRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect
 
       case RDDI_STRICTSTRUCT:
       {
-         BOOL fStrictStruct = pData->fStrictStruct;
+         HB_BOOL fStrictStruct = pData->fStrictStruct;
          if( hb_itemType( pItem ) == HB_IT_LOGICAL )
             pData->fStrictStruct = hb_itemGetL( pItem );
          hb_itemPutL( pItem, fStrictStruct );
@@ -7713,7 +7713,7 @@ static HB_ERRCODE hb_ntxRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect
 
       case RDDI_MULTIKEY:
       {
-         BOOL fMultiKey = pData->fMultiKey;
+         HB_BOOL fMultiKey = pData->fMultiKey;
          if( hb_itemType( pItem ) == HB_IT_LOGICAL )
             pData->fMultiKey = hb_itemGetL( pItem );
          hb_itemPutL( pItem, fMultiKey );
diff --git a/harbour/src/rdd/dbsql.c b/harbour/src/rdd/dbsql.c
index ae33c922cf..f0703275e8 100644
--- a/harbour/src/rdd/dbsql.c
+++ b/harbour/src/rdd/dbsql.c
@@ -131,8 +131,8 @@ static PHB_FILEBUF hb_createFBuffer( HB_FHANDLE hFile, ULONG ulSize )
 
 
 /* Export field value into the buffer in SQL format */
-static BOOL hb_exportBufSqlVar( PHB_FILEBUF pFileBuf, PHB_ITEM pValue,
-                                const char * szDelim, const char * szEsc )
+static HB_BOOL hb_exportBufSqlVar( PHB_FILEBUF pFileBuf, PHB_ITEM pValue,
+                                   const char * szDelim, const char * szEsc )
 {
    switch( hb_itemType( pValue ) )
    {
@@ -228,9 +228,9 @@ static BOOL hb_exportBufSqlVar( PHB_FILEBUF pFileBuf, PHB_ITEM pValue,
       /* an "M" field or the other, might be a "V" in SixDriver */
       default:
          /* We do not want MEMO contents */
-         return FALSE;
+         return HB_FALSE;
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 /* Export DBF content to a SQL script file */
@@ -238,17 +238,17 @@ static ULONG hb_db2Sql( AREAP pArea, PHB_ITEM pFields, HB_LONG llNext,
                         PHB_ITEM pWhile, PHB_ITEM pFor,
                         const char * szDelim, const char * szSep,
                         const char * szEsc, const char * szTable,
-                        HB_FHANDLE hFile, BOOL fInsert, BOOL fRecno )
+                        HB_FHANDLE hFile, HB_BOOL fInsert, HB_BOOL fRecno )
 {
    PHB_FILEBUF pFileBuf;
    ULONG ulRecords = 0;
    USHORT uiFields = 0, ui;
    PHB_ITEM pTmp;
-   BOOL fWriteSep = FALSE;
+   HB_BOOL fWriteSep = HB_FALSE;
    const char * szNewLine = hb_conNewLine();
    char * szInsert = NULL;
-   BOOL fEof = TRUE;
-   BOOL fNoFieldPassed = ( pFields == NULL || hb_arrayLen( pFields ) == 0 );
+   HB_BOOL fEof = HB_TRUE;
+   HB_BOOL fNoFieldPassed = ( pFields == NULL || hb_arrayLen( pFields ) == 0 );
 
    if( SELF_FIELDCOUNT( pArea, &uiFields ) != HB_SUCCESS )
       return 0;
@@ -321,7 +321,7 @@ static ULONG hb_db2Sql( AREAP pArea, PHB_ITEM pFields, HB_LONG llNext,
          if( szInsert )
             hb_addStrToFBuffer( pFileBuf, " );" );
          hb_addStrToFBuffer( pFileBuf, szNewLine );
-         fWriteSep = FALSE;
+         fWriteSep = HB_FALSE;
       }
 
       if( SELF_SKIP( pArea, 1 ) != HB_SUCCESS )
@@ -347,7 +347,7 @@ HB_FUNC( __DBSQL )
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
    if( pArea )
    {
-      BOOL fExport            = hb_parl( 1 );
+      HB_BOOL fExport         = hb_parl( 1 );
       const char * szFileName = hb_parc( 2 );
       const char * szTable    = hb_parc( 3 );
       PHB_ITEM pFields        = hb_param( 4, HB_IT_ARRAY );
@@ -355,10 +355,10 @@ HB_FUNC( __DBSQL )
       PHB_ITEM pWhile         = hb_param( 6, HB_IT_BLOCK );
       PHB_ITEM pNext          = hb_param( 7, HB_IT_NUMERIC );
       PHB_ITEM pRecord        = HB_ISNIL( 8 ) ? NULL : hb_param( 8, HB_IT_ANY );
-      BOOL fRest              = pWhile != NULL || hb_parl( 9 );
-      BOOL fAppend            = hb_parl( 10 );
-      BOOL fInsert            = hb_parl( 11 );
-      BOOL fRecno             = hb_parl( 12 );
+      HB_BOOL fRest           = pWhile != NULL || hb_parl( 9 );
+      HB_BOOL fAppend         = hb_parl( 10 );
+      HB_BOOL fInsert         = hb_parl( 11 );
+      HB_BOOL fRecno          = hb_parl( 12 );
       const char * szSep      = hb_parcx( 13 );
       const char * szDelim    = hb_parcx( 14 );
       const char * szEsc      = hb_parcx( 15 );
@@ -371,7 +371,7 @@ HB_FUNC( __DBSQL )
       else if( fExport )   /* COPY TO SQL */
       {
          PHB_ITEM pError = NULL;
-         BOOL fRetry;
+         HB_BOOL fRetry;
 
          /* Try to create Dat file */
          do
@@ -407,7 +407,7 @@ HB_FUNC( __DBSQL )
                fRetry = hb_errLaunch( pError ) == E_RETRY;
             }
             else
-               fRetry = FALSE;
+               fRetry = HB_FALSE;
          }
          while( fRetry );
 
diff --git a/harbour/src/rdd/delim1.c b/harbour/src/rdd/delim1.c
index 8df50575d4..a7ab9ccc41 100644
--- a/harbour/src/rdd/delim1.c
+++ b/harbour/src/rdd/delim1.c
@@ -323,7 +323,7 @@ static HB_ERRCODE hb_delimReadRecord( DELIMAREAP pArea )
             {
                HB_LONG lVal;
                double dVal;
-               BOOL fDbl;
+               HB_BOOL fDbl;
 
                fDbl = hb_strnToNum( (const char *) buffer, uiSize, &lVal, &dVal );
                if( fDbl )
@@ -357,13 +357,13 @@ static HB_ERRCODE hb_delimReadRecord( DELIMAREAP pArea )
        pArea->ulRecordOffset == ( HB_FOFFSET ) ( pArea->ulBufferStart +
                                                  pArea->ulBufferIndex ) )
    {
-      pArea->area.fEof = TRUE;
-      pArea->fPositioned = FALSE;
+      pArea->area.fEof = HB_TRUE;
+      pArea->fPositioned = HB_FALSE;
    }
    else
    {
-      pArea->area.fEof = FALSE;
-      pArea->fPositioned = TRUE;
+      pArea->area.fEof = HB_FALSE;
+      pArea->fPositioned = HB_TRUE;
    }
 
    return HB_SUCCESS;
@@ -377,8 +377,8 @@ static HB_ERRCODE hb_delimNextRecord( DELIMAREAP pArea )
    {
       if( pArea->ulNextOffset == ( HB_FOFFSET ) -1 )
       {
-         pArea->area.fEof = TRUE;
-         pArea->fPositioned = FALSE;
+         pArea->area.fEof = HB_TRUE;
+         pArea->fPositioned = HB_FALSE;
          hb_delimClearRecordBuffer( pArea );
       }
       else
@@ -405,8 +405,8 @@ static HB_ERRCODE hb_delimGoTop( DELIMAREAP pArea )
    if( SELF_GOCOLD( ( AREAP ) pArea ) != HB_SUCCESS )
       return HB_FAILURE;
 
-   pArea->area.fTop = TRUE;
-   pArea->area.fBottom = FALSE;
+   pArea->area.fTop = HB_TRUE;
+   pArea->area.fBottom = HB_FALSE;
 
    pArea->ulRecordOffset = 0;
    pArea->ulRecNo = 1;
@@ -435,13 +435,13 @@ static HB_ERRCODE hb_delimSkipRaw( DELIMAREAP pArea, LONG lToSkip )
 /*
  * Determine deleted status for a record.
  */
-static HB_ERRCODE hb_delimDeleted( DELIMAREAP pArea, BOOL * pDeleted )
+static HB_ERRCODE hb_delimDeleted( DELIMAREAP pArea, HB_BOOL * pDeleted )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_delimDeleted(%p,%p)", pArea, pDeleted));
 
    HB_SYMBOL_UNUSED( pArea );
 
-   * pDeleted = FALSE;
+   * pDeleted = HB_FALSE;
 
    return HB_SUCCESS;
 }
@@ -502,7 +502,7 @@ static HB_ERRCODE hb_delimRecId( DELIMAREAP pArea, PHB_ITEM pRecNo )
 /*
  * Append a record to the WorkArea.
  */
-static HB_ERRCODE hb_delimAppend( DELIMAREAP pArea, BOOL fUnLockAll )
+static HB_ERRCODE hb_delimAppend( DELIMAREAP pArea, HB_BOOL fUnLockAll )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_delimAppend(%p,%d)", pArea, (int) fUnLockAll));
 
@@ -516,8 +516,8 @@ static HB_ERRCODE hb_delimAppend( DELIMAREAP pArea, BOOL fUnLockAll )
 
    pArea->ulRecordOffset = pArea->ulFileSize;
    pArea->ulRecNo = ++pArea->ulRecCount;
-   pArea->area.fEof = FALSE;
-   pArea->fPositioned = TRUE;
+   pArea->area.fEof = HB_FALSE;
+   pArea->fPositioned = HB_TRUE;
    hb_delimClearRecordBuffer( pArea );
 
    return HB_SUCCESS;
@@ -533,8 +533,8 @@ static HB_ERRCODE hb_delimDeleteRec( DELIMAREAP pArea )
    if( pArea->fRecordChanged )
    {
       pArea->ulRecCount--;
-      pArea->area.fEof = TRUE;
-      pArea->fPositioned = pArea->fRecordChanged = FALSE;
+      pArea->area.fEof = HB_TRUE;
+      pArea->fPositioned = pArea->fRecordChanged = HB_FALSE;
       hb_delimClearRecordBuffer( pArea );
    }
 
@@ -576,10 +576,10 @@ static HB_ERRCODE hb_delimGetValue( DELIMAREAP pArea, USHORT uiIndex, PHB_ITEM p
             case 't':
             case 'Y':
             case 'y':
-               hb_itemPutL( pItem, TRUE );
+               hb_itemPutL( pItem, HB_TRUE );
                break;
             default:
-               hb_itemPutL( pItem, FALSE );
+               hb_itemPutL( pItem, HB_FALSE );
                break;
          }
          break;
@@ -592,7 +592,7 @@ static HB_ERRCODE hb_delimGetValue( DELIMAREAP pArea, USHORT uiIndex, PHB_ITEM p
       {
          HB_LONG lVal;
          double dVal;
-         BOOL fDbl;
+         HB_BOOL fDbl;
 
          fDbl = hb_strnToNum( (const char *) pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
                               pField->uiLen, &lVal, &dVal );
@@ -797,7 +797,7 @@ static HB_ERRCODE hb_delimTrans( DELIMAREAP pArea, LPDBTRANSINFO pTransInfo )
          pTransInfo->uiFlags |= DBTF_PUTREC;
       else
       {
-         PHB_ITEM pPutRec = hb_itemPutL( NULL, FALSE );
+         PHB_ITEM pPutRec = hb_itemPutL( NULL, HB_FALSE );
          if( SELF_INFO( ( AREAP ) pTransInfo->lpaDest, DBI_CANPUTREC, pPutRec ) != HB_SUCCESS )
          {
             hb_itemRelease( pPutRec );
@@ -840,8 +840,8 @@ static HB_ERRCODE hb_delimGoCold( DELIMAREAP pArea )
       }
       pArea->ulFileSize += ulSize;
       pArea->ulNextOffset = pArea->ulFileSize;
-      pArea->fRecordChanged = FALSE;
-      pArea->fFlush = TRUE;
+      pArea->fRecordChanged = HB_FALSE;
+      pArea->fFlush = HB_TRUE;
    }
    return HB_SUCCESS;
 }
@@ -865,7 +865,7 @@ static HB_ERRCODE hb_delimGoHot( DELIMAREAP pArea )
       hb_itemRelease( pError );
       return HB_FAILURE;
    }
-   pArea->fRecordChanged = TRUE;
+   pArea->fRecordChanged = HB_TRUE;
    return HB_SUCCESS;
 }
 
@@ -886,7 +886,7 @@ static HB_ERRCODE hb_delimFlush( DELIMAREAP pArea )
       if( hb_setGetHardCommit() )
       {
          hb_fileCommit( pArea->pFile );
-         pArea->fFlush = FALSE;
+         pArea->fFlush = HB_FALSE;
       }
    }
 
@@ -1043,7 +1043,7 @@ static HB_ERRCODE hb_delimAddField( DELIMAREAP pArea, LPDBFIELDINFO pFieldInfo )
       case HB_FT_OLE:
          pFieldInfo->uiType = HB_FT_MEMO;
          pFieldInfo->uiLen = 0;
-         pArea->fTransRec = FALSE;
+         pArea->fTransRec = HB_FALSE;
          break;
 
       case HB_FT_ANY:
@@ -1062,14 +1062,14 @@ static HB_ERRCODE hb_delimAddField( DELIMAREAP pArea, LPDBFIELDINFO pFieldInfo )
             pFieldInfo->uiType = HB_FT_MEMO;
             pFieldInfo->uiLen = 0;
          }
-         pArea->fTransRec = FALSE;
+         pArea->fTransRec = HB_FALSE;
          break;
 
       case HB_FT_DATE:
          if( pFieldInfo->uiLen != 8 )
          {
             pFieldInfo->uiLen = 8;
-            pArea->fTransRec = FALSE;
+            pArea->fTransRec = HB_FALSE;
          }
          break;
 
@@ -1085,19 +1085,19 @@ static HB_ERRCODE hb_delimAddField( DELIMAREAP pArea, LPDBFIELDINFO pFieldInfo )
          pFieldInfo->uiLen = s_uiNumLength[ pFieldInfo->uiLen ];
          if( pFieldInfo->uiDec )
             pFieldInfo->uiLen++;
-         pArea->fTransRec = FALSE;
+         pArea->fTransRec = HB_FALSE;
          break;
 
       case HB_FT_DOUBLE:
       case HB_FT_CURDOUBLE:
          pFieldInfo->uiType = HB_FT_LONG;
          pFieldInfo->uiLen = 20;
-         pArea->fTransRec = FALSE;
+         pArea->fTransRec = HB_FALSE;
          break;
 
       case HB_FT_VARLENGTH:
          pFieldInfo->uiType = HB_FT_STRING;
-         pArea->fTransRec = FALSE;
+         pArea->fTransRec = HB_FALSE;
          uiDelim = 2;
          break;
 
@@ -1105,7 +1105,7 @@ static HB_ERRCODE hb_delimAddField( DELIMAREAP pArea, LPDBFIELDINFO pFieldInfo )
          if( pFieldInfo->uiLen != 1 )
          {
             pFieldInfo->uiLen = 1;
-            pArea->fTransRec = FALSE;
+            pArea->fTransRec = HB_FALSE;
          }
          break;
 
@@ -1115,20 +1115,20 @@ static HB_ERRCODE hb_delimAddField( DELIMAREAP pArea, LPDBFIELDINFO pFieldInfo )
       case HB_FT_TIME:
          pFieldInfo->uiType = HB_FT_STRING;
          pFieldInfo->uiLen = 12;
-         pArea->fTransRec = FALSE;
+         pArea->fTransRec = HB_FALSE;
          break;
 
       case HB_FT_TIMESTAMP:
       case HB_FT_MODTIME:
          pFieldInfo->uiType = HB_FT_STRING;
          pFieldInfo->uiLen = 23;
-         pArea->fTransRec = FALSE;
+         pArea->fTransRec = HB_FALSE;
          break;
 
       default:
          pFieldInfo->uiType = HB_FT_NONE;
          pFieldInfo->uiLen = 0;
-         pArea->fTransRec = FALSE;
+         pArea->fTransRec = HB_FALSE;
          break;
    }
 
@@ -1171,7 +1171,7 @@ static HB_ERRCODE hb_delimNewArea( DELIMAREAP pArea )
       return HB_FAILURE;
 
    pArea->pFile = NULL;
-   pArea->fTransRec = TRUE;
+   pArea->fTransRec = HB_TRUE;
    pArea->uiRecordLen = 0;
    pArea->ulBufferSize = 0;
 
@@ -1250,13 +1250,13 @@ static HB_ERRCODE hb_delimCreate( DELIMAREAP pArea, LPDBOPENINFO pCreateInfo )
    PHB_ITEM pError = NULL;
    PHB_FNAME pFileName;
    HB_ERRCODE errCode;
-   BOOL fRetry;
+   HB_BOOL fRetry;
    char szFileName[ HB_PATH_MAX ];
 
    HB_TRACE(HB_TR_DEBUG, ("hb_delimCreate(%p,%p)", pArea, pCreateInfo));
 
-   pArea->fShared = FALSE;    /* pCreateInfo->fShared; */
-   pArea->fReadonly = FALSE;  /* pCreateInfo->fReadonly */
+   pArea->fShared = HB_FALSE;    /* pCreateInfo->fShared; */
+   pArea->fReadonly = HB_FALSE;  /* pCreateInfo->fReadonly */
 
    if( pCreateInfo->cdpId )
    {
@@ -1304,7 +1304,7 @@ static HB_ERRCODE hb_delimCreate( DELIMAREAP pArea, LPDBOPENINFO pCreateInfo )
          fRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
       }
       else
-         fRetry = FALSE;
+         fRetry = HB_FALSE;
    }
    while( fRetry );
 
@@ -1336,14 +1336,14 @@ static HB_ERRCODE hb_delimOpen( DELIMAREAP pArea, LPDBOPENINFO pOpenInfo )
    PHB_FNAME pFileName;
    HB_ERRCODE errCode;
    USHORT uiFlags;
-   BOOL fRetry;
+   HB_BOOL fRetry;
    char szFileName[ HB_PATH_MAX ];
    char szAlias[ HB_RDD_MAX_ALIAS_LEN + 1 ];
 
    HB_TRACE(HB_TR_DEBUG, ("hb_delimOpen(%p,%p)", pArea, pOpenInfo));
 
-   pArea->fShared = TRUE;     /* pOpenInfo->fShared; */
-   pArea->fReadonly = TRUE;   /* pOpenInfo->fReadonly; */
+   pArea->fShared = HB_TRUE;     /* pOpenInfo->fShared; */
+   pArea->fReadonly = HB_TRUE;   /* pOpenInfo->fReadonly; */
 
    if( pOpenInfo->cdpId )
    {
@@ -1406,7 +1406,7 @@ static HB_ERRCODE hb_delimOpen( DELIMAREAP pArea, LPDBOPENINFO pOpenInfo )
          fRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
       }
       else
-         fRetry = FALSE;
+         fRetry = HB_FALSE;
    }
    while( fRetry );
 
@@ -1440,7 +1440,7 @@ static HB_ERRCODE hb_delimRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConne
    {
       case RDDI_CANPUTREC:
       case RDDI_LOCAL:
-         hb_itemPutL( pItem, TRUE );
+         hb_itemPutL( pItem, HB_TRUE );
          break;
 
       case RDDI_TABLEEXT:
diff --git a/harbour/src/rdd/hbdbsort.c b/harbour/src/rdd/hbdbsort.c
index 7796c94a94..84675c2e45 100644
--- a/harbour/src/rdd/hbdbsort.c
+++ b/harbour/src/rdd/hbdbsort.c
@@ -52,12 +52,12 @@
 
 #include "hbdbsort.h"
 
-BOOL hb_dbQSortInit( LPDBQUICKSORT pQuickSort, LPDBSORTINFO pSortInfo, USHORT uiRecordLen )
+HB_BOOL hb_dbQSortInit( LPDBQUICKSORT pQuickSort, LPDBSORTINFO pSortInfo, USHORT uiRecordLen )
 {
    /* Create temp file */
    pQuickSort->hFile = hb_fsCreateTemp( NULL, NULL, FC_NORMAL, pQuickSort->szTempName );
    if( pQuickSort->hFile == FS_ERROR )
-      return FALSE;
+      return HB_FALSE;
 
    /* Alloc buffers */
    pQuickSort->uiMaxRecords = USHRT_MAX / uiRecordLen;
@@ -70,7 +70,7 @@ BOOL hb_dbQSortInit( LPDBQUICKSORT pQuickSort, LPDBSORTINFO pSortInfo, USHORT ui
    /* Fill structure */
    pQuickSort->uiRecordLen = uiRecordLen;
    pQuickSort->pSortInfo = pSortInfo;
-   return TRUE;
+   return HB_TRUE;
 }
 
 void hb_dbQSortExit( LPDBQUICKSORT pQuickSort )
@@ -87,7 +87,7 @@ void hb_dbQSortExit( LPDBQUICKSORT pQuickSort )
    hb_xfree( pQuickSort->pCmpBufferB );
 }
 
-BOOL hb_dbQSortAdvance( LPDBQUICKSORT pQuickSort, USHORT uiCount )
+HB_BOOL hb_dbQSortAdvance( LPDBQUICKSORT pQuickSort, USHORT uiCount )
 {
    USHORT uiSize;
 
@@ -96,12 +96,12 @@ BOOL hb_dbQSortAdvance( LPDBQUICKSORT pQuickSort, USHORT uiCount )
    return ( hb_fsWrite( pQuickSort->hFile, pQuickSort->pBuffer, uiSize ) == uiSize );
 }
 
-static BOOL hb_dbQSortIsLess( LPDBQUICKSORT pQuickSort, ULONG ulRecNo1, ULONG ulRecNo2 )
+static HB_BOOL hb_dbQSortIsLess( LPDBQUICKSORT pQuickSort, ULONG ulRecNo1, ULONG ulRecNo2 )
 {
    USHORT uiCount, uiField;
    DBFAREAP pArea;
    LPFIELD pField;
-   BOOL bAscending, bIgnoreCase;
+   HB_BOOL bAscending, bIgnoreCase;
    int iResult;
 
    pArea = ( DBFAREAP ) pQuickSort->pSortInfo->dbtri.lpaSource;
@@ -165,7 +165,7 @@ static BOOL hb_dbQSortIsLess( LPDBQUICKSORT pQuickSort, ULONG ulRecNo1, ULONG ul
       else
          return ( iResult > 0 );
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 static void hb_dbQSortSwap( LPDBQUICKSORT pQuickSort, ULONG ulRecNo1, ULONG ulRecNo2 )
@@ -246,7 +246,7 @@ void hb_dbQSortComplete( LPDBQUICKSORT pQuickSort )
          }
 
          /* Append a new record and copy data */
-         if( SELF_APPEND( pArea, TRUE ) == HB_FAILURE ||
+         if( SELF_APPEND( pArea, HB_TRUE ) == HB_FAILURE ||
              SELF_PUTREC( pArea, pQuickSort->pSwapBufferA ) == HB_FAILURE )
             break;
       }
diff --git a/harbour/src/rdd/hbsix/sxcompr.c b/harbour/src/rdd/hbsix/sxcompr.c
index d7d1ea4138..13df100eb0 100644
--- a/harbour/src/rdd/hbsix/sxcompr.c
+++ b/harbour/src/rdd/hbsix/sxcompr.c
@@ -235,8 +235,8 @@ static PHB_LZSSX_COMPR hb_LZSSxInit(
 
    pCompr->ulMaxSize   = 0;
    pCompr->ulOutSize   = 0;
-   pCompr->fResult     = TRUE;
-   pCompr->fContinue   = FALSE;
+   pCompr->fResult     = HB_TRUE;
+   pCompr->fContinue   = HB_FALSE;
 
    if( pCompr->fInFree )
       pCompr->inBuffer    = ( BYTE * ) hb_xgrab( ulDstBuf );
@@ -258,7 +258,7 @@ static HB_BOOL hb_LZSSxFlush( PHB_LZSSX_COMPR pCompr )
       if( hb_fsWriteLarge( pCompr->hOutput, pCompr->outBuffer,
                            pCompr->outBuffPos ) != pCompr->outBuffPos )
       {
-         pCompr->fResult = FALSE;
+         pCompr->fResult = HB_FALSE;
       }
       else
       {
@@ -278,7 +278,7 @@ static HB_BOOL hb_LZSSxWrite( PHB_LZSSX_COMPR pCompr, UCHAR ucVal )
       if( pCompr->outBuffPos < pCompr->outBuffSize )
          pCompr->outBuffer[ pCompr->outBuffPos ] = ucVal;
       else
-         pCompr->fResult = FALSE;
+         pCompr->fResult = HB_FALSE;
    }
    pCompr->outBuffPos++;
    return pCompr->fResult || pCompr->fContinue;
@@ -302,7 +302,7 @@ static int hb_LZSSxRead( PHB_LZSSX_COMPR pCompr )
 
 static HB_BOOL hb_LZSSxDecode( PHB_LZSSX_COMPR pCompr )
 {
-   HB_BOOL fResult = TRUE;
+   HB_BOOL fResult = HB_TRUE;
    USHORT itemMask;
    int offset, length, index, c, h;
 
@@ -327,7 +327,7 @@ static HB_BOOL hb_LZSSxDecode( PHB_LZSSX_COMPR pCompr )
       {
          if( ! hb_LZSSxWrite( pCompr, ( UCHAR ) c ) )
          {
-            fResult = FALSE;
+            fResult = HB_FALSE;
             break;
          }
          pCompr->ring_buffer[ index ] = ( UCHAR ) c;
@@ -337,7 +337,7 @@ static HB_BOOL hb_LZSSxDecode( PHB_LZSSX_COMPR pCompr )
       {
          if( ( h = hb_LZSSxRead( pCompr ) ) == -1 )
          {
-            /* fResult = FALSE; */
+            /* fResult = HB_FALSE; */
             break;
          }
          offset = LZSS_OFFSET( c, h );   /* get offset to ring buffer */
@@ -347,7 +347,7 @@ static HB_BOOL hb_LZSSxDecode( PHB_LZSSX_COMPR pCompr )
             c = pCompr->ring_buffer[ RBUFINDEX( offset + h ) ];
             if( ! hb_LZSSxWrite( pCompr, ( UCHAR ) c ) )
             {
-               fResult = FALSE;
+               fResult = HB_FALSE;
                break;
             }
             /* SIX does not use additional buffers and dynamically
@@ -615,7 +615,7 @@ HB_BOOL hb_LZSSxDecompressFile( HB_FHANDLE hInput, HB_FHANDLE hOutput )
 
 HB_FUNC( SX_FCOMPRESS )
 {
-   HB_BOOL fRet = FALSE;
+   HB_BOOL fRet = HB_FALSE;
    HB_FHANDLE hInput, hOutput;
    const char * szSource = hb_parc( 1 ), * szDestin = hb_parc( 2 );
    BYTE buf[ 4 ];
@@ -652,7 +652,7 @@ HB_FUNC( SX_FCOMPRESS )
 
 HB_FUNC( SX_FDECOMPRESS )
 {
-   HB_BOOL fRet = FALSE;
+   HB_BOOL fRet = HB_FALSE;
    HB_FHANDLE hInput, hOutput;
    const char * szSource = hb_parc( 1 ), * szDestin = hb_parc( 2 );
 
@@ -707,7 +707,7 @@ HB_FUNC( _SX_STRCOMPRESS )
 
 HB_FUNC( _SX_STRDECOMPRESS )
 {
-   HB_BOOL fOK = FALSE;
+   HB_BOOL fOK = HB_FALSE;
    const char * pStr = hb_parc( 1 );
    char * pBuf;
 
@@ -721,7 +721,7 @@ HB_FUNC( _SX_STRDECOMPRESS )
          if( ulBuf == HB_SX_UNCOMPRESED )
          {
             hb_retclen( pStr + 4, ulLen - 4 );
-            fOK = TRUE;
+            fOK = HB_TRUE;
          }
          else
          {
diff --git a/harbour/src/rdd/hbsix/sxcrypt.c b/harbour/src/rdd/hbsix/sxcrypt.c
index a398815259..07f28368b9 100644
--- a/harbour/src/rdd/hbsix/sxcrypt.c
+++ b/harbour/src/rdd/hbsix/sxcrypt.c
@@ -133,9 +133,9 @@ void hb_sxDeCrypt( const char * pSrc, char * pDst, const char * pKeyVal, HB_SIZE
    }
 }
 
-static BOOL _hb_sxGetKey( PHB_ITEM pKeyItem, char * pKeyVal )
+static HB_BOOL _hb_sxGetKey( PHB_ITEM pKeyItem, char * pKeyVal )
 {
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
    PHB_ITEM pItem = NULL;
    ULONG ulKey;
 
@@ -157,7 +157,7 @@ static BOOL _hb_sxGetKey( PHB_ITEM pKeyItem, char * pKeyVal )
          memcpy( pKeyVal, hb_itemGetCPtr( pKeyItem ), HB_MIN( ulKey, 8 ) );
       if( ulKey < 8 )
          memset( pKeyVal + ulKey, 0, 8 - ulKey );
-      fResult = TRUE;
+      fResult = HB_TRUE;
    }
    if( pItem )
       hb_itemRelease( pItem );
diff --git a/harbour/src/rdd/hbsix/sxfname.c b/harbour/src/rdd/hbsix/sxfname.c
index 6b151b6318..e6254febbf 100644
--- a/harbour/src/rdd/hbsix/sxfname.c
+++ b/harbour/src/rdd/hbsix/sxfname.c
@@ -81,14 +81,14 @@ HB_FUNC( SX_FNAMEPARSER )
          if( pFileName->szName )
          {
             ulLen = strlen( pFileName->szName );
-            ulLen = hb_strRTrimLen( pFileName->szName, ulLen, FALSE );
+            ulLen = hb_strRTrimLen( pFileName->szName, ulLen, HB_FALSE );
             pFileName->szName = hb_strLTrim( pFileName->szName, &ulLen );
             ( ( char * ) pFileName->szName )[ulLen] = '\0';
          }
          if( pFileName->szExtension )
          {
             ulLen = strlen( pFileName->szExtension );
-            ulLen = hb_strRTrimLen( pFileName->szExtension, ulLen, FALSE );
+            ulLen = hb_strRTrimLen( pFileName->szExtension, ulLen, HB_FALSE );
             pFileName->szExtension = hb_strLTrim( pFileName->szExtension, &ulLen );
             ( ( char * ) pFileName->szExtension )[ulLen] = '\0';
          }
diff --git a/harbour/src/rdd/hbsix/sxord.c b/harbour/src/rdd/hbsix/sxord.c
index 1ad6c364ce..95d91367c6 100644
--- a/harbour/src/rdd/hbsix/sxord.c
+++ b/harbour/src/rdd/hbsix/sxord.c
@@ -87,7 +87,7 @@
 #include "hbapifs.h"
 #include "hbapirdd.h"
 
-static BOOL hb_sxOrdParam( LPDBORDERINFO pInfo )
+static HB_BOOL hb_sxOrdParam( LPDBORDERINFO pInfo )
 {
    memset( pInfo, 0, sizeof( DBORDERINFO ) );
 
@@ -103,10 +103,10 @@ static BOOL hb_sxOrdParam( LPDBORDERINFO pInfo )
       {
          pInfo->atomBagName = hb_param( 2, HB_IT_NUMERIC );
          if( hb_parni( 2 ) <= 0 )
-            return FALSE;
+            return HB_FALSE;
       }
    }
-   return TRUE;
+   return HB_TRUE;
 }
 
 HB_FUNC( SX_TAGORDER )
@@ -185,8 +185,8 @@ HB_FUNC( SX_FREEZE )
 
       if( hb_sxOrdParam( &Info ) )
       {
-         BOOL fResult = FALSE;
-         Info.itmNewVal = hb_itemPutL( NULL, TRUE );
+         HB_BOOL fResult = HB_FALSE;
+         Info.itmNewVal = hb_itemPutL( NULL, HB_TRUE );
          Info.itmResult = hb_itemNew( NULL );
          if( SELF_ORDINFO( pArea, DBOI_CUSTOM, &Info ) == HB_SUCCESS )
             fResult = HB_IS_LOGICAL( Info.itmResult ) &&
@@ -208,8 +208,8 @@ HB_FUNC( SX_WARM )
 
       if( hb_sxOrdParam( &Info ) )
       {
-         BOOL fResult = FALSE;
-         Info.itmNewVal = hb_itemPutL( NULL, FALSE );
+         HB_BOOL fResult = HB_FALSE;
+         Info.itmNewVal = hb_itemPutL( NULL, HB_FALSE );
          Info.itmResult = hb_itemNew( NULL );
          if( SELF_ORDINFO( pArea, DBOI_CHGONLY, &Info ) == HB_SUCCESS )
             fResult = HB_IS_LOGICAL( Info.itmResult ) &&
@@ -231,8 +231,8 @@ HB_FUNC( SX_CHILL )
 
       if( hb_sxOrdParam( &Info ) )
       {
-         BOOL fResult = FALSE;
-         Info.itmNewVal = hb_itemPutL( NULL, TRUE );
+         HB_BOOL fResult = HB_FALSE;
+         Info.itmNewVal = hb_itemPutL( NULL, HB_TRUE );
          Info.itmResult = hb_itemNew( NULL );
          if( SELF_ORDINFO( pArea, DBOI_CHGONLY, &Info ) == HB_SUCCESS )
             fResult = HB_IS_LOGICAL( Info.itmResult ) &&
@@ -330,7 +330,7 @@ HB_FUNC( SX_SETSCOPE )
 HB_FUNC( SX_ISREINDEX )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fReindex = FALSE;
+   HB_BOOL fReindex = HB_FALSE;
 
    if( pArea )
    {
@@ -499,14 +499,14 @@ HB_FUNC( SX_DESCEND )
 HB_FUNC( SX_KEYADD )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
 
    if( pArea )
    {
       DBORDERINFO Info;
       if( hb_sxOrdParam( &Info ) )
       {
-         Info.itmResult = hb_itemPutL( NULL, FALSE );
+         Info.itmResult = hb_itemPutL( NULL, HB_FALSE );
          Info.itmNewVal = hb_param( 3 , HB_IT_ANY );
          SELF_ORDINFO( pArea, DBOI_KEYADD, &Info );
          fResult = hb_itemGetL( Info.itmResult );
@@ -519,14 +519,14 @@ HB_FUNC( SX_KEYADD )
 HB_FUNC( SX_KEYDROP )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
 
    if( pArea )
    {
       DBORDERINFO Info;
       if( hb_sxOrdParam( &Info ) )
       {
-         Info.itmResult = hb_itemPutL( NULL, FALSE );
+         Info.itmResult = hb_itemPutL( NULL, HB_FALSE );
          Info.itmNewVal = hb_param( 3 , HB_IT_ANY );
          SELF_ORDINFO( pArea, DBOI_KEYDELETE, &Info );
          fResult = hb_itemGetL( Info.itmResult );
@@ -555,7 +555,7 @@ HB_FUNC( SX_KEYDATA )
 HB_FUNC( SX_KEYSKIP )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fResult = FALSE, fBEof = FALSE;
+   HB_BOOL fResult = HB_FALSE, fBEof = HB_FALSE;
 
    if( pArea )
    {
@@ -611,7 +611,7 @@ HB_FUNC( SX_KEYNO )
 HB_FUNC( SX_KEYGOTO )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
 
    if( pArea && hb_parnl( 3 ) != 0 )
    {
@@ -647,17 +647,17 @@ HB_FUNC( SX_SKIPUNIQUE )
 HB_FUNC( SX_SEEKLAST )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fFound = FALSE;
+   HB_BOOL fFound = HB_FALSE;
 
    if( pArea && hb_pcount() > 0 )
    {
       PHB_ITEM pKey = hb_param( 1, HB_IT_ANY );
-      BOOL bSoftSeek = hb_parl( 2 );
+      HB_BOOL bSoftSeek = hb_parl( 2 );
 
-      if( SELF_SEEK( pArea, bSoftSeek, pKey, TRUE ) == HB_SUCCESS )
+      if( SELF_SEEK( pArea, bSoftSeek, pKey, HB_TRUE ) == HB_SUCCESS )
       {
          if( SELF_FOUND( pArea, &fFound ) != HB_SUCCESS )
-            fFound = FALSE;
+            fFound = HB_FALSE;
       }
    }
    hb_retl( fFound );
@@ -672,7 +672,7 @@ HB_FUNC( SX_TAGUNIQUE )
       DBORDERINFO Info;
       if( hb_sxOrdParam( &Info ) )
       {
-         Info.itmResult = hb_itemPutL( NULL, FALSE );
+         Info.itmResult = hb_itemPutL( NULL, HB_FALSE );
          SELF_ORDINFO( pArea, DBOI_UNIQUE, &Info );
          hb_itemReturnRelease( Info.itmResult );
       }
@@ -683,8 +683,8 @@ HB_FUNC( SX_WILDSEEK )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
    const char * szPattern = hb_parc( 1 );
-   BOOL fCont = hb_parl( 2 );
-   BOOL fFound = FALSE;
+   HB_BOOL fCont = hb_parl( 2 );
+   HB_BOOL fFound = HB_FALSE;
    int iOrder = 0;
 
    if( pArea )
@@ -733,15 +733,15 @@ HB_FUNC( SX_WILDSEEK )
 HB_FUNC( SX_ROXLOCK )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fLocked = FALSE;
+   HB_BOOL fLocked = HB_FALSE;
 
    if( pArea )
    {
       DBORDERINFO Info;
       if( hb_sxOrdParam( &Info ) )
       {
-         Info.itmNewVal = hb_itemPutL( NULL, TRUE );
-         Info.itmResult = hb_itemPutL( NULL, FALSE );
+         Info.itmNewVal = hb_itemPutL( NULL, HB_TRUE );
+         Info.itmResult = hb_itemPutL( NULL, HB_FALSE );
          if( SELF_ORDINFO( pArea, DBOI_READLOCK, &Info ) == HB_SUCCESS )
             fLocked = hb_itemGetL( Info.itmResult );
          hb_itemRelease( Info.itmNewVal );
@@ -760,8 +760,8 @@ HB_FUNC( SX_ROXUNLOCK )
       DBORDERINFO Info;
       if( hb_sxOrdParam( &Info ) )
       {
-         Info.itmNewVal = hb_itemPutL( NULL, FALSE );
-         Info.itmResult = hb_itemPutL( NULL, FALSE );
+         Info.itmNewVal = hb_itemPutL( NULL, HB_FALSE );
+         Info.itmResult = hb_itemPutL( NULL, HB_FALSE );
          SELF_ORDINFO( pArea, DBOI_READLOCK, &Info );
          hb_itemRelease( Info.itmNewVal );
          hb_itemRelease( Info.itmResult );
@@ -772,7 +772,7 @@ HB_FUNC( SX_ROXUNLOCK )
 HB_FUNC( SX_ISMYROX )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fLocked = FALSE;
+   HB_BOOL fLocked = HB_FALSE;
 
    if( pArea )
    {
@@ -791,7 +791,7 @@ HB_FUNC( SX_ISMYROX )
 HB_FUNC( SX_ISROXLOCK )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fLocked = FALSE;
+   HB_BOOL fLocked = HB_FALSE;
 
    if( pArea )
    {
@@ -803,12 +803,12 @@ HB_FUNC( SX_ISROXLOCK )
             fLocked = hb_itemGetL( Info.itmResult );
          if( !fLocked )
          {
-            Info.itmNewVal = hb_itemPutL( NULL, TRUE );
+            Info.itmNewVal = hb_itemPutL( NULL, HB_TRUE );
             if( SELF_ORDINFO( pArea, DBOI_READLOCK, &Info ) == HB_SUCCESS )
                fLocked = hb_itemGetL( Info.itmResult );
             if( fLocked )
             {
-               hb_itemPutL( Info.itmNewVal, FALSE );
+               hb_itemPutL( Info.itmNewVal, HB_FALSE );
                SELF_ORDINFO( pArea, DBOI_READLOCK, &Info );
             }
             hb_itemRelease( Info.itmNewVal );
@@ -822,7 +822,7 @@ HB_FUNC( SX_ISROXLOCK )
 HB_FUNC( SX_SORTOPTION )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fUseCurrent = TRUE;
+   HB_BOOL fUseCurrent = HB_TRUE;
 
    if( pArea )
    {
diff --git a/harbour/src/rdd/hbsix/sxsem.c b/harbour/src/rdd/hbsix/sxsem.c
index d196e024ce..db4c399c8d 100644
--- a/harbour/src/rdd/hbsix/sxsem.c
+++ b/harbour/src/rdd/hbsix/sxsem.c
@@ -59,16 +59,16 @@
 #include "hbapirdd.h"
 
 
-static BOOL hb_sxSemName( char * szFileName )
+static HB_BOOL hb_sxSemName( char * szFileName )
 {
    const char * szName = hb_parc( 1 );
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
 
    if( szName && szName[0] )
    {
       hb_strncpy( szFileName, szName, HB_PATH_MAX - 1 );
       hb_strLower( szFileName, strlen( szFileName ) );
-      fResult = TRUE;
+      fResult = HB_TRUE;
    }
    else
    {
@@ -88,7 +88,7 @@ static BOOL hb_sxSemName( char * szFileName )
          {
             hb_strncpy( szFileName, szName, HB_PATH_MAX - 1 );
             hb_strLower( szFileName, strlen( szFileName ) );
-            fResult = TRUE;
+            fResult = HB_TRUE;
          }
          hb_itemRelease( pOrderInfo.itmResult );
       }
@@ -97,7 +97,7 @@ static BOOL hb_sxSemName( char * szFileName )
    return fResult;
 }
 
-static HB_FHANDLE hb_sxSemOpen( char * szFileName, BOOL * pfNewFile )
+static HB_FHANDLE hb_sxSemOpen( char * szFileName, HB_BOOL * pfNewFile )
 {
    HB_FHANDLE hFile;
    int i = 0;
@@ -117,7 +117,7 @@ static HB_FHANDLE hb_sxSemOpen( char * szFileName, BOOL * pfNewFile )
                                FXO_SHARELOCK | FXO_COPYNAME, NULL, NULL );
          if( hFile != FS_ERROR )
          {
-            *pfNewFile = TRUE;
+            *pfNewFile = HB_TRUE;
             break;
          }
       }
@@ -141,7 +141,7 @@ HB_FUNC( SX_MAKESEM )
    char szFileName[HB_PATH_MAX];
    BYTE buffer[2];
    int iUsers = -1;
-   BOOL fError = FALSE, fNewFile = FALSE;
+   HB_BOOL fError = HB_FALSE, fNewFile = HB_FALSE;
 
    if( hb_sxSemName( szFileName ) )
    {
@@ -154,7 +154,7 @@ HB_FUNC( SX_MAKESEM )
          {
             hb_fsSeek( hFile, 0, FS_SET );
             if( hb_fsRead( hFile, buffer, 2 ) != 2 )
-               fError = TRUE;
+               fError = HB_TRUE;
             else
                iUsers = HB_GET_LE_INT16( buffer ) + 1;
          }
@@ -163,7 +163,7 @@ HB_FUNC( SX_MAKESEM )
             HB_PUT_LE_UINT16( buffer, iUsers );
             hb_fsSeek( hFile, 0, FS_SET );
             if( hb_fsWrite( hFile, buffer, 2 ) != 2 )
-               fError = TRUE;
+               fError = HB_TRUE;
          }
          hb_fsClose( hFile );
       }
diff --git a/harbour/src/rdd/hbsix/sxtable.c b/harbour/src/rdd/hbsix/sxtable.c
index 922cad3626..ec5767f5b5 100644
--- a/harbour/src/rdd/hbsix/sxtable.c
+++ b/harbour/src/rdd/hbsix/sxtable.c
@@ -89,7 +89,7 @@ HB_FUNC( SX_GETLOCKS )
 HB_FUNC( SX_ISFLOCKED )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fLocked = FALSE;
+   HB_BOOL fLocked = HB_FALSE;
 
    if( pArea )
    {
@@ -105,7 +105,7 @@ HB_FUNC( SX_ISFLOCKED )
 HB_FUNC( SX_ISREADONLY )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fReadOnly = FALSE;
+   HB_BOOL fReadOnly = HB_FALSE;
 
    if( pArea )
    {
@@ -121,7 +121,7 @@ HB_FUNC( SX_ISREADONLY )
 HB_FUNC( SX_ISSHARED )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fShared = FALSE;
+   HB_BOOL fShared = HB_FALSE;
 
    if( pArea )
    {
@@ -195,7 +195,7 @@ static void hb_sxRollBackChild( AREAP pArea, PHB_ITEM pItem )
 
 HB_FUNC( SX_ROLLBACK )
 {
-   BOOL fResult = FALSE, fRollChild = FALSE;
+   HB_BOOL fResult = HB_FALSE, fRollChild = HB_FALSE;
    int iArea = 0;
    AREAP pArea;
 
@@ -225,13 +225,13 @@ HB_FUNC( SX_ROLLBACK )
 HB_FUNC( SX_RLOCK )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
    PHB_ITEM pResult = NULL, pRecords;
 
    if( pArea )
    {
       DBLOCKINFO dbLockInfo;
-      dbLockInfo.fResult = FALSE;
+      dbLockInfo.fResult = HB_FALSE;
       dbLockInfo.uiMethod = DBLM_MULTIPLE;
       pRecords = hb_param( 1, HB_IT_ARRAY );
       if( pRecords )
@@ -284,7 +284,7 @@ HB_FUNC( SX_UNLOCK )
 HB_FUNC( SX_SETPASS )
 {
    int iPCount = hb_pcount();
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
    PHB_ITEM pItem;
 
    if( iPCount >=1 )
@@ -296,7 +296,7 @@ HB_FUNC( SX_SETPASS )
          {
             pItem = hb_itemParam( 1 );
             if( SELF_INFO( pArea, DBI_PASSWORD, pItem ) == HB_SUCCESS )
-               fResult = TRUE;
+               fResult = HB_TRUE;
             hb_itemRelease( pItem );
          }
       }
@@ -323,7 +323,7 @@ HB_FUNC( SX_SETPASS )
          {
             pItem = hb_itemParam( 1 );
             if( SELF_RDDINFO( pRDDNode, RDDI_PENDINGPASSWORD, hb_parnl( 4 ), pItem ) == HB_SUCCESS )
-               fResult = TRUE;
+               fResult = HB_TRUE;
             hb_itemRelease( pItem );
          }
       }
@@ -362,7 +362,7 @@ HB_FUNC( SX_SETPASS )
 HB_FUNC( SX_DBFENCRYPT )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
 
    if( pArea )
    {
@@ -382,7 +382,7 @@ HB_FUNC( SX_DBFENCRYPT )
 HB_FUNC( SX_DBFDECRYPT )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
 
    if( pArea )
    {
@@ -397,7 +397,7 @@ HB_FUNC( SX_DBFDECRYPT )
 HB_FUNC( SX_MEMOPACK )
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
 
    if( pArea )
    {
@@ -421,11 +421,11 @@ HB_FUNC( SX_TURBOAREA )
       if( hb_pcount() > 0 && HB_IS_NIL( pItem ) )
          hb_itemPutNI( pItem, 0 );
       if( SELF_INFO( pArea, DBI_DIRTYREAD, pItem ) != HB_SUCCESS )
-         hb_itemPutL( pItem, FALSE );
+         hb_itemPutL( pItem, HB_FALSE );
       hb_itemReturnRelease( pItem );
    }
    else
-      hb_retl( FALSE );
+      hb_retl( HB_FALSE );
 }
 
 HB_FUNC( SX_SETTURBO )
@@ -448,7 +448,7 @@ HB_FUNC( SX_SETTURBO )
       if( hb_pcount() > 0 && HB_IS_NIL( pItem ) )
          hb_itemPutNI( pItem, 0 );
       if( SELF_RDDINFO( pRDDNode, RDDI_DIRTYREAD, 0, pItem ) != HB_SUCCESS )
-         hb_itemPutL( pItem, FALSE );
+         hb_itemPutL( pItem, HB_FALSE );
       hb_itemReturnRelease( pItem );
    }
 }
diff --git a/harbour/src/rdd/hbsix/sxutil.c b/harbour/src/rdd/hbsix/sxutil.c
index b8e4ae1522..af9172cf16 100644
--- a/harbour/src/rdd/hbsix/sxutil.c
+++ b/harbour/src/rdd/hbsix/sxutil.c
@@ -92,9 +92,9 @@ HB_FUNC( SX_SLIMFAST )
 HB_FUNC( SX_WILDMATCH )
 {
    const char * szPattern = hb_parc( 1 ), * szValue = hb_parc( 2 );
-   BOOL fMatch = FALSE;
+   HB_BOOL fMatch = HB_FALSE;
 
-   if( szPattern && szPattern[0] && szValue )
+   if( szPattern && szPattern[ 0 ] && szValue )
       fMatch = hb_strMatchWild( szValue, szPattern );
 
    hb_retl( fMatch );
diff --git a/harbour/src/rdd/hsx/hsx.c b/harbour/src/rdd/hsx/hsx.c
index ab60bccc70..084d8c4bfb 100644
--- a/harbour/src/rdd/hsx/hsx.c
+++ b/harbour/src/rdd/hsx/hsx.c
@@ -309,21 +309,21 @@ typedef struct _HSXINFO
    int        iHandle;          /* HSX handle */
    ULONG      ulRecCount;       /* number of records */
    USHORT     uiRecordSize;     /* record size in bytes */
-   BOOL       fIgnoreCase;      /* ignore case */
+   HB_BOOL    fIgnoreCase;      /* ignore case */
    int        iFilterType;      /* character filter */
-   BOOL       fUseHash;         /* use Hash functions for alphas */
+   HB_BOOL    fUseHash;         /* use Hash functions for alphas */
 
    PHB_FILE   pFile;            /* file handle */
    char *     szFileName;       /* file name */
-   BOOL       fShared;          /* Shared file */
-   BOOL       fReadonly;        /* Read only file */
+   HB_BOOL    fShared;          /* Shared file */
+   HB_BOOL    fReadonly;        /* Read only file */
    ULONG      ulBufSize;        /* size of buffer in records */
    ULONG      ulBufRec;         /* number of record in buffer */
    ULONG      ulFirstRec;       /* first record in the buffer */
    BYTE *     pBuffer;          /* the buffer pointer */
-   BOOL       fChanged;         /* the buffer is changed and should be written to index file */
-   BOOL       fHdrChanged;      /* new records, header file has to be updated */
-   BOOL       fWrLocked;        /* the index is locked for writing */
+   HB_BOOL    fChanged;         /* the buffer is changed and should be written to index file */
+   HB_BOOL    fHdrChanged;      /* new records, header file has to be updated */
+   HB_BOOL    fWrLocked;        /* the index is locked for writing */
 
    char *     pSearchVal;       /* current search value for HS_NEXT */
    ULONG      ulSearch;         /* the length of search value */
@@ -334,7 +334,7 @@ typedef struct _HSXINFO
    int        iArea;            /* work area number if bound with WA or 0 */
    char *     szKeyExpr;        /* key expression when bound with WA for automatic update */
    PHB_ITEM   pKeyItem;         /* item with compiled key expression */
-   BOOL       fFlush;           /* data was written to file and not commited */
+   HB_BOOL    fFlush;           /* data was written to file and not commited */
 } HSXINFO;
 typedef HSXINFO * LPHSXINFO;
 
@@ -416,7 +416,7 @@ static const UCHAR hb_hsxHashArray[] = {
 /* Z */  42,  4,  4,  4, 56,  4,  4,  4, 24,  4,  4,  4,  4,  4, 41,  4,  4,  4,  4,  4,  4,  4,  4,  4,  3,  4 };
 
 static int hb_hsxHashVal( int c1, int c2, int iKeyBits,
-                          BOOL fNoCase, int iFilter, BOOL fUseHash )
+                          HB_BOOL fNoCase, int iFilter, HB_BOOL fUseHash )
 {
    int iBitNum;
 
@@ -460,7 +460,7 @@ static int hb_hsxHashVal( int c1, int c2, int iKeyBits,
 }
 
 static void hb_hsxHashStr( const char * pStr, ULONG ulLen, BYTE * pKey, int iKeySize,
-                           BOOL fNoCase, int iFilter, BOOL fUseHash )
+                           HB_BOOL fNoCase, int iFilter, HB_BOOL fUseHash )
 {
    int c1, c2, iBitNum, iKeyBits = iKeySize << 3;
 
@@ -492,9 +492,9 @@ static void hb_hsxHashStr( const char * pStr, ULONG ulLen, BYTE * pKey, int iKey
 }
 
 static int hb_hsxStrCmp( const char * pSub, ULONG ulSub, const char * pStr, ULONG ulLen,
-                         BOOL fNoCase, int iFilter )
+                         HB_BOOL fNoCase, int iFilter )
 {
-   BOOL fResult = FALSE;
+   HB_BOOL fResult = HB_FALSE;
    UCHAR c1, c2;
    ULONG ul;
 
@@ -503,7 +503,7 @@ static int hb_hsxStrCmp( const char * pSub, ULONG ulSub, const char * pStr, ULON
 
    while( !fResult && ulLen >= ulSub )
    {
-      fResult = TRUE;
+      fResult = HB_TRUE;
       for( ul = 0; fResult && ul < ulSub; ul++ )
       {
          c1 = ( UCHAR ) pSub[ ul ];
@@ -581,7 +581,7 @@ static int hb_hsxCompile( const char * szExpr, PHB_ITEM * pExpr )
    return HSX_SUCCESS;
 }
 
-static int hb_hsxEval( int iHandle, PHB_ITEM pExpr, BYTE *pKey, BOOL *fDeleted )
+static int hb_hsxEval( int iHandle, PHB_ITEM pExpr, BYTE *pKey, HB_BOOL *fDeleted )
 {
    LPHSXINFO pHSX = hb_hsxGetPointer( iHandle );
    int iResult = HSX_SUCCESS;
@@ -602,7 +602,7 @@ static int hb_hsxEval( int iHandle, PHB_ITEM pExpr, BYTE *pKey, BOOL *fDeleted )
       pStr = hb_itemGetCPtr( pExpr );
       ulLen = hb_itemGetCLen( pExpr );
       if( fDeleted )
-         *fDeleted = FALSE;
+         *fDeleted = HB_FALSE;
    }
    else
    {
@@ -624,7 +624,7 @@ static int hb_hsxEval( int iHandle, PHB_ITEM pExpr, BYTE *pKey, BOOL *fDeleted )
       {
          AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
          if( !pArea )
-            *fDeleted = FALSE;
+            *fDeleted = HB_FALSE;
          else if( SELF_DELETED( pArea, fDeleted ) == HB_FAILURE )
             iResult = HSX_RDDFAILURE;
       }
@@ -677,8 +677,8 @@ static int hb_hsxHdrFlush( int iHandle )
       if( hb_fileWriteAt( pHSX->pFile, headrBuf, HSXHEADER_LEN, 0 ) != HSXHEADER_LEN )
          return HSX_BADHDRWRITE;
 
-      pHSX->fHdrChanged = FALSE;
-      pHSX->fFlush = TRUE;
+      pHSX->fHdrChanged = HB_FALSE;
+      pHSX->fFlush = HB_TRUE;
    }
    return HSX_SUCCESS;
 }
@@ -703,8 +703,8 @@ static int hb_hsxFlush( int iHandle )
       if( hb_fileWriteAt( pHSX->pFile, pHSX->pBuffer, ulSize, fOffset ) != ulSize )
          return HSX_BADWRITE;
 
-      pHSX->fChanged = FALSE;
-      pHSX->fFlush = TRUE;
+      pHSX->fChanged = HB_FALSE;
+      pHSX->fFlush = HB_TRUE;
    }
    return HSX_SUCCESS;
 }
@@ -755,7 +755,7 @@ static int hb_hsxHdrRead( int iHandle )
 static int hb_hsxRead( int iHandle, ULONG ulRecord, BYTE ** pRecPtr )
 {
    LPHSXINFO pHSX = hb_hsxGetPointer( iHandle );
-   BOOL fCount = pHSX->fShared;
+   HB_BOOL fCount = pHSX->fShared;
 
    if( ! pHSX )
       return HSX_BADHANDLE;
@@ -763,7 +763,7 @@ static int hb_hsxRead( int iHandle, ULONG ulRecord, BYTE ** pRecPtr )
    if( ulRecord > pHSX->ulRecCount && fCount )
    {
       hb_hsxGetRecCount( pHSX );
-      fCount = FALSE;
+      fCount = HB_FALSE;
    }
 
    if( ulRecord == 0 || ulRecord > pHSX->ulRecCount )
@@ -833,7 +833,7 @@ static int hb_hsxAppend( int iHandle, ULONG * pulRecNo, BYTE **pRecPtr )
       *pulRecNo = ++pHSX->ulRecCount;
    }
    *pRecPtr = pHSX->pBuffer + ( pHSX->ulBufRec - 1 ) * pHSX->uiRecordSize;
-   pHSX->fHdrChanged = TRUE;
+   pHSX->fHdrChanged = HB_TRUE;
 
    return HSX_SUCCESS;
 }
@@ -880,7 +880,7 @@ static int hb_hsxLock( int iHandle, int iAction, ULONG ulRecord )
 {
    LPHSXINFO pHSX = hb_hsxGetPointer( iHandle );
    int iRetVal = HSX_SUCCESS, iRet;
-   BOOL fResult;
+   HB_BOOL fResult;
 
    HB_SYMBOL_UNUSED( ulRecord );
 
@@ -930,7 +930,7 @@ static int hb_hsxLock( int iHandle, int iAction, ULONG ulRecord )
                if( iAction == HSX_APPENDLOCK )
                   hb_hsxGetRecCount( pHSX );
                else if( iAction == HSX_WRITELOCK )
-                  pHSX->fWrLocked = TRUE;
+                  pHSX->fWrLocked = HB_TRUE;
             }
             break;
 
@@ -964,7 +964,7 @@ static int hb_hsxLock( int iHandle, int iAction, ULONG ulRecord )
          case HSX_APPENDUNLOCK:
             iRetVal = hb_hsxFlush( iHandle );
             if( iAction == HSX_APPENDLOCK )
-               pHSX->fWrLocked = FALSE;
+               pHSX->fWrLocked = HB_FALSE;
          case HSX_HDRWRITEUNLOCK:
             iRet = hb_hsxHdrFlush( iHandle );
             if( iRetVal == HSX_SUCCESS )
@@ -1023,7 +1023,7 @@ static int hb_hsxDelete( int iHandle, ULONG ulRecord )
          else
          {
             *pRecPtr |= 0x80;
-            pHSX->fChanged = TRUE;
+            pHSX->fChanged = HB_TRUE;
             iRetVal = HSX_SUCCESS;
          }
       }
@@ -1055,7 +1055,7 @@ static int hb_hsxUnDelete( int iHandle, ULONG ulRecord )
          else
          {
             *pRecPtr &= ~0x80;
-            pHSX->fChanged = TRUE;
+            pHSX->fChanged = HB_TRUE;
             iRetVal = HSX_SUCCESS;
          }
       }
@@ -1066,7 +1066,7 @@ static int hb_hsxUnDelete( int iHandle, ULONG ulRecord )
    return iRetVal;
 }
 
-static int hb_hsxReplace( int iHandle, ULONG ulRecord, PHB_ITEM pExpr, BOOL fDeleted )
+static int hb_hsxReplace( int iHandle, ULONG ulRecord, PHB_ITEM pExpr, HB_BOOL fDeleted )
 {
    LPHSXINFO pHSX = hb_hsxGetPointer( iHandle );
    int iRetVal, iRet;
@@ -1087,7 +1087,7 @@ static int hb_hsxReplace( int iHandle, ULONG ulRecord, PHB_ITEM pExpr, BOOL fDel
          {
             if( fDeleted )
                *pRecPtr |= 0x80;
-            pHSX->fChanged = TRUE;
+            pHSX->fChanged = HB_TRUE;
          }
       }
       iRet = hb_hsxLock( iHandle, HSX_WRITEUNLOCK, ulRecord );
@@ -1097,7 +1097,7 @@ static int hb_hsxReplace( int iHandle, ULONG ulRecord, PHB_ITEM pExpr, BOOL fDel
    return iRetVal;
 }
 
-static int hb_hsxAdd( int iHandle, ULONG *pulRecNo, PHB_ITEM pExpr, BOOL fDeleted )
+static int hb_hsxAdd( int iHandle, ULONG *pulRecNo, PHB_ITEM pExpr, HB_BOOL fDeleted )
 {
    LPHSXINFO pHSX = hb_hsxGetPointer( iHandle );
    int iRetVal, iRet;
@@ -1122,7 +1122,7 @@ static int hb_hsxAdd( int iHandle, ULONG *pulRecNo, PHB_ITEM pExpr, BOOL fDelete
          {
             if( fDeleted )
                *pRecPtr |= 0x80;
-            pHSX->fChanged = TRUE;
+            pHSX->fChanged = HB_TRUE;
             if( pulRecNo )
                *pulRecNo = ulRecNo;
          }
@@ -1377,7 +1377,7 @@ static int hb_hsxDestroy( int iHandle )
 }
 
 static int hb_hsxCreate( const char * szFile, int iBufSize, int iKeySize,
-                         BOOL fIgnoreCase, int iFilter, PHB_ITEM pExpr )
+                         HB_BOOL fIgnoreCase, int iFilter, PHB_ITEM pExpr )
 {
    char szFileName[ HB_PATH_MAX ];
    const char * szExpr = NULL;
@@ -1438,8 +1438,8 @@ static int hb_hsxCreate( const char * szFile, int iBufSize, int iKeySize,
    pHSX = hb_hsxNew();
    pHSX->pFile = pFile;
    pHSX->szFileName = hb_strdup( szFileName );
-   pHSX->fShared = FALSE;
-   pHSX->fReadonly = FALSE;
+   pHSX->fShared = HB_FALSE;
+   pHSX->fReadonly = HB_FALSE;
    pHSX->uiRecordSize = uiRecordSize;
    pHSX->fIgnoreCase = fIgnoreCase;
    pHSX->iFilterType = iFilter;
@@ -1455,7 +1455,7 @@ static int hb_hsxCreate( const char * szFile, int iBufSize, int iKeySize,
    }
    pHSX->ulBufSize = ulBufSize;
 
-   pHSX->fHdrChanged = TRUE;
+   pHSX->fHdrChanged = HB_TRUE;
    iRetVal = hb_hsxHdrFlush( pHSX->iHandle );
    if( iRetVal != HSX_SUCCESS )
    {
@@ -1469,7 +1469,7 @@ static int hb_hsxCreate( const char * szFile, int iBufSize, int iKeySize,
 static int hb_hsxOpen( const char * szFile, int iBufSize, int iMode )
 {
    char szFileName[ HB_PATH_MAX ];
-   BOOL fShared, fReadonly;
+   HB_BOOL fShared, fReadonly;
    PHB_FILE pFile;
    ULONG ulBufSize;
    USHORT uiFlags;
@@ -1495,7 +1495,7 @@ static int hb_hsxOpen( const char * szFile, int iBufSize, int iMode )
    fReadonly = ( iMode & 0x02 ) != 0;
    fShared = ( iMode & 0x01 ) == 0;
    if( hb_setGetAutoShare() == 2 )
-      fShared = FALSE;
+      fShared = HB_FALSE;
    uiFlags = ( fReadonly ? FO_READ : FO_READWRITE ) |
              ( fShared ? FO_DENYNONE : FO_EXCLUSIVE );
 
@@ -1541,7 +1541,7 @@ static int hb_hsxOpen( const char * szFile, int iBufSize, int iMode )
 }
 
 static int hb_hsxIndex( const char * szFile, PHB_ITEM pExpr, int iKeySize,
-                        int iMode, int iBufSize, BOOL fIgnoreCase, int iFilter )
+                        int iMode, int iBufSize, HB_BOOL fIgnoreCase, int iFilter )
 {
    int iRetVal = HSX_SUCCESS, iHandle;
    ULONG ulRecNo = 0, ulRecCount = 0, ulNewRec, ulRec;
@@ -1569,7 +1569,7 @@ static int hb_hsxIndex( const char * szFile, PHB_ITEM pExpr, int iKeySize,
             errCode = SELF_GOTO( pArea, ulRec );
             if( errCode == HB_FAILURE )
                break;
-            iRetVal = hb_hsxAdd( iHandle, &ulNewRec, NULL, FALSE );
+            iRetVal = hb_hsxAdd( iHandle, &ulNewRec, NULL, HB_FALSE );
             if( iRetVal != HSX_SUCCESS )
                break;
             if( ulNewRec != ulRec )
@@ -1601,7 +1601,7 @@ static int hb_hsxFilter( int iHandle, const char * pSeek, ULONG ulSeek,
 {
    AREAP pArea = ( AREAP ) hb_rddGetCurrentWorkAreaPointer();
    LPHSXINFO pHSX = hb_hsxGetPointer( iHandle );
-   BOOL fDestroyExpr = FALSE, fValid;
+   HB_BOOL fDestroyExpr = HB_FALSE, fValid;
    int iResult = HSX_SUCCESS;
    HB_ERRCODE errCode;
    ULONG ulRecNo = 0, ulRec;
@@ -1625,7 +1625,7 @@ static int hb_hsxFilter( int iHandle, const char * pSeek, ULONG ulSeek,
          iResult = hb_hsxCompile( hb_itemGetCPtr( pVerify ), &pVerify );
          if( iResult != HSX_SUCCESS )
             return HSX_BADPARMS;
-         fDestroyExpr = TRUE;
+         fDestroyExpr = HB_TRUE;
       }
       else if( hb_itemType( pVerify ) != HB_IT_BLOCK )
       {
@@ -1637,7 +1637,7 @@ static int hb_hsxFilter( int iHandle, const char * pSeek, ULONG ulSeek,
    if( errCode != HB_FAILURE )
       iResult = hb_hsxSeekSet( iHandle, pSeek, ulSeek );
 
-   fValid = TRUE;
+   fValid = HB_TRUE;
    pItem = hb_itemNew( NULL );
    while( iResult == HSX_SUCCESS && errCode != HB_FAILURE )
    {
@@ -1832,7 +1832,7 @@ HB_FUNC( HS_FILTER )
    char * pBuff = NULL;
    ULONG ulLen = hb_parclen( 2 ), ulRecords = 0, ull, ul;
    int iHandle = -1, iResult = HSX_BADPARMS;
-   BOOL fNew = FALSE, fToken = TRUE;
+   HB_BOOL fNew = HB_FALSE, fToken = HB_TRUE;
 
    if( hb_parclen( 1 ) > 0 )
    {
@@ -1841,7 +1841,7 @@ HB_FUNC( HS_FILTER )
          iHandle = hb_hsxOpen( hb_parc( 1 ), hb_parni( 4 ),
                hb_param( 5, HB_IT_NUMERIC ) ? hb_parni( 5 ) : HSXDEFOPENMODE );
          if( iHandle >= 0 )
-            fNew = TRUE;
+            fNew = HB_TRUE;
          else
             iResult = iHandle;
       }
@@ -1864,7 +1864,7 @@ HB_FUNC( HS_FILTER )
                memcpy( pBuff, pHSX->pSearchVal, ulLen );
                pBuff[ ulLen ] = '\0';
                szText = pBuff;
-               fToken = FALSE;
+               fToken = HB_FALSE;
             }
          }
       }
@@ -1988,7 +1988,7 @@ HB_FUNC( HS_VERIFY )
       PHB_ITEM pExpr = hb_param( 1, HB_IT_BLOCK );
       const char * szSub = hb_parc( 2 ), * szText = NULL;
       ULONG ulSub = hb_parclen( 2 ), ulLen = 0;
-      BOOL fIgnoreCase = hb_parl( 3 );
+      HB_BOOL fIgnoreCase = hb_parl( 3 );
 
       if( ulSub )
       {
diff --git a/harbour/src/rdd/nulsys/nulsys.c b/harbour/src/rdd/nulsys/nulsys.c
index 3a9d22aac8..c1f6c19608 100644
--- a/harbour/src/rdd/nulsys/nulsys.c
+++ b/harbour/src/rdd/nulsys/nulsys.c
@@ -158,7 +158,7 @@ HB_FUNC( DBGOTOP ) {}
 
 HB_FUNC( DBGOBOTTOM ) {}
 
-HB_FUNC( DBSEEK ) { hb_retl( FALSE ); }
+HB_FUNC( DBSEEK ) { hb_retl( HB_FALSE ); }
 
 HB_FUNC( DBSKIP ) { hb_retni( 0 ); }
 
@@ -172,9 +172,9 @@ HB_FUNC( DBRECALL ) {}
 
 HB_FUNC( DBDELETE ) {}
 
-HB_FUNC( DBRLOCK ) { hb_retl( FALSE ); }
+HB_FUNC( DBRLOCK ) { hb_retl( HB_FALSE ); }
 
-HB_FUNC( DBUNLOCK ) { hb_retl( FALSE ); }
+HB_FUNC( DBUNLOCK ) { hb_retl( HB_FALSE ); }
 
 HB_FUNC( DBRELATION ) { hb_retc_null(); }
 
@@ -188,23 +188,23 @@ HB_FUNC( SELECT ) { hb_retni( 0 ); }
 
 HB_FUNC( ALIAS ) { hb_retc_null(); }
 
-HB_FUNC( USED ) { hb_retl( FALSE ); }
+HB_FUNC( USED ) { hb_retl( HB_FALSE ); }
 
-HB_FUNC( NETERR ) { hb_retl( FALSE ); }
+HB_FUNC( NETERR ) { hb_retl( HB_FALSE ); }
 
-HB_FUNC( LOCK ) { hb_retl( FALSE ); }
+HB_FUNC( LOCK ) { hb_retl( HB_FALSE ); }
 
-HB_FUNC( FLOCK ) { hb_retl( FALSE ); }
+HB_FUNC( FLOCK ) { hb_retl( HB_FALSE ); }
 
-HB_FUNC( RLOCK ) { hb_retl( FALSE ); }
+HB_FUNC( RLOCK ) { hb_retl( HB_FALSE ); }
 
-HB_FUNC( BOF ) { hb_retl( FALSE ); }
+HB_FUNC( BOF ) { hb_retl( HB_FALSE ); }
 
-HB_FUNC( EOF ) { hb_retl( FALSE ); }
+HB_FUNC( EOF ) { hb_retl( HB_FALSE ); }
 
-HB_FUNC( FOUND ) { hb_retl( FALSE ); }
+HB_FUNC( FOUND ) { hb_retl( HB_FALSE ); }
 
-HB_FUNC( DELETED ) { hb_retl( FALSE ); }
+HB_FUNC( DELETED ) { hb_retl( HB_FALSE ); }
 
 HB_FUNC( RECNO ) { hb_retni( 0 ); }
 
diff --git a/harbour/src/rdd/sdf1.c b/harbour/src/rdd/sdf1.c
index 62cd147fcc..018fde8881 100644
--- a/harbour/src/rdd/sdf1.c
+++ b/harbour/src/rdd/sdf1.c
@@ -112,14 +112,14 @@ static HB_ERRCODE hb_sdfReadRecord( SDFAREAP pArea )
 
    if( uiRead == 0 )
    {
-      pArea->area.fEof = TRUE;
-      pArea->fPositioned = FALSE;
+      pArea->area.fEof = HB_TRUE;
+      pArea->fPositioned = HB_FALSE;
       hb_sdfClearRecordBuffer( pArea );
    }
    else
    {
-      pArea->area.fEof = FALSE;
-      pArea->fPositioned = TRUE;
+      pArea->area.fEof = HB_FALSE;
+      pArea->fPositioned = HB_TRUE;
       uiEolPos = ( USHORT ) hb_strAt( pArea->szEol, pArea->uiEolLen,
                                       ( char * ) pArea->pRecord, uiRead );
       if( uiEolPos )
@@ -206,8 +206,8 @@ static HB_ERRCODE hb_sdfNextRecord( SDFAREAP pArea )
 
    if( pArea->ulNextOffset == ( HB_FOFFSET ) -1 )
    {
-      pArea->area.fEof = TRUE;
-      pArea->fPositioned = FALSE;
+      pArea->area.fEof = HB_TRUE;
+      pArea->fPositioned = HB_FALSE;
       hb_sdfClearRecordBuffer( pArea );
       return HB_SUCCESS;
    }
@@ -230,8 +230,8 @@ static HB_ERRCODE hb_sdfGoTop( SDFAREAP pArea )
    if( SELF_GOCOLD( ( AREAP ) pArea ) != HB_SUCCESS )
       return HB_FAILURE;
 
-   pArea->area.fTop = TRUE;
-   pArea->area.fBottom = FALSE;
+   pArea->area.fTop = HB_TRUE;
+   pArea->area.fBottom = HB_FALSE;
 
    pArea->ulRecordOffset = 0;
    pArea->ulRecNo = 1;
@@ -260,13 +260,13 @@ static HB_ERRCODE hb_sdfSkipRaw( SDFAREAP pArea, LONG lToSkip )
 /*
  * Determine deleted status for a record.
  */
-static HB_ERRCODE hb_sdfDeleted( SDFAREAP pArea, BOOL * pDeleted )
+static HB_ERRCODE hb_sdfDeleted( SDFAREAP pArea, HB_BOOL * pDeleted )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_sdfDeleted(%p,%p)", pArea, pDeleted));
 
    HB_SYMBOL_UNUSED( pArea );
 
-   * pDeleted = FALSE;
+   * pDeleted = HB_FALSE;
 
    return HB_SUCCESS;
 }
@@ -325,7 +325,7 @@ static HB_ERRCODE hb_sdfRecId( SDFAREAP pArea, PHB_ITEM pRecNo )
 /*
  * Append a record to the WorkArea.
  */
-static HB_ERRCODE hb_sdfAppend( SDFAREAP pArea, BOOL fUnLockAll )
+static HB_ERRCODE hb_sdfAppend( SDFAREAP pArea, HB_BOOL fUnLockAll )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_sdfAppend(%p,%d)", pArea, (int) fUnLockAll));
 
@@ -339,8 +339,8 @@ static HB_ERRCODE hb_sdfAppend( SDFAREAP pArea, BOOL fUnLockAll )
 
    pArea->ulRecordOffset = pArea->ulFileSize;
    pArea->ulRecNo = ++pArea->ulRecCount;
-   pArea->area.fEof = FALSE;
-   pArea->fPositioned = TRUE;
+   pArea->area.fEof = HB_FALSE;
+   pArea->fPositioned = HB_TRUE;
    hb_sdfClearRecordBuffer( pArea );
 
    return HB_SUCCESS;
@@ -356,8 +356,8 @@ static HB_ERRCODE hb_sdfDeleteRec( SDFAREAP pArea )
    if( pArea->fRecordChanged )
    {
       pArea->ulRecCount--;
-      pArea->area.fEof = TRUE;
-      pArea->fPositioned = pArea->fRecordChanged = FALSE;
+      pArea->area.fEof = HB_TRUE;
+      pArea->fPositioned = pArea->fRecordChanged = HB_FALSE;
       hb_sdfClearRecordBuffer( pArea );
    }
 
@@ -399,10 +399,10 @@ static HB_ERRCODE hb_sdfGetValue( SDFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem
             case 't':
             case 'Y':
             case 'y':
-               hb_itemPutL( pItem, TRUE );
+               hb_itemPutL( pItem, HB_TRUE );
                break;
             default:
-               hb_itemPutL( pItem, FALSE );
+               hb_itemPutL( pItem, HB_FALSE );
                break;
          }
          break;
@@ -415,7 +415,7 @@ static HB_ERRCODE hb_sdfGetValue( SDFAREAP pArea, USHORT uiIndex, PHB_ITEM pItem
          {
             HB_LONG lVal;
             double dVal;
-            BOOL fDbl;
+            HB_BOOL fDbl;
 
             fDbl = hb_strnToNum( (const char *) pArea->pRecord + pArea->pFieldOffset[ uiIndex ],
                                  pField->uiLen, &lVal, &dVal );
@@ -626,7 +626,7 @@ static HB_ERRCODE hb_sdfTrans( SDFAREAP pArea, LPDBTRANSINFO pTransInfo )
          pTransInfo->uiFlags |= DBTF_PUTREC;
       else
       {
-         PHB_ITEM pPutRec = hb_itemPutL( NULL, FALSE );
+         PHB_ITEM pPutRec = hb_itemPutL( NULL, HB_FALSE );
          if( SELF_INFO( ( AREAP ) pTransInfo->lpaDest, DBI_CANPUTREC, pPutRec ) != HB_SUCCESS )
          {
             hb_itemRelease( pPutRec );
@@ -669,8 +669,8 @@ static HB_ERRCODE hb_sdfGoCold( SDFAREAP pArea )
       }
       pArea->ulFileSize += ulWrite;
       pArea->ulNextOffset = pArea->ulFileSize;
-      pArea->fRecordChanged = FALSE;
-      pArea->fFlush = TRUE;
+      pArea->fRecordChanged = HB_FALSE;
+      pArea->fFlush = HB_TRUE;
    }
    return HB_SUCCESS;
 }
@@ -694,7 +694,7 @@ static HB_ERRCODE hb_sdfGoHot( SDFAREAP pArea )
       hb_itemRelease( pError );
       return HB_FAILURE;
    }
-   pArea->fRecordChanged = TRUE;
+   pArea->fRecordChanged = HB_TRUE;
    return HB_SUCCESS;
 }
 
@@ -715,7 +715,7 @@ static HB_ERRCODE hb_sdfFlush( SDFAREAP pArea )
       if( hb_setGetHardCommit() )
       {
          hb_fileCommit( pArea->pFile );
-         pArea->fFlush = FALSE;
+         pArea->fFlush = HB_FALSE;
       }
    }
 
@@ -797,7 +797,7 @@ static HB_ERRCODE hb_sdfAddField( SDFAREAP pArea, LPDBFIELDINFO pFieldInfo )
       case HB_FT_OLE:
          pFieldInfo->uiType = HB_FT_MEMO;
          pFieldInfo->uiLen = 0;
-         pArea->fTransRec = FALSE;
+         pArea->fTransRec = HB_FALSE;
          break;
 
       case HB_FT_ANY:
@@ -816,14 +816,14 @@ static HB_ERRCODE hb_sdfAddField( SDFAREAP pArea, LPDBFIELDINFO pFieldInfo )
             pFieldInfo->uiType = HB_FT_MEMO;
             pFieldInfo->uiLen = 0;
          }
-         pArea->fTransRec = FALSE;
+         pArea->fTransRec = HB_FALSE;
          break;
 
       case HB_FT_DATE:
          if( pFieldInfo->uiLen != 8 )
          {
             pFieldInfo->uiLen = 8;
-            pArea->fTransRec = FALSE;
+            pArea->fTransRec = HB_FALSE;
          }
          break;
 
@@ -839,26 +839,26 @@ static HB_ERRCODE hb_sdfAddField( SDFAREAP pArea, LPDBFIELDINFO pFieldInfo )
          pFieldInfo->uiLen = s_uiNumLength[ pFieldInfo->uiLen ];
          if( pFieldInfo->uiDec )
             pFieldInfo->uiLen++;
-         pArea->fTransRec = FALSE;
+         pArea->fTransRec = HB_FALSE;
          break;
 
       case HB_FT_DOUBLE:
       case HB_FT_CURDOUBLE:
          pFieldInfo->uiType = HB_FT_LONG;
          pFieldInfo->uiLen = 20;
-         pArea->fTransRec = FALSE;
+         pArea->fTransRec = HB_FALSE;
          break;
 
       case HB_FT_VARLENGTH:
          pFieldInfo->uiType = HB_FT_STRING;
-         pArea->fTransRec = FALSE;
+         pArea->fTransRec = HB_FALSE;
          break;
 
       case HB_FT_LOGICAL:
          if( pFieldInfo->uiLen != 1 )
          {
             pFieldInfo->uiLen = 1;
-            pArea->fTransRec = FALSE;
+            pArea->fTransRec = HB_FALSE;
          }
          break;
 
@@ -869,20 +869,20 @@ static HB_ERRCODE hb_sdfAddField( SDFAREAP pArea, LPDBFIELDINFO pFieldInfo )
       case HB_FT_TIME:
          pFieldInfo->uiType = HB_FT_STRING;
          pFieldInfo->uiLen = 12;
-         pArea->fTransRec = FALSE;
+         pArea->fTransRec = HB_FALSE;
          break;
 
       case HB_FT_TIMESTAMP:
       case HB_FT_MODTIME:
          pFieldInfo->uiType = HB_FT_STRING;
          pFieldInfo->uiLen = 23;
-         pArea->fTransRec = FALSE;
+         pArea->fTransRec = HB_FALSE;
          break;
 
       default:
          pFieldInfo->uiType = HB_FT_NONE;
          pFieldInfo->uiLen = 0;
-         pArea->fTransRec = FALSE;
+         pArea->fTransRec = HB_FALSE;
          break;
    }
 
@@ -924,7 +924,7 @@ static HB_ERRCODE hb_sdfNewArea( SDFAREAP pArea )
       return HB_FAILURE;
 
    pArea->pFile = NULL;
-   pArea->fTransRec = TRUE;
+   pArea->fTransRec = HB_TRUE;
    pArea->uiRecordLen = 0;
 
    return HB_SUCCESS;
@@ -991,13 +991,13 @@ static HB_ERRCODE hb_sdfCreate( SDFAREAP pArea, LPDBOPENINFO pCreateInfo )
    HB_ERRCODE errCode;
    PHB_FNAME pFileName;
    PHB_ITEM pError = NULL;
-   BOOL fRetry;
+   HB_BOOL fRetry;
    char szFileName[ HB_PATH_MAX ];
 
    HB_TRACE(HB_TR_DEBUG, ("hb_sdfCreate(%p,%p)", pArea, pCreateInfo));
 
-   pArea->fShared = FALSE;    /* pCreateInfo->fShared; */
-   pArea->fReadonly = FALSE;  /* pCreateInfo->fReadonly */
+   pArea->fShared = HB_FALSE;    /* pCreateInfo->fShared; */
+   pArea->fReadonly = HB_FALSE;  /* pCreateInfo->fReadonly */
 
    if( pCreateInfo->cdpId )
    {
@@ -1045,7 +1045,7 @@ static HB_ERRCODE hb_sdfCreate( SDFAREAP pArea, LPDBOPENINFO pCreateInfo )
          fRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
       }
       else
-         fRetry = FALSE;
+         fRetry = HB_FALSE;
    }
    while( fRetry );
 
@@ -1077,14 +1077,14 @@ static HB_ERRCODE hb_sdfOpen( SDFAREAP pArea, LPDBOPENINFO pOpenInfo )
    PHB_FNAME pFileName;
    HB_ERRCODE errCode;
    USHORT uiFlags;
-   BOOL fRetry;
+   HB_BOOL fRetry;
    char szFileName[ HB_PATH_MAX ];
    char szAlias[ HB_RDD_MAX_ALIAS_LEN + 1 ];
 
    HB_TRACE(HB_TR_DEBUG, ("hb_sdfOpen(%p,%p)", pArea, pOpenInfo));
 
-   pArea->fShared = TRUE;     /* pOpenInfo->fShared; */
-   pArea->fReadonly = TRUE;   /* pOpenInfo->fReadonly; */
+   pArea->fShared = HB_TRUE;     /* pOpenInfo->fShared; */
+   pArea->fReadonly = HB_TRUE;   /* pOpenInfo->fReadonly; */
 
    if( pOpenInfo->cdpId )
    {
@@ -1147,7 +1147,7 @@ static HB_ERRCODE hb_sdfOpen( SDFAREAP pArea, LPDBOPENINFO pOpenInfo )
          fRetry = ( SELF_ERROR( ( AREAP ) pArea, pError ) == E_RETRY );
       }
       else
-         fRetry = FALSE;
+         fRetry = HB_FALSE;
    }
    while( fRetry );
 
@@ -1181,7 +1181,7 @@ static HB_ERRCODE hb_sdfRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnect
    {
       case RDDI_CANPUTREC:
       case RDDI_LOCAL:
-         hb_itemPutL( pItem, TRUE );
+         hb_itemPutL( pItem, HB_TRUE );
          break;
 
       case RDDI_TABLEEXT:
diff --git a/harbour/src/rdd/usrrdd/usrrdd.c b/harbour/src/rdd/usrrdd/usrrdd.c
index 091dda3023..22244e5bba 100644
--- a/harbour/src/rdd/usrrdd/usrrdd.c
+++ b/harbour/src/rdd/usrrdd/usrrdd.c
@@ -90,14 +90,14 @@ typedef USRRDDDATA * LPUSRRDDDATA;
 static USHORT s_uiUsrNodes = 0;
 static LPUSRRDDNODE * s_pUsrRddNodes = NULL;
 
-static BOOL hb_usrIsMethod( PHB_ITEM pMethods, USHORT uiMethod )
+static HB_BOOL hb_usrIsMethod( PHB_ITEM pMethods, USHORT uiMethod )
 {
    PHB_ITEM pItem = hb_arrayGetItemPtr( pMethods, uiMethod );
 
    return pItem && ( HB_IS_SYMBOL( pItem ) || HB_IS_BLOCK( pItem ) );
 }
 
-static BOOL hb_usrPushMethod( PHB_ITEM pMethods, USHORT uiMethod )
+static HB_BOOL hb_usrPushMethod( PHB_ITEM pMethods, USHORT uiMethod )
 {
    PHB_ITEM pItem = hb_arrayGetItemPtr( pMethods, uiMethod );
 
@@ -107,16 +107,16 @@ static BOOL hb_usrPushMethod( PHB_ITEM pMethods, USHORT uiMethod )
       {
          hb_vmPush( pItem );
          hb_vmPushNil();
-         return TRUE;
+         return HB_TRUE;
       }
       else if( HB_IS_BLOCK( pItem ) )
       {
          hb_vmPushEvalSym();
          hb_vmPush( pItem );
-         return TRUE;
+         return HB_TRUE;
       }
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 static HB_ERRCODE hb_usrReturn( void )
@@ -205,7 +205,7 @@ static PHB_ITEM hb_usrFieldInfoToItem( LPDBFIELDINFO pFieldInfo )
    return pItem;
 }
 
-static BOOL hb_usrItemToFieldInfo( PHB_ITEM pItem, LPDBFIELDINFO pFieldInfo )
+static HB_BOOL hb_usrItemToFieldInfo( PHB_ITEM pItem, LPDBFIELDINFO pFieldInfo )
 {
    if( pItem && hb_arrayLen( pItem ) == UR_FI_SIZE )
    {
@@ -214,9 +214,9 @@ static BOOL hb_usrItemToFieldInfo( PHB_ITEM pItem, LPDBFIELDINFO pFieldInfo )
       pFieldInfo->uiTypeExtended = hb_arrayGetNI( pItem, UR_FI_TYPEEXT );
       pFieldInfo->uiLen          = hb_arrayGetNI( pItem, UR_FI_LEN );
       pFieldInfo->uiDec          = hb_arrayGetNI( pItem, UR_FI_DEC );
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 static PHB_ITEM hb_usrOpenInfoToItem( LPDBOPENINFO pOpenInfo )
@@ -240,7 +240,7 @@ static PHB_ITEM hb_usrOpenInfoToItem( LPDBOPENINFO pOpenInfo )
    return pItem;
 }
 
-static BOOL hb_usrItemToOpenInfo( PHB_ITEM pItem, LPDBOPENINFO pOpenInfo )
+static HB_BOOL hb_usrItemToOpenInfo( PHB_ITEM pItem, LPDBOPENINFO pOpenInfo )
 {
    if( pItem && hb_arrayLen( pItem ) == UR_OI_SIZE )
    {
@@ -252,9 +252,9 @@ static BOOL hb_usrItemToOpenInfo( PHB_ITEM pItem, LPDBOPENINFO pOpenInfo )
       pOpenInfo->cdpId        = hb_usrArrayGetC( pItem, UR_OI_CDPID );
       pOpenInfo->ulConnection = hb_arrayGetNL( pItem, UR_OI_CONNECT );
       pOpenInfo->lpdbHeader   = hb_arrayGetPtr( pItem, UR_OI_HEADER );
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 static PHB_ITEM hb_usrFilterInfoToItem( LPDBFILTERINFO pFilterInfo )
@@ -273,7 +273,7 @@ static PHB_ITEM hb_usrFilterInfoToItem( LPDBFILTERINFO pFilterInfo )
    return pItem;
 }
 
-static BOOL hb_usrItemToFilterInfo( PHB_ITEM pItem, LPDBFILTERINFO pFilterInfo )
+static HB_BOOL hb_usrItemToFilterInfo( PHB_ITEM pItem, LPDBFILTERINFO pFilterInfo )
 {
    if( pItem && hb_arrayLen( pItem ) == UR_FRI_SIZE )
    {
@@ -282,9 +282,9 @@ static BOOL hb_usrItemToFilterInfo( PHB_ITEM pItem, LPDBFILTERINFO pFilterInfo )
       pFilterInfo->fFilter      = hb_arrayGetL( pItem, UR_FRI_ACTIVE );
       pFilterInfo->fOptimized   = hb_arrayGetL( pItem, UR_FRI_OPTIMIZED );
       pFilterInfo->lpvCargo     = hb_arrayGetPtr( pItem, UR_FRI_CARGO );
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 static PHB_ITEM hb_usrRelInfoToItem( LPDBRELINFO pRelInfo )
@@ -305,7 +305,7 @@ static PHB_ITEM hb_usrRelInfoToItem( LPDBRELINFO pRelInfo )
    return pItem;
 }
 
-static BOOL hb_usrItemToRelInfo( PHB_ITEM pItem, LPDBRELINFO pRelInfo )
+static HB_BOOL hb_usrItemToRelInfo( PHB_ITEM pItem, LPDBRELINFO pRelInfo )
 {
    if( pItem && hb_arrayLen( pItem ) == UR_RI_SIZE )
    {
@@ -316,9 +316,9 @@ static BOOL hb_usrItemToRelInfo( PHB_ITEM pItem, LPDBRELINFO pRelInfo )
       pRelInfo->lpaParent   = hb_usrGetAreaPointer( hb_arrayGetNI( pItem, UR_RI_PARENT ) );
       pRelInfo->lpaChild    = hb_usrGetAreaPointer( hb_arrayGetNI( pItem, UR_RI_CHILD ) );
       pRelInfo->lpdbriNext  = ( LPDBRELINFO ) hb_arrayGetPtr( pItem, UR_RI_NEXT );
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 static PHB_ITEM hb_usrLockInfoToItem( LPDBLOCKINFO pLockInfo )
@@ -334,16 +334,16 @@ static PHB_ITEM hb_usrLockInfoToItem( LPDBLOCKINFO pLockInfo )
    return pItem;
 }
 
-static BOOL hb_usrItemToLockInfo( PHB_ITEM pItem, LPDBLOCKINFO pLockInfo )
+static HB_BOOL hb_usrItemToLockInfo( PHB_ITEM pItem, LPDBLOCKINFO pLockInfo )
 {
    if( pItem && hb_arrayLen( pItem ) == UR_LI_SIZE )
    {
       pLockInfo->itmRecID = hb_usrArrayGet( pItem, UR_LI_RECORD, HB_IT_ANY );
       pLockInfo->uiMethod = hb_arrayGetNI( pItem, UR_LI_METHOD );
       pLockInfo->fResult  = hb_arrayGetL( pItem, UR_LI_RESULT );
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 static PHB_ITEM hb_usrScopeInfoToItem( LPDBSCOPEINFO pScopeInfo )
@@ -375,7 +375,7 @@ static PHB_ITEM hb_usrScopeInfoToItem( LPDBSCOPEINFO pScopeInfo )
    return pItem;
 }
 
-static BOOL hb_usrItemToScopeInfo( PHB_ITEM pItem, LPDBSCOPEINFO pScopeInfo )
+static HB_BOOL hb_usrItemToScopeInfo( PHB_ITEM pItem, LPDBSCOPEINFO pScopeInfo )
 {
    if( pItem && hb_arrayLen( pItem ) == UR_SI_SIZE )
    {
@@ -392,9 +392,9 @@ static BOOL hb_usrItemToScopeInfo( PHB_ITEM pItem, LPDBSCOPEINFO pScopeInfo )
       pScopeInfo->fIgnoreDuplicates = hb_arrayGetL( pItem, UR_SI_IGNOREDUPS );
       pScopeInfo->fBackward         = hb_arrayGetL( pItem, UR_SI_BACKWARD );
       pScopeInfo->fOptimized        = hb_arrayGetL( pItem, UR_SI_OPTIMIZED );
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 static PHB_ITEM hb_usrEvalInfoToItem( LPDBEVALINFO pEvalInfo )
@@ -413,7 +413,7 @@ static PHB_ITEM hb_usrEvalInfoToItem( LPDBEVALINFO pEvalInfo )
    return pItem;
 }
 
-static BOOL hb_usrItemToEvalInfo( PHB_ITEM pItem, LPDBEVALINFO pEvalInfo )
+static HB_BOOL hb_usrItemToEvalInfo( PHB_ITEM pItem, LPDBEVALINFO pEvalInfo )
 {
    if( pItem && hb_arrayLen( pItem ) == UR_EI_SIZE )
    {
@@ -422,7 +422,7 @@ static BOOL hb_usrItemToEvalInfo( PHB_ITEM pItem, LPDBEVALINFO pEvalInfo )
       return hb_usrItemToScopeInfo( hb_arrayGetItemPtr( pItem, UR_EI_SCOPE ),
                                     &pEvalInfo->dbsci );
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 static PHB_ITEM hb_usrTransInfoToItem( LPDBTRANSINFO pTransInfo )
@@ -456,7 +456,7 @@ static PHB_ITEM hb_usrTransInfoToItem( LPDBTRANSINFO pTransInfo )
    return pItem;
 }
 
-static BOOL hb_usrItemToTransInfo( PHB_ITEM pItem, LPDBTRANSINFO pTransInfo )
+static HB_BOOL hb_usrItemToTransInfo( PHB_ITEM pItem, LPDBTRANSINFO pTransInfo )
 {
    if( pItem && hb_arrayLen( pItem ) == UR_TI_SIZE )
    {
@@ -489,10 +489,10 @@ static BOOL hb_usrItemToTransInfo( PHB_ITEM pItem, LPDBTRANSINFO pTransInfo )
          {
             pTransInfo->lpTransItems = NULL;
          }
-         return TRUE;
+         return HB_TRUE;
       }
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 static void hb_usrTransInfoFree( LPDBTRANSINFO pTransInfo )
@@ -529,7 +529,7 @@ static PHB_ITEM hb_usrSortInfoToItem( LPDBSORTINFO pSortInfo )
    return pItem;
 }
 
-static BOOL hb_usrItemToSortInfo( PHB_ITEM pItem, LPDBSORTINFO pSortInfo )
+static HB_BOOL hb_usrItemToSortInfo( PHB_ITEM pItem, LPDBSORTINFO pSortInfo )
 {
    if( pItem && hb_arrayLen( pItem ) == UR_SRI_SIZE )
    {
@@ -559,10 +559,10 @@ static BOOL hb_usrItemToSortInfo( PHB_ITEM pItem, LPDBSORTINFO pSortInfo )
          {
             pSortInfo->lpdbsItem = NULL;
          }
-         return TRUE;
+         return HB_TRUE;
       }
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 static void hb_usrSortInfoFree( LPDBSORTINFO pSortInfo )
@@ -592,7 +592,7 @@ static PHB_ITEM hb_usrOrderInfoToItem( LPDBORDERINFO pOrderInfo )
    return pItem;
 }
 
-static BOOL hb_usrItemToOrderInfo( PHB_ITEM pItem, LPDBORDERINFO pOrderInfo )
+static HB_BOOL hb_usrItemToOrderInfo( PHB_ITEM pItem, LPDBORDERINFO pOrderInfo )
 {
    if( pItem && hb_arrayLen( pItem ) == UR_ORI_SIZE )
    {
@@ -602,9 +602,9 @@ static BOOL hb_usrItemToOrderInfo( PHB_ITEM pItem, LPDBORDERINFO pOrderInfo )
       pOrderInfo->itmResult   = hb_usrArrayGet( pItem, UR_ORI_RESULT, HB_IT_ANY );
       pOrderInfo->itmNewVal   = hb_usrArrayGet( pItem, UR_ORI_NEWVAL, HB_IT_ANY );
       pOrderInfo->fAllTags    = hb_arrayGetL( pItem, UR_ORI_ALLTAGS );
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 static PHB_ITEM hb_usrOrderCondInfoToItem( LPDBORDERCONDINFO pOrderCondInfo )
@@ -646,8 +646,8 @@ static PHB_ITEM hb_usrOrderCondInfoToItem( LPDBORDERCONDINFO pOrderCondInfo )
    return pItem;
 }
 
-static BOOL hb_usrItemToOrderCondInfo( PHB_ITEM pItem,
-                                       LPDBORDERCONDINFO pOrderCondInfo )
+static HB_BOOL hb_usrItemToOrderCondInfo( PHB_ITEM pItem,
+                                          LPDBORDERCONDINFO pOrderCondInfo )
 {
    if( pItem && hb_arrayLen( pItem ) == UR_ORC_SIZE )
    {
@@ -674,9 +674,9 @@ static BOOL hb_usrItemToOrderCondInfo( PHB_ITEM pItem,
       pOrderCondInfo->fTemporary    = hb_arrayGetL( pItem, UR_ORC_TEMPORARY );
       pOrderCondInfo->fExclusive    = hb_arrayGetL( pItem, UR_ORC_EXCLUSIVE );
       pOrderCondInfo->lpvCargo      = hb_arrayGetPtr( pItem, UR_ORC_CARGO );
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 static void hb_usrOrderCondFree( LPDBORDERCONDINFO pOrderCondInfo )
@@ -742,8 +742,8 @@ static PHB_ITEM hb_usrOrderCreateInfoToItem( LPDBORDERCREATEINFO pOrderCreateInf
    return pItem;
 }
 
-static BOOL hb_usrItemToOrderCreateInfo( PHB_ITEM pItem,
-                                         LPDBORDERCREATEINFO pOrderCreateInfo )
+static HB_BOOL hb_usrItemToOrderCreateInfo( PHB_ITEM pItem,
+                                            LPDBORDERCREATEINFO pOrderCreateInfo )
 {
    if( pItem && hb_arrayLen( pItem ) == UR_ORCR_SIZE )
    {
@@ -756,7 +756,7 @@ static BOOL hb_usrItemToOrderCreateInfo( PHB_ITEM pItem,
          if( !hb_usrItemToOrderCondInfo( pCond, pOrderCondInfo ) )
          {
             hb_xfree( pOrderCondInfo );
-            return FALSE;
+            return HB_FALSE;
          }
          pOrderCreateInfo->lpdbOrdCondInfo = pOrderCondInfo;
       }
@@ -772,9 +772,9 @@ static BOOL hb_usrItemToOrderCreateInfo( PHB_ITEM pItem,
       pOrderCreateInfo->itmCobExpr  = hb_usrArrayGet( pItem, UR_ORCR_BKEY, HB_IT_ANY );
       pOrderCreateInfo->abExpr      = hb_usrArrayGet( pItem, UR_ORCR_CKEY, HB_IT_ANY );
 
-      return TRUE;
+      return HB_TRUE;
    }
-   return FALSE;
+   return HB_FALSE;
 }
 
 static void hb_usrOrderCreateFree( LPDBORDERCREATEINFO pOrderCreateInfo )
@@ -951,7 +951,7 @@ static HB_ERRCODE hb_usrRelease( AREAP pArea )
  * Movement and positioning methods
  */
 
-static HB_ERRCODE hb_usrBof( AREAP pArea, BOOL * pBof )
+static HB_ERRCODE hb_usrBof( AREAP pArea, HB_BOOL * pBof )
 {
    LONG lOffset;
 
@@ -978,7 +978,7 @@ static HB_ERRCODE hb_usrBof( AREAP pArea, BOOL * pBof )
    return hb_usrReturn();
 }
 
-static HB_ERRCODE hb_usrEof( AREAP pArea, BOOL * pEof )
+static HB_ERRCODE hb_usrEof( AREAP pArea, HB_BOOL * pEof )
 {
    LONG lOffset;
 
@@ -1005,7 +1005,7 @@ static HB_ERRCODE hb_usrEof( AREAP pArea, BOOL * pEof )
    return hb_usrReturn();
 }
 
-static HB_ERRCODE hb_usrFound( AREAP pArea, BOOL * pFound )
+static HB_ERRCODE hb_usrFound( AREAP pArea, HB_BOOL * pFound )
 {
    LONG lOffset;
 
@@ -1086,7 +1086,7 @@ static HB_ERRCODE hb_usrGoToId( AREAP pArea, PHB_ITEM pRecNo )
    return hb_usrReturn();
 }
 
-static HB_ERRCODE hb_usrSeek( AREAP pArea, BOOL fSoftSeek, PHB_ITEM pItem, BOOL fFindLast )
+static HB_ERRCODE hb_usrSeek( AREAP pArea, HB_BOOL fSoftSeek, PHB_ITEM pItem, HB_BOOL fFindLast )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_usrSeek(%p,%d,%p,%d)", pArea, fSoftSeek, pItem, fFindLast));
 
@@ -1149,14 +1149,14 @@ static HB_ERRCODE hb_usrSkipRaw( AREAP pArea, LONG lRecords )
  * Data management
  */
 
-static HB_ERRCODE hb_usrDeleted( AREAP pArea, BOOL * pDeleted )
+static HB_ERRCODE hb_usrDeleted( AREAP pArea, HB_BOOL * pDeleted )
 {
    LONG lOffset;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_usrDeleted(%p, %p)", pArea, pDeleted));
 
    lOffset = hb_stackTopOffset() - hb_stackBaseOffset();
-   hb_vmPushLogical( FALSE );
+   hb_vmPushLogical( HB_FALSE );
    if( !hb_usrPushMethod( SELF_USRNODE( pArea )->pMethods, UR_DELETED ) )
    {
       hb_stackPop();
@@ -1239,7 +1239,7 @@ static HB_ERRCODE hb_usrFieldName( AREAP pArea, USHORT uiIndex, char * szName )
    return hb_usrReturn();
 }
 
-static HB_ERRCODE hb_usrAppend( AREAP pArea, BOOL fUnLockAll )
+static HB_ERRCODE hb_usrAppend( AREAP pArea, HB_BOOL fUnLockAll )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_usrAppend(%p, %d)", pArea, fUnLockAll));
 
@@ -1690,14 +1690,14 @@ static HB_ERRCODE hb_usrPack( AREAP pArea )
    return hb_usrReturn();
 }
 
-static HB_ERRCODE hb_usrPackRec( AREAP pArea, ULONG ulRecNo, BOOL * pWritten )
+static HB_ERRCODE hb_usrPackRec( AREAP pArea, ULONG ulRecNo, HB_BOOL * pWritten )
 {
    LONG lOffset;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_usrPackRec(%p,%lu,%p)", pArea, ulRecNo, pWritten));
 
    lOffset = hb_stackTopOffset() - hb_stackBaseOffset();
-   hb_vmPushLogical( TRUE );
+   hb_vmPushLogical( HB_TRUE );
    if( !hb_usrPushMethod( SELF_USRNODE( pArea )->pMethods, UR_PACKREC ) )
    {
       hb_stackPop();
@@ -2278,7 +2278,7 @@ static HB_ERRCODE hb_usrSetLocate( AREAP pArea, LPDBSCOPEINFO pScopeInfo )
    return hb_usrReturn();
 }
 
-static HB_ERRCODE hb_usrLocate( AREAP pArea, BOOL fContinue )
+static HB_ERRCODE hb_usrLocate( AREAP pArea, HB_BOOL fContinue )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_usrLocate(%p,%d)", pArea, fContinue));
 
@@ -3133,7 +3133,7 @@ HB_FUNC_UR_SUPER( BOF )
 
    if( pArea )
    {
-      BOOL fBof;
+      HB_BOOL fBof;
 
       hb_retni( SUPER_BOF( pArea, &fBof ) );
       hb_storl( fBof, 2 );
@@ -3146,7 +3146,7 @@ HB_FUNC_UR_SUPER( EOF )
 
    if( pArea )
    {
-      BOOL fEof;
+      HB_BOOL fEof;
 
       hb_retni( SUPER_EOF( pArea, &fEof ) );
       hb_storl( fEof, 2 );
@@ -3159,7 +3159,7 @@ HB_FUNC_UR_SUPER( FOUND )
 
    if( pArea )
    {
-      BOOL fFound;
+      HB_BOOL fFound;
 
       hb_retni( SUPER_FOUND( pArea, &fFound ) );
       hb_storl( fFound, 2 );
@@ -3237,7 +3237,7 @@ HB_FUNC_UR_SUPER( DELETED )
 
    if( pArea )
    {
-      BOOL fDeleted;
+      HB_BOOL fDeleted;
 
       hb_retni( SUPER_DELETED( pArea, &fDeleted ) );
       hb_storl( fDeleted, 2 );
@@ -3594,7 +3594,7 @@ HB_FUNC_UR_SUPER( PACKREC )
 
    if( pArea )
    {
-      BOOL fWritten;
+      HB_BOOL fWritten;
 
       hb_retni( SUPER_PACKREC( pArea, hb_parnl( 2 ), &fWritten ) );
       hb_storl( fWritten, 3 );
diff --git a/harbour/src/rdd/wacore.c b/harbour/src/rdd/wacore.c
index 5ca1b1d4f5..71616759d0 100644
--- a/harbour/src/rdd/wacore.c
+++ b/harbour/src/rdd/wacore.c
@@ -259,13 +259,13 @@ void hb_rddCloseAll( void )
    pRddInfo = hb_stackRDD();
    if( pRddInfo->uiWaMax > 0 )
    {
-      BOOL isParents, isFinish = FALSE;
+      HB_BOOL isParents, isFinish = HB_FALSE;
       AREAP pArea;
       USHORT uiIndex;
 
       do
       {
-         isParents = FALSE;
+         isParents = HB_FALSE;
          for( uiIndex = 1; uiIndex < pRddInfo->uiWaMax; uiIndex++ )
          {
             pArea = ( AREAP ) pRddInfo->waList[ uiIndex ];
@@ -278,7 +278,7 @@ void hb_rddCloseAll( void )
             }
             else if( pArea->uiParents )
             {
-               isParents = TRUE;
+               isParents = HB_TRUE;
             }
             else
             {
@@ -287,7 +287,7 @@ void hb_rddCloseAll( void )
          }
          if( !isParents && !isFinish )
          {
-            isParents = isFinish = TRUE;
+            isParents = isFinish = HB_TRUE;
          }
       }
       while( isParents );
@@ -352,12 +352,12 @@ HB_ERRCODE hb_rddIterateWorkAreas( WACALLBACK pCallBack, void * cargo )
    return errCode;
 }
 
-BOOL hb_rddGetNetErr( void )
+HB_BOOL hb_rddGetNetErr( void )
 {
    return hb_stackRDD()->fNetError;
 }
 
-void hb_rddSetNetErr( BOOL fNetErr )
+void hb_rddSetNetErr( HB_BOOL fNetErr )
 {
    hb_stackRDD()->fNetError = fNetErr;
 }
@@ -574,7 +574,7 @@ HB_ERRCODE hb_rddDetachArea( AREAP pArea, PHB_ITEM pCargo )
 }
 
 AREAP hb_rddRequestArea( const char * szAlias, PHB_ITEM pCargo,
-                         BOOL fNewArea, BOOL fWait )
+                         HB_BOOL fNewArea, HB_BOOL fWait )
 {
    PHB_DYNS pSymAlias = NULL;
    AREAP pArea = NULL;
diff --git a/harbour/src/rdd/wafunc.c b/harbour/src/rdd/wafunc.c
index 0a9155112d..5e06feac7d 100644
--- a/harbour/src/rdd/wafunc.c
+++ b/harbour/src/rdd/wafunc.c
@@ -308,7 +308,7 @@ USHORT hb_rddFieldExpIndex( AREAP pArea, const char * szField )
  */
 HB_ERRCODE hb_rddGetAliasNumber( const char * szAlias, int * iArea )
 {
-   BOOL fOneLetter;
+   HB_BOOL fOneLetter;
    char c;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_rddGetAliasNumber(%s, %p)", szAlias, iArea));
@@ -585,7 +585,7 @@ HB_ERRCODE hb_rddPutFieldValue( HB_ITEM_PTR pItem, PHB_SYMB pFieldSymbol )
 
 HB_ERRCODE hb_rddOpenTable( const char * szFileName, const char * szDriver,
                             USHORT uiArea, const char *szAlias,
-                            BOOL fShared, BOOL fReadonly,
+                            HB_BOOL fShared, HB_BOOL fReadonly,
                             const char * szCpId, ULONG ulConnection,
                             PHB_ITEM pStruct, PHB_ITEM pDelim )
 {
@@ -611,7 +611,7 @@ HB_ERRCODE hb_rddOpenTable( const char * szFileName, const char * szDriver,
 
    /* Clipper clears NETERR flag before parameter validation, [druzus]
     */
-   hb_rddSetNetErr( FALSE );
+   hb_rddSetNetErr( HB_FALSE );
 
    /* Now check parameters, first RDD name.
     * Clipper seems to make sth like:
@@ -673,7 +673,7 @@ HB_ERRCODE hb_rddOpenTable( const char * szFileName, const char * szDriver,
 
 HB_ERRCODE hb_rddCreateTable( const char * szFileName, const char * szDriver,
                               USHORT uiArea, const char *szAlias,
-                              BOOL fKeepOpen,
+                              HB_BOOL fKeepOpen,
                               const char * szCpId, ULONG ulConnection,
                               PHB_ITEM pStruct, PHB_ITEM pDelim )
 {
@@ -717,8 +717,8 @@ HB_ERRCODE hb_rddCreateTable( const char * szFileName, const char * szDriver,
    pInfo.uiArea = pArea->uiArea;
    pInfo.abName = szFileName;
    pInfo.atomAlias = szAlias;
-   pInfo.fShared = FALSE;
-   pInfo.fReadonly = FALSE;
+   pInfo.fShared = HB_FALSE;
+   pInfo.fReadonly = HB_FALSE;
    pInfo.cdpId = szCpId ? szCpId : hb_setGetDBCODEPAGE();
    pInfo.ulConnection = ulConnection;
    pInfo.lpdbHeader = NULL;
@@ -782,13 +782,13 @@ HB_ERRCODE hb_rddCreateTableTemp( const char * szDriver,
    pInfo.uiArea = pArea->uiArea;
    pInfo.abName = NULL;
    pInfo.atomAlias = szAlias;
-   pInfo.fShared = FALSE;
-   pInfo.fReadonly = FALSE;
+   pInfo.fShared = HB_FALSE;
+   pInfo.fReadonly = HB_FALSE;
    pInfo.cdpId = szCpId ? szCpId : hb_setGetDBCODEPAGE();
    pInfo.ulConnection = ulConnection;
    pInfo.lpdbHeader = NULL;
 
-   pItem = hb_itemPutL( NULL, TRUE );
+   pItem = hb_itemPutL( NULL, HB_TRUE );
    errCode = SELF_INFO( pArea, DBI_ISTEMPORARY, pItem );
    hb_itemRelease( pItem );
 
@@ -876,7 +876,7 @@ HB_ERRCODE hb_dbTransStruct( AREAP lpaSource, AREAP lpaDest,
    USHORT uiFields, uiSize, uiCount, uiPosSrc, uiPosDst, uiSizeSrc, uiSizeDst;
    HB_ERRCODE errCode;
    const char * szField;
-   BOOL fAll;
+   HB_BOOL fAll;
 
    errCode = SELF_FIELDCOUNT( lpaSource, &uiSizeSrc );
    if( errCode != HB_SUCCESS )
@@ -934,7 +934,7 @@ HB_ERRCODE hb_dbTransStruct( AREAP lpaSource, AREAP lpaDest,
             szField = hb_itemGetCPtr( pItem );
             uiPosDst = hb_rddFieldExpIndex( lpaDest, szField );
             if( uiPosDst != uiCount )
-               fAll = FALSE;
+               fAll = HB_FALSE;
             if( uiPosDst )
             {
                USHORT ui;
@@ -983,7 +983,7 @@ HB_ERRCODE hb_dbTransStruct( AREAP lpaSource, AREAP lpaDest,
             if( uiPosDst )
             {
                if( uiPosSrc != uiPosDst )
-                  fAll = FALSE;
+                  fAll = HB_FALSE;
                lpdbTransInfo->lpTransItems[ uiSize ].uiSource = uiPosSrc;
                lpdbTransInfo->lpTransItems[ uiSize++ ].uiDest = uiPosDst;
                if( !lpaDest )
@@ -998,14 +998,14 @@ HB_ERRCODE hb_dbTransStruct( AREAP lpaSource, AREAP lpaDest,
    }
 
    if( uiSize != uiSizeSrc )
-      fAll = FALSE;
+      fAll = HB_FALSE;
 
    if( fAll && lpaDest )
    {
       PHB_ITEM pSrcItm = hb_itemNew( NULL ),
                pDstItm = hb_itemNew( NULL );
       /*
-       * if fAll is TRUE here then it means that all fields are included
+       * if fAll is HB_TRUE here then it means that all fields are included
        * and they are on the same positions in both tables, so now check
        * if their types and sizes are also equal
        */
@@ -1020,7 +1020,7 @@ HB_ERRCODE hb_dbTransStruct( AREAP lpaSource, AREAP lpaDest,
          if( hb_stricmp( hb_itemGetCPtr( pSrcItm ),
                          hb_itemGetCPtr( pDstItm ) ) != 0 )
          {
-            fAll = FALSE;
+            fAll = HB_FALSE;
             break;
          }
          if( SELF_FIELDINFO( lpaSource, uiCount, DBS_LEN, pSrcItm ) != HB_SUCCESS ||
@@ -1031,7 +1031,7 @@ HB_ERRCODE hb_dbTransStruct( AREAP lpaSource, AREAP lpaDest,
          }
          if( hb_itemGetNL( pSrcItm ) != hb_itemGetNL( pDstItm ) )
          {
-            fAll = FALSE;
+            fAll = HB_FALSE;
             break;
          }
          if( SELF_FIELDINFO( lpaSource, uiCount, DBS_DEC, pSrcItm ) != HB_SUCCESS ||
@@ -1042,7 +1042,7 @@ HB_ERRCODE hb_dbTransStruct( AREAP lpaSource, AREAP lpaDest,
          }
          if( hb_itemGetNL( pSrcItm ) != hb_itemGetNL( pDstItm ) )
          {
-            fAll = FALSE;
+            fAll = HB_FALSE;
             break;
          }
 #ifdef DBS_FLAG
@@ -1055,7 +1055,7 @@ HB_ERRCODE hb_dbTransStruct( AREAP lpaSource, AREAP lpaDest,
 #endif
          if( hb_itemGetNL( pSrcItm ) != hb_itemGetNL( pDstItm ) )
          {
-            fAll = FALSE;
+            fAll = HB_FALSE;
             break;
          }
       }
@@ -1070,15 +1070,15 @@ HB_ERRCODE hb_dbTransStruct( AREAP lpaSource, AREAP lpaDest,
 }
 
 HB_ERRCODE hb_rddTransRecords( AREAP pArea,
-                            const char *szFileName, const char *szDriver,
-                            ULONG ulConnection,
-                            PHB_ITEM pFields, BOOL fExport,
-                            PHB_ITEM pCobFor, PHB_ITEM pStrFor,
-                            PHB_ITEM pCobWhile, PHB_ITEM pStrWhile,
-                            PHB_ITEM pNext, PHB_ITEM pRecID,
-                            PHB_ITEM pRest,
-                            const char *szCpId,
-                            PHB_ITEM pDelim )
+                               const char *szFileName, const char *szDriver,
+                               ULONG ulConnection,
+                               PHB_ITEM pFields, HB_BOOL fExport,
+                               PHB_ITEM pCobFor, PHB_ITEM pStrFor,
+                               PHB_ITEM pCobWhile, PHB_ITEM pStrWhile,
+                               PHB_ITEM pNext, PHB_ITEM pRecID,
+                               PHB_ITEM pRest,
+                               const char *szCpId,
+                               PHB_ITEM pDelim )
 {
    AREAP lpaClose = NULL;
    PHB_ITEM pStruct = NULL;
@@ -1100,7 +1100,7 @@ HB_ERRCODE hb_rddTransRecords( AREAP pArea,
       if( errCode == HB_SUCCESS )
       {
          errCode = hb_rddCreateTable( szFileName, szDriver, 0, "",
-                                      TRUE,
+                                      HB_TRUE,
                                       szCpId, ulConnection, pStruct, pDelim );
          if( errCode == HB_SUCCESS )
          {
@@ -1136,7 +1136,7 @@ HB_ERRCODE hb_rddTransRecords( AREAP pArea,
 
          if( errCode == HB_SUCCESS )
          {
-            errCode = hb_rddOpenTable( szFileName, szDriver, 0, "", TRUE, TRUE,
+            errCode = hb_rddOpenTable( szFileName, szDriver, 0, "", HB_TRUE, HB_TRUE,
                                        szCpId, ulConnection, pStruct, pDelim );
             if( errCode == HB_SUCCESS )
             {
@@ -1147,7 +1147,7 @@ HB_ERRCODE hb_rddTransRecords( AREAP pArea,
       }
       else
       {
-         errCode = hb_rddOpenTable( szFileName, szDriver, 0, "", TRUE, TRUE,
+         errCode = hb_rddOpenTable( szFileName, szDriver, 0, "", HB_TRUE, HB_TRUE,
                                     szCpId, ulConnection, NULL, pDelim );
          if( errCode == HB_SUCCESS )
          {
@@ -1173,11 +1173,11 @@ HB_ERRCODE hb_rddTransRecords( AREAP pArea,
       dbTransInfo.dbsci.itmRecID    = pRecID;
       dbTransInfo.dbsci.fRest       = pRest;
 
-      dbTransInfo.dbsci.fIgnoreFilter     = TRUE;
-      dbTransInfo.dbsci.fIncludeDeleted   = TRUE;
-      dbTransInfo.dbsci.fLast             = FALSE;
-      dbTransInfo.dbsci.fIgnoreDuplicates = FALSE;
-      dbTransInfo.dbsci.fBackward         = FALSE;
+      dbTransInfo.dbsci.fIgnoreFilter     = HB_TRUE;
+      dbTransInfo.dbsci.fIncludeDeleted   = HB_TRUE;
+      dbTransInfo.dbsci.fLast             = HB_FALSE;
+      dbTransInfo.dbsci.fIgnoreDuplicates = HB_FALSE;
+      dbTransInfo.dbsci.fBackward         = HB_FALSE;
 
       errCode = SELF_TRANS( dbTransInfo.lpaSource, &dbTransInfo );
    }
diff --git a/harbour/src/rdd/workarea.c b/harbour/src/rdd/workarea.c
index 71837e517b..96ae4382e1 100644
--- a/harbour/src/rdd/workarea.c
+++ b/harbour/src/rdd/workarea.c
@@ -72,7 +72,7 @@
 /*
  * Determine logical beginning of file.
  */
-static HB_ERRCODE hb_waBof( AREAP pArea, BOOL * pBof )
+static HB_ERRCODE hb_waBof( AREAP pArea, HB_BOOL * pBof )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_waBof(%p, %p)", pArea, pBof));
 
@@ -83,7 +83,7 @@ static HB_ERRCODE hb_waBof( AREAP pArea, BOOL * pBof )
 /*
  * Determine logical end of file.
  */
-static HB_ERRCODE hb_waEof( AREAP pArea, BOOL * pEof )
+static HB_ERRCODE hb_waEof( AREAP pArea, HB_BOOL * pEof )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_waEof(%p, %p)", pArea, pEof));
 
@@ -94,7 +94,7 @@ static HB_ERRCODE hb_waEof( AREAP pArea, BOOL * pEof )
 /*
  * Determine outcome of the last search operation.
  */
-static HB_ERRCODE hb_waFound( AREAP pArea, BOOL * pFound )
+static HB_ERRCODE hb_waFound( AREAP pArea, HB_BOOL * pFound )
 {
    HB_TRACE(HB_TR_DEBUG, ("hb_waFound(%p, %p)", pArea, pFound));
 
@@ -115,7 +115,7 @@ static HB_ERRCODE hb_waSkip( AREAP pArea, LONG lToSkip )
    if( lToSkip == 0 )
       return SELF_SKIPRAW( pArea, 0 );
 
-   pArea->fTop = pArea->fBottom = FALSE;
+   pArea->fTop = pArea->fBottom = HB_FALSE;
 
    if( lToSkip > 0 )
       lSkip = 1;
@@ -136,9 +136,9 @@ static HB_ERRCODE hb_waSkip( AREAP pArea, LONG lToSkip )
 
    /* Update Bof and Eof flags */
    if( lSkip < 0 )
-      pArea->fEof = FALSE;
+      pArea->fEof = HB_FALSE;
    else /* ( lSkip > 0 ) */
-      pArea->fBof = FALSE;
+      pArea->fBof = HB_FALSE;
 
    return HB_SUCCESS;
 }
@@ -148,7 +148,7 @@ static HB_ERRCODE hb_waSkip( AREAP pArea, LONG lToSkip )
  */
 static HB_ERRCODE hb_waSkipFilter( AREAP pArea, LONG lUpDown )
 {
-   BOOL fBottom, fDeleted;
+   HB_BOOL fBottom, fDeleted;
    HB_ERRCODE errCode;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_waSkipFilter(%p, %ld)", pArea, lUpDown));
@@ -222,7 +222,7 @@ static HB_ERRCODE hb_waSkipFilter( AREAP pArea, LONG lUpDown )
       else
       {
          errCode = SELF_GOTOP( pArea );
-         pArea->fBof = TRUE;
+         pArea->fBof = HB_TRUE;
       }
    }
    else
@@ -689,7 +689,7 @@ static HB_ERRCODE hb_waInfo( AREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
       case DBI_CANPUTREC:
       case DBI_ISFLOCK:
       case DBI_SHARED:
-         hb_itemPutL( pItem, FALSE );
+         hb_itemPutL( pItem, HB_FALSE );
          break;
 
       /*
@@ -769,7 +769,7 @@ static HB_ERRCODE hb_waInfo( AREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
       case DBI_SCOPEDRELATION:
       {
          int iRelNo = hb_itemGetNI( pItem );
-         BOOL fScoped = FALSE;
+         HB_BOOL fScoped = HB_FALSE;
 
          if( iRelNo > 0 )
          {
@@ -793,7 +793,7 @@ static HB_ERRCODE hb_waInfo( AREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
          if( SELF_RECNO( pArea, &ulRecNo ) != HB_SUCCESS )
             return HB_FAILURE;
          if( ulRecNo == 0 )
-            hb_itemPutL( pItem, FALSE );
+            hb_itemPutL( pItem, HB_FALSE );
          else if( SELF_RECCOUNT( pArea, &ulRecCount ) != HB_SUCCESS )
             return HB_FAILURE;
          else
@@ -801,7 +801,7 @@ static HB_ERRCODE hb_waInfo( AREAP pArea, USHORT uiIndex, PHB_ITEM pItem )
          break;
       }
       case DBI_RM_SUPPORTED:
-         hb_itemPutL( pItem, FALSE );
+         hb_itemPutL( pItem, HB_FALSE );
          break;
 
       case DBI_DB_VERSION:
@@ -959,7 +959,7 @@ static HB_ERRCODE hb_waSysName( AREAP pArea, char * pBuffer )
 static HB_ERRCODE hb_waEval( AREAP pArea, LPDBEVALINFO pEvalInfo )
 {
    LONG lNext = 1;
-   BOOL fEof, fFor;
+   HB_BOOL fEof, fFor;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_waEval(%p, %p)", pArea, pEvalInfo));
 
@@ -1006,7 +1006,7 @@ static HB_ERRCODE hb_waEval( AREAP pArea, LPDBEVALINFO pEvalInfo )
             fFor = hb_itemGetL( pArea->valResult );
          }
          else
-            fFor = TRUE;
+            fFor = HB_TRUE;
 
          if( fFor )
          {
@@ -1028,10 +1028,10 @@ static HB_ERRCODE hb_waEval( AREAP pArea, LPDBEVALINFO pEvalInfo )
 /*
  * Locate a record which pass given condition
  */
-static HB_ERRCODE hb_waLocate( AREAP pArea, BOOL fContinue )
+static HB_ERRCODE hb_waLocate( AREAP pArea, HB_BOOL fContinue )
 {
    LONG lNext = 1;
-   BOOL fEof;
+   HB_BOOL fEof;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_waLocate(%p, %d)", pArea, fContinue));
 
@@ -1059,7 +1059,7 @@ static HB_ERRCODE hb_waLocate( AREAP pArea, BOOL fContinue )
          return HB_FAILURE;
    }
 
-   pArea->fFound = FALSE;
+   pArea->fFound = HB_FALSE;
 
    /* TODO: use SKIPSCOPE() method and fRest parameter */
 
@@ -1083,7 +1083,7 @@ static HB_ERRCODE hb_waLocate( AREAP pArea, BOOL fContinue )
 
          if( ! pArea->dbsi.itmCobFor )
          {
-            pArea->fFound = TRUE;
+            pArea->fFound = HB_TRUE;
             break;
          }
          else
@@ -1093,7 +1093,7 @@ static HB_ERRCODE hb_waLocate( AREAP pArea, BOOL fContinue )
 
             if( hb_itemGetL( pArea->valResult ) )
             {
-               pArea->fFound = TRUE;
+               pArea->fFound = HB_TRUE;
                break;
             }
          }
@@ -1116,7 +1116,7 @@ static HB_ERRCODE hb_waLocate( AREAP pArea, BOOL fContinue )
 static HB_ERRCODE hb_waTrans( AREAP pArea, LPDBTRANSINFO pTransInfo )
 {
    LONG lNext = 1;
-   BOOL fEof, fFor;
+   HB_BOOL fEof, fFor;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_waTrans(%p, %p)", pArea, pTransInfo));
 
@@ -1163,7 +1163,7 @@ static HB_ERRCODE hb_waTrans( AREAP pArea, LPDBTRANSINFO pTransInfo )
             fFor = hb_itemGetL( pArea->valResult );
          }
          else
-            fFor = TRUE;
+            fFor = HB_TRUE;
 
          if( fFor )
          {
@@ -1187,7 +1187,7 @@ static HB_ERRCODE hb_waTrans( AREAP pArea, LPDBTRANSINFO pTransInfo )
  */
 static HB_ERRCODE hb_waTransRec( AREAP pArea, LPDBTRANSINFO pTransInfo )
 {
-   BOOL bDeleted;
+   HB_BOOL bDeleted;
    BYTE *pRecord;
    HB_ERRCODE errCode;
 
@@ -1205,7 +1205,7 @@ static HB_ERRCODE hb_waTransRec( AREAP pArea, LPDBTRANSINFO pTransInfo )
          return errCode;
 
       /* Append a new record */
-      errCode = SELF_APPEND( ( AREAP ) pTransInfo->lpaDest, TRUE );
+      errCode = SELF_APPEND( ( AREAP ) pTransInfo->lpaDest, HB_TRUE );
       if( errCode != HB_SUCCESS )
          return errCode;
 
@@ -1219,7 +1219,7 @@ static HB_ERRCODE hb_waTransRec( AREAP pArea, LPDBTRANSINFO pTransInfo )
       USHORT uiCount;
 
       /* Append a new record */
-      errCode = SELF_APPEND( ( AREAP ) pTransInfo->lpaDest, TRUE );
+      errCode = SELF_APPEND( ( AREAP ) pTransInfo->lpaDest, HB_TRUE );
       if( errCode != HB_SUCCESS )
          return errCode;
 
@@ -1380,7 +1380,7 @@ static HB_ERRCODE hb_waRelEval( AREAP pArea, LPDBRELINFO pRelInfo )
    DBORDERINFO pInfo;
    HB_ERRCODE errCode;
    int iOrder;
-   BOOL fEof;
+   HB_BOOL fEof;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_waRelEval(%p, %p)", pArea, pRelInfo));
 
@@ -1416,7 +1416,7 @@ static HB_ERRCODE hb_waRelEval( AREAP pArea, LPDBRELINFO pRelInfo )
                         errCode = SELF_ORDINFO( pArea, DBOI_SCOPEBOTTOM, &pInfo );
                   }
                   if( errCode == HB_SUCCESS )
-                     errCode = SELF_SEEK( pArea, FALSE, pResult, FALSE );
+                     errCode = SELF_SEEK( pArea, HB_FALSE, pResult, HB_FALSE );
                }
                else
                {
@@ -1518,8 +1518,8 @@ static HB_ERRCODE hb_waClearFilter( AREAP pArea )
       hb_itemRelease( pArea->dbfi.abFilterText );
       pArea->dbfi.abFilterText = NULL;
    }
-   pArea->dbfi.fOptimized = FALSE;
-   pArea->dbfi.fFilter = FALSE;
+   pArea->dbfi.fOptimized = HB_FALSE;
+   pArea->dbfi.fFilter = HB_FALSE;
 
    return HB_SUCCESS;
 }
@@ -1604,7 +1604,7 @@ static HB_ERRCODE hb_waSetFilter( AREAP pArea, LPDBFILTERINFO pFilterInfo )
       pArea->dbfi.abFilterText = hb_itemNew( pFilterInfo->abFilterText );
    }
    pArea->dbfi.fOptimized = pFilterInfo->fOptimized;
-   pArea->dbfi.fFilter = TRUE;
+   pArea->dbfi.fFilter = HB_TRUE;
 
    return HB_SUCCESS;
 }
@@ -1722,7 +1722,7 @@ static HB_ERRCODE hb_waEvalBlock( AREAP pArea, PHB_ITEM pBlock )
  */
 static HB_ERRCODE hb_waRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnection, PHB_ITEM pItem )
 {
-   BOOL fResult;
+   HB_BOOL fResult;
    int iResult;
 
    HB_TRACE(HB_TR_DEBUG, ("hb_rddInfo(%p, %hu, %lu, %p)", pRDD, uiIndex, ulConnection, pItem));
@@ -1745,7 +1745,7 @@ static HB_ERRCODE hb_waRddInfo( LPRDDNODE pRDD, USHORT uiIndex, ULONG ulConnecti
       case RDDI_SORTRECNO:
       case RDDI_MULTIKEY:
       case RDDI_BLOB_SUPPORT:
-         hb_itemPutL( pItem, FALSE );
+         hb_itemPutL( pItem, HB_FALSE );
          break;
 
       case RDDI_CONNECTION: