rebase to DEV300_m100

author: Philipp Lohmann [pl] <Philipp.Lohmann@Oracle.COM> 2011-02-14 16:17:22 +0100
committer: Philipp Lohmann [pl] <Philipp.Lohmann@Oracle.COM> 2011-02-14 16:17:22 +0100
commit: 1fb042333fe6287756ff1fac11d18cd7c150730d (patch)
tree: 595de5d187177832ce656d7832af9dce9dce2d99 /connectivity/source/drivers/dbase
parent: 5b3e910e926c7dd1e8dcfe8e0a5c6cb5bd17480a (diff)
parent: cd0d6a5a6775f197fdb7e78b54c8133074a7a236 (diff)
7 files changed, 277 insertions, 277 deletions
diff --git a/connectivity/source/drivers/dbase/DCode.cxx b/connectivity/source/drivers/dbase/DCode.cxx
index d292c7ab5291..8c826766b2c4 100644
--- a/connectivity/source/drivers/dbase/DCode.cxx
+++ b/connectivity/source/drivers/dbase/DCode.cxx
@@ -114,7 +114,7 @@ OEvaluateSet* OFILEOperandAttr::preProcess(OBoolOperator* pOp, OOperand* pRight)
                 if (pIter)
                 {
                     pEvaluateSet = new OEvaluateSet();
-                    ULONG nRec = pIter->First();
+                    sal_uIntPtr nRec = pIter->First();
                     while (nRec != NODE_NOTFOUND)
                     {
                         (*pEvaluateSet)[nRec] = nRec;
diff --git a/connectivity/source/drivers/dbase/DIndex.cxx b/connectivity/source/drivers/dbase/DIndex.cxx
index c7e64beeef1a..cd11204b3570 100644
--- a/connectivity/source/drivers/dbase/DIndex.cxx
+++ b/connectivity/source/drivers/dbase/DIndex.cxx
@@ -67,7 +67,7 @@ using namespace com::sun::star::lang;
 
 IMPLEMENT_SERVICE_INFO(ODbaseIndex,"com.sun.star.sdbcx.driver.dbase.Index","com.sun.star.sdbcx.Index");
 // -------------------------------------------------------------------------
-ODbaseIndex::ODbaseIndex(ODbaseTable* _pTable) : OIndex(sal_True/*_pTable->getConnection()->getMetaData()->storesMixedCaseQuotedIdentifiers()*/)
+ODbaseIndex::ODbaseIndex(ODbaseTable* _pTable) : OIndex(sal_True/*_pTable->getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers()*/)
     ,m_pFileStream(NULL)
     ,m_nCurNode(NODE_NOTFOUND)
     ,m_pTable(_pTable)
@@ -80,7 +80,7 @@ ODbaseIndex::ODbaseIndex(ODbaseTable* _pTable) : OIndex(sal_True/*_pTable->getCo
 ODbaseIndex::ODbaseIndex(   ODbaseTable* _pTable,
                             const NDXHeader& _rHeader,
                             const ::rtl::OUString& _rName)
-    :OIndex(_rName,::rtl::OUString(),_rHeader.db_unique,sal_False,sal_False,sal_True) // _pTable->getConnection()->getMetaData()->storesMixedCaseQuotedIdentifiers()
+    :OIndex(_rName,::rtl::OUString(),_rHeader.db_unique,sal_False,sal_False,sal_True) // _pTable->getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers()
     ,m_pFileStream(NULL)
     ,m_aHeader(_rHeader)
     ,m_nCurNode(NODE_NOTFOUND)
@@ -143,7 +143,7 @@ ONDXPagePtr ODbaseIndex::getRoot()
     {
         m_nRootPage = m_aHeader.db_rootpage;
         m_nPageCount = m_aHeader.db_pagecount;
-        m_aRoot = CreatePage(m_nRootPage,NULL,TRUE);
+        m_aRoot = CreatePage(m_nRootPage,NULL,sal_True);
     }
     return m_aRoot;
 }
@@ -185,7 +185,7 @@ OIndexIterator* ODbaseIndex::createIterator(OBoolOperator* pOp,
     return new OIndexIterator(this, pOp, pOperand);
 }
 //------------------------------------------------------------------
-BOOL ODbaseIndex::ConvertToKey(ONDXKey* rKey, sal_uInt32 nRec, const ORowSetValue& rValue)
+sal_Bool ODbaseIndex::ConvertToKey(ONDXKey* rKey, sal_uInt32 nRec, const ORowSetValue& rValue)
 {
     OSL_ENSURE(m_pFileStream,"FileStream is not opened!");
     // Sucht ein bestimmten Wert im Index
@@ -207,13 +207,13 @@ BOOL ODbaseIndex::ConvertToKey(ONDXKey* rKey, sal_uInt32 nRec, const ORowSetValu
     catch (Exception&)
     {
         OSL_ASSERT(0);
-        return FALSE;
+        return sal_False;
     }
-    return TRUE;
+    return sal_True;
 }
 
 //------------------------------------------------------------------
-BOOL ODbaseIndex::Find(sal_uInt32 nRec, const ORowSetValue& rValue)
+sal_Bool ODbaseIndex::Find(sal_uInt32 nRec, const ORowSetValue& rValue)
 {
     openIndexFile();
     OSL_ENSURE(m_pFileStream,"FileStream is not opened!");
@@ -224,7 +224,7 @@ BOOL ODbaseIndex::Find(sal_uInt32 nRec, const ORowSetValue& rValue)
 }
 
 //------------------------------------------------------------------
-BOOL ODbaseIndex::Insert(sal_uInt32 nRec, const ORowSetValue& rValue)
+sal_Bool ODbaseIndex::Insert(sal_uInt32 nRec, const ORowSetValue& rValue)
 {
     openIndexFile();
     OSL_ENSURE(m_pFileStream,"FileStream is not opened!");
@@ -233,35 +233,35 @@ BOOL ODbaseIndex::Insert(sal_uInt32 nRec, const ORowSetValue& rValue)
     // Existiert der Wert bereits
     // Find immer verwenden um das aktuelle Blatt zu bestimmen
     if (!ConvertToKey(&aKey, nRec, rValue) || (getRoot()->Find(aKey) && isUnique()))
-        return FALSE;
+        return sal_False;
 
     ONDXNode aNewNode(aKey);
 
     // einfuegen in das aktuelle Blatt
     if (!m_aCurLeaf.Is())
-        return FALSE;
+        return sal_False;
 
-    BOOL bResult = m_aCurLeaf->Insert(aNewNode);
+    sal_Bool bResult = m_aCurLeaf->Insert(aNewNode);
     Release(bResult);
 
     return bResult;
 }
 
 //------------------------------------------------------------------
-BOOL ODbaseIndex::Update(sal_uInt32 nRec, const ORowSetValue& rOldValue,
+sal_Bool ODbaseIndex::Update(sal_uInt32 nRec, const ORowSetValue& rOldValue,
                          const ORowSetValue& rNewValue)
 {
     openIndexFile();
     OSL_ENSURE(m_pFileStream,"FileStream is not opened!");
     ONDXKey aKey;
     if (!ConvertToKey(&aKey, nRec, rNewValue) || (isUnique() && getRoot()->Find(aKey)))
-        return FALSE;
+        return sal_False;
     else
         return Delete(nRec, rOldValue) && Insert(nRec,rNewValue);
 }
 
 //------------------------------------------------------------------
-BOOL ODbaseIndex::Delete(sal_uInt32 nRec, const ORowSetValue& rValue)
+sal_Bool ODbaseIndex::Delete(sal_uInt32 nRec, const ORowSetValue& rValue)
 {
     openIndexFile();
     OSL_ENSURE(m_pFileStream,"FileStream is not opened!");
@@ -269,13 +269,13 @@ BOOL ODbaseIndex::Delete(sal_uInt32 nRec, const ORowSetValue& rValue)
     // Find immer verwenden um das aktuelle Blatt zu bestimmen
     ONDXKey aKey;
     if (!ConvertToKey(&aKey, nRec, rValue) || !getRoot()->Find(aKey))
-        return FALSE;
+        return sal_False;
 
     ONDXNode aNewNode(aKey);
 
     // einfuegen in das aktuelle Blatt
     if (!m_aCurLeaf.Is())
-        return FALSE;
+        return sal_False;
 #if OSL_DEBUG_LEVEL > 1
     m_aRoot->PrintPage();
 #endif
@@ -289,10 +289,10 @@ void ODbaseIndex::Collect(ONDXPage* pPage)
         m_aCollector.push_back(pPage);
 }
 //------------------------------------------------------------------
-void ODbaseIndex::Release(BOOL bSave)
+void ODbaseIndex::Release(sal_Bool bSave)
 {
     // Freigeben der Indexressourcen
-    m_bUseCollector = FALSE;
+    m_bUseCollector = sal_False;
 
     if (m_aCurLeaf.Is())
     {
@@ -307,7 +307,7 @@ void ODbaseIndex::Release(BOOL bSave)
         m_aRoot.Clear();
     }
     // alle Referenzen freigeben, bevor der FileStream geschlossen wird
-    for (ULONG i = 0; i < m_aCollector.size(); i++)
+    for (sal_uIntPtr i = 0; i < m_aCollector.size(); i++)
         m_aCollector[i]->QueryDelete();
 
     m_aCollector.clear();
@@ -335,7 +335,7 @@ void ODbaseIndex::closeImpl()
     }
 }
 //------------------------------------------------------------------
-ONDXPage* ODbaseIndex::CreatePage(sal_uInt32 nPagePos, ONDXPage* pParent, BOOL bLoad)
+ONDXPage* ODbaseIndex::CreatePage(sal_uInt32 nPagePos, ONDXPage* pParent, sal_Bool bLoad)
 {
     OSL_ENSURE(m_pFileStream,"FileStream is not opened!");
 
@@ -412,14 +412,14 @@ void ODbaseIndex::createINFEntry()
     Config aInfFile(sPhysicalPath);
     aInfFile.SetGroup(dBASE_III_GROUP);
 
-    USHORT nSuffix = aInfFile.GetKeyCount();
+    sal_uInt16 nSuffix = aInfFile.GetKeyCount();
     ByteString aNewEntry,aKeyName;
-    BOOL bCase = isCaseSensitive();
+    sal_Bool bCase = isCaseSensitive();
     while (!aNewEntry.Len())
     {
         aNewEntry = "NDX";
         aNewEntry += ByteString::CreateFromInt32(++nSuffix);
-        for (USHORT i = 0; i < aInfFile.GetKeyCount(); i++)
+        for (sal_uInt16 i = 0; i < aInfFile.GetKeyCount(); i++)
         {
             aKeyName = aInfFile.GetKeyName(i);
             if (bCase ? aKeyName == aNewEntry : aKeyName.EqualsIgnoreCaseAscii(aNewEntry))
@@ -432,7 +432,7 @@ void ODbaseIndex::createINFEntry()
     aInfFile.WriteKey(aNewEntry,ByteString(sEntry,m_pTable->getConnection()->getTextEncoding()));
 }
 // -------------------------------------------------------------------------
-BOOL ODbaseIndex::DropImpl()
+sal_Bool ODbaseIndex::DropImpl()
 {
     closeImpl();
 
@@ -456,13 +456,13 @@ BOOL ODbaseIndex::DropImpl()
 
     Config aInfFile(sPhysicalPath);
     aInfFile.SetGroup(dBASE_III_GROUP);
-    USHORT nKeyCnt = aInfFile.GetKeyCount();
+    sal_uInt16 nKeyCnt = aInfFile.GetKeyCount();
     ByteString aKeyName;
     String sEntry = m_Name;
     sEntry += String::CreateFromAscii(".ndx");
 
     // delete entries from the inf file
-    for (USHORT nKey = 0; nKey < nKeyCnt; nKey++)
+    for (sal_uInt16 nKey = 0; nKey < nKeyCnt; nKey++)
     {
         // Verweist der Key auf ein Indexfile?...
         aKeyName = aInfFile.GetKeyName( nKey );
@@ -475,7 +475,7 @@ BOOL ODbaseIndex::DropImpl()
             }
         }
     }
-    return TRUE;
+    return sal_True;
 }
 // -------------------------------------------------------------------------
 void ODbaseIndex::impl_killFileAndthrowError_throw(sal_uInt16 _nErrorId,const ::rtl::OUString& _sFile)
@@ -486,7 +486,7 @@ void ODbaseIndex::impl_killFileAndthrowError_throw(sal_uInt16 _nErrorId,const ::
     m_pTable->getConnection()->throwGenericSQLException(_nErrorId,*this);
 }
 //------------------------------------------------------------------
-BOOL ODbaseIndex::CreateImpl()
+sal_Bool ODbaseIndex::CreateImpl()
 {
     // Anlegen des Index
     const ::rtl::OUString sFile = getCompletePath();
@@ -515,7 +515,7 @@ BOOL ODbaseIndex::CreateImpl()
 //              String::CreateFromAscii("01000"),
 //              aStatus.CreateErrorMessage(aText),
 //              0, String() );
-//      return FALSE;
+//      return sal_False;
 //  }
 
     // create the index file
@@ -586,7 +586,7 @@ BOOL ODbaseIndex::CreateImpl()
     xTableCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE)) >>= nType;
 
     m_aHeader.db_keytype = (nType == DataType::VARCHAR || nType == DataType::CHAR) ? 0 : 1;
-    m_aHeader.db_keylen  = (m_aHeader.db_keytype) ? 8 : (USHORT)getINT32(xTableCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION)));
+    m_aHeader.db_keylen  = (m_aHeader.db_keytype) ? 8 : (sal_uInt16)getINT32(xTableCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_PRECISION)));
     m_aHeader.db_keylen = (( m_aHeader.db_keylen - 1) / 4 + 1) * 4;
     m_aHeader.db_maxkeys = (PAGE_SIZE - 4) / (8 + m_aHeader.db_keylen);
     if ( m_aHeader.db_maxkeys < 3 )
@@ -597,7 +597,7 @@ BOOL ODbaseIndex::CreateImpl()
     m_pFileStream->SetStreamSize(PAGE_SIZE);
 
     ByteString aCol(aName,m_pTable->getConnection()->getTextEncoding());
-    strncpy(m_aHeader.db_name,aCol.GetBuffer(),std::min((USHORT)sizeof(m_aHeader.db_name), aCol.Len()));
+    strncpy(m_aHeader.db_name,aCol.GetBuffer(),std::min((sal_uInt16)sizeof(m_aHeader.db_name), aCol.Len()));
     m_aHeader.db_unique  = m_IsUnique ? 1: 0;
     m_aHeader.db_keyrec  = m_aHeader.db_keylen + 8;
 
@@ -609,11 +609,11 @@ BOOL ODbaseIndex::CreateImpl()
 
     //  ODatabaseType eType = m_aHeader.db_keytype == 0 ? DataType::VARCHAR : DataType::DOUBLE;
     m_aCurLeaf = m_aRoot = CreatePage(m_nRootPage);
-    m_aRoot->SetModified(TRUE);
+    m_aRoot->SetModified(sal_True);
 
-    m_bUseCollector = TRUE;
+    m_bUseCollector = sal_True;
 
-    //  ULONG nRowsLeft = pCursor->RowCount();
+    //  sal_uIntPtr nRowsLeft = pCursor->RowCount();
     sal_Int32 nRowsLeft = 0;
     Reference<XRow> xRow(xSet,UNO_QUERY);
 
diff --git a/connectivity/source/drivers/dbase/DIndexColumns.cxx b/connectivity/source/drivers/dbase/DIndexColumns.cxx
index 59682a38d8af..1ea40b7bc03f 100644
--- a/connectivity/source/drivers/dbase/DIndexColumns.cxx
+++ b/connectivity/source/drivers/dbase/DIndexColumns.cxx
@@ -69,7 +69,7 @@ sdbcx::ObjectType ODbaseIndexColumns::createObject(const ::rtl::OUString& _rName
                                                     ,sal_False
                                                     ,sal_False
                                                     ,sal_False
-                                                    ,pTable->getConnection()->getMetaData()->storesMixedCaseQuotedIdentifiers());
+                                                    ,pTable->getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers());
 
     return xRet;
 }
@@ -82,7 +82,7 @@ void ODbaseIndexColumns::impl_refresh() throw(RuntimeException)
 // -------------------------------------------------------------------------
 Reference< XPropertySet > ODbaseIndexColumns::createDescriptor()
 {
-    return new sdbcx::OIndexColumn(m_pIndex->getTable()->getConnection()->getMetaData()->storesMixedCaseQuotedIdentifiers());
+    return new sdbcx::OIndexColumn(m_pIndex->getTable()->getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers());
 }
 // -------------------------------------------------------------------------
 sdbcx::ObjectType ODbaseIndexColumns::appendObject( const ::rtl::OUString& /*_rForName*/, const Reference< XPropertySet >& descriptor )
diff --git a/connectivity/source/drivers/dbase/DIndexIter.cxx b/connectivity/source/drivers/dbase/DIndexIter.cxx
index f32b1f2cffe0..b35caa0a3da1 100644
--- a/connectivity/source/drivers/dbase/DIndexIter.cxx
+++ b/connectivity/source/drivers/dbase/DIndexIter.cxx
@@ -46,22 +46,22 @@ OIndexIterator::~OIndexIterator()
 }
 
 //------------------------------------------------------------------
-ULONG OIndexIterator::First()
+sal_uIntPtr OIndexIterator::First()
 {
-    return Find(TRUE);
+    return Find(sal_True);
 }
 
 //------------------------------------------------------------------
-ULONG OIndexIterator::Next()
+sal_uIntPtr OIndexIterator::Next()
 {
-    return Find(FALSE);
+    return Find(sal_False);
 }
 //------------------------------------------------------------------
-ULONG OIndexIterator::Find(BOOL bFirst)
+sal_uIntPtr OIndexIterator::Find(sal_Bool bFirst)
 {
     //  ONDXIndex* m_pIndex = GetNDXIndex();
 
-    ULONG nRes = STRING_NOTFOUND;
+    sal_uIntPtr nRes = STRING_NOTFOUND;
 //  if (!m_pIndex->IsOpen())
 //      return nRes;
 
@@ -108,7 +108,7 @@ ONDXKey* OIndexIterator::GetFirstKey(ONDXPage* pPage, const OOperand& rKey)
     // dieses findet beim Insert besondere Beachtung
     //  ONDXIndex* m_pIndex = GetNDXIndex();
     OOp_COMPARE aTempOp(SQLFilterOperator::GREATER);
-    USHORT i = 0;
+    sal_uInt16 i = 0;
 
     if (pPage->IsLeaf())
     {
@@ -146,7 +146,7 @@ ONDXKey* OIndexIterator::GetFirstKey(ONDXPage* pPage, const OOperand& rKey)
 }
 
 //------------------------------------------------------------------
-ULONG OIndexIterator::GetCompare(BOOL bFirst)
+sal_uIntPtr OIndexIterator::GetCompare(sal_Bool bFirst)
 {
     ONDXKey* pKey = NULL;
     //  ONDXIndex* m_pIndex = GetNDXIndex();
@@ -217,7 +217,7 @@ ULONG OIndexIterator::GetCompare(BOOL bFirst)
 }
 
 //------------------------------------------------------------------
-ULONG OIndexIterator::GetLike(BOOL bFirst)
+sal_uIntPtr OIndexIterator::GetLike(sal_Bool bFirst)
 {
     //  ONDXIndex* m_pIndex = GetNDXIndex();
     if (bFirst)
@@ -238,7 +238,7 @@ ULONG OIndexIterator::GetLike(BOOL bFirst)
 }
 
 //------------------------------------------------------------------
-ULONG OIndexIterator::GetNull(BOOL bFirst)
+sal_uIntPtr OIndexIterator::GetNull(sal_Bool bFirst)
 {
     //  ONDXIndex* m_pIndex = GetNDXIndex();
     if (bFirst)
@@ -261,16 +261,16 @@ ULONG OIndexIterator::GetNull(BOOL bFirst)
 }
 
 //------------------------------------------------------------------
-ULONG OIndexIterator::GetNotNull(BOOL bFirst)
+sal_uIntPtr OIndexIterator::GetNotNull(sal_Bool bFirst)
 {
     ONDXKey* pKey;
     //  ONDXIndex* m_pIndex = GetNDXIndex();
     if (bFirst)
     {
         // erst alle NULL werte abklappern
-        for (ULONG nRec = GetNull(bFirst);
+        for (sal_uIntPtr nRec = GetNull(bFirst);
              nRec != STRING_NOTFOUND;
-             nRec = GetNull(FALSE))
+             nRec = GetNull(sal_False))
                  ;
         pKey = m_aCurLeaf.Is() ? &(*m_aCurLeaf)[m_nCurNode].GetKey() : NULL;
     }
@@ -293,7 +293,7 @@ ONDXKey* OIndexIterator::GetNextKey()
             ONDXPage* pParentPage = pPage->GetParent();
             if (pParentPage)
             {
-                USHORT nPos = pParentPage->Search(pPage);
+                sal_uInt16 nPos = pParentPage->Search(pPage);
                 if (nPos != pParentPage->Count() - 1)
                 {   // Seite gefunden
                     pPage = (*pParentPage)[nPos+1].GetChild(m_pIndex,pParentPage);
diff --git a/connectivity/source/drivers/dbase/DNoException.cxx b/connectivity/source/drivers/dbase/DNoException.cxx
index b39581f1be15..7534d06f068c 100644
--- a/connectivity/source/drivers/dbase/DNoException.cxx
+++ b/connectivity/source/drivers/dbase/DNoException.cxx
@@ -90,7 +90,7 @@ sal_Bool ODbaseTable::seekRow(IResultSetHelper::Movement eCursorPosition, sal_In
         OSL_ENSURE(m_nFilePos >= 1,"SdbDBFCursor::FileFetchRow: ungueltige Record-Position");
         sal_Int32 nPos = m_aHeader.db_kopf + (sal_Int32)(m_nFilePos-1) * nEntryLen;
 
-        ULONG nLen = m_pFileStream->Seek(nPos);
+        sal_uIntPtr nLen = m_pFileStream->Seek(nPos);
         if (m_pFileStream->GetError() != ERRCODE_NONE)
             goto Error;
 
@@ -127,10 +127,10 @@ End:
     return sal_True;
 }
 // -----------------------------------------------------------------------------
-BOOL ODbaseTable::ReadMemo(ULONG nBlockNo, ORowSetValue& aVariable)
+sal_Bool ODbaseTable::ReadMemo(sal_uIntPtr nBlockNo, ORowSetValue& aVariable)
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::ReadMemo" );
-    BOOL bIsText = TRUE;
+    sal_Bool bIsText = sal_True;
     //  SdbConnection* pConnection = GetConnection();
 
     m_pMemoStream->Seek(nBlockNo * m_aMemoHeader.db_size);
@@ -142,13 +142,13 @@ BOOL ODbaseTable::ReadMemo(ULONG nBlockNo, ORowSetValue& aVariable)
             ByteString aBStr;
             static char aBuf[514];
             aBuf[512] = 0;          // sonst kann der Zufall uebel mitspielen
-            BOOL bReady = sal_False;
+            sal_Bool bReady = sal_False;
 
             do
             {
                 m_pMemoStream->Read(&aBuf,512);
 
-                USHORT i = 0;
+                sal_uInt16 i = 0;
                 while (aBuf[i] != cEOF && ++i < 512)
                     ;
                 bReady = aBuf[i] == cEOF;
@@ -170,7 +170,7 @@ BOOL ODbaseTable::ReadMemo(ULONG nBlockNo, ORowSetValue& aVariable)
             // Foxpro stores text and binary data
             if (m_aMemoHeader.db_typ == MemoFoxPro)
             {
-                if (((BYTE)sHeader[0]) != 0 || ((BYTE)sHeader[1]) != 0 || ((BYTE)sHeader[2]) != 0)
+                if (((sal_uInt8)sHeader[0]) != 0 || ((sal_uInt8)sHeader[1]) != 0 || ((sal_uInt8)sHeader[2]) != 0)
                 {
 //                  String aText = String(SdbResId(STR_STAT_IResultSetHelper::INVALID));
 //                  aText.SearchAndReplace(String::CreateFromAscii("%%d"),m_pMemoStream->GetFileName());
@@ -184,7 +184,7 @@ BOOL ODbaseTable::ReadMemo(ULONG nBlockNo, ORowSetValue& aVariable)
 
                 bIsText = sHeader[3] != 0;
             }
-            else if (((BYTE)sHeader[0]) != 0xFF || ((BYTE)sHeader[1]) != 0xFF || ((BYTE)sHeader[2]) != 0x08)
+            else if (((sal_uInt8)sHeader[0]) != 0xFF || ((sal_uInt8)sHeader[1]) != 0xFF || ((sal_uInt8)sHeader[2]) != 0x08)
             {
 //              String aText = String(SdbResId(STR_STAT_IResultSetHelper::INVALID));
 //              aText.SearchAndReplace(String::CreateFromAscii("%%d"),m_pMemoStream->GetFileName());
@@ -232,7 +232,7 @@ BOOL ODbaseTable::ReadMemo(ULONG nBlockNo, ORowSetValue& aVariable)
 void ODbaseTable::AllocBuffer()
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::AllocBuffer" );
-    UINT16 nSize = m_aHeader.db_slng;
+    sal_uInt16 nSize = m_aHeader.db_slng;
     OSL_ENSURE(nSize > 0, "Size too small");
 
     if (m_nBufferSize != nSize)
@@ -245,11 +245,11 @@ void ODbaseTable::AllocBuffer()
     if (m_pBuffer == NULL && nSize)
     {
         m_nBufferSize = nSize;
-        m_pBuffer       = new BYTE[m_nBufferSize+1];
+        m_pBuffer       = new sal_uInt8[m_nBufferSize+1];
     }
 }
 // -----------------------------------------------------------------------------
-BOOL ODbaseTable::WriteBuffer()
+sal_Bool ODbaseTable::WriteBuffer()
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::WriteBuffer" );
     OSL_ENSURE(m_nFilePos >= 1,"SdbDBFCursor::FileFetchRow: ungueltige Record-Position");
@@ -285,7 +285,7 @@ void ONDXNode::Read(SvStream &rStream, ODbaseIndex& rIndex)
     else
     {
         ByteString aBuf;
-        USHORT nLen = rIndex.getHeader().db_keylen;
+        sal_uInt16 nLen = rIndex.getHeader().db_keylen;
         char* pStr = aBuf.AllocBuffer(nLen+1);
 
         rStream.Read(pStr,nLen);
@@ -319,7 +319,7 @@ void ONDXNode::Write(SvStream &rStream, const ONDXPage& rPage) const
         if (aKey.getValue().isNull())
         {
             memset(aNodeData.aData,0,rIndex.getHeader().db_keylen);
-            rStream.Write((BYTE*)aNodeData.aData,rIndex.getHeader().db_keylen);
+            rStream.Write((sal_uInt8*)aNodeData.aData,rIndex.getHeader().db_keylen);
         }
         else
             rStream << (double) aKey.getValue();
@@ -333,7 +333,7 @@ void ONDXNode::Write(SvStream &rStream, const ONDXPage& rPage) const
             ByteString aText(sValue.getStr(), rIndex.m_pTable->getConnection()->getTextEncoding());
             strncpy(aNodeData.aData,aText.GetBuffer(),std::min(rIndex.getHeader().db_keylen, aText.Len()));
         }
-        rStream.Write((BYTE*)aNodeData.aData,rIndex.getHeader().db_keylen);
+        rStream.Write((sal_uInt8*)aNodeData.aData,rIndex.getHeader().db_keylen);
     }
     rStream << aChild;
 }
@@ -354,7 +354,7 @@ ONDXPagePtr& ONDXNode::GetChild(ODbaseIndex* pIndex, ONDXPage* pParent)
 // ONDXKey
 //==================================================================
 //------------------------------------------------------------------
-BOOL ONDXKey::IsText(sal_Int32 eType)
+sal_Bool ONDXKey::IsText(sal_Int32 eType)
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ONDXKey::IsText" );
     return eType == DataType::VARCHAR || eType == DataType::CHAR;
@@ -383,7 +383,7 @@ StringCompare ONDXKey::Compare(const ONDXKey& rKey) const
     }
     else if (IsText(getDBType()))
     {
-        INT32 nRes = getValue().getString().compareTo(rKey.getValue());
+        sal_Int32 nRes = getValue().getString().compareTo(rKey.getValue());
         eResult = (nRes > 0) ? COMPARE_GREATER : (nRes == 0) ? COMPARE_EQUAL : COMPARE_LESS;
     }
     else
@@ -460,16 +460,16 @@ ONDXPagePtr& ONDXPagePtr::operator= (ONDXPage* pRef)
     return *this;
 }
 // -----------------------------------------------------------------------------
-static UINT32 nValue;
+static sal_uInt32 nValue;
 //------------------------------------------------------------------
 SvStream& connectivity::dbase::operator >> (SvStream &rStream, ONDXPage& rPage)
 {
     rStream.Seek(rPage.GetPagePos() * 512);
     rStream >> nValue >> rPage.aChild;
-    rPage.nCount = USHORT(nValue);
+    rPage.nCount = sal_uInt16(nValue);
 
 //  DBG_ASSERT(rPage.nCount && rPage.nCount < rPage.GetIndex().GetMaxNodes(), "Falscher Count");
-    for (USHORT i = 0; i < rPage.nCount; i++)
+    for (sal_uInt16 i = 0; i < rPage.nCount; i++)
         rPage[i].Read(rStream, rPage.GetIndex());
     return rStream;
 }
@@ -478,7 +478,7 @@ SvStream& connectivity::dbase::operator >> (SvStream &rStream, ONDXPage& rPage)
 SvStream& connectivity::dbase::operator << (SvStream &rStream, const ONDXPage& rPage)
 {
     // Seite existiert noch nicht
-    ULONG nSize = (rPage.GetPagePos() + 1) * 512;
+    sal_uIntPtr nSize = (rPage.GetPagePos() + 1) * 512;
     if (nSize > rStream.Seek(STREAM_SEEK_TO_END))
     {
         rStream.SetStreamSize(nSize);
@@ -486,27 +486,27 @@ SvStream& connectivity::dbase::operator << (SvStream &rStream, const ONDXPage& r
 
         char aEmptyData[512];
         memset(aEmptyData,0x00,512);
-        rStream.Write((BYTE*)aEmptyData,512);
+        rStream.Write((sal_uInt8*)aEmptyData,512);
     }
-    ULONG nCurrentPos = rStream.Seek(rPage.GetPagePos() * 512);
+    sal_uIntPtr nCurrentPos = rStream.Seek(rPage.GetPagePos() * 512);
     OSL_UNUSED( nCurrentPos );
 
     nValue = rPage.nCount;
     rStream << nValue << rPage.aChild;
 
-    USHORT i = 0;
+    sal_uInt16 i = 0;
     for (; i < rPage.nCount; i++)
         rPage[i].Write(rStream, rPage);
 
     // check if we have to fill the stream with '\0'
     if(i < rPage.rIndex.getHeader().db_maxkeys)
     {
-        ULONG nTell = rStream.Tell() % 512;
-        USHORT nBufferSize = rStream.GetBufferSize();
-        ULONG nSize = nBufferSize - nTell;
+        sal_uIntPtr nTell = rStream.Tell() % 512;
+        sal_uInt16 nBufferSize = rStream.GetBufferSize();
+        sal_uIntPtr nSize = nBufferSize - nTell;
         char* pEmptyData = new char[nSize];
         memset(pEmptyData,0x00,nSize);
-        rStream.Write((BYTE*)pEmptyData,nSize);
+        rStream.Write((sal_uInt8*)pEmptyData,nSize);
         rStream.Seek(nTell);
         delete [] pEmptyData;
     }
@@ -521,7 +521,7 @@ void ONDXPage::PrintPage()
     DBG_TRACE4("\nSDB: -----------Page: %d  Parent: %d  Count: %d  Child: %d-----",
         nPagePos, HasParent() ? aParent->GetPagePos() : 0 ,nCount, aChild.GetPagePos());
 
-    for (USHORT i = 0; i < nCount; i++)
+    for (sal_uInt16 i = 0; i < nCount; i++)
     {
         ONDXNode rNode = (*this)[i];
         ONDXKey&  rKey = rNode.GetKey();
@@ -546,7 +546,7 @@ void ONDXPage::PrintPage()
     {
 #if OSL_DEBUG_LEVEL > 1
         GetChild(&rIndex)->PrintPage();
-        for (USHORT i = 0; i < nCount; i++)
+        for (sal_uInt16 i = 0; i < nCount; i++)
         {
             ONDXNode rNode = (*this)[i];
             rNode.GetChild(&rIndex,this)->PrintPage();
@@ -557,18 +557,18 @@ void ONDXPage::PrintPage()
 }
 #endif
 // -----------------------------------------------------------------------------
-BOOL ONDXPage::IsFull() const
+sal_Bool ONDXPage::IsFull() const
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ONDXPage::IsFull" );
     return Count() == rIndex.getHeader().db_maxkeys;
 }
 // -----------------------------------------------------------------------------
 //------------------------------------------------------------------
-USHORT ONDXPage::Search(const ONDXKey& rSearch)
+sal_uInt16 ONDXPage::Search(const ONDXKey& rSearch)
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ONDXPage::Search" );
     // binare Suche spaeter
-    USHORT i = 0xFFFF;
+    sal_uInt16 i = 0xFFFF;
     while (++i < Count())
         if ((*this)[i].GetKey() == rSearch)
             break;
@@ -577,10 +577,10 @@ USHORT ONDXPage::Search(const ONDXKey& rSearch)
 }
 
 //------------------------------------------------------------------
-USHORT ONDXPage::Search(const ONDXPage* pPage)
+sal_uInt16 ONDXPage::Search(const ONDXPage* pPage)
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ONDXPage::Search" );
-    USHORT i = 0xFFFF;
+    sal_uInt16 i = 0xFFFF;
     while (++i < Count())
         if (((*this)[i]).GetChild() == pPage)
             break;
@@ -598,7 +598,7 @@ void ONDXPage::SearchAndReplace(const ONDXKey& rSearch,
     OSL_ENSURE(rSearch != rReplace,"Invalid here:rSearch == rReplace");
     if (rSearch != rReplace)
     {
-        USHORT nPos = NODE_NOTFOUND;
+        sal_uInt16 nPos = NODE_NOTFOUND;
         ONDXPage* pPage = this;
 
         while (pPage && (nPos = pPage->Search(rSearch)) == NODE_NOTFOUND)
@@ -607,34 +607,34 @@ void ONDXPage::SearchAndReplace(const ONDXKey& rSearch,
         if (pPage)
         {
             (*pPage)[nPos].GetKey() = rReplace;
-            pPage->SetModified(TRUE);
+            pPage->SetModified(sal_True);
         }
     }
 }
 // -----------------------------------------------------------------------------
-ONDXNode& ONDXPage::operator[] (USHORT nPos)
+ONDXNode& ONDXPage::operator[] (sal_uInt16 nPos)
 {
     DBG_ASSERT(nCount > nPos, "falscher Indexzugriff");
     return ppNodes[nPos];
 }
 
 //------------------------------------------------------------------
-const ONDXNode& ONDXPage::operator[] (USHORT nPos) const
+const ONDXNode& ONDXPage::operator[] (sal_uInt16 nPos) const
 {
     DBG_ASSERT(nCount > nPos, "falscher Indexzugriff");
     return ppNodes[nPos];
 }
 // -----------------------------------------------------------------------------
-void ONDXPage::Remove(USHORT nPos)
+void ONDXPage::Remove(sal_uInt16 nPos)
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ONDXPage::Remove" );
     DBG_ASSERT(nCount > nPos, "falscher Indexzugriff");
 
-    for (USHORT i = nPos; i < (nCount-1); i++)
+    for (sal_uInt16 i = nPos; i < (nCount-1); i++)
         (*this)[i] = (*this)[i+1];
 
     nCount--;
-    bModified = TRUE;
+    bModified = sal_True;
 }
 // -----------------------------------------------------------------------------
 
diff --git a/connectivity/source/drivers/dbase/DTable.cxx b/connectivity/source/drivers/dbase/DTable.cxx
index 011d0e89ce7a..a0844b93b0b7 100644
--- a/connectivity/source/drivers/dbase/DTable.cxx
+++ b/connectivity/source/drivers/dbase/DTable.cxx
@@ -229,12 +229,12 @@ void ODbaseTable::readHeader()
     m_pFileStream->RefreshBuffer(); // sicherstellen, dass die Kopfinformationen tatsaechlich neu gelesen werden
     m_pFileStream->Seek(STREAM_SEEK_TO_BEGIN);
 
-    BYTE nType=0;
+    sal_uInt8 nType=0;
     (*m_pFileStream) >> nType;
     if(ERRCODE_NONE != m_pFileStream->GetErrorCode())
         throwInvalidDbaseFormat();
 
-    m_pFileStream->Read((char*)(&m_aHeader.db_aedat), 3*sizeof(BYTE));
+    m_pFileStream->Read((char*)(&m_aHeader.db_aedat), 3*sizeof(sal_uInt8));
     if(ERRCODE_NONE != m_pFileStream->GetErrorCode())
         throwInvalidDbaseFormat();
     (*m_pFileStream) >> m_aHeader.db_anz;
@@ -246,7 +246,7 @@ void ODbaseTable::readHeader()
     (*m_pFileStream) >> m_aHeader.db_slng;
     if(ERRCODE_NONE != m_pFileStream->GetErrorCode())
         throwInvalidDbaseFormat();
-    m_pFileStream->Read((char*)(&m_aHeader.db_frei), 20*sizeof(BYTE));
+    m_pFileStream->Read((char*)(&m_aHeader.db_frei), 20*sizeof(sal_uInt8));
     if(ERRCODE_NONE != m_pFileStream->GetErrorCode())
         throwInvalidDbaseFormat();
 
@@ -340,7 +340,7 @@ void ODbaseTable::fillColumns()
     aStrFieldName.AssignAscii("Column");
     ::rtl::OUString aTypeName;
     static const ::rtl::OUString sVARCHAR(RTL_CONSTASCII_USTRINGPARAM("VARCHAR"));
-    const sal_Bool bCase = getConnection()->getMetaData()->storesMixedCaseQuotedIdentifiers();
+    const sal_Bool bCase = getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers();
     const bool bFoxPro = m_aHeader.db_typ == VisualFoxPro || m_aHeader.db_typ == VisualFoxProAuto || m_aHeader.db_typ == FoxProMemo;
 
     sal_Int32 i = 0;
@@ -552,7 +552,7 @@ void ODbaseTable::construct()
         //  if(!m_pColumns && (!m_aColumns.isValid() || !m_aColumns->size()))
         fillColumns();
 
-        UINT32 nFileSize = lcl_getFileSize(*m_pFileStream);
+        sal_uInt32 nFileSize = lcl_getFileSize(*m_pFileStream);
         m_pFileStream->Seek(STREAM_SEEK_TO_BEGIN);
         if ( m_aHeader.db_anz == 0 && ((nFileSize-m_aHeader.db_kopf)/m_aHeader.db_slng) > 0) // seems to be empty or someone wrote bullshit into the dbase file
             m_aHeader.db_anz = ((nFileSize-m_aHeader.db_kopf)/m_aHeader.db_slng);
@@ -580,7 +580,7 @@ void ODbaseTable::construct()
     }
 }
 //------------------------------------------------------------------
-BOOL ODbaseTable::ReadMemoHeader()
+sal_Bool ODbaseTable::ReadMemoHeader()
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::ReadMemoHeader" );
     m_pMemoStream->SetNumberFormatInt(NUMBERFORMAT_INT_LITTLEENDIAN);
@@ -605,7 +605,7 @@ BOOL ODbaseTable::ReadMemoHeader()
                 m_pMemoStream->Seek(m_aMemoHeader.db_size);
                 m_pMemoStream->Read(sHeader,4);
 
-                if ((m_pMemoStream->GetErrorCode() != ERRCODE_NONE) || ((BYTE)sHeader[0]) != 0xFF || ((BYTE)sHeader[1]) != 0xFF || ((BYTE)sHeader[2]) != 0x08)
+                if ((m_pMemoStream->GetErrorCode() != ERRCODE_NONE) || ((sal_uInt8)sHeader[0]) != 0xFF || ((sal_uInt8)sHeader[1]) != 0xFF || ((sal_uInt8)sHeader[2]) != 0x08)
                     m_aMemoHeader.db_typ  = MemodBaseIII;
                 else
                     m_aMemoHeader.db_typ  = MemodBaseIV;
@@ -628,7 +628,7 @@ BOOL ODbaseTable::ReadMemoHeader()
             OSL_ENSURE( false, "ODbaseTable::ReadMemoHeader: unsupported memo type!" );
             break;
     }
-    return TRUE;
+    return sal_True;
 }
 // -------------------------------------------------------------------------
 String ODbaseTable::getEntry(OConnection* _pConnection,const ::rtl::OUString& _sName )
@@ -704,11 +704,11 @@ void ODbaseTable::refreshIndexes()
         aURL.setExtension(String::CreateFromAscii("inf"));
         Config aInfFile(aURL.getFSysPath(INetURLObject::FSYS_DETECT));
         aInfFile.SetGroup(dBASE_III_GROUP);
-        USHORT nKeyCnt = aInfFile.GetKeyCount();
+        sal_uInt16 nKeyCnt = aInfFile.GetKeyCount();
         ByteString aKeyName;
         ByteString aIndexName;
 
-        for (USHORT nKey = 0; nKey < nKeyCnt; nKey++)
+        for (sal_uInt16 nKey = 0; nKey < nKeyCnt; nKey++)
         {
             // Verweist der Key auf ein Indexfile?...
             aKeyName = aInfFile.GetKeyName( nKey );
@@ -812,7 +812,7 @@ sal_Bool ODbaseTable::fetchRow(OValueRefRow& _rRow,const OSQLColumns & _rCols, s
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::fetchRow" );
     // Einlesen der Daten
-    BOOL bIsCurRecordDeleted = ((char)m_pBuffer[0] == '*') ? TRUE : sal_False;
+    sal_Bool bIsCurRecordDeleted = ((char)m_pBuffer[0] == '*') ? sal_True : sal_False;
 
     // only read the bookmark
 
@@ -822,7 +822,7 @@ sal_Bool ODbaseTable::fetchRow(OValueRefRow& _rRow,const OSQLColumns & _rCols, s
     *(_rRow->get())[0] = m_nFilePos;
 
     if (!bRetrieveData)
-        return TRUE;
+        return sal_True;
 
     sal_Size nByteOffset = 1;
     // Felder:
@@ -982,13 +982,13 @@ sal_Bool ODbaseTable::fetchRow(OValueRefRow& _rRow,const OSQLColumns & _rCols, s
                 break;
                 case DataType::BIT:
                 {
-                    BOOL b;
+                    sal_Bool b;
                     switch (* ((const char *)pData))
                     {
                         case 'T':
                         case 'Y':
-                        case 'J':   b = TRUE; break;
-                        default:    b = FALSE; break;
+                        case 'J':   b = sal_True; break;
+                        default:    b = sal_False; break;
                     }
                     *(_rRow->get())[i] = b;
                     //  pVal->setDouble(b);
@@ -1034,7 +1034,7 @@ void ODbaseTable::FileClose()
     ODbaseTable_BASE::FileClose();
 }
 // -------------------------------------------------------------------------
-BOOL ODbaseTable::CreateImpl()
+sal_Bool ODbaseTable::CreateImpl()
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::CreateImpl" );
     OSL_ENSURE(!m_pFileStream, "SequenceError");
@@ -1084,7 +1084,7 @@ BOOL ODbaseTable::CreateImpl()
     {
     }
 
-    BOOL bMemoFile = sal_False;
+    sal_Bool bMemoFile = sal_False;
 
     sal_Bool bOk = CreateFile(aURL, bMemoFile);
 
@@ -1148,7 +1148,7 @@ BOOL ODbaseTable::CreateImpl()
     else
         m_aHeader.db_typ = dBaseIII;
 
-    return TRUE;
+    return sal_True;
 }
 // -----------------------------------------------------------------------------
 void ODbaseTable::throwInvalidColumnType(const sal_uInt16 _nErrorId,const ::rtl::OUString& _sColumnName)
@@ -1171,7 +1171,7 @@ void ODbaseTable::throwInvalidColumnType(const sal_uInt16 _nErrorId,const ::rtl:
 }
 //------------------------------------------------------------------
 // erzeugt grundsaetzlich dBase IV Datei Format
-BOOL ODbaseTable::CreateFile(const INetURLObject& aFile, BOOL& bCreateMemo)
+sal_Bool ODbaseTable::CreateFile(const INetURLObject& aFile, sal_Bool& bCreateMemo)
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::CreateFile" );
     bCreateMemo = sal_False;
@@ -1182,7 +1182,7 @@ BOOL ODbaseTable::CreateFile(const INetURLObject& aFile, BOOL& bCreateMemo)
     if (!m_pFileStream)
         return sal_False;
 
-    BYTE nDbaseType = dBaseIII;
+    sal_uInt8 nDbaseType = dBaseIII;
     Reference<XIndexAccess> xColumns(getColumns(),UNO_QUERY);
     Reference<XPropertySet> xCol;
     const ::rtl::OUString sPropType = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_TYPE);
@@ -1224,19 +1224,19 @@ BOOL ODbaseTable::CreateFile(const INetURLObject& aFile, BOOL& bCreateMemo)
     memset(aBuffer,0,sizeof(aBuffer));
 
     m_pFileStream->Seek(0L);
-    (*m_pFileStream) << (BYTE) nDbaseType;                              // dBase format
-    (*m_pFileStream) << (BYTE) (aDate.GetYear() % 100);                 // aktuelles Datum
+    (*m_pFileStream) << (sal_uInt8) nDbaseType;                              // dBase format
+    (*m_pFileStream) << (sal_uInt8) (aDate.GetYear() % 100);                 // aktuelles Datum
 
 
-    (*m_pFileStream) << (BYTE) aDate.GetMonth();
-    (*m_pFileStream) << (BYTE) aDate.GetDay();
+    (*m_pFileStream) << (sal_uInt8) aDate.GetMonth();
+    (*m_pFileStream) << (sal_uInt8) aDate.GetDay();
     (*m_pFileStream) << 0L;                                             // Anzahl der Datensaetze
-    (*m_pFileStream) << (USHORT)((m_pColumns->getCount()+1) * 32 + 1);  // Kopfinformationen,
+    (*m_pFileStream) << (sal_uInt16)((m_pColumns->getCount()+1) * 32 + 1);  // Kopfinformationen,
                                                                         // pColumns erhaelt immer eine Spalte mehr
-    (*m_pFileStream) << (USHORT) 0;                                     // Satzlaenge wird spaeter bestimmt
+    (*m_pFileStream) << (sal_uInt16) 0;                                     // Satzlaenge wird spaeter bestimmt
     m_pFileStream->Write(aBuffer, 20);
 
-    USHORT nRecLength = 1;                                              // Laenge 1 fuer deleted flag
+    sal_uInt16 nRecLength = 1;                                              // Laenge 1 fuer deleted flag
     sal_Int32  nMaxFieldLength = m_pConnection->getMetaData()->getMaxColumnNameLength();
     ::rtl::OUString aName;
     const ::rtl::OUString sPropName = OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME);
@@ -1329,9 +1329,9 @@ BOOL ODbaseTable::CreateFile(const INetURLObject& aFile, BOOL& bCreateMemo)
                     {
                         throwInvalidColumnType(STR_INVALID_COLUMN_PRECISION, aName);
                     }
-                    (*m_pFileStream) << (BYTE) Min((ULONG)nPrecision, 255UL);      //Feldlaenge
-                    nRecLength = nRecLength + (USHORT)::std::min((USHORT)nPrecision, (USHORT)255UL);
-                    (*m_pFileStream) << (BYTE)0;                                                                //Nachkommastellen
+                    (*m_pFileStream) << (sal_uInt8) Min((sal_uIntPtr)nPrecision, 255UL);      //Feldlaenge
+                    nRecLength = nRecLength + (sal_uInt16)::std::min((sal_uInt16)nPrecision, (sal_uInt16)255UL);
+                    (*m_pFileStream) << (sal_uInt8)0;                                                                //Nachkommastellen
                     break;
                 case 'F':
                 case 'N':
@@ -1343,41 +1343,41 @@ BOOL ODbaseTable::CreateFile(const INetURLObject& aFile, BOOL& bCreateMemo)
                     }
                     if (getBOOL(xCol->getPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_ISCURRENCY)))) // Currency wird gesondert behandelt
                     {
-                        (*m_pFileStream) << (BYTE)10;          // Standard Laenge
-                        (*m_pFileStream) << (BYTE)4;
+                        (*m_pFileStream) << (sal_uInt8)10;          // Standard Laenge
+                        (*m_pFileStream) << (sal_uInt8)4;
                         nRecLength += 10;
                     }
                     else
                     {
                         sal_Int32 nPrec = SvDbaseConverter::ConvertPrecisionToDbase(nPrecision,nScale);
 
-                        (*m_pFileStream) << (BYTE)( nPrec);
-                        (*m_pFileStream) << (BYTE)nScale;
-                        nRecLength += (USHORT)nPrec;
+                        (*m_pFileStream) << (sal_uInt8)( nPrec);
+                        (*m_pFileStream) << (sal_uInt8)nScale;
+                        nRecLength += (sal_uInt16)nPrec;
                     }
                     break;
                 case 'L':
-                    (*m_pFileStream) << (BYTE)1;
-                    (*m_pFileStream) << (BYTE)0;
+                    (*m_pFileStream) << (sal_uInt8)1;
+                    (*m_pFileStream) << (sal_uInt8)0;
                     ++nRecLength;
                     break;
                 case 'I':
-                    (*m_pFileStream) << (BYTE)4;
-                    (*m_pFileStream) << (BYTE)0;
+                    (*m_pFileStream) << (sal_uInt8)4;
+                    (*m_pFileStream) << (sal_uInt8)0;
                     nRecLength += 4;
                     break;
                 case 'Y':
                 case 'B':
                 case 'T':
                 case 'D':
-                    (*m_pFileStream) << (BYTE)8;
-                    (*m_pFileStream) << (BYTE)0;
+                    (*m_pFileStream) << (sal_uInt8)8;
+                    (*m_pFileStream) << (sal_uInt8)0;
                     nRecLength += 8;
                     break;
                 case 'M':
-                    bCreateMemo = TRUE;
-                    (*m_pFileStream) << (BYTE)10;
-                    (*m_pFileStream) << (BYTE)0;
+                    bCreateMemo = sal_True;
+                    (*m_pFileStream) << (sal_uInt8)10;
+                    (*m_pFileStream) << (sal_uInt8)0;
                     nRecLength += 10;
                     if ( bBinary )
                         aBuffer[0] = 0x06;
@@ -1389,7 +1389,7 @@ BOOL ODbaseTable::CreateFile(const INetURLObject& aFile, BOOL& bCreateMemo)
             aBuffer[0] = 0x00;
         }
 
-        (*m_pFileStream) << (BYTE)FIELD_DESCRIPTOR_TERMINATOR;              // kopf ende
+        (*m_pFileStream) << (sal_uInt8)FIELD_DESCRIPTOR_TERMINATOR;              // kopf ende
         (*m_pFileStream) << (char)DBF_EOL;
         m_pFileStream->Seek(10L);
         (*m_pFileStream) << nRecLength;                                     // Satzlaenge nachtraeglich eintragen
@@ -1398,9 +1398,9 @@ BOOL ODbaseTable::CreateFile(const INetURLObject& aFile, BOOL& bCreateMemo)
         {
             m_pFileStream->Seek(0L);
             if (nDbaseType == VisualFoxPro)
-                (*m_pFileStream) << (BYTE) FoxProMemo;
+                (*m_pFileStream) << (sal_uInt8) FoxProMemo;
             else
-                (*m_pFileStream) << (BYTE) dBaseIIIMemo;
+                (*m_pFileStream) << (sal_uInt8) dBaseIIIMemo;
         } // if (bCreateMemo)
     }
     catch ( const Exception& e )
@@ -1415,12 +1415,12 @@ BOOL ODbaseTable::CreateFile(const INetURLObject& aFile, BOOL& bCreateMemo)
         catch(const Exception&) { }
         throw;
     }
-    return TRUE;
+    return sal_True;
 }
 
 //------------------------------------------------------------------
 // erzeugt grundsaetzlich dBase III Datei Format
-BOOL ODbaseTable::CreateMemoFile(const INetURLObject& aFile)
+sal_Bool ODbaseTable::CreateMemoFile(const INetURLObject& aFile)
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::CreateMemoFile" );
     // Makro zum Filehandling fuers Erzeugen von Tabellen
@@ -1441,16 +1441,16 @@ BOOL ODbaseTable::CreateMemoFile(const INetURLObject& aFile)
     m_pMemoStream->Flush();
     delete m_pMemoStream;
     m_pMemoStream = NULL;
-    return TRUE;
+    return sal_True;
 }
 //------------------------------------------------------------------
-BOOL ODbaseTable::Drop_Static(const ::rtl::OUString& _sUrl,sal_Bool _bHasMemoFields,OCollection* _pIndexes )
+sal_Bool ODbaseTable::Drop_Static(const ::rtl::OUString& _sUrl,sal_Bool _bHasMemoFields,OCollection* _pIndexes )
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::Drop_Static" );
     INetURLObject aURL;
     aURL.SetURL(_sUrl);
 
-    BOOL bDropped = ::utl::UCBContentHelper::Kill(aURL.GetMainURL(INetURLObject::NO_DECODE));
+    sal_Bool bDropped = ::utl::UCBContentHelper::Kill(aURL.GetMainURL(INetURLObject::NO_DECODE));
 
     if(bDropped)
     {
@@ -1495,7 +1495,7 @@ BOOL ODbaseTable::Drop_Static(const ::rtl::OUString& _sUrl,sal_Bool _bHasMemoFie
     return bDropped;
 }
 // -----------------------------------------------------------------------------
-BOOL ODbaseTable::DropImpl()
+sal_Bool ODbaseTable::DropImpl()
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::DropImpl" );
     FileClose();
@@ -1503,7 +1503,7 @@ BOOL ODbaseTable::DropImpl()
     if(!m_pIndexes)
         refreshIndexes(); // look for indexes which must be deleted as well
 
-    BOOL bDropped = Drop_Static(getEntry(m_pConnection,m_Name),HasMemoFields(),m_pIndexes);
+    sal_Bool bDropped = Drop_Static(getEntry(m_pConnection,m_Name),HasMemoFields(),m_pIndexes);
     if(!bDropped)
     {// we couldn't drop the table so we have to reopen it
         construct();
@@ -1514,7 +1514,7 @@ BOOL ODbaseTable::DropImpl()
 }
 
 //------------------------------------------------------------------
-BOOL ODbaseTable::InsertRow(OValueRefVector& rRow, BOOL bFlush,const Reference<XIndexAccess>& _xCols)
+sal_Bool ODbaseTable::InsertRow(OValueRefVector& rRow, sal_Bool bFlush,const Reference<XIndexAccess>& _xCols)
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::InsertRow" );
     // Buffer mit Leerzeichen fuellen
@@ -1524,12 +1524,12 @@ BOOL ODbaseTable::InsertRow(OValueRefVector& rRow, BOOL bFlush,const Reference<X
 
     // Gesamte neue Row uebernehmen:
     // ... und am Ende als neuen Record hinzufuegen:
-    UINT32 nTempPos = m_nFilePos,
+    sal_uInt32 nTempPos = m_nFilePos,
            nFileSize = 0,
            nMemoFileSize = 0;
 
-    m_nFilePos = (ULONG)m_aHeader.db_anz + 1;
-    BOOL bInsertRow = UpdateBuffer( rRow, NULL, _xCols );
+    m_nFilePos = (sal_uIntPtr)m_aHeader.db_anz + 1;
+    sal_Bool bInsertRow = UpdateBuffer( rRow, NULL, _xCols );
     if ( bInsertRow )
     {
         nFileSize = lcl_getFileSize(*m_pFileStream);
@@ -1572,7 +1572,7 @@ BOOL ODbaseTable::InsertRow(OValueRefVector& rRow, BOOL bFlush,const Reference<X
 }
 
 //------------------------------------------------------------------
-BOOL ODbaseTable::UpdateRow(OValueRefVector& rRow, OValueRefRow& pOrgRow,const Reference<XIndexAccess>& _xCols)
+sal_Bool ODbaseTable::UpdateRow(OValueRefVector& rRow, OValueRefRow& pOrgRow,const Reference<XIndexAccess>& _xCols)
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::UpdateRow" );
     // Buffer mit Leerzeichen fuellen
@@ -1583,7 +1583,7 @@ BOOL ODbaseTable::UpdateRow(OValueRefVector& rRow, OValueRefRow& pOrgRow,const R
     m_pFileStream->Seek(nPos);
     m_pFileStream->Read((char*)m_pBuffer, m_aHeader.db_slng);
 
-    UINT32 nMemoFileSize( 0 );
+    sal_uInt32 nMemoFileSize( 0 );
     if (HasMemoFields() && m_pMemoStream)
     {
         m_pMemoStream->Seek(STREAM_SEEK_TO_END);
@@ -1602,7 +1602,7 @@ BOOL ODbaseTable::UpdateRow(OValueRefVector& rRow, OValueRefRow& pOrgRow,const R
 }
 
 //------------------------------------------------------------------
-BOOL ODbaseTable::DeleteRow(const OSQLColumns& _rCols)
+sal_Bool ODbaseTable::DeleteRow(const OSQLColumns& _rCols)
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::DeleteRow" );
     // Einfach das Loesch-Flag setzen (egal, ob es schon gesetzt war
@@ -1613,13 +1613,13 @@ BOOL ODbaseTable::DeleteRow(const OSQLColumns& _rCols)
 
     OValueRefRow aRow = new OValueRefVector(_rCols.get().size());
 
-    if (!fetchRow(aRow,_rCols,TRUE,TRUE))
+    if (!fetchRow(aRow,_rCols,sal_True,sal_True))
         return sal_False;
 
     Reference<XPropertySet> xCol;
     ::rtl::OUString aColName;
     ::comphelper::UStringMixEqual aCase(isCaseSensitive());
-    for (USHORT i = 0; i < m_pColumns->getCount(); i++)
+    for (sal_uInt16 i = 0; i < m_pColumns->getCount(); i++)
     {
         Reference<XPropertySet> xIndex = isUniqueByColumnName(i);
         if (xIndex.is())
@@ -1651,7 +1651,7 @@ BOOL ODbaseTable::DeleteRow(const OSQLColumns& _rCols)
     }
 
     m_pFileStream->Seek(nFilePos);
-    (*m_pFileStream) << (BYTE)'*'; // mark the row in the table as deleted
+    (*m_pFileStream) << (sal_uInt8)'*'; // mark the row in the table as deleted
     m_pFileStream->Flush();
     return sal_True;
 }
@@ -1691,18 +1691,18 @@ double toDouble(const ByteString& rString)
 }
 
 //------------------------------------------------------------------
-BOOL ODbaseTable::UpdateBuffer(OValueRefVector& rRow, OValueRefRow pOrgRow,const Reference<XIndexAccess>& _xCols)
+sal_Bool ODbaseTable::UpdateBuffer(OValueRefVector& rRow, OValueRefRow pOrgRow,const Reference<XIndexAccess>& _xCols)
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::UpdateBuffer" );
     OSL_ENSURE(m_pBuffer,"Buffer is NULL!");
     if ( !m_pBuffer )
-        return FALSE;
+        return sal_False;
     sal_Int32 nByteOffset  = 1;
 
     // Felder aktualisieren:
     Reference<XPropertySet> xCol;
     Reference<XPropertySet> xIndex;
-    USHORT i;
+    sal_uInt16 i;
     ::rtl::OUString aColName;
     const sal_Int32 nColumnCount = m_pColumns->getCount();
     ::std::vector< Reference<XPropertySet> > aIndexedCols(nColumnCount);
@@ -1936,7 +1936,7 @@ BOOL ODbaseTable::UpdateBuffer(OValueRefVector& rRow, OValueRefRow pOrgRow,const
                     // sein koennte und muesste
 
                     const ByteString aDefaultValue( ::rtl::math::doubleToString( n, rtl_math_StringFormat_F, nScale, '.', NULL, 0));
-                    BOOL bValidLength  = aDefaultValue.Len() <= nLen;
+                    sal_Bool bValidLength  = aDefaultValue.Len() <= nLen;
                     if ( bValidLength )
                     {
                         strncpy(pData,aDefaultValue.GetBuffer(),nLen);
@@ -1970,7 +1970,7 @@ BOOL ODbaseTable::UpdateBuffer(OValueRefVector& rRow, OValueRefRow pOrgRow,const
                     char cNext = pData[nLen]; // merken und temporaer durch 0 ersetzen
                     pData[nLen] = '\0';       // das geht, da der Puffer immer ein Zeichen groesser ist ...
 
-                    ULONG nBlockNo = strtol((const char *)pData,NULL,10);   // Blocknummer lesen
+                    sal_uIntPtr nBlockNo = strtol((const char *)pData,NULL,10); // Blocknummer lesen
 
                     // Naechstes Anfangszeichen wieder restaurieren:
                     pData[nLen] = cNext;
@@ -2028,14 +2028,14 @@ BOOL ODbaseTable::UpdateBuffer(OValueRefVector& rRow, OValueRefRow pOrgRow,const
 }
 
 // -----------------------------------------------------------------------------
-BOOL ODbaseTable::WriteMemo(ORowSetValue& aVariable, ULONG& rBlockNr)
+sal_Bool ODbaseTable::WriteMemo(ORowSetValue& aVariable, sal_uIntPtr& rBlockNr)
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::WriteMemo" );
     // wird die BlockNr 0 vorgegeben, wird der block ans Ende gehaengt
-    ULONG nSize = 0;
+    sal_uIntPtr nSize = 0;
     ::rtl::OString aStr;
     ::com::sun::star::uno::Sequence<sal_Int8> aValue;
-    BYTE nHeader[4];
+    sal_uInt8 nHeader[4];
     const bool bBinary = aVariable.getTypeKind() == DataType::LONGVARBINARY && m_aMemoHeader.db_typ == MemoFoxPro;
     if ( bBinary )
     {
@@ -2048,7 +2048,7 @@ BOOL ODbaseTable::WriteMemo(ORowSetValue& aVariable, ULONG& rBlockNr)
     }
 
     // Anhaengen oder ueberschreiben
-    BOOL bAppend = rBlockNr == 0;
+    sal_Bool bAppend = rBlockNr == 0;
 
     if (!bAppend)
     {
@@ -2065,7 +2065,7 @@ BOOL ODbaseTable::WriteMemo(ORowSetValue& aVariable, ULONG& rBlockNr)
                 m_pMemoStream->SeekRel(4L);
                 m_pMemoStream->Read(sHeader,4);
 
-                ULONG nOldSize;
+                sal_uIntPtr nOldSize;
                 if (m_aMemoHeader.db_typ == MemoFoxPro)
                     nOldSize = ((((unsigned char)sHeader[0]) * 256 +
                                  (unsigned char)sHeader[1]) * 256 +
@@ -2078,7 +2078,7 @@ BOOL ODbaseTable::WriteMemo(ORowSetValue& aVariable, ULONG& rBlockNr)
                                  (unsigned char)sHeader[0]  - 8;
 
                 // passt die neue Laenge in die belegten Bloecke
-                ULONG nUsedBlocks = ((nSize + 8) / m_aMemoHeader.db_size) + (((nSize + 8) % m_aMemoHeader.db_size > 0) ? 1 : 0),
+                sal_uIntPtr nUsedBlocks = ((nSize + 8) / m_aMemoHeader.db_size) + (((nSize + 8) % m_aMemoHeader.db_size > 0) ? 1 : 0),
                       nOldUsedBlocks = ((nOldSize + 8) / m_aMemoHeader.db_size) + (((nOldSize + 8) % m_aMemoHeader.db_size > 0) ? 1 : 0);
                 bAppend = nUsedBlocks > nOldUsedBlocks;
             }
@@ -2087,7 +2087,7 @@ BOOL ODbaseTable::WriteMemo(ORowSetValue& aVariable, ULONG& rBlockNr)
 
     if (bAppend)
     {
-        ULONG nStreamSize = m_pMemoStream->Seek(STREAM_SEEK_TO_END);
+        sal_uIntPtr nStreamSize = m_pMemoStream->Seek(STREAM_SEEK_TO_END);
         // letzten block auffuellen
         rBlockNr = (nStreamSize / m_aMemoHeader.db_size) + ((nStreamSize % m_aMemoHeader.db_size) > 0 ? 1 : 0);
 
@@ -2112,30 +2112,30 @@ BOOL ODbaseTable::WriteMemo(ORowSetValue& aVariable, ULONG& rBlockNr)
         case MemodBaseIV: // dBase IV-Memofeld mit Laengenangabe
         {
             if ( MemodBaseIV == m_aMemoHeader.db_typ )
-                (*m_pMemoStream) << (BYTE)0xFF
-                                 << (BYTE)0xFF
-                                 << (BYTE)0x08;
+                (*m_pMemoStream) << (sal_uInt8)0xFF
+                                 << (sal_uInt8)0xFF
+                                 << (sal_uInt8)0x08;
             else
-                (*m_pMemoStream) << (BYTE)0x00
-                                 << (BYTE)0x00
-                                 << (BYTE)0x00;
+                (*m_pMemoStream) << (sal_uInt8)0x00
+                                 << (sal_uInt8)0x00
+                                 << (sal_uInt8)0x00;
 
-            UINT32 nWriteSize = nSize;
+            sal_uInt32 nWriteSize = nSize;
             if (m_aMemoHeader.db_typ == MemoFoxPro)
             {
                 if ( bBinary )
-                    (*m_pMemoStream) << (BYTE) 0x00; // Picture
+                    (*m_pMemoStream) << (sal_uInt8) 0x00; // Picture
                 else
-                    (*m_pMemoStream) << (BYTE) 0x01; // Memo
+                    (*m_pMemoStream) << (sal_uInt8) 0x01; // Memo
                 for (int i = 4; i > 0; nWriteSize >>= 8)
-                    nHeader[--i] = (BYTE) (nWriteSize % 256);
+                    nHeader[--i] = (sal_uInt8) (nWriteSize % 256);
             }
             else
             {
-                (*m_pMemoStream) << (BYTE) 0x00;
+                (*m_pMemoStream) << (sal_uInt8) 0x00;
                 nWriteSize += 8;
                 for (int i = 0; i < 4; nWriteSize >>= 8)
-                    nHeader[i++] = (BYTE) (nWriteSize % 256);
+                    nHeader[i++] = (sal_uInt8) (nWriteSize % 256);
             }
 
             m_pMemoStream->Write(nHeader,4);
@@ -2151,7 +2151,7 @@ BOOL ODbaseTable::WriteMemo(ORowSetValue& aVariable, ULONG& rBlockNr)
     // Schreiben der neuen Blocknummer
     if (bAppend)
     {
-        ULONG nStreamSize = m_pMemoStream->Seek(STREAM_SEEK_TO_END);
+        sal_uIntPtr nStreamSize = m_pMemoStream->Seek(STREAM_SEEK_TO_END);
         m_aMemoHeader.db_next = (nStreamSize / m_aMemoHeader.db_size) + ((nStreamSize % m_aMemoHeader.db_size) > 0 ? 1 : 0);
 
         // Schreiben der neuen Blocknummer
@@ -2208,7 +2208,7 @@ void ODbaseTable::alterColumn(sal_Int32 index,
         if(xOldColumn.is())
             xCopyColumn = xOldColumn->createDataDescriptor();
         else
-            xCopyColumn = new OColumn(getConnection()->getMetaData()->storesMixedCaseQuotedIdentifiers());
+            xCopyColumn = new OColumn(getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers());
 
         ::comphelper::copyProperties(descriptor,xCopyColumn);
 
@@ -2233,7 +2233,7 @@ void ODbaseTable::alterColumn(sal_Int32 index,
             if(xColumn.is())
                 xCpy = xColumn->createDataDescriptor();
             else
-                xCpy = new OColumn(getConnection()->getMetaData()->storesMixedCaseQuotedIdentifiers());
+                xCpy = new OColumn(getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers());
             ::comphelper::copyProperties(xProp,xCpy);
             xAppend->appendByDescriptor(xCpy);
         }
@@ -2249,7 +2249,7 @@ void ODbaseTable::alterColumn(sal_Int32 index,
             if(xColumn.is())
                 xCpy = xColumn->createDataDescriptor();
             else
-                xCpy = new OColumn(getConnection()->getMetaData()->storesMixedCaseQuotedIdentifiers());
+                xCpy = new OColumn(getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers());
             ::comphelper::copyProperties(xProp,xCpy);
             xAppend->appendByDescriptor(xCpy);
         }
@@ -2390,7 +2390,7 @@ void ODbaseTable::addColumn(const Reference< XPropertySet >& _xNewColumn)
     pNewTable->setPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME),makeAny(::rtl::OUString(sTempName)));
     {
         Reference<XAppend> xAppend(pNewTable->getColumns(),UNO_QUERY);
-        sal_Bool bCase = getConnection()->getMetaData()->storesMixedCaseQuotedIdentifiers();
+        sal_Bool bCase = getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers();
         // copy the structure
         for(sal_Int32 i=0;i < m_pColumns->getCount();++i)
         {
@@ -2423,7 +2423,7 @@ void ODbaseTable::addColumn(const Reference< XPropertySet >& _xNewColumn)
         ::dbtools::throwGenericSQLException( sError, *this );
     }
 
-    BOOL bAlreadyDroped = FALSE;
+    sal_Bool bAlreadyDroped = sal_False;
     try
     {
         pNewTable->construct();
@@ -2432,7 +2432,7 @@ void ODbaseTable::addColumn(const Reference< XPropertySet >& _xNewColumn)
         // drop the old table
         if(DropImpl())
         {
-            bAlreadyDroped = TRUE;
+            bAlreadyDroped = sal_True;
             pNewTable->renameImpl(m_Name);
             // release the temp file
         }
@@ -2463,7 +2463,7 @@ void ODbaseTable::dropColumn(sal_Int32 _nPos)
     pNewTable->setPropertyValue(OMetaConnection::getPropMap().getNameByIndex(PROPERTY_ID_NAME),makeAny(::rtl::OUString(sTempName)));
     {
         Reference<XAppend> xAppend(pNewTable->getColumns(),UNO_QUERY);
-        sal_Bool bCase = getConnection()->getMetaData()->storesMixedCaseQuotedIdentifiers();
+        sal_Bool bCase = getConnection()->getMetaData()->supportsMixedCaseQuotedIdentifiers();
         // copy the structure
         for(sal_Int32 i=0;i < m_pColumns->getCount();++i)
         {
@@ -2660,7 +2660,7 @@ sal_Bool ODbaseTable::seekRow(IResultSetHelper::Movement eCursorPosition, sal_In
         OSL_ENSURE(m_nFilePos >= 1,"SdbDBFCursor::FileFetchRow: ungueltige Record-Position");
         sal_Int32 nPos = m_aHeader.db_kopf + (sal_Int32)(m_nFilePos-1) * nEntryLen;
 
-        ULONG nLen = m_pFileStream->Seek(nPos);
+        sal_uIntPtr nLen = m_pFileStream->Seek(nPos);
         if (m_pFileStream->GetError() != ERRCODE_NONE)
             goto Error;
 
@@ -2697,10 +2697,10 @@ End:
     return sal_True;
 }
 // -----------------------------------------------------------------------------
-BOOL ODbaseTable::ReadMemo(ULONG nBlockNo, ORowSetValue& aVariable)
+sal_Bool ODbaseTable::ReadMemo(sal_uIntPtr nBlockNo, ORowSetValue& aVariable)
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::ReadMemo" );
-    BOOL bIsText = TRUE;
+    sal_Bool bIsText = sal_True;
     //  SdbConnection* pConnection = GetConnection();
 
     m_pMemoStream->Seek(nBlockNo * m_aMemoHeader.db_size);
@@ -2712,13 +2712,13 @@ BOOL ODbaseTable::ReadMemo(ULONG nBlockNo, ORowSetValue& aVariable)
             ByteString aBStr;
             static char aBuf[514];
             aBuf[512] = 0;          // sonst kann der Zufall uebel mitspielen
-            BOOL bReady = sal_False;
+            sal_Bool bReady = sal_False;
 
             do
             {
                 m_pMemoStream->Read(&aBuf,512);
 
-                USHORT i = 0;
+                sal_uInt16 i = 0;
                 while (aBuf[i] != cEOF && ++i < 512)
                     ;
                 bReady = aBuf[i] == cEOF;
@@ -2740,7 +2740,7 @@ BOOL ODbaseTable::ReadMemo(ULONG nBlockNo, ORowSetValue& aVariable)
             // Foxpro stores text and binary data
             if (m_aMemoHeader.db_typ == MemoFoxPro)
             {
-//              if (((BYTE)sHeader[0]) != 0 || ((BYTE)sHeader[1]) != 0 || ((BYTE)sHeader[2]) != 0)
+//              if (((sal_uInt8)sHeader[0]) != 0 || ((sal_uInt8)sHeader[1]) != 0 || ((sal_uInt8)sHeader[2]) != 0)
 //              {
 ////                    String aText = String(SdbResId(STR_STAT_IResultSetHelper::INVALID));
 ////                    aText.SearchAndReplace(String::CreateFromAscii("%%d"),m_pMemoStream->GetFileName());
@@ -2754,7 +2754,7 @@ BOOL ODbaseTable::ReadMemo(ULONG nBlockNo, ORowSetValue& aVariable)
 //
                 bIsText = sHeader[3] != 0;
             }
-            else if (((BYTE)sHeader[0]) != 0xFF || ((BYTE)sHeader[1]) != 0xFF || ((BYTE)sHeader[2]) != 0x08)
+            else if (((sal_uInt8)sHeader[0]) != 0xFF || ((sal_uInt8)sHeader[1]) != 0xFF || ((sal_uInt8)sHeader[2]) != 0x08)
             {
 //              String aText = String(SdbResId(STR_STAT_IResultSetHelper::INVALID));
 //              aText.SearchAndReplace(String::CreateFromAscii("%%d"),m_pMemoStream->GetFileName());
@@ -2812,7 +2812,7 @@ BOOL ODbaseTable::ReadMemo(ULONG nBlockNo, ORowSetValue& aVariable)
 void ODbaseTable::AllocBuffer()
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::AllocBuffer" );
-    UINT16 nSize = m_aHeader.db_slng;
+    sal_uInt16 nSize = m_aHeader.db_slng;
     OSL_ENSURE(nSize > 0, "Size too small");
 
     if (m_nBufferSize != nSize)
@@ -2825,11 +2825,11 @@ void ODbaseTable::AllocBuffer()
     if (m_pBuffer == NULL && nSize)
     {
         m_nBufferSize = nSize;
-        m_pBuffer       = new BYTE[m_nBufferSize+1];
+        m_pBuffer       = new sal_uInt8[m_nBufferSize+1];
     }
 }
 // -----------------------------------------------------------------------------
-BOOL ODbaseTable::WriteBuffer()
+sal_Bool ODbaseTable::WriteBuffer()
 {
     RTL_LOGFILE_CONTEXT_AUTHOR( aLogger, "dbase", "Ocke.Janssen@sun.com", "ODbaseTable::WriteBuffer" );
     OSL_ENSURE(m_nFilePos >= 1,"SdbDBFCursor::FileFetchRow: ungueltige Record-Position");
diff --git a/connectivity/source/drivers/dbase/dindexnode.cxx b/connectivity/source/drivers/dbase/dindexnode.cxx
index 9a8905b6a6ba..767595d06b85 100644
--- a/connectivity/source/drivers/dbase/dindexnode.cxx
+++ b/connectivity/source/drivers/dbase/dindexnode.cxx
@@ -42,19 +42,19 @@ using namespace connectivity::dbase;
 using namespace connectivity::file;
 using namespace com::sun::star::sdbc;
 // -----------------------------------------------------------------------------
-ONDXKey::ONDXKey(UINT32 nRec)
+ONDXKey::ONDXKey(sal_uInt32 nRec)
     :nRecord(nRec)
 {
 }
 // -----------------------------------------------------------------------------
-ONDXKey::ONDXKey(const ORowSetValue& rVal, sal_Int32 eType, UINT32 nRec)
+ONDXKey::ONDXKey(const ORowSetValue& rVal, sal_Int32 eType, sal_uInt32 nRec)
     : ONDXKey_BASE(eType)
     , nRecord(nRec)
     , xValue(rVal)
 {
 }
 // -----------------------------------------------------------------------------
-ONDXKey::ONDXKey(const rtl::OUString& aStr, UINT32 nRec)
+ONDXKey::ONDXKey(const rtl::OUString& aStr, sal_uInt32 nRec)
     : ONDXKey_BASE(::com::sun::star::sdbc::DataType::VARCHAR)
      ,nRecord(nRec)
 {
@@ -66,7 +66,7 @@ ONDXKey::ONDXKey(const rtl::OUString& aStr, UINT32 nRec)
 }
 // -----------------------------------------------------------------------------
 
-ONDXKey::ONDXKey(double aVal, UINT32 nRec)
+ONDXKey::ONDXKey(double aVal, sal_uInt32 nRec)
     : ONDXKey_BASE(::com::sun::star::sdbc::DataType::DOUBLE)
      ,nRecord(nRec)
      ,xValue(aVal)
@@ -79,7 +79,7 @@ ONDXKey::ONDXKey(double aVal, UINT32 nRec)
 //==================================================================
 ONDXPage::ONDXPage(ODbaseIndex& rInd, sal_uInt32 nPos, ONDXPage* pParent)
            :nPagePos(nPos)
-           ,bModified(FALSE)
+           ,bModified(sal_False)
            ,nCount(0)
            ,aParent(pParent)
            ,rIndex(rInd)
@@ -103,16 +103,16 @@ void ONDXPage::QueryDelete()
     if (IsModified() && rIndex.m_pFileStream)
         (*rIndex.m_pFileStream) << *this;
 
-    bModified = FALSE;
+    bModified = sal_False;
     if (rIndex.UseCollector())
     {
         if (aChild.Is())
-            aChild->Release(FALSE);
+            aChild->Release(sal_False);
 
-        for (USHORT i = 0; i < rIndex.getHeader().db_maxkeys;i++)
+        for (sal_uInt16 i = 0; i < rIndex.getHeader().db_maxkeys;i++)
         {
             if (ppNodes[i].GetChild().Is())
-                ppNodes[i].GetChild()->Release(FALSE);
+                ppNodes[i].GetChild()->Release(sal_False);
 
             ppNodes[i] = ONDXNode();
         }
@@ -136,10 +136,10 @@ ONDXPagePtr& ONDXPage::GetChild(ODbaseIndex* pIndex)
 }
 
 //------------------------------------------------------------------
-USHORT ONDXPage::FindPos(const ONDXKey& rKey) const
+sal_uInt16 ONDXPage::FindPos(const ONDXKey& rKey) const
 {
     // sucht nach Platz fuer den vorgegeben key auf einer Seite
-    USHORT i = 0;
+    sal_uInt16 i = 0;
     while (i < nCount && rKey > ((*this)[i]).GetKey())
            i++;
 
@@ -147,18 +147,18 @@ USHORT ONDXPage::FindPos(const ONDXKey& rKey) const
 }
 
 //------------------------------------------------------------------
-BOOL ONDXPage::Find(const ONDXKey& rKey)
+sal_Bool ONDXPage::Find(const ONDXKey& rKey)
 {
     // sucht den vorgegeben key
     // Besonderheit: gelangt der Algorithmus ans Ende
     // wird immer die aktuelle Seite und die Knotenposition vermerkt
     // auf die die Bedingung <= zutrifft
     // dieses findet beim Insert besondere Beachtung
-    USHORT i = 0;
+    sal_uInt16 i = 0;
     while (i < nCount && rKey > ((*this)[i]).GetKey())
            i++;
 
-    BOOL bResult = FALSE;
+    sal_Bool bResult = sal_False;
 
     if (!IsLeaf())
     {
@@ -170,7 +170,7 @@ BOOL ONDXPage::Find(const ONDXKey& rKey)
     {
         rIndex.m_aCurLeaf = this;
         rIndex.m_nCurNode = i - 1;
-        bResult = FALSE;
+        bResult = sal_False;
     }
     else
     {
@@ -182,14 +182,14 @@ BOOL ONDXPage::Find(const ONDXKey& rKey)
 }
 
 //------------------------------------------------------------------
-BOOL ONDXPage::Insert(ONDXNode& rNode, sal_uInt32 nRowsLeft)
+sal_Bool ONDXPage::Insert(ONDXNode& rNode, sal_uInt32 nRowsLeft)
 {
     // beim Erzeugen eines Index koennen auch mehrere Knoten eingefuegt werden
     // diese sin dann aufsteigend sortiert
-    BOOL bAppend = nRowsLeft > 0;
+    sal_Bool bAppend = nRowsLeft > 0;
     if (IsFull())
     {
-        BOOL bResult = TRUE;
+        sal_Bool bResult = sal_True;
         ONDXNode aSplitNode;
         if (bAppend)
             aSplitNode = rNode;
@@ -210,7 +210,7 @@ BOOL ONDXPage::Insert(ONDXNode& rNode, sal_uInt32 nRowsLeft)
                 }
                 else  // Position unbekannt
                 {
-                    USHORT nPos = NODE_NOTFOUND;
+                    sal_uInt16 nPos = NODE_NOTFOUND;
                     while (++nPos < nCount && rNode.GetKey() > ((*this)[nPos]).GetKey()) ;
 
                     --nCount;   // (sonst bekomme ich u.U. Assertions und GPFs - 60593)
@@ -295,7 +295,7 @@ BOOL ONDXPage::Insert(ONDXNode& rNode, sal_uInt32 nRowsLeft)
         }
         else
         {
-            USHORT nNodePos = FindPos(rNode.GetKey());
+            sal_uInt16 nNodePos = FindPos(rNode.GetKey());
             if (IsLeaf())
                 rIndex.m_nCurNode = nNodePos;
 
@@ -305,17 +305,17 @@ BOOL ONDXPage::Insert(ONDXNode& rNode, sal_uInt32 nRowsLeft)
 }
 
 //------------------------------------------------------------------
-BOOL ONDXPage::Insert(USHORT nPos, ONDXNode& rNode)
+sal_Bool ONDXPage::Insert(sal_uInt16 nPos, ONDXNode& rNode)
 {
-    USHORT nMaxCount = rIndex.getHeader().db_maxkeys;
+    sal_uInt16 nMaxCount = rIndex.getHeader().db_maxkeys;
     if (nPos >= nMaxCount)
-        return FALSE;
+        return sal_False;
 
     if (nCount)
     {
         ++nCount;
         // nach rechts verschieben
-        for (USHORT i = std::min((USHORT)(nMaxCount-1), (USHORT)(nCount-1)); nPos < i; --i)
+        for (sal_uInt16 i = std::min((sal_uInt16)(nMaxCount-1), (sal_uInt16)(nCount-1)); nPos < i; --i)
             (*this)[i] = (*this)[i-1];
     }
     else
@@ -331,19 +331,19 @@ BOOL ONDXPage::Insert(USHORT nPos, ONDXNode& rNode)
         rNode.GetChild()->SetParent(this);
     }
 
-    bModified = TRUE;
+    bModified = sal_True;
 
-    return TRUE;
+    return sal_True;
 }
 
 //------------------------------------------------------------------
-BOOL ONDXPage::Append(ONDXNode& rNode)
+sal_Bool ONDXPage::Append(ONDXNode& rNode)
 {
     DBG_ASSERT(!IsFull(), "kein Append moeglich");
     return Insert(nCount, rNode);
 }
 //------------------------------------------------------------------
-void ONDXPage::Release(BOOL bSave)
+void ONDXPage::Release(sal_Bool bSave)
 {
     // freigeben der Pages
     if (aChild.Is())
@@ -352,7 +352,7 @@ void ONDXPage::Release(BOOL bSave)
     // Pointer freigeben
     aChild.Clear();
 
-    for (USHORT i = 0; i < rIndex.getHeader().db_maxkeys;i++)
+    for (sal_uInt16 i = 0; i < rIndex.getHeader().db_maxkeys;i++)
     {
         if (ppNodes[i].GetChild())
             ppNodes[i].GetChild()->Release(bSave);
@@ -362,7 +362,7 @@ void ONDXPage::Release(BOOL bSave)
     aParent = NULL;
 }
 //------------------------------------------------------------------
-void ONDXPage::ReleaseFull(BOOL bSave)
+void ONDXPage::ReleaseFull(sal_Bool bSave)
 {
     ONDXPagePtr aTempParent = aParent;
     Release(bSave);
@@ -371,7 +371,7 @@ void ONDXPage::ReleaseFull(BOOL bSave)
     {
         // Freigeben nicht benoetigter Seiten, danach besteht keine Referenz
         // mehr auf die Seite, danach kann 'this' nicht mehr gueltig sein!!!
-        USHORT nParentPos = aTempParent->Search(this);
+        sal_uInt16 nParentPos = aTempParent->Search(this);
         if (nParentPos != NODE_NOTFOUND)
             (*aTempParent)[nParentPos].GetChild().Clear();
         else
@@ -379,7 +379,7 @@ void ONDXPage::ReleaseFull(BOOL bSave)
     }
 }
 //------------------------------------------------------------------
-BOOL ONDXPage::Delete(USHORT nNodePos)
+sal_Bool ONDXPage::Delete(sal_uInt16 nNodePos)
 {
     if (IsLeaf())
     {
@@ -402,7 +402,7 @@ BOOL ONDXPage::Delete(USHORT nNodePos)
     if (HasParent() && nCount < (rIndex.GetMaxNodes() / 2))
     {
         // Feststellen, welcher Knoten auf die Seite zeigt
-        USHORT nParentNodePos = aParent->Search(this);
+        sal_uInt16 nParentNodePos = aParent->Search(this);
         // letzte Element auf Vaterseite
         // -> zusammenlegen mit vorletzter Seite
         if (nParentNodePos == (aParent->Count() - 1))
@@ -455,7 +455,7 @@ BOOL ONDXPage::Delete(USHORT nNodePos)
     else if (IsRoot())
         // Sicherstellen das die Position der Wurzel festgehalten wird
         rIndex.SetRootPos(nPagePos);
-    return TRUE;
+    return sal_True;
 }
 
 
@@ -476,7 +476,7 @@ ONDXNode ONDXPage::Split(ONDXPage& rPage)
     ONDXNode aResultNode;
     if (IsLeaf())
     {
-        for (USHORT i = (nCount - (nCount / 2)), j = 0 ; i < nCount; i++)
+        for (sal_uInt16 i = (nCount - (nCount / 2)), j = 0 ; i < nCount; i++)
             rPage.Insert(j++,(*this)[i]);
 
         // dieser Knoten enthaelt einen Schluessel der noch einmal im Tree vorkommt
@@ -491,7 +491,7 @@ ONDXNode ONDXPage::Split(ONDXPage& rPage)
     }
     else
     {
-        for (USHORT i = (nCount + 1) / 2 + 1, j = 0 ; i < nCount; i++)
+        for (sal_uInt16 i = (nCount + 1) / 2 + 1, j = 0 ; i < nCount; i++)
             rPage.Insert(j++,(*this)[i]);
 
         aResultNode = (*this)[(nCount + 1) / 2];
@@ -506,31 +506,31 @@ ONDXNode ONDXPage::Split(ONDXPage& rPage)
     // innere Knoten haben keine Recordnummer
     if (rIndex.isUnique())
         aResultNode.GetKey().ResetRecord();
-    bModified = TRUE;
+    bModified = sal_True;
     return aResultNode;
 }
 
 //------------------------------------------------------------------
-void ONDXPage::Merge(USHORT nParentNodePos, ONDXPagePtr xPage)
+void ONDXPage::Merge(sal_uInt16 nParentNodePos, ONDXPagePtr xPage)
 {
     DBG_ASSERT(HasParent(), "kein Vater vorhanden");
     DBG_ASSERT(nParentNodePos != NODE_NOTFOUND, "Falscher Indexaufbau");
 
     /*  Zusammenlegen zweier Seiten */
     ONDXNode aResultNode;
-    USHORT nMaxNodes = rIndex.GetMaxNodes(),
+    sal_uInt16 nMaxNodes = rIndex.GetMaxNodes(),
            nMaxNodes_2 = nMaxNodes / 2;
 
     // Feststellen ob Seite rechter oder linker Nachbar
-    BOOL    bRight    = ((*xPage)[0].GetKey() > (*this)[0].GetKey()); // TRUE, wenn xPage die rechte Seite ist
-    USHORT  nNewCount = (*xPage).Count() + Count();
+    sal_Bool    bRight    = ((*xPage)[0].GetKey() > (*this)[0].GetKey()); // sal_True, wenn xPage die rechte Seite ist
+    sal_uInt16  nNewCount = (*xPage).Count() + Count();
 
     if (IsLeaf())
     {
         // Bedingung fuers zusammenlegen
         if (nNewCount < (nMaxNodes_2 * 2))
         {
-            USHORT nLastNode = bRight ? Count() - 1 : xPage->Count() - 1;
+            sal_uInt16 nLastNode = bRight ? Count() - 1 : xPage->Count() - 1;
             if (bRight)
             {
                 DBG_ASSERT(&xPage != this,"xPage und THIS duerfen nicht gleich sein: Endlosschleife");
@@ -555,7 +555,7 @@ void ONDXPage::Merge(USHORT nParentNodePos, ONDXPagePtr xPage)
                     (*aParent)[nParentNodePos-1].SetChild(this,aParent);
                 else // oder als rechten Knoten setzen
                     aParent->SetChild(this);
-                aParent->SetModified(TRUE);
+                aParent->SetModified(sal_True);
 
             }
 
@@ -571,12 +571,12 @@ void ONDXPage::Merge(USHORT nParentNodePos, ONDXPagePtr xPage)
                 aParent = NULL;
                 rIndex.SetRootPos(nPagePos);
                 rIndex.m_aRoot = this;
-                SetModified(TRUE);
+                SetModified(sal_True);
             }
             else
                 aParent->SearchAndReplace((*this)[nLastNode].GetKey(),(*this)[nCount-1].GetKey());
 
-            xPage->SetModified(FALSE);
+            xPage->SetModified(sal_False);
             xPage->ReleaseFull(); // wird nicht mehr benoetigt
         }
         // Ausgleichen der Elemente   nNewCount >= (nMaxNodes_2 * 2)
@@ -620,7 +620,7 @@ void ONDXPage::Merge(USHORT nParentNodePos, ONDXPagePtr xPage)
                 // erhaelt zunaechst Child von xPage
                 (*aParent)[nParentNodePos].SetChild(xPage->GetChild(),aParent);
                 Append((*aParent)[nParentNodePos]);
-                for (USHORT i = 0 ; i < xPage->Count(); i++)
+                for (sal_uInt16 i = 0 ; i < xPage->Count(); i++)
                     Append((*xPage)[i]);
             }
             else
@@ -645,7 +645,7 @@ void ONDXPage::Merge(USHORT nParentNodePos, ONDXPagePtr xPage)
 
             // danach wird der Vaterknoten zurueckgesetzt
             (*aParent)[nParentNodePos].SetChild();
-            aParent->SetModified(TRUE);
+            aParent->SetModified(sal_True);
 
             if(aParent->IsRoot() && aParent->Count() == 1)
             {
@@ -654,7 +654,7 @@ void ONDXPage::Merge(USHORT nParentNodePos, ONDXPagePtr xPage)
                 aParent = NULL;
                 rIndex.SetRootPos(nPagePos);
                 rIndex.m_aRoot = this;
-                SetModified(TRUE);
+                SetModified(sal_True);
             }
             else if(nParentNodePos)
                 // Austauschen des KnotenWertes
@@ -662,7 +662,7 @@ void ONDXPage::Merge(USHORT nParentNodePos, ONDXPagePtr xPage)
                 // deshalb muss der Knoten auch hier aktualisiert werden
                 aParent->SearchAndReplace((*aParent)[nParentNodePos-1].GetKey(),(*aParent)[nParentNodePos].GetKey());
 
-            xPage->SetModified(FALSE);
+            xPage->SetModified(sal_False);
             xPage->ReleaseFull();
         }
         // Ausgleichen der Elemente
@@ -693,7 +693,7 @@ void ONDXPage::Merge(USHORT nParentNodePos, ONDXPagePtr xPage)
                 (*aParent)[nParentNodePos].SetChild(this,aParent);
 
             }
-            aParent->SetModified(TRUE);
+            aParent->SetModified(sal_True);
         }
     }
 }
@@ -715,7 +715,7 @@ void ONDXNode::Read(SvStream &rStream, ODbaseIndex& rIndex)
     else
     {
         ByteString aBuf;
-        USHORT nLen = rIndex.getHeader().db_keylen;
+        sal_uInt16 nLen = rIndex.getHeader().db_keylen;
         char* pStr = aBuf.AllocBuffer(nLen+1);
 
         rStream.Read(pStr,nLen);
@@ -748,7 +748,7 @@ void ONDXNode::Write(SvStream &rStream, const ONDXPage& rPage) const
         if (aKey.getValue().isNull())
         {
             memset(aNodeData.aData,0,rIndex.getHeader().db_keylen);
-            rStream.Write((BYTE*)aNodeData.aData,rIndex.getHeader().db_keylen);
+            rStream.Write((sal_uInt8*)aNodeData.aData,rIndex.getHeader().db_keylen);
         }
         else
             rStream << (double) aKey.getValue();
@@ -762,7 +762,7 @@ void ONDXNode::Write(SvStream &rStream, const ONDXPage& rPage) const
             ByteString aText(sValue.getStr(), rIndex.m_pTable->getConnection()->getTextEncoding());
             strncpy(aNodeData.aData,aText.GetBuffer(),std::min(rIndex.getHeader().db_keylen, aText.Len()));
         }
-        rStream.Write((BYTE*)aNodeData.aData,rIndex.getHeader().db_keylen);
+        rStream.Write((sal_uInt8*)aNodeData.aData,rIndex.getHeader().db_keylen);
     }
     rStream << aChild;
 }
@@ -782,7 +782,7 @@ ONDXPagePtr& ONDXNode::GetChild(ODbaseIndex* pIndex, ONDXPage* pParent)
 // ONDXKey
 //==================================================================
 //------------------------------------------------------------------
-BOOL ONDXKey::IsText(sal_Int32 eType)
+sal_Bool ONDXKey::IsText(sal_Int32 eType)
 {
     return eType == DataType::VARCHAR || eType == DataType::CHAR;
 }
@@ -809,7 +809,7 @@ StringCompare ONDXKey::Compare(const ONDXKey& rKey) const
     }
     else if (IsText(getDBType()))
     {
-        INT32 nRes = getValue().getString().compareTo(rKey.getValue());
+        sal_Int32 nRes = getValue().getString().compareTo(rKey.getValue());
         eResult = (nRes > 0) ? COMPARE_GREATER : (nRes == 0) ? COMPARE_EQUAL : COMPARE_LESS;
     }
     else
@@ -882,16 +882,16 @@ ONDXPagePtr& ONDXPagePtr::operator= (ONDXPage* pRef)
     return *this;
 }
 // -----------------------------------------------------------------------------
-static UINT32 nValue;
+static sal_uInt32 nValue;
 //------------------------------------------------------------------
 SvStream& connectivity::dbase::operator >> (SvStream &rStream, ONDXPage& rPage)
 {
     rStream.Seek(rPage.GetPagePos() * PAGE_SIZE);
     rStream >> nValue >> rPage.aChild;
-    rPage.nCount = USHORT(nValue);
+    rPage.nCount = sal_uInt16(nValue);
 
 //  DBG_ASSERT(rPage.nCount && rPage.nCount < rPage.GetIndex().GetMaxNodes(), "Falscher Count");
-    for (USHORT i = 0; i < rPage.nCount; i++)
+    for (sal_uInt16 i = 0; i < rPage.nCount; i++)
         rPage[i].Read(rStream, rPage.GetIndex());
     return rStream;
 }
@@ -900,7 +900,7 @@ SvStream& connectivity::dbase::operator >> (SvStream &rStream, ONDXPage& rPage)
 SvStream& connectivity::dbase::operator << (SvStream &rStream, const ONDXPage& rPage)
 {
     // Seite existiert noch nicht
-    ULONG nSize = (rPage.GetPagePos() + 1) * PAGE_SIZE;
+    sal_uIntPtr nSize = (rPage.GetPagePos() + 1) * PAGE_SIZE;
     if (nSize > rStream.Seek(STREAM_SEEK_TO_END))
     {
         rStream.SetStreamSize(nSize);
@@ -908,27 +908,27 @@ SvStream& connectivity::dbase::operator << (SvStream &rStream, const ONDXPage& r
 
         char aEmptyData[PAGE_SIZE];
         memset(aEmptyData,0x00,PAGE_SIZE);
-        rStream.Write((BYTE*)aEmptyData,PAGE_SIZE);
+        rStream.Write((sal_uInt8*)aEmptyData,PAGE_SIZE);
     }
-    ULONG nCurrentPos = rStream.Seek(rPage.GetPagePos() * PAGE_SIZE);
+    sal_uIntPtr nCurrentPos = rStream.Seek(rPage.GetPagePos() * PAGE_SIZE);
     OSL_UNUSED( nCurrentPos );
 
     nValue = rPage.nCount;
     rStream << nValue << rPage.aChild;
 
-    USHORT i = 0;
+    sal_uInt16 i = 0;
     for (; i < rPage.nCount; i++)
         rPage[i].Write(rStream, rPage);
 
     // check if we have to fill the stream with '\0'
     if(i < rPage.rIndex.getHeader().db_maxkeys)
     {
-        ULONG nTell = rStream.Tell() % PAGE_SIZE;
-        USHORT nBufferSize = rStream.GetBufferSize();
-        ULONG nRemainSize = nBufferSize - nTell;
+        sal_uIntPtr nTell = rStream.Tell() % PAGE_SIZE;
+        sal_uInt16 nBufferSize = rStream.GetBufferSize();
+        sal_uIntPtr nRemainSize = nBufferSize - nTell;
         char* pEmptyData = new char[nRemainSize];
         memset(pEmptyData,0x00,nRemainSize);
-        rStream.Write((BYTE*)pEmptyData,nRemainSize);
+        rStream.Write((sal_uInt8*)pEmptyData,nRemainSize);
         rStream.Seek(nTell);
         delete [] pEmptyData;
     }
@@ -942,7 +942,7 @@ void ONDXPage::PrintPage()
     DBG_TRACE4("\nSDB: -----------Page: %d  Parent: %d  Count: %d  Child: %d-----",
         nPagePos, HasParent() ? aParent->GetPagePos() : 0 ,nCount, aChild.GetPagePos());
 
-    for (USHORT i = 0; i < nCount; i++)
+    for (sal_uInt16 i = 0; i < nCount; i++)
     {
         ONDXNode rNode = (*this)[i];
         ONDXKey&  rKey = rNode.GetKey();
@@ -967,7 +967,7 @@ void ONDXPage::PrintPage()
     {
 #if OSL_DEBUG_LEVEL > 1
         GetChild(&rIndex)->PrintPage();
-        for (USHORT i = 0; i < nCount; i++)
+        for (sal_uInt16 i = 0; i < nCount; i++)
         {
             ONDXNode rNode = (*this)[i];
             rNode.GetChild(&rIndex,this)->PrintPage();
@@ -978,16 +978,16 @@ void ONDXPage::PrintPage()
 }
 #endif
 // -----------------------------------------------------------------------------
-BOOL ONDXPage::IsFull() const
+sal_Bool ONDXPage::IsFull() const
 {
     return Count() == rIndex.getHeader().db_maxkeys;
 }
 // -----------------------------------------------------------------------------
 //------------------------------------------------------------------
-USHORT ONDXPage::Search(const ONDXKey& rSearch)
+sal_uInt16 ONDXPage::Search(const ONDXKey& rSearch)
 {
     // binare Suche spaeter
-    USHORT i = NODE_NOTFOUND;
+    sal_uInt16 i = NODE_NOTFOUND;
     while (++i < Count())
         if ((*this)[i].GetKey() == rSearch)
             break;
@@ -996,9 +996,9 @@ USHORT ONDXPage::Search(const ONDXKey& rSearch)
 }
 
 //------------------------------------------------------------------
-USHORT ONDXPage::Search(const ONDXPage* pPage)
+sal_uInt16 ONDXPage::Search(const ONDXPage* pPage)
 {
-    USHORT i = NODE_NOTFOUND;
+    sal_uInt16 i = NODE_NOTFOUND;
     while (++i < Count())
         if (((*this)[i]).GetChild() == pPage)
             break;
@@ -1015,7 +1015,7 @@ void ONDXPage::SearchAndReplace(const ONDXKey& rSearch,
     OSL_ENSURE(rSearch != rReplace,"Invalid here:rSearch == rReplace");
     if (rSearch != rReplace)
     {
-        USHORT nPos = NODE_NOTFOUND;
+        sal_uInt16 nPos = NODE_NOTFOUND;
         ONDXPage* pPage = this;
 
         while (pPage && (nPos = pPage->Search(rSearch)) == NODE_NOTFOUND)
@@ -1024,33 +1024,33 @@ void ONDXPage::SearchAndReplace(const ONDXKey& rSearch,
         if (pPage)
         {
             (*pPage)[nPos].GetKey() = rReplace;
-            pPage->SetModified(TRUE);
+            pPage->SetModified(sal_True);
         }
     }
 }
 // -----------------------------------------------------------------------------
-ONDXNode& ONDXPage::operator[] (USHORT nPos)
+ONDXNode& ONDXPage::operator[] (sal_uInt16 nPos)
 {
     DBG_ASSERT(nCount > nPos, "falscher Indexzugriff");
     return ppNodes[nPos];
 }
 
 //------------------------------------------------------------------
-const ONDXNode& ONDXPage::operator[] (USHORT nPos) const
+const ONDXNode& ONDXPage::operator[] (sal_uInt16 nPos) const
 {
     DBG_ASSERT(nCount > nPos, "falscher Indexzugriff");
     return ppNodes[nPos];
 }
 // -----------------------------------------------------------------------------
-void ONDXPage::Remove(USHORT nPos)
+void ONDXPage::Remove(sal_uInt16 nPos)
 {
     DBG_ASSERT(nCount > nPos, "falscher Indexzugriff");
 
-    for (USHORT i = nPos; i < (nCount-1); i++)
+    for (sal_uInt16 i = nPos; i < (nCount-1); i++)
         (*this)[i] = (*this)[i+1];
 
     nCount--;
-    bModified = TRUE;
+    bModified = sal_True;
 }
 // -----------------------------------------------------------------------------
author	Philipp Lohmann [pl] <Philipp.Lohmann@Oracle.COM>	2011-02-14 16:17:22 +0100
committer	Philipp Lohmann [pl] <Philipp.Lohmann@Oracle.COM>	2011-02-14 16:17:22 +0100
commit	1fb042333fe6287756ff1fac11d18cd7c150730d (patch)
tree	595de5d187177832ce656d7832af9dce9dce2d99 /connectivity/source/drivers/dbase
parent	5b3e910e926c7dd1e8dcfe8e0a5c6cb5bd17480a (diff)
parent	cd0d6a5a6775f197fdb7e78b54c8133074a7a236 (diff)