#i112600#: clean up l10ntools, rsc, sot, svl, tools and unotools

1 files changed, 136 insertions, 136 deletions

diff --git a/sot/source/sdstor/stgdir.cxx b/sot/source/sdstor/stgdir.cxx
index f093dc60cbe7..0b1cf2582501 100644
--- a/sot/source/sdstor/stgdir.cxx
+++ b/sot/source/sdstor/stgdir.cxx
@@ -54,7 +54,7 @@
 // Problem der Implementation: Keine Hierarchischen commits. Daher nur
 // insgesamt transaktionsorientert oder direkt.
 
-StgDirEntry::StgDirEntry( const void* pFrom, BOOL * pbOk ) : StgAvlNode()
+StgDirEntry::StgDirEntry( const void* pFrom, sal_Bool * pbOk ) : StgAvlNode()
 {
     *pbOk = aEntry.Load( pFrom );
 
@@ -81,14 +81,14 @@ void StgDirEntry::InitMembers()
     nEntry      =
     nRefCnt     = 0;
     nMode       = STREAM_READ;
-    bDirect     = TRUE;
+    bDirect     = sal_True;
     bInvalid    =
     bCreated    =
     bRenamed    =
     bRemoved    =
     bTemp       =
     bDirty      =
-    bZombie     = FALSE;
+    bZombie     = sal_False;
 }
 
 StgDirEntry::~StgDirEntry()
@@ -113,9 +113,9 @@ short StgDirEntry::Compare( const StgAvlNode* p ) const
 // the TOC tree into the TOC stream. Remember that aSave is
 // stored, not aEntry.
 
-void StgDirEntry::Enum( INT32& n )
+void StgDirEntry::Enum( sal_Int32& n )
 {
-    INT32 nLeft = STG_FREE, nRight = STG_FREE, nDown = STG_FREE;
+    sal_Int32 nLeft = STG_FREE, nRight = STG_FREE, nDown = STG_FREE;
     nEntry = n++;
     if( pLeft )
     {
@@ -137,17 +137,17 @@ void StgDirEntry::Enum( INT32& n )
 // Delete all temporary entries before writing the TOC stream.
 // Until now Deltem is never called with bForce True
 
-void StgDirEntry::DelTemp( BOOL bForce )
+void StgDirEntry::DelTemp( sal_Bool bForce )
 {
     if( pLeft )
-        ((StgDirEntry*) pLeft)->DelTemp( FALSE );
+        ((StgDirEntry*) pLeft)->DelTemp( sal_False );
     if( pRight )
-        ((StgDirEntry*) pRight)->DelTemp( FALSE );
+        ((StgDirEntry*) pRight)->DelTemp( sal_False );
     if( pDown )
     {
         // If the storage is dead, of course all elements are dead, too
         if( bInvalid && aEntry.GetType() == STG_STORAGE )
-            bForce = TRUE;
+            bForce = sal_True;
         pDown->DelTemp( bForce );
     }
     if( ( bForce || bInvalid )
@@ -157,12 +157,12 @@ void StgDirEntry::DelTemp( BOOL bForce )
         if( pUp )
         {
             // this deletes the element if refcnt == 0!
-            BOOL bDel = nRefCnt == 0;
+            sal_Bool bDel = nRefCnt == 0;
             StgAvlNode::Remove( (StgAvlNode**) &pUp->pDown, this, bDel );
             if( !bDel )
             {
                 pLeft = pRight = pDown = 0;
-                bInvalid = bZombie = TRUE;
+                bInvalid = bZombie = sal_True;
             }
         }
     }
@@ -170,26 +170,26 @@ void StgDirEntry::DelTemp( BOOL bForce )
 
 // Save the tree into the given dir stream
 
-BOOL StgDirEntry::Store( StgDirStrm& rStrm )
+sal_Bool StgDirEntry::Store( StgDirStrm& rStrm )
 {
-    void* pEntry = rStrm.GetEntry( nEntry, TRUE );
+    void* pEntry = rStrm.GetEntry( nEntry, sal_True );
     if( !pEntry )
-        return FALSE;
+        return sal_False;
     // Do not store the current (maybe not commited) entry
     aSave.Store( pEntry );
     if( pLeft )
         if( !((StgDirEntry*) pLeft)->Store( rStrm ) )
-            return FALSE;
+            return sal_False;
     if( pRight )
         if( !((StgDirEntry*) pRight)->Store( rStrm ) )
-            return FALSE;
+            return sal_False;
     if( pDown )
         if( !pDown->Store( rStrm ) )
-            return FALSE;
-    return TRUE;
+            return sal_False;
+    return sal_True;
 }
 
-BOOL StgDirEntry::StoreStream( StgIo& rIo )
+sal_Bool StgDirEntry::StoreStream( StgIo& rIo )
 {
     if( aEntry.GetType() == STG_STREAM || aEntry.GetType() == STG_ROOT )
     {
@@ -206,27 +206,27 @@ BOOL StgDirEntry::StoreStream( StgIo& rIo )
         }
         // or write the data stream
         else if( !Tmp2Strm() )
-            return FALSE;
+            return sal_False;
     }
-    return TRUE;
+    return sal_True;
 }
 
 // Save all dirty streams
 
-BOOL StgDirEntry::StoreStreams( StgIo& rIo )
+sal_Bool StgDirEntry::StoreStreams( StgIo& rIo )
 {
     if( !StoreStream( rIo ) )
-        return FALSE;
+        return sal_False;
     if( pLeft )
         if( !((StgDirEntry*) pLeft)->StoreStreams( rIo ) )
-            return FALSE;
+            return sal_False;
     if( pRight )
         if( !((StgDirEntry*) pRight)->StoreStreams( rIo ) )
-            return FALSE;
+            return sal_False;
     if( pDown )
         if( !pDown->StoreStreams( rIo ) )
-            return FALSE;
-    return TRUE;
+            return sal_False;
+    return sal_True;
 }
 
 // Revert all directory entries after failure to write the TOC stream
@@ -244,24 +244,24 @@ void StgDirEntry::RevertAll()
 
 // Look if any element of the tree is dirty
 
-BOOL StgDirEntry::IsDirty()
+sal_Bool StgDirEntry::IsDirty()
 {
     if( bDirty || bInvalid )
-        return TRUE;
+        return sal_True;
     if( pLeft && ((StgDirEntry*) pLeft)->IsDirty() )
-        return TRUE;
+        return sal_True;
     if( pRight && ((StgDirEntry*) pRight)->IsDirty() )
-        return TRUE;
+        return sal_True;
     if( pDown && pDown->IsDirty() )
-        return TRUE;
-    return FALSE;
+        return sal_True;
+    return sal_False;
 }
 
 // Set up a stream.
 
-void StgDirEntry::OpenStream( StgIo& rIo, BOOL bForceBig )
+void StgDirEntry::OpenStream( StgIo& rIo, sal_Bool bForceBig )
 {
-    INT32 nThreshold = (USHORT) rIo.aHdr.GetThreshold();
+    sal_Int32 nThreshold = (sal_uInt16) rIo.aHdr.GetThreshold();
     delete pStgStrm;
     if( !bForceBig && aEntry.GetSize() < nThreshold )
         pStgStrm = new StgSmallStrm( rIo, this );
@@ -271,7 +271,7 @@ void StgDirEntry::OpenStream( StgIo& rIo, BOOL bForceBig )
     {
         // This entry has invalid data, so delete that data
         SetSize( 0L );
-//      bRemoved = bInvalid = FALSE;
+//      bRemoved = bInvalid = sal_False;
     }
     nPos = 0;
 }
@@ -291,9 +291,9 @@ void StgDirEntry::Close()
 
 // Get the current stream size
 
-INT32 StgDirEntry::GetSize()
+sal_Int32 StgDirEntry::GetSize()
 {
-    INT32 n;
+    sal_Int32 n;
     if( pTmpStrm )
         n = pTmpStrm->GetSize();
     else if( pCurStrm )
@@ -304,14 +304,14 @@ INT32 StgDirEntry::GetSize()
 
 // Set the stream size. This means also creating a temp stream.
 
-BOOL StgDirEntry::SetSize( INT32 nNewSize )
+sal_Bool StgDirEntry::SetSize( sal_Int32 nNewSize )
 {
     if (
          !( nMode & STREAM_WRITE ) ||
          (!bDirect && !pTmpStrm && !Strm2Tmp())
        )
     {
-        return FALSE;
+        return sal_False;
     }
 
     if( nNewSize < nPos )
@@ -320,26 +320,26 @@ BOOL StgDirEntry::SetSize( INT32 nNewSize )
     {
         pTmpStrm->SetSize( nNewSize );
         pStgStrm->GetIo().SetError( pTmpStrm->GetError() );
-        return BOOL( pTmpStrm->GetError() == SVSTREAM_OK );
+        return sal_Bool( pTmpStrm->GetError() == SVSTREAM_OK );
     }
     else
     {
-        BOOL bRes = FALSE;
+        sal_Bool bRes = sal_False;
         StgIo& rIo = pStgStrm->GetIo();
-        INT32 nThreshold = rIo.aHdr.GetThreshold();
+        sal_Int32 nThreshold = rIo.aHdr.GetThreshold();
         // ensure the correct storage stream!
         StgStrm* pOld = NULL;
-        USHORT nOldSize = 0;
+        sal_uInt16 nOldSize = 0;
         if( nNewSize >= nThreshold && pStgStrm->IsSmallStrm() )
         {
             pOld = pStgStrm;
-            nOldSize = (USHORT) pOld->GetSize();
+            nOldSize = (sal_uInt16) pOld->GetSize();
             pStgStrm = new StgDataStrm( rIo, STG_EOF, 0 );
         }
         else if( nNewSize < nThreshold && !pStgStrm->IsSmallStrm() )
         {
             pOld = pStgStrm;
-            nOldSize = (USHORT) nNewSize;
+            nOldSize = (sal_uInt16) nNewSize;
             pStgStrm = new StgSmallStrm( rIo, STG_EOF, 0 );
         }
         // now set the new size
@@ -351,16 +351,16 @@ BOOL StgDirEntry::SetSize( INT32 nNewSize )
                 // if so, we probably need to copy the old data
                 if( nOldSize )
                 {
-                    void* pBuf = new BYTE[ nOldSize ];
+                    void* pBuf = new sal_uInt8[ nOldSize ];
                     pOld->Pos2Page( 0L );
                     pStgStrm->Pos2Page( 0L );
                     if( pOld->Read( pBuf, nOldSize )
                      && pStgStrm->Write( pBuf, nOldSize ) )
-                        bRes = TRUE;
-                    delete[] static_cast<BYTE*>(pBuf);
+                        bRes = sal_True;
+                    delete[] static_cast<sal_uInt8*>(pBuf);
                 }
                 else
-                    bRes = TRUE;
+                    bRes = sal_True;
                 if( bRes )
                 {
                     pOld->SetSize( 0 );
@@ -378,7 +378,7 @@ BOOL StgDirEntry::SetSize( INT32 nNewSize )
             else
             {
                 pStgStrm->Pos2Page( nPos );
-                bRes = TRUE;
+                bRes = sal_True;
             }
         }
         return bRes;
@@ -387,7 +387,7 @@ BOOL StgDirEntry::SetSize( INT32 nNewSize )
 
 // Seek. On negative values, seek to EOF.
 
-INT32 StgDirEntry::Seek( INT32 nNew )
+sal_Int32 StgDirEntry::Seek( sal_Int32 nNew )
 {
     if( pTmpStrm )
     {
@@ -403,7 +403,7 @@ INT32 StgDirEntry::Seek( INT32 nNew )
     }
     else
     {
-        INT32 nSize = aEntry.GetSize();
+        sal_Int32 nSize = aEntry.GetSize();
 
         if( nNew < 0 )
             nNew = nSize;
@@ -427,7 +427,7 @@ INT32 StgDirEntry::Seek( INT32 nNew )
 
 // Read
 
-INT32 StgDirEntry::Read( void* p, INT32 nLen )
+sal_Int32 StgDirEntry::Read( void* p, sal_Int32 nLen )
 {
     if( nLen <= 0 )
         return 0;
@@ -443,7 +443,7 @@ INT32 StgDirEntry::Read( void* p, INT32 nLen )
 
 // Write
 
-INT32 StgDirEntry::Write( const void* p, INT32 nLen )
+sal_Int32 StgDirEntry::Write( const void* p, sal_Int32 nLen )
 {
     if( nLen <= 0 || !( nMode & STREAM_WRITE ) )
         return 0;
@@ -461,7 +461,7 @@ INT32 StgDirEntry::Write( const void* p, INT32 nLen )
     }
     else
     {
-        INT32 nNew = nPos + nLen;
+        sal_Int32 nNew = nPos + nLen;
         if( nNew > pStgStrm->GetSize() )
         {
             if( !SetSize( nNew ) )
@@ -478,16 +478,16 @@ INT32 StgDirEntry::Write( const void* p, INT32 nLen )
 
 void StgDirEntry::Copy( StgDirEntry& rDest )
 {
-    INT32 n = GetSize();
+    sal_Int32 n = GetSize();
     if( rDest.SetSize( n ) && n )
     {
-        BYTE aTempBytes[ 4096 ];
+        sal_uInt8 aTempBytes[ 4096 ];
         void* p = static_cast<void*>( aTempBytes );
         Seek( 0L );
         rDest.Seek( 0L );
         while( n )
         {
-            INT32 nn = n;
+            sal_Int32 nn = n;
             if( nn > 4096 )
                 nn = 4096;
             if( Read( p, nn ) != nn )
@@ -501,22 +501,22 @@ void StgDirEntry::Copy( StgDirEntry& rDest )
 
 void StgDirEntry::Copy( BaseStorageStream& rDest )
 {
-    INT32 n = GetSize();
+    sal_Int32 n = GetSize();
     if( rDest.SetSize( n ) && n )
     {
-        ULONG Pos = rDest.Tell();
-        BYTE aTempBytes[ 4096 ];
+        sal_uIntPtr Pos = rDest.Tell();
+        sal_uInt8 aTempBytes[ 4096 ];
         void* p = static_cast<void*>( aTempBytes );
         Seek( 0L );
         rDest.Seek( 0L );
         while( n )
         {
-            INT32 nn = n;
+            sal_Int32 nn = n;
             if( nn > 4096 )
                 nn = 4096;
             if( Read( p, nn ) != nn )
                 break;
-            if( sal::static_int_cast<INT32>(rDest.Write( p, nn )) != nn )
+            if( sal::static_int_cast<sal_Int32>(rDest.Write( p, nn )) != nn )
                 break;
             n -= nn;
         }
@@ -526,12 +526,12 @@ void StgDirEntry::Copy( BaseStorageStream& rDest )
 
 // Commit this entry
 
-BOOL StgDirEntry::Commit()
+sal_Bool StgDirEntry::Commit()
 {
     // OSL_ENSURE( nMode & STREAM_WRITE, "Trying to commit readonly stream!" );
 
     aSave = aEntry;
-    BOOL bRes = TRUE;
+    sal_Bool bRes = sal_True;
     if( aEntry.GetType() == STG_STREAM )
     {
         if( pTmpStrm )
@@ -552,7 +552,7 @@ BOOL StgDirEntry::Commit()
 
 // Revert the entry
 
-BOOL StgDirEntry::Revert()
+sal_Bool StgDirEntry::Revert()
 {
     aEntry = aSave;
     switch( aEntry.GetType() )
@@ -563,24 +563,24 @@ BOOL StgDirEntry::Revert()
             break;
         case STG_STORAGE:
         {
-            BOOL bSomeRenamed = FALSE;
+            sal_Bool bSomeRenamed = sal_False;
             StgIterator aOIter( *this );
             StgDirEntry* op = aOIter.First();
             while( op )
             {
                 op->aEntry = op->aSave;
-                op->bDirty = FALSE;
-                bSomeRenamed = BOOL( bSomeRenamed | op->bRenamed );
+                op->bDirty = sal_False;
+                bSomeRenamed = sal_Bool( bSomeRenamed | op->bRenamed );
                 // Remove any new entries
                 if( op->bCreated )
                 {
-                    op->bCreated = FALSE;
+                    op->bCreated = sal_False;
                     op->Close();
-                    op->bInvalid = TRUE;
+                    op->bInvalid = sal_True;
                 }
                 // Reactivate any removed entries
                 else if( op->bRemoved )
-                    op->bRemoved = op->bInvalid = op->bTemp = FALSE;
+                    op->bRemoved = op->bInvalid = op->bTemp = sal_False;
                 op = aOIter.Next();
             }
             // Resort all renamed entries
@@ -595,12 +595,12 @@ BOOL StgDirEntry::Revert()
                         StgAvlNode::Move
                             ( (StgAvlNode**) &p->pUp->pDown,
                               (StgAvlNode**) &p->pUp->pDown, p );
-                        p->bRenamed = FALSE;
+                        p->bRenamed = sal_False;
                     }
                     p = aIter.Next();
                 }
             }
-            DelTemp( FALSE );
+            DelTemp( sal_False );
             break;
         }
         case STG_EMPTY:
@@ -609,22 +609,22 @@ BOOL StgDirEntry::Revert()
         case STG_ROOT:
          break;
     }
-    return TRUE;
+    return sal_True;
 }
 
 // Copy the stg stream to the temp stream
 
-BOOL StgDirEntry::Strm2Tmp()
+sal_Bool StgDirEntry::Strm2Tmp()
 {
     if( !pTmpStrm )
     {
-        ULONG n = 0;
+        sal_uIntPtr n = 0;
         if( pCurStrm )
         {
             // It was already commited once
             pTmpStrm = new StgTmpStrm;
             if( pTmpStrm->GetError() == SVSTREAM_OK && pTmpStrm->Copy( *pCurStrm ) )
-                return TRUE;
+                return sal_True;
             n = 1;  // indicates error
         }
         else
@@ -635,15 +635,15 @@ BOOL StgDirEntry::Strm2Tmp()
             {
                 if( n )
                 {
-                    BYTE aTempBytes[ 4096 ];
+                    sal_uInt8 aTempBytes[ 4096 ];
                     void* p = static_cast<void*>( aTempBytes );
                     pStgStrm->Pos2Page( 0L );
                     while( n )
                     {
-                        ULONG nn = n;
+                        sal_uIntPtr nn = n;
                         if( nn > 4096 )
                             nn = 4096;
-                        if( (ULONG) pStgStrm->Read( p, nn ) != nn )
+                        if( (sal_uIntPtr) pStgStrm->Read( p, nn ) != nn )
                             break;
                         if( pTmpStrm->Write( p, nn ) != nn )
                             break;
@@ -661,41 +661,41 @@ BOOL StgDirEntry::Strm2Tmp()
             pStgStrm->GetIo().SetError( pTmpStrm->GetError() );
             delete pTmpStrm;
             pTmpStrm = NULL;
-            return FALSE;
+            return sal_False;
         }
     }
-    return TRUE;
+    return sal_True;
 }
 
 // Copy the temp stream to the stg stream during the final commit
 
-BOOL StgDirEntry::Tmp2Strm()
+sal_Bool StgDirEntry::Tmp2Strm()
 {
     // We did commit once, but have not written since then
     if( !pTmpStrm )
         pTmpStrm = pCurStrm, pCurStrm = NULL;
     if( pTmpStrm )
     {
-        ULONG n = pTmpStrm->GetSize();
+        sal_uIntPtr n = pTmpStrm->GetSize();
         StgStrm* pNewStrm;
         StgIo& rIo = pStgStrm->GetIo();
-        ULONG nThreshold = (ULONG) rIo.aHdr.GetThreshold();
+        sal_uIntPtr nThreshold = (sal_uIntPtr) rIo.aHdr.GetThreshold();
         if( n < nThreshold )
             pNewStrm = new StgSmallStrm( rIo, STG_EOF, 0 );
         else
             pNewStrm = new StgDataStrm( rIo, STG_EOF, 0 );
         if( pNewStrm->SetSize( n ) )
         {
-            BYTE p[ 4096 ];
+            sal_uInt8 p[ 4096 ];
             pTmpStrm->Seek( 0L );
             while( n )
             {
-                ULONG nn = n;
+                sal_uIntPtr nn = n;
                 if( nn > 4096 )
                     nn = 4096;
                 if( pTmpStrm->Read( p, nn ) != nn )
                     break;
-                if( (ULONG) pNewStrm->Write( p, nn ) != nn )
+                if( (sal_uIntPtr) pNewStrm->Write( p, nn ) != nn )
                     break;
                 n -= nn;
             }
@@ -704,7 +704,7 @@ BOOL StgDirEntry::Tmp2Strm()
                 pTmpStrm->Seek( nPos );
                 pStgStrm->GetIo().SetError( pTmpStrm->GetError() );
                 delete pNewStrm;
-                return FALSE;
+                return sal_False;
             }
             else
             {
@@ -720,12 +720,12 @@ BOOL StgDirEntry::Tmp2Strm()
             }
         }
     }
-    return TRUE;
+    return sal_True;
 }
 
 // Check if the given entry is contained in this entry
 
-BOOL StgDirEntry::IsContained( StgDirEntry* pStg )
+sal_Bool StgDirEntry::IsContained( StgDirEntry* pStg )
 {
     if( aEntry.GetType() == STG_STORAGE )
     {
@@ -734,25 +734,25 @@ BOOL StgDirEntry::IsContained( StgDirEntry* pStg )
         while( p )
         {
             if( !p->aEntry.Compare( pStg->aEntry ) )
-                return FALSE;
+                return sal_False;
             if( p->aEntry.GetType() == STG_STORAGE )
                 if( !p->IsContained( pStg ) )
-                    return FALSE;
+                    return sal_False;
             p = aIter.Next();
         }
     }
-    return TRUE;
+    return sal_True;
 }
 
 // Invalidate all open entries by setting the RefCount to 0. If the bDel
 // flag is set, also set the invalid flag to indicate deletion during the
 // next dir stream flush.
 
-void StgDirEntry::Invalidate( BOOL bDel )
+void StgDirEntry::Invalidate( sal_Bool bDel )
 {
 //  nRefCnt = 0;
     if( bDel )
-        bRemoved = bInvalid = TRUE;
+        bRemoved = bInvalid = sal_True;
     switch( aEntry.GetType() )
     {
         case STG_STORAGE:
@@ -807,12 +807,12 @@ StgDirStrm::~StgDirStrm()
 
 // Recursively parse the directory tree during reading the TOC stream
 
-void StgDirStrm::SetupEntry( INT32 n, StgDirEntry* pUpper )
+void StgDirStrm::SetupEntry( sal_Int32 n, StgDirEntry* pUpper )
 {
     void* p = ( n == STG_FREE ) ? NULL : GetEntry( n );
     if( p )
     {
-        BOOL bOk(FALSE);
+        sal_Bool bOk(sal_False);
         StgDirEntry* pCur = new StgDirEntry( p, &bOk );
 
         if( !bOk )
@@ -827,10 +827,10 @@ void StgDirStrm::SetupEntry( INT32 n, StgDirEntry* pUpper )
         if( !pUpper )
             pCur->aEntry.SetType( STG_ROOT );
 
-        INT32 nLeft = pCur->aEntry.GetLeaf( STG_LEFT );
-        INT32 nRight = pCur->aEntry.GetLeaf( STG_RIGHT );
+        sal_Int32 nLeft = pCur->aEntry.GetLeaf( STG_LEFT );
+        sal_Int32 nRight = pCur->aEntry.GetLeaf( STG_RIGHT );
         // substorage?
-        INT32 nLeaf = STG_FREE;
+        sal_Int32 nLeaf = STG_FREE;
         if( pCur->aEntry.GetType() == STG_STORAGE || pCur->aEntry.GetType() == STG_ROOT )
         {
             nLeaf = pCur->aEntry.GetLeaf( STG_CHILD );
@@ -865,7 +865,7 @@ void StgDirStrm::SetupEntry( INT32 n, StgDirEntry* pUpper )
 
 // Extend or shrink the directory stream.
 
-BOOL StgDirStrm::SetSize( INT32 nBytes )
+sal_Bool StgDirStrm::SetSize( sal_Int32 nBytes )
 {
     // Always allocate full pages
     nBytes = ( ( nBytes + nPageSize - 1 ) / nPageSize ) * nPageSize;
@@ -874,72 +874,72 @@ BOOL StgDirStrm::SetSize( INT32 nBytes )
 
 // Save the TOC stream into a new substream after saving all data streams
 
-BOOL StgDirStrm::Store()
+sal_Bool StgDirStrm::Store()
 {
     if( !pRoot->IsDirty() )
-        return TRUE;
+        return sal_True;
     if( !pRoot->StoreStreams( rIo ) )
-        return FALSE;
+        return sal_False;
     // After writing all streams, the data FAT stream has changed,
     // so we have to commit the root again
     pRoot->Commit();
     // We want a completely new stream, so fake an empty stream
-    INT32 nOldStart = nStart;       // save for later deletion
-    INT32 nOldSize  = nSize;
+    sal_Int32 nOldStart = nStart;       // save for later deletion
+    sal_Int32 nOldSize  = nSize;
     nStart = nPage = STG_EOF;
     nSize  = nPos = 0;
     nOffset = 0;
     // Delete all temporary entries
-    pRoot->DelTemp( FALSE );
+    pRoot->DelTemp( sal_False );
     // set the entry numbers
-    INT32 n = 0;
+    sal_Int32 n = 0;
     pRoot->Enum( n );
     if( !SetSize( n * STGENTRY_SIZE ) )
     {
         nStart = nOldStart; nSize = nOldSize;
         pRoot->RevertAll();
-        return FALSE;
+        return sal_False;
     }
     // set up the cache elements for the new stream
     if( !Copy( STG_FREE, nSize ) )
     {
         pRoot->RevertAll();
-        return FALSE;
+        return sal_False;
     }
     // Write the data to the new stream
     if( !pRoot->Store( *this ) )
     {
         pRoot->RevertAll();
-        return FALSE;
+        return sal_False;
     }
     // fill any remaining entries with empty data
-    INT32 ne = nSize / STGENTRY_SIZE;
+    sal_Int32 ne = nSize / STGENTRY_SIZE;
     StgEntry aEmpty;
     aEmpty.Init();
     while( n < ne )
     {
-        void* p = GetEntry( n++, TRUE );
+        void* p = GetEntry( n++, sal_True );
         if( !p )
         {
             pRoot->RevertAll();
-            return FALSE;
+            return sal_False;
         }
         aEmpty.Store( p );
     }
     // Now we can release the old stream
-    pFat->FreePages( nOldStart, TRUE );
+    pFat->FreePages( nOldStart, sal_True );
     rIo.aHdr.SetTOCStart( nStart );
-    return TRUE;
+    return sal_True;
 }
 
 // Get a dir entry.
 
-void* StgDirStrm::GetEntry( INT32 n, BOOL bDirty )
+void* StgDirStrm::GetEntry( sal_Int32 n, sal_Bool bDirty )
 {
     n *= STGENTRY_SIZE;
     if( n >= nSize )
         return NULL;
-    return GetPtr( n, TRUE, bDirty );
+    return GetPtr( n, sal_True, bDirty );
 }
 
 // Find a dir entry.
@@ -986,9 +986,9 @@ StgDirEntry* StgDirStrm::Create
         }
         pRes->bInvalid =
         pRes->bRemoved =
-        pRes->bTemp    = FALSE;
+        pRes->bTemp    = sal_False;
         pRes->bCreated =
-        pRes->bDirty   = TRUE;
+        pRes->bDirty   = sal_True;
     }
     else
     {
@@ -998,7 +998,7 @@ StgDirEntry* StgDirStrm::Create
             pRes->pUp    = &rStg;
             pRes->ppRoot = &pRoot;
             pRes->bCreated =
-            pRes->bDirty = TRUE;
+            pRes->bDirty = sal_True;
         }
         else
         {
@@ -1011,44 +1011,44 @@ StgDirEntry* StgDirStrm::Create
 
 // Rename the given entry.
 
-BOOL StgDirStrm::Rename( StgDirEntry& rStg, const String& rOld, const String& rNew )
+sal_Bool StgDirStrm::Rename( StgDirEntry& rStg, const String& rOld, const String& rNew )
 {
     StgDirEntry* p = Find( rStg, rOld );
     if( p )
     {
 
-        if( !StgAvlNode::Remove( (StgAvlNode**) &rStg.pDown, p, FALSE ) )
-            return FALSE;
+        if( !StgAvlNode::Remove( (StgAvlNode**) &rStg.pDown, p, sal_False ) )
+            return sal_False;
         p->aEntry.SetName( rNew );
         if( !StgAvlNode::Insert( (StgAvlNode**) &rStg.pDown, p ) )
-            return FALSE;
-        p->bRenamed = p->bDirty   = TRUE;
-        return TRUE;
+            return sal_False;
+        p->bRenamed = p->bDirty   = sal_True;
+        return sal_True;
     }
     else
     {
         rIo.SetError( SVSTREAM_FILE_NOT_FOUND );
-        return FALSE;
+        return sal_False;
     }
 }
 
 // Move the given entry to a different storage.
 
-BOOL StgDirStrm::Move( StgDirEntry& rStg1, StgDirEntry& rStg2, const String& rName )
+sal_Bool StgDirStrm::Move( StgDirEntry& rStg1, StgDirEntry& rStg2, const String& rName )
 {
     StgDirEntry* p = Find( rStg1, rName );
     if( p )
     {
         if( !StgAvlNode::Move
             ( (StgAvlNode**) &rStg1.pDown, (StgAvlNode**) &rStg2.pDown, p ) )
-            return FALSE;
-        p->bDirty = TRUE;
-        return TRUE;
+            return sal_False;
+        p->bDirty = sal_True;
+        return sal_True;
     }
     else
     {
         rIo.SetError( SVSTREAM_FILE_NOT_FOUND );
-        return FALSE;
+        return sal_False;
     }
 }