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

8 files changed, 195 insertions, 195 deletions

diff --git a/tools/source/fsys/comdep.hxx b/tools/source/fsys/comdep.hxx
index 043c5815f764..2c8ab11471d5 100644
--- a/tools/source/fsys/comdep.hxx
+++ b/tools/source/fsys/comdep.hxx
@@ -74,16 +74,16 @@ struct DirReader_Impl
     DirEntry*   pParent;
     String      aPath;
     ByteString  aBypass;
-    BOOL        bReady;
-    BOOL        bInUse;
+    sal_Bool        bReady;
+    sal_Bool        bInUse;
 
                 DirReader_Impl( Dir &rDir )
                 :   pDir( &rDir ),
                     pDosEntry( 0 ),
                     pParent( 0 ),
                     aPath( GUI2FSYS(rDir.GetFull()) ),
-                    bReady ( FALSE ),
-                    bInUse( FALSE )
+                    bReady ( sal_False ),
+                    bInUse( sal_False )
                 {
 #ifndef BOOTSTRAP
                     // Redirection
@@ -145,9 +145,9 @@ struct FileCopier_Impl
 //--------------------------------------------------------------------
 
 #if defined WNT || defined OS2
-BOOL IsRedirectable_Impl( const ByteString &rPath );
+sal_Bool IsRedirectable_Impl( const ByteString &rPath );
 #else
-#define IsRedirectable_Impl( rPath )    TRUE
+#define IsRedirectable_Impl( rPath )    sal_True
 #endif
 
 //--------------------------------------------------------------------
diff --git a/tools/source/fsys/dirent.cxx b/tools/source/fsys/dirent.cxx
index 1bd43bffc4e7..b38d510322ac 100644
--- a/tools/source/fsys/dirent.cxx
+++ b/tools/source/fsys/dirent.cxx
@@ -130,11 +130,11 @@ int Sys2SolarError_Impl( int nSysErr )
 #ifndef BOOTSTRAP
 
 FSysRedirector* FSysRedirector::_pRedirector = 0;
-BOOL FSysRedirector::_bEnabled = TRUE;
+sal_Bool FSysRedirector::_bEnabled = sal_True;
 #ifdef UNX
-BOOL bInRedirection = TRUE;
+sal_Bool bInRedirection = sal_True;
 #else
-BOOL bInRedirection = FALSE;
+sal_Bool bInRedirection = sal_False;
 #endif
 static NAMESPACE_VOS( OMutex )* pRedirectMutex = 0;
 
@@ -172,7 +172,7 @@ void FSysRedirector::DoRedirect( String &rPath )
                 return;
 
         // dont redirect on nested calls
-        bInRedirection = TRUE;
+        bInRedirection = sal_True;
 
         // convert to URL
 #ifndef UNX
@@ -186,7 +186,7 @@ void FSysRedirector::DoRedirect( String &rPath )
         // do redirection
         Redirector();
 
-        bInRedirection = FALSE;
+        bInRedirection = sal_False;
         return;
 }
 
@@ -293,7 +293,7 @@ ByteString ImplCutPath( const ByteString& rStr, USHORT nMax, char cAccDel )
 {
     USHORT  nMaxPathLen = nMax;
     ByteString  aCutPath( rStr );
-    BOOL    bInsertPrefix = FALSE;
+    sal_Bool    bInsertPrefix = sal_False;
     USHORT  nBegin = aCutPath.Search( cAccDel );
 
     if( nBegin == STRING_NOTFOUND )
@@ -310,7 +310,7 @@ ByteString ImplCutPath( const ByteString& rStr, USHORT nMax, char cAccDel )
         {
             nCount = nEnd - nBegin;
             aCutPath.Erase( nBegin, nCount );
-            bInsertPrefix = TRUE;
+            bInsertPrefix = sal_True;
         }
         else
             break;
@@ -1010,7 +1010,7 @@ DirEntry* DirEntry::ImpGetPreTopPtr()
 |*
 *************************************************************************/
 
-DirEntry* DirEntry::ImpChangeParent( DirEntry* pNewParent, BOOL bNormalize )
+DirEntry* DirEntry::ImpChangeParent( DirEntry* pNewParent, sal_Bool bNormalize )
 {
     DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
 
@@ -1037,14 +1037,14 @@ DirEntry* DirEntry::ImpChangeParent( DirEntry* pNewParent, BOOL bNormalize )
 |*
 *************************************************************************/
 
-BOOL DirEntry::Exists( FSysAccess nAccess ) const
+sal_Bool DirEntry::Exists( FSysAccess nAccess ) const
 {
 #ifndef BOOTSTRAP
     static NAMESPACE_VOS(OMutex) aLocalMutex;
     NAMESPACE_VOS(OGuard) aGuard( aLocalMutex );
 #endif
         if ( !IsValid() )
-                return FALSE;
+                return sal_False;
 
 #if defined WNT || defined OS2
     // spezielle Filenamen sind vom System da
@@ -1060,14 +1060,14 @@ BOOL DirEntry::Exists( FSysAccess nAccess ) const
            aName.CompareIgnoreCaseToAscii("LPT3") == COMPARE_EQUAL ||
            aName.CompareIgnoreCaseToAscii("NUL") == COMPARE_EQUAL ||
            aName.CompareIgnoreCaseToAscii("PRN") == COMPARE_EQUAL ) )
-        return TRUE;
+        return sal_True;
 #endif
 
         FSysFailOnErrorImpl();
         DirEntryKind eKind = FileStat( *this, nAccess ).GetKind();
         if ( eKind & ( FSYS_KIND_FILE | FSYS_KIND_DIR ) )
         {
-                return TRUE;
+                return sal_True;
         }
 
 #if defined WNT || defined OS2
@@ -1090,7 +1090,7 @@ BOOL DirEntry::Exists( FSysAccess nAccess ) const
 |*
 *************************************************************************/
 
-BOOL DirEntry::First()
+sal_Bool DirEntry::First()
 {
     FSysFailOnErrorImpl();
 
@@ -1120,12 +1120,12 @@ BOOL DirEntry::First()
                         {
                                 aName = aFound;
                                 closedir( pDir );
-                                return TRUE;
+                                return sal_True;
                         }
                 }
                 closedir( pDir );
         }
-        return FALSE;
+        return sal_False;
 }
 
 /*************************************************************************
@@ -1138,7 +1138,7 @@ BOOL DirEntry::First()
 |*
 *************************************************************************/
 
-String DirEntry::GetFull( FSysPathStyle eStyle, BOOL bWithDelimiter,
+String DirEntry::GetFull( FSysPathStyle eStyle, sal_Bool bWithDelimiter,
                           USHORT nMaxChars ) const
 {
     DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
@@ -1463,18 +1463,18 @@ StringCompare DirEntry::NameCompare( const DirEntry &rWith ) const
 |*
 *************************************************************************/
 
-BOOL DirEntry::operator==( const DirEntry& rEntry ) const
+sal_Bool DirEntry::operator==( const DirEntry& rEntry ) const
 {
     DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
 
     // test wheather the contents are textual the same
 
     if ( nError && ( nError == rEntry.nError ) )
-        return TRUE;
+        return sal_True;
     if ( nError || rEntry.nError ||
          ( eFlag == FSYS_FLAG_INVALID ) ||
          ( rEntry.eFlag == FSYS_FLAG_INVALID ) )
-        return FALSE;
+        return sal_False;
 
 #ifndef OS2
     const
@@ -1547,10 +1547,10 @@ DirEntry DirEntry::operator+( const DirEntry& rEntry ) const
 {
     DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
 #ifdef DBG_UTIL
-        static BOOL bTested = FALSE;
+        static sal_Bool bTested = sal_False;
         if ( !bTested )
         {
-                bTested = TRUE;
+                bTested = sal_True;
                 FSysTest();
         }
 #endif
@@ -1572,7 +1572,7 @@ DirEntry DirEntry::operator+( const DirEntry& rEntry ) const
         (eFlag == FSYS_FLAG_RELROOT && !aName.Len()) ||
         (
          (pEntryTop->aName.Len()  ||
-          ((rEntry.Level()>1)?(rEntry[rEntry.Level()-2].aName.CompareIgnoreCaseToAscii(RFS_IDENTIFIER)==COMPARE_EQUAL):FALSE))
+          ((rEntry.Level()>1)?(rEntry[rEntry.Level()-2].aName.CompareIgnoreCaseToAscii(RFS_IDENTIFIER)==COMPARE_EQUAL):sal_False))
           &&
          (pEntryTop->eFlag == FSYS_FLAG_ABSROOT ||
           pEntryTop->eFlag == FSYS_FLAG_RELROOT ||
@@ -1767,14 +1767,14 @@ void DirEntry::SetName( const String& rName, FSysPathStyle eFormatter )
 |*    Letzte Aenderung  MA 02.12.91
 |*
 *************************************************************************/
-BOOL DirEntry::Find( const String& rPfad, char cDelim )
+sal_Bool DirEntry::Find( const String& rPfad, char cDelim )
 {
     DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
 
         if ( ImpGetTopPtr()->eFlag == FSYS_FLAG_ABSROOT )
-                return TRUE;
+                return sal_True;
 
-        BOOL bWild = aName.Search( '*' ) != STRING_NOTFOUND ||
+        sal_Bool bWild = aName.Search( '*' ) != STRING_NOTFOUND ||
                                  aName.Search( '?' ) != STRING_NOTFOUND;
         if ( !cDelim )
                 cDelim = SEARCHDELIM(DEFSTYLE)[0];
@@ -1797,11 +1797,11 @@ BOOL DirEntry::Find( const String& rPfad, char cDelim )
                          ( ( !bWild && aEntry.Exists() ) || ( bWild && aEntry.First() ) ) )
                 {
                         (*this) = aEntry;
-                        return TRUE;
+                        return sal_True;
                 }
             }
         }
-        return FALSE;
+        return sal_False;
 }
 
 /*************************************************************************
@@ -1814,7 +1814,7 @@ BOOL DirEntry::Find( const String& rPfad, char cDelim )
 |*
 *************************************************************************/
 
-BOOL DirEntry::ImpToRel( String aCurStr )
+sal_Bool DirEntry::ImpToRel( String aCurStr )
 {
     DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
 
@@ -1840,7 +1840,7 @@ BOOL DirEntry::ImpToRel( String aCurStr )
     {
         // dann ist der relative Pfad das aktuelle Verzeichnis
         *this = DirEntry();
-        return TRUE;
+        return sal_True;
     }
 
     // Sonderfall, die DirEntries sind total verschieden
@@ -1848,7 +1848,7 @@ BOOL DirEntry::ImpToRel( String aCurStr )
     {
         // dann ist der relativste Pfad absolut
         *this = aThis;
-        return FALSE;
+        return sal_False;
     }
 
     // sonst nehmen wir die identischen Einzelteile vorne weg
@@ -1864,7 +1864,7 @@ BOOL DirEntry::ImpToRel( String aCurStr )
 
     // das ist dann unser relativer Pfad
     *this = DirEntry( aThisStr, FSYS_STYLE_HPFS );
-    return TRUE;
+    return sal_True;
 }
 
 /*************************************************************************
@@ -1917,7 +1917,7 @@ USHORT DirEntry::CutRelParents()
 |*
 *************************************************************************/
 
-BOOL DirEntry::ToRel()
+sal_Bool DirEntry::ToRel()
 {
     DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
 
@@ -1936,7 +1936,7 @@ BOOL DirEntry::ToRel()
 |*
 *************************************************************************/
 
-BOOL DirEntry::ToRel( const DirEntry& rStart )
+sal_Bool DirEntry::ToRel( const DirEntry& rStart )
 {
     DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
 
@@ -2075,7 +2075,7 @@ const DirEntry& DirEntry::SetTempNameBase( const String &rBase )
         {
             // Create the directory and only on success give all rights to
             // everyone. Use mkdir instead of DirEntry::MakeDir because
-            // this returns TRUE even if directory already exists.
+            // this returns sal_True even if directory already exists.
 
             if ( !mkdir( aName.GetBuffer(), S_IRWXU | S_IRWXG | S_IRWXO ) )
                 chmod( aName.GetBuffer(), S_IRWXU | S_IRWXG | S_IRWXO );
@@ -2427,11 +2427,11 @@ ErrCode CreateEntry_Impl( const DirEntry &rPath, DirEntryKind eKind )
     return eErr;
 }
 
-BOOL IsValidEntry_Impl( const DirEntry &rPath,
+sal_Bool IsValidEntry_Impl( const DirEntry &rPath,
                         const String &rLongName,
                         DirEntryKind eKind,
-                        BOOL bIsShortened,
-                        BOOL bUseDelim )
+                        sal_Bool bIsShortened,
+                        sal_Bool bUseDelim )
 {
     // Parameter-Pr"uefung
     DBG_ASSERT( eKind == FSYS_KIND_NONE || eKind == FSYS_KIND_ALL ||
@@ -2445,16 +2445,16 @@ BOOL IsValidEntry_Impl( const DirEntry &rPath,
     DirEntry aPath(rPath);
     DirEntry aName(rLongName, eStyle);
     if ( !aName.IsValid() || aName.Level() != 1 )
-        return FALSE;
+        return sal_False;
     aPath += aName;
     if ( 1 == aPath.Level() )
-        return FALSE;
+        return sal_False;
     if ( eStyle == FSYS_STYLE_FAT || eStyle == FSYS_STYLE_NWFS ||
          eStyle == FSYS_STYLE_UNKNOWN )
     {
         DirEntry aDosEntry( rLongName, FSYS_STYLE_FAT );
         if ( !aDosEntry.IsValid() )
-            return FALSE;
+            return sal_False;
     }
 
         // Pfad-Trenner sind nicht erlaubt (bei ungek"urzten auch nicht FSYS_SHORTNAME_DELIMITER)
@@ -2464,12 +2464,12 @@ BOOL IsValidEntry_Impl( const DirEntry &rPath,
          (!bIsShortened && rLongName.Search(cDelim) != STRING_NOTFOUND)
        )
     {
-        return FALSE;
+        return sal_False;
     }
 
     // MI: Abfrage nach 'CON:' etc. wird jetzt in Exists() mitgemacht
     if ( aPath.Exists() )
-        return FALSE;
+        return sal_False;
 
     return (ERRCODE_NONE == CreateEntry_Impl( aPath, eKind ));
 }
@@ -2488,8 +2488,8 @@ BOOL IsValidEntry_Impl( const DirEntry &rPath,
 #define MAX_LEN_MAX       255
 #define INVALID_CHARS_DEF   "\\/\"':|^<>?*"
 
-BOOL DirEntry::MakeShortName( const String& rLongName, DirEntryKind eKind,
-                              BOOL bUseDelim, FSysPathStyle eStyle )
+sal_Bool DirEntry::MakeShortName( const String& rLongName, DirEntryKind eKind,
+                              sal_Bool bUseDelim, FSysPathStyle eStyle )
 {
         String aLongName(rLongName);
 
@@ -2525,10 +2525,10 @@ BOOL DirEntry::MakeShortName( const String& rLongName, DirEntryKind eKind,
         }
 
         // ist der Langname direkt verwendbar?
-        if ( IsValidEntry_Impl( *this, aLongName, eKind, FALSE, bUseDelim ) )
+        if ( IsValidEntry_Impl( *this, aLongName, eKind, sal_False, bUseDelim ) )
         {
             operator+=( DirEntry(aLongName) );
-            return TRUE;
+            return sal_True;
         }
 
         // max L"angen feststellen
@@ -2604,11 +2604,11 @@ BOOL DirEntry::MakeShortName( const String& rLongName, DirEntryKind eKind,
         operator+=( DirEntry(String(aNewName, osl_getThreadTextEncoding())) );
         if ( FSYS_KIND_ALL == eKind && CMP_LOWER(aName) == aOldName )
         if ( FSYS_KIND_ALL == eKind && CMP_LOWER(ByteString(GetName(), osl_getThreadTextEncoding())) == aOldName )
-            return TRUE;
+            return sal_True;
 
         // kann der gek"urzte Name direkt verwendet werden?
         if ( !Exists() && (ERRCODE_NONE == CreateEntry_Impl( *this, eKind )) )
-            return TRUE;
+            return sal_True;
 
         // darf '?##' verwendet werden, um eindeutigen Name zu erzeugen?
         if ( bUseDelim )
@@ -2639,7 +2639,7 @@ BOOL DirEntry::MakeShortName( const String& rLongName, DirEntryKind eKind,
 
         // keine ## mehr frei / ?## soll nicht verwendet werden
         nError = ERRCODE_IO_ALREADYEXISTS;
-        return FALSE;
+        return sal_False;
 }
 
 /*************************************************************************
@@ -2652,34 +2652,34 @@ BOOL DirEntry::MakeShortName( const String& rLongName, DirEntryKind eKind,
 |*
 *************************************************************************/
 
-BOOL DirEntry::MakeDir( BOOL bSloppy ) const
+sal_Bool DirEntry::MakeDir( sal_Bool bSloppy ) const
 {
     DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
 
         // Schnellpruefung, ob vorhanden
         if ( FileStat( *this ).IsKind( FSYS_KIND_DIR ) )
-                return TRUE;
+                return sal_True;
         if ( bSloppy && pParent )
                  if ( FileStat( *pParent ).IsKind( FSYS_KIND_DIR ) )
-                          return TRUE;
+                          return sal_True;
 
         const DirEntry *pNewDir = bSloppy ? pParent : this;
         if ( pNewDir )
         {
                 // den Path zum Dir erzeugen
-                if ( pNewDir->pParent && !pNewDir->pParent->MakeDir(FALSE) )
-                        return FALSE;
+                if ( pNewDir->pParent && !pNewDir->pParent->MakeDir(sal_False) )
+                        return sal_False;
 
                 // das Dir selbst erzeugen
                 if ( pNewDir->eFlag == FSYS_FLAG_ABSROOT ||
                          pNewDir->eFlag == FSYS_FLAG_ABSROOT ||
                          pNewDir->eFlag == FSYS_FLAG_VOLUME )
-                        return TRUE;
+                        return sal_True;
                 else
                 {
                         //? nError = ???
                         if ( FileStat( *pNewDir ).IsKind( FSYS_KIND_DIR ) )
-                                return TRUE;
+                                return sal_True;
                         else
                         {
                                 FSysFailOnErrorImpl();
@@ -2693,7 +2693,7 @@ BOOL DirEntry::MakeDir( BOOL bSloppy ) const
 #ifdef WIN32
                                 SetLastError(0);
 #endif
-                                BOOL bResult = (0 == _mkdir( (char*) bDirName.GetBuffer() ));
+                                sal_Bool bResult = (0 == _mkdir( (char*) bDirName.GetBuffer() ));
                                 if ( !bResult )
                                 {
                                     // Wer hat diese Methode const gemacht ?
@@ -2708,7 +2708,7 @@ BOOL DirEntry::MakeDir( BOOL bSloppy ) const
                         }
                 }
         }
-        return TRUE;
+        return sal_True;
 }
 
 /*************************************************************************
@@ -2820,7 +2820,7 @@ FSysError DirEntry::MoveTo( const DirEntry& rNewName ) const
             // ja, also intra-device-move mit MoveFile
             MoveFile( bFrom.GetBuffer(), bTo.GetBuffer() );
             // MoveFile ist buggy bei cross-device operationen.
-            // Der R?ckgabewert ist auch dann TRUE, wenn nur ein Teil der Operation geklappt hat.
+            // Der R?ckgabewert ist auch dann sal_True, wenn nur ein Teil der Operation geklappt hat.
             // Zudem zeigt MoveFile unterschiedliches Verhalten bei unterschiedlichen NT-Versionen.
             return Sys2SolarError_Impl( GetLastError() );
         }
@@ -2942,10 +2942,10 @@ FSysError DirEntry::Kill(  FSysAction nActions ) const
         pName[bTmpName.Len()+1] = (char) 0;
 
         //read-only files sollen auch geloescht werden koennen
-        BOOL isReadOnly = FileStat::GetReadOnlyFlag(*this);
+        sal_Bool isReadOnly = FileStat::GetReadOnlyFlag(*this);
         if (isReadOnly)
         {
-            FileStat::SetReadOnlyFlag(*this, FALSE);
+            FileStat::SetReadOnlyFlag(*this, sal_False);
         }
 
         // directory?
@@ -3058,7 +3058,7 @@ FSysError DirEntry::Kill(  FSysAction nActions ) const
 |*
 *************************************************************************/
 
-BOOL DirEntry::Contains( const DirEntry &rSubEntry ) const
+sal_Bool DirEntry::Contains( const DirEntry &rSubEntry ) const
 {
     DBG_ASSERT( IsAbs() && rSubEntry.IsAbs(), "must be absolute entries" );
 
@@ -3068,10 +3068,10 @@ BOOL DirEntry::Contains( const DirEntry &rSubEntry ) const
     {
         for ( ; nThisLevel; --nThisLevel, --nSubLevel )
             if ( (*this)[nThisLevel-1] != rSubEntry[nSubLevel-1] )
-                return FALSE;
-        return TRUE;
+                return sal_False;
+        return sal_True;
     }
-    return FALSE;
+    return sal_False;
 }
 
 /*************************************************************************
@@ -3139,7 +3139,7 @@ String DirEntry::ConvertSystemToName( const String &rName )
 |*
 *************************************************************************/
 
-BOOL DirEntry::IsValid() const
+sal_Bool DirEntry::IsValid() const
 {
         return (nError == FSYS_ERR_OK);
 }
@@ -3154,9 +3154,9 @@ BOOL DirEntry::IsValid() const
 |*
 *************************************************************************/
 
-BOOL DirEntry::IsRFSAvailable()
+sal_Bool DirEntry::IsRFSAvailable()
 {
-    return FALSE;
+    return sal_False;
 }
 
 /*************************************************************************
@@ -3171,14 +3171,14 @@ BOOL DirEntry::IsRFSAvailable()
 |*
 *************************************************************************/
 
-BOOL DirEntry::IsLongNameOnFAT() const
+sal_Bool DirEntry::IsLongNameOnFAT() const
 {
         // FAT-System?
         DirEntry aTempDirEntry(*this);
         aTempDirEntry.ToAbs();
         if (DirEntry::GetPathStyle(aTempDirEntry.GetDevice().GetName().GetChar(0)) != FSYS_STYLE_FAT)
         {
-            return FALSE;       // nein, also false
+            return sal_False;       // nein, also false
         }
 
         // DirEntry-Kette auf lange Dateinamen pr?fen
@@ -3190,15 +3190,15 @@ BOOL DirEntry::IsLongNameOnFAT() const
 
             if (aBase.Len()>8)  // Name > 8?
             {
-                return TRUE;
+                return sal_True;
             }
 
             if (aExtension.Len()>3) // Extension > 3?
             {
-                return TRUE;
+                return sal_True;
             }
         }
-        return FALSE;
+        return sal_False;
 }
 
 //========================================================================
diff --git a/tools/source/fsys/filecopy.cxx b/tools/source/fsys/filecopy.cxx
index 62d361aa4af4..d5dc5af3990a 100644
--- a/tools/source/fsys/filecopy.cxx
+++ b/tools/source/fsys/filecopy.cxx
@@ -158,14 +158,14 @@ FileCopier& FileCopier::operator = ( const FileCopier &rCopier )
 |*
 *************************************************************************/
 
-BOOL FileCopier::Progress()
+sal_Bool FileCopier::Progress()
 {
     if ( !aProgressLink )
-        return TRUE;
+        return sal_True;
     else
     {
         if ( aProgressLink.Call( this ) )
-            return TRUE;
+            return sal_True;
         return ( 0 == Error( ERRCODE_ABORT, 0, 0 ) );
     }
 }
@@ -243,7 +243,7 @@ FSysError FileCopier::DoCopy_Impl(
     // HPFS->FAT?
     FSysPathStyle eSourceStyle = DirEntry::GetPathStyle( rSource.ImpGetTopPtr()->GetName() );
     FSysPathStyle eTargetStyle = DirEntry::GetPathStyle( rTarget.ImpGetTopPtr()->GetName() );
-    BOOL bMakeShortNames = ( eSourceStyle == FSYS_STYLE_HPFS && eTargetStyle == FSYS_STYLE_FAT );
+    sal_Bool bMakeShortNames = ( eSourceStyle == FSYS_STYLE_HPFS && eTargetStyle == FSYS_STYLE_FAT );
 
     // Zieldateiname ggf. kuerzen
     DirEntry aTgt;
diff --git a/tools/source/fsys/fstat.cxx b/tools/source/fsys/fstat.cxx
index acdbe6bae510..8949ada7a612 100644
--- a/tools/source/fsys/fstat.cxx
+++ b/tools/source/fsys/fstat.cxx
@@ -86,8 +86,8 @@ FileStat::FileStat( const DirEntry& rDirEntry, FSysAccess nAccess )
     aDateAccessed( ULONG(0) ),
     aTimeAccessed( ULONG(0) )
 {
-    BOOL bCached = FSYS_ACCESS_CACHED == (nAccess & FSYS_ACCESS_CACHED);
-    BOOL bFloppy = FSYS_ACCESS_FLOPPY == (nAccess & FSYS_ACCESS_FLOPPY);
+    sal_Bool bCached = FSYS_ACCESS_CACHED == (nAccess & FSYS_ACCESS_CACHED);
+    sal_Bool bFloppy = FSYS_ACCESS_FLOPPY == (nAccess & FSYS_ACCESS_FLOPPY);
 
 #ifdef FEAT_FSYS_DOUBLESPEED
     const FileStat *pStatFromDir = bCached ? rDirEntry.ImpGetStat() : 0;
@@ -120,18 +120,18 @@ FileStat::FileStat( const DirEntry& rDirEntry, FSysAccess nAccess )
 |*
 *************************************************************************/
 
-// TRUE  wenn die Instanz j"unger als rIsOlder ist.
-// FALSE wenn die Instanz "alter oder gleich alt wie rIsOlder ist.
+// sal_True  wenn die Instanz j"unger als rIsOlder ist.
+// sal_False wenn die Instanz "alter oder gleich alt wie rIsOlder ist.
 
-BOOL FileStat::IsYounger( const FileStat& rIsOlder ) const
+sal_Bool FileStat::IsYounger( const FileStat& rIsOlder ) const
 {
     if ( aDateModified > rIsOlder.aDateModified )
-        return TRUE;
+        return sal_True;
     if ( ( aDateModified == rIsOlder.aDateModified ) &&
          ( aTimeModified > rIsOlder.aTimeModified ) )
-        return TRUE;
+        return sal_True;
 
-    return FALSE;
+    return sal_False;
 }
 
 /*************************************************************************
@@ -143,9 +143,9 @@ BOOL FileStat::IsYounger( const FileStat& rIsOlder ) const
 |*
 *************************************************************************/
 
-BOOL FileStat::IsKind( DirEntryKind nKind ) const
+sal_Bool FileStat::IsKind( DirEntryKind nKind ) const
 {
-    BOOL bRet = ( ( nKind == FSYS_KIND_UNKNOWN ) &&
+    sal_Bool bRet = ( ( nKind == FSYS_KIND_UNKNOWN ) &&
                   ( nKindFlags == FSYS_KIND_UNKNOWN ) ) ||
                    ( ( nKindFlags & nKind ) == nKind );
     return bRet;
@@ -160,12 +160,12 @@ BOOL FileStat::IsKind( DirEntryKind nKind ) const
 |*
 *************************************************************************/
 
-BOOL FileStat::HasReadOnlyFlag()
+sal_Bool FileStat::HasReadOnlyFlag()
 {
 #if defined WNT || defined UNX || defined OS2
-    return TRUE;
+    return sal_True;
 #else
-    return FALSE;
+    return sal_False;
 #endif
 }
 
@@ -178,7 +178,7 @@ BOOL FileStat::HasReadOnlyFlag()
 |*
 *************************************************************************/
 
-BOOL FileStat::GetReadOnlyFlag( const DirEntry &rEntry )
+sal_Bool FileStat::GetReadOnlyFlag( const DirEntry &rEntry )
 {
 
     ByteString aFPath(rEntry.GetFull(), osl_getThreadTextEncoding());
@@ -194,17 +194,17 @@ BOOL FileStat::GetReadOnlyFlag( const DirEntry &rEntry )
         case NO_ERROR:
             return FILE_READONLY == ( aFileStat.attrFile & FILE_READONLY );
         default:
-            return FALSE;
+            return sal_False;
     }
 #elif defined UNX
     /* could we stat the object? */
     struct stat aBuf;
     if (stat(aFPath.GetBuffer(), &aBuf))
-        return FALSE;
+        return sal_False;
     /* jupp, is writable for user? */
     return((aBuf.st_mode & S_IWUSR) != S_IWUSR);
 #else
-    return FALSE;
+    return sal_False;
 #endif
 }
 
@@ -217,7 +217,7 @@ BOOL FileStat::GetReadOnlyFlag( const DirEntry &rEntry )
 |*
 *************************************************************************/
 
-ULONG FileStat::SetReadOnlyFlag( const DirEntry &rEntry, BOOL bRO )
+ULONG FileStat::SetReadOnlyFlag( const DirEntry &rEntry, sal_Bool bRO )
 {
 
     ByteString aFPath(rEntry.GetFull(), osl_getThreadTextEncoding());
diff --git a/tools/source/fsys/tdir.cxx b/tools/source/fsys/tdir.cxx
index b6bf48a8cdf9..6c3cbf47af32 100644
--- a/tools/source/fsys/tdir.cxx
+++ b/tools/source/fsys/tdir.cxx
@@ -60,7 +60,7 @@ DECLARE_LIST( FileStatList, FileStat* )
 |*
 *************************************************************************/
 
-BOOL Dir::ImpInsertPointReached( const DirEntry& rNewEntry,
+sal_Bool Dir::ImpInsertPointReached( const DirEntry& rNewEntry,
                                  const FileStat& rNewStat,
                                  ULONG nCurPos, ULONG nSortIndex ) const
 {
@@ -70,7 +70,7 @@ BOOL Dir::ImpInsertPointReached( const DirEntry& rNewEntry,
 
     // einfache Dinge erfordern einfache Loesungen
     if ( !pLst->Count() )
-        return TRUE;
+        return sal_True;
 
     FSysSort  nSort      = *( pSortLst->GetObject( nSortIndex ) );
     FileStat *pOldStat   = NULL;
@@ -83,121 +83,121 @@ BOOL Dir::ImpInsertPointReached( const DirEntry& rNewEntry,
         case  FSYS_SORT_NAME:
         case (FSYS_SORT_NAME | FSYS_SORT_ASCENDING):
             if ( pCurLstObj->aName > rNewEntry.aName )
-                return TRUE;
+                return sal_True;
             if ( !(pCurLstObj->aName == rNewEntry.aName) )
-                return FALSE;
+                return sal_False;
             break;
         case (FSYS_SORT_NAME | FSYS_SORT_DESCENDING):
             if ( pCurLstObj->aName < rNewEntry.aName )
-                return TRUE;
+                return sal_True;
             if ( !(pCurLstObj->aName == rNewEntry.aName) )
-                return FALSE;
+                return sal_False;
             break;
 
         case  FSYS_SORT_EXT:
         case (FSYS_SORT_EXT | FSYS_SORT_ASCENDING):
         {
             if ( pCurLstObj->GetExtension() > rNewEntry.GetExtension() )
-                return TRUE;
+                return sal_True;
             if ( !(pCurLstObj->GetExtension() == rNewEntry.GetExtension()) )
-                return FALSE;
+                return sal_False;
             break;
         }
         case (FSYS_SORT_EXT | FSYS_SORT_DESCENDING):
         {
             if ( pCurLstObj->GetExtension() < rNewEntry.GetExtension() )
-                return TRUE;
+                return sal_True;
             if ( !(pCurLstObj->GetExtension() == rNewEntry.GetExtension()) )
-                return FALSE;
+                return sal_False;
             break;
         }
 
         case  FSYS_SORT_KIND:
         case (FSYS_SORT_KIND | FSYS_SORT_ASCENDING ):
             if ( VALUE(pOldStat->nKindFlags) > VALUE(rNewStat.nKindFlags) )
-                return TRUE;
+                return sal_True;
             if ( !(VALUE(pOldStat->nKindFlags) == VALUE(rNewStat.nKindFlags)) )
-                return FALSE;
+                return sal_False;
             break;
         case (FSYS_SORT_KIND | FSYS_SORT_DESCENDING):
             if ( VALUE(pOldStat->nKindFlags) < VALUE(rNewStat.nKindFlags) )
-                return TRUE;
+                return sal_True;
             if ( !(VALUE(pOldStat->nKindFlags) == VALUE(rNewStat.nKindFlags)) )
-                return FALSE;
+                return sal_False;
             break;
 
         case  FSYS_SORT_SIZE:
         case (FSYS_SORT_SIZE | FSYS_SORT_ASCENDING):
             if ( pOldStat->nSize > rNewStat.nSize )
-                return TRUE;
+                return sal_True;
             if ( !(pOldStat->nSize == rNewStat.nSize) )
-                return FALSE;
+                return sal_False;
             break;
         case (FSYS_SORT_SIZE | FSYS_SORT_DESCENDING):
             if ( pOldStat->nSize < rNewStat.nSize )
-                return TRUE;
+                return sal_True;
             if ( !(pOldStat->nSize == rNewStat.nSize) )
-                return FALSE;
+                return sal_False;
             break;
 
         case  FSYS_SORT_MODIFYED:
         case (FSYS_SORT_MODIFYED | FSYS_SORT_ASCENDING):
             if ( (pOldStat->aDateModified >= rNewStat.aDateModified) &&
                  (pOldStat->aTimeModified >  rNewStat.aTimeModified) )
-                 return TRUE;
+                 return sal_True;
             if ( !((pOldStat->aDateModified == rNewStat.aDateModified) &&
                    (pOldStat->aTimeModified == rNewStat.aTimeModified)) )
-                return FALSE;
+                return sal_False;
             break;
         case (FSYS_SORT_MODIFYED | FSYS_SORT_DESCENDING):
             if ( (pOldStat->aDateModified <= rNewStat.aDateModified) &&
                  (pOldStat->aTimeModified <  rNewStat.aTimeModified) )
-                 return TRUE;
+                 return sal_True;
             if ( !((pOldStat->aDateModified == rNewStat.aDateModified) &&
                    (pOldStat->aTimeModified == rNewStat.aTimeModified)) )
-                return FALSE;
+                return sal_False;
             break;
 
         case  FSYS_SORT_CREATED:
         case (FSYS_SORT_CREATED | FSYS_SORT_ASCENDING):
             if ( (pOldStat->aDateCreated >= rNewStat.aDateCreated) &&
                  (pOldStat->aTimeCreated >  rNewStat.aTimeCreated) )
-                 return TRUE;
+                 return sal_True;
             if ( !((pOldStat->aDateCreated == rNewStat.aDateCreated) &&
                    (pOldStat->aTimeCreated == rNewStat.aTimeCreated)) )
-                return FALSE;
+                return sal_False;
             break;
         case (FSYS_SORT_CREATED | FSYS_SORT_DESCENDING):
             if ( (pOldStat->aDateCreated <= rNewStat.aDateCreated) &&
                  (pOldStat->aTimeCreated <  rNewStat.aTimeCreated) )
-                 return TRUE;
+                 return sal_True;
             if ( !((pOldStat->aDateCreated == rNewStat.aDateCreated) &&
                    (pOldStat->aTimeCreated == rNewStat.aTimeCreated)) )
-                return FALSE;
+                return sal_False;
             break;
 
         case  FSYS_SORT_ACCESSED:
         case (FSYS_SORT_ACCESSED | FSYS_SORT_ASCENDING):
             if ( (pOldStat->aDateAccessed >= rNewStat.aDateAccessed) &&
                  (pOldStat->aTimeAccessed >  rNewStat.aTimeAccessed) )
-                 return TRUE;
+                 return sal_True;
             if ( !((pOldStat->aDateAccessed == rNewStat.aDateAccessed) &&
                    (pOldStat->aTimeAccessed == rNewStat.aTimeAccessed)) )
-                return FALSE;
+                return sal_False;
             break;
         case (FSYS_SORT_ACCESSED | FSYS_SORT_DESCENDING):
             if ( (pOldStat->aDateAccessed <= rNewStat.aDateAccessed) &&
                  (pOldStat->aTimeAccessed <  rNewStat.aTimeAccessed) )
-                 return TRUE;
+                 return sal_True;
             if ( !((pOldStat->aDateAccessed == rNewStat.aDateAccessed) &&
                    (pOldStat->aTimeAccessed == rNewStat.aTimeAccessed)) )
-                return FALSE;
+                return sal_False;
             break;
         default: /* Kann nicht sein */;
     }
 
     if ( nSortIndex == ( pSortLst->Count() - 1 ) )
-        return TRUE;
+        return sal_True;
     else
         //Rekursion
         return ImpInsertPointReached( rNewEntry, rNewStat,
@@ -285,7 +285,7 @@ void Dir::Construct( DirEntryKind nKindFlags )
 |*
 *************************************************************************/
 
-BOOL Dir::Update()
+sal_Bool Dir::Update()
 {
     Reset();
     return Scan( USHRT_MAX ) > 0;
@@ -390,7 +390,7 @@ USHORT Dir::Scan( USHORT nCount )
         if ( !pLst->Count() )
         {
             // dann ggf. Laufwerke scannen
-            pReader->bInUse = TRUE;
+            pReader->bInUse = sal_True;
             nRead = pReader->Init();
         }
 
@@ -548,7 +548,7 @@ Dir::~Dir()
 
 FSysError Dir::ImpSetSort( std::va_list pArgs, int nFirstSort )
 {
-    BOOL             bLast;
+    sal_Bool             bLast;
     FSysSort        *pSort;
     FSysSortList    *pNewSortLst = new FSysSortList;
 
@@ -722,14 +722,14 @@ Dir& Dir::operator+=( const Dir& rDir )
         pLst = new DirEntryList();
 
     //Verlangen die Sortierkriterien FileStat's?
-    BOOL bStat = FALSE;
+    sal_Bool bStat = sal_False;
     if ( pSortLst ) {
         pSortLst->First();
         do {
             if ( *(pSortLst->GetCurObject()) &
                   ( FSYS_SORT_CREATED | FSYS_SORT_MODIFYED | FSYS_SORT_SIZE |
                     FSYS_SORT_ACCESSED | FSYS_SORT_KIND ) )
-                bStat = TRUE;
+                bStat = sal_True;
         } while ( !bStat && pSortLst->Next() );
     }
     FileStat * stat = NULL;
@@ -758,7 +758,7 @@ Dir& Dir::operator+=( const Dir& rDir )
 *************************************************************************/
 
 
-USHORT Dir::Count( BOOL bUpdated ) const
+USHORT Dir::Count( sal_Bool bUpdated ) const
 {
     // ggf. erst den Rest lesen
     if ( bUpdated && pReader )
diff --git a/tools/source/fsys/wldcrd.cxx b/tools/source/fsys/wldcrd.cxx
index 293d16877498..16c71cbc51d5 100644
--- a/tools/source/fsys/wldcrd.cxx
+++ b/tools/source/fsys/wldcrd.cxx
@@ -48,7 +48,7 @@
  *
  */
 
-USHORT WildCard::ImpMatch( const char *pWild, const char *pStr ) const
+sal_uInt16 WildCard::ImpMatch( const char *pWild, const char *pStr ) const
 {
     int    pos=0;
     int    flag=0;
@@ -117,12 +117,12 @@ USHORT WildCard::ImpMatch( const char *pWild, const char *pStr ) const
 |*
 *************************************************************************/
 
-BOOL WildCard::Matches( const String& rString ) const
+sal_Bool WildCard::Matches( const String& rString ) const
 {
     ByteString aTmpWild = aWildString;
     ByteString aString(rString, osl_getThreadTextEncoding());
 
-    USHORT  nSepPos;
+    sal_uInt16  nSepPos;
 
     if ( cSepSymbol != '\0' )
     {
@@ -130,14 +130,14 @@ BOOL WildCard::Matches( const String& rString ) const
         {
             // alle getrennten WildCard's pruefen
             if ( ImpMatch( aTmpWild.Copy( 0, nSepPos ).GetBuffer(), aString.GetBuffer() ) )
-                return TRUE;
+                return sal_True;
             aTmpWild.Erase( 0, nSepPos + 1 ); // Trennsymbol entfernen
         }
         // und noch den hinter dem letzen Trennsymbol bzw. den einzigen
     }
 
     if ( ImpMatch( aTmpWild.GetBuffer(), aString.GetBuffer() ) )
-        return TRUE;
+        return sal_True;
     else
-        return FALSE;
+        return sal_False;
 }
diff --git a/tools/source/fsys/wntmsc.cxx b/tools/source/fsys/wntmsc.cxx
index a8cf1c1eecec..17421d83feaa 100644
--- a/tools/source/fsys/wntmsc.cxx
+++ b/tools/source/fsys/wntmsc.cxx
@@ -52,7 +52,7 @@ DECLARE_LIST( FileStatList, FileStat* );
 
 int Sys2SolarError_Impl( int nSysErr );
 
-static BOOL   bLastCaseSensitive    = FALSE;
+static sal_Bool   bLastCaseSensitive    = sal_False;
 
 //--------------------------------------------------------------------
 
@@ -103,7 +103,7 @@ struct dirent *readdir( DIR *pDir )
 
 int closedir( DIR *pDir )
 {
-    BOOL bOk = FALSE;
+    sal_Bool bOk = sal_False;
     if ( pDir )
     {
         bOk = 0 != pDir->p || FindClose( pDir->h );
@@ -136,7 +136,7 @@ ErrCode GetPathStyle_Impl( const String &rDevice, FSysPathStyle &rStyle )
 
     // Windows95 hat VFAT, WindowsNT nicht
     DWORD nVer = GetVersion();
-    BOOL bW95 = ( nVer & 0xFF ) >= 4;
+    sal_Bool bW95 = ( nVer & 0xFF ) >= 4;
 
     FSysFailOnErrorImpl();
     rStyle = FSYS_STYLE_UNKNOWN;
@@ -185,7 +185,7 @@ FSysPathStyle DirEntry::GetPathStyle( const String &rDevice )
 |*
 *************************************************************************/
 
-BOOL DirEntry::IsCaseSensitive( FSysPathStyle eFormatter ) const
+sal_Bool DirEntry::IsCaseSensitive( FSysPathStyle eFormatter ) const
 {
 
     if (eFormatter==FSYS_STYLE_HOST)
@@ -194,7 +194,7 @@ BOOL DirEntry::IsCaseSensitive( FSysPathStyle eFormatter ) const
         DirEntry            aRoot(*this);
         aRoot.ToAbs();
         aRoot =             aRoot[Level()-1];
-        String aRootDir =   aRoot.GetFull(FSYS_STYLE_HOST, TRUE);
+        String aRootDir =   aRoot.GetFull(FSYS_STYLE_HOST, sal_True);
 
         char sVolumeName[256];
         DWORD nVolumeSerial;
@@ -211,30 +211,30 @@ BOOL DirEntry::IsCaseSensitive( FSysPathStyle eFormatter ) const
                                     sFileSysName,
                                     16 ))
         {
-            return (nFlags & FS_CASE_SENSITIVE) ? TRUE : FALSE;
+            return (nFlags & FS_CASE_SENSITIVE) ? sal_True : sal_False;
         }
         else
         {
-            return FALSE;
+            return sal_False;
         }
 */
         //
         // guter versuch, aber FS_CASE_SENSITIVE ist D?nnsinn in T?ten:
         //
         // sFileSysName     FS_CASE_SENSITIVE
-        // FAT              FALSE
-        // NTFS             TRUE !!!
-        // NWCompat         FALSE
-        // Samba            FALSE
+        // FAT              sal_False
+        // NTFS             sal_True !!!
+        // NWCompat         sal_False
+        // Samba            sal_False
         //
         // NT spricht auch NTFS lediglich case preserving an, also ist unter NT alles case insensitiv
         //
 
-        return FALSE;
+        return sal_False;
     }
     else
     {
-        BOOL isCaseSensitive = FALSE;   // ich bin unter win32, also ist der default case insensitiv
+        sal_Bool isCaseSensitive = sal_False;   // ich bin unter win32, also ist der default case insensitiv
         switch ( eFormatter )
         {
             case FSYS_STYLE_MAC:
@@ -245,18 +245,18 @@ BOOL DirEntry::IsCaseSensitive( FSysPathStyle eFormatter ) const
             case FSYS_STYLE_HPFS:
             case FSYS_STYLE_DETECT:
                 {
-                    isCaseSensitive = FALSE;
+                    isCaseSensitive = sal_False;
                     break;
                 }
             case FSYS_STYLE_SYSV:
             case FSYS_STYLE_BSD:
                 {
-                    isCaseSensitive = TRUE;
+                    isCaseSensitive = sal_True;
                     break;
                 }
             default:
                 {
-                    isCaseSensitive = FALSE;    // ich bin unter win32, also ist der default case insensitiv
+                    isCaseSensitive = sal_False;    // ich bin unter win32, also ist der default case insensitiv
                     break;
                 }
         }
@@ -274,19 +274,19 @@ BOOL DirEntry::IsCaseSensitive( FSysPathStyle eFormatter ) const
 |*
 *************************************************************************/
 
-BOOL DirEntry::ToAbs()
+sal_Bool DirEntry::ToAbs()
 {
     DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
 
     if ( FSYS_FLAG_VOLUME == eFlag )
     {
         eFlag = FSYS_FLAG_ABSROOT;
-        return TRUE;
+        return sal_True;
     }
 
     if ( IsAbs() )
     {
-        return TRUE;
+        return sal_True;
     }
 
 
@@ -295,10 +295,10 @@ BOOL DirEntry::ToAbs()
     ByteString aFullName( GetFull(), osl_getThreadTextEncoding() );
     FSysFailOnErrorImpl();
     if ( GetFullPathName((char*)aFullName.GetBuffer(),256,sBuf,&pOld) > 511 )
-        return FALSE;
+        return sal_False;
 
     *this = DirEntry( String(sBuf, osl_getThreadTextEncoding() ));
-    return TRUE;
+    return sal_True;
 }
 
 
@@ -364,27 +364,27 @@ String DirEntry::GetVolume() const
 |*
 *************************************************************************/
 
-BOOL DirEntry::SetCWD( BOOL bSloppy ) const
+sal_Bool DirEntry::SetCWD( sal_Bool bSloppy ) const
 {
     DBG_CHKTHIS( DirEntry, ImpCheckDirEntry );
 
     FSysFailOnErrorImpl();
 
     if ( eFlag == FSYS_FLAG_CURRENT && !aName.Len() )
-        return TRUE;
+        return sal_True;
 
     if ( SetCurrentDirectory(ByteString(GetFull(), osl_getThreadTextEncoding()).GetBuffer()) )
     {
-        return TRUE;
+        return sal_True;
     }
 
     if ( bSloppy && pParent &&
          SetCurrentDirectory(ByteString(pParent->GetFull(), osl_getThreadTextEncoding()).GetBuffer()) )
     {
-        return TRUE;
+        return sal_True;
     }
 
-    return FALSE;
+    return sal_False;
 }
 
 //-------------------------------------------------------------------------
@@ -444,7 +444,7 @@ USHORT DirReader_Impl::Read()
         CharLowerBuff( (char*) aLowerName.GetBuffer(), aLowerName.Len() );
 
         // Flags pruefen
-        BOOL bIsDirAndWantsDir =
+        sal_Bool bIsDirAndWantsDir =
                 ( ( pDir->eAttrMask & FSYS_KIND_DIR ) &&
 #ifdef ICC
                     ( pDosEntry->d_type & ( strcmp(pDosEntry->d_name,".") ||
@@ -452,7 +452,7 @@ USHORT DirReader_Impl::Read()
 #else
                     ( pDosEntry->d_type & DOS_DIRECT ) );
 #endif
-        BOOL bIsFileAndWantsFile =
+        sal_Bool bIsFileAndWantsFile =
                 ( ( pDir->eAttrMask & FSYS_KIND_FILE ) &&
 #ifdef ICC
                     !( pDosEntry->d_type & ( strcmp(pDosEntry->d_name,".") ||
@@ -461,8 +461,8 @@ USHORT DirReader_Impl::Read()
                     !( pDosEntry->d_type & DOS_DIRECT ) &&
 #endif
                     !( pDosEntry->d_type & DOS_VOLUMEID ) );
-        BOOL bIsHidden = (pDosEntry->d_type & _A_HIDDEN) != 0;
-        BOOL bWantsHidden = 0 == ( pDir->eAttrMask & FSYS_KIND_VISIBLE );
+        sal_Bool bIsHidden = (pDosEntry->d_type & _A_HIDDEN) != 0;
+        sal_Bool bWantsHidden = 0 == ( pDir->eAttrMask & FSYS_KIND_VISIBLE );
         if ( ( bIsDirAndWantsDir || bIsFileAndWantsFile ) &&
              ( bWantsHidden || !bIsHidden ) &&
              pDir->aNameMask.Matches( String(aLowerName, osl_getThreadTextEncoding()) ) )
@@ -483,7 +483,7 @@ USHORT DirReader_Impl::Read()
             pTemp->ImpSetStat( new FileStat( (void*) pDosDir, (void*) 0 ) );
 #endif
             if ( pParent )
-                pTemp->ImpChangeParent( new DirEntry( *pParent ), FALSE );
+                pTemp->ImpChangeParent( new DirEntry( *pParent ), sal_False );
             if ( pDir->pStatLst ) //Status fuer Sort gewuenscht?
             {
                 FileStat *pNewStat = new FileStat( (void*) pDosDir, (void*) 0 );
@@ -502,7 +502,7 @@ USHORT DirReader_Impl::Read()
 
     }
     else
-        bReady = TRUE;
+        bReady = sal_True;
     return 0;
 }
 
@@ -793,13 +793,13 @@ HRESULT SHResolvePath( HWND hwndOwner, LPCTSTR pszPath, LPITEMIDLIST *ppidl )
 // The Wrapper
 //---------------------------------------------------------------------------
 
-BOOL Exists_Impl( const ByteString & crPath )
+sal_Bool Exists_Impl( const ByteString & crPath )
 {
     // We do not know if OLE was initialized for this thread
 
     CoInitialize( NULL );
 
-    BOOL    bSuccess = SUCCEEDED( SHResolvePath(NULL, crPath.GetBuffer(), NULL) );
+    sal_Bool    bSuccess = SUCCEEDED( SHResolvePath(NULL, crPath.GetBuffer(), NULL) );
 
     CoUninitialize();
 
@@ -808,7 +808,7 @@ BOOL Exists_Impl( const ByteString & crPath )
 
 //---------------------------------------------------------------------------
 
-BOOL FileStat::Update( const DirEntry& rDirEntry, BOOL bForceAccess )
+sal_Bool FileStat::Update( const DirEntry& rDirEntry, sal_Bool bForceAccess )
 {
         nSize = 0;
         nKindFlags = 0;
@@ -825,7 +825,7 @@ BOOL FileStat::Update( const DirEntry& rDirEntry, BOOL bForceAccess )
         {
             nError = FSYS_ERR_UNKNOWN;
             nKindFlags = 0;
-            return FALSE;
+            return sal_False;
         }
 
         // Sonderbehandlung falls es sich um eine Root ohne Laufwerk handelt
@@ -834,7 +834,7 @@ BOOL FileStat::Update( const DirEntry& rDirEntry, BOOL bForceAccess )
         {
             nKindFlags = FSYS_KIND_DIR;
             nError = FSYS_ERR_OK;
-            return TRUE;
+            return sal_True;
         }
 
         // keine Error-Boxen anzeigen
@@ -849,7 +849,7 @@ BOOL FileStat::Update( const DirEntry& rDirEntry, BOOL bForceAccess )
 
         // ist ein Medium im Laufwerk?
         HACK("wie?")
-        BOOL bAccess = TRUE;
+        sal_Bool bAccess = sal_True;
         const DirEntry *pTop = aDirEntry.ImpGetTopPtr();
         ByteString aName = ByteString(pTop->aName).ToLowerAscii();
         if ( !bForceAccess &&
@@ -857,7 +857,7 @@ BOOL FileStat::Update( const DirEntry& rDirEntry, BOOL bForceAccess )
                 pTop->eFlag == FSYS_FLAG_RELROOT ||
                 pTop->eFlag == FSYS_FLAG_VOLUME ) )
             if ( aName == "a:" || aName == "b:" )
-                bAccess = FALSE;
+                bAccess = sal_False;
             else
                 DBG_TRACE( "FSys: will access removable device!" );
         if ( bAccess && ( aName == "a:" || aName == "b:" ) ) {
@@ -881,7 +881,7 @@ BOOL FileStat::Update( const DirEntry& rDirEntry, BOOL bForceAccess )
                     nKindFlags |= FSYS_KIND_REMOVEABLE;
                 nError = FSYS_ERR_NOTEXISTS;
                 nKindFlags = 0;
-                return FALSE;
+                return sal_False;
             }
 
             ByteString aRootDir = aDirEntry.aName;
@@ -891,7 +891,7 @@ BOOL FileStat::Update( const DirEntry& rDirEntry, BOOL bForceAccess )
             {
                 nError = FSYS_ERR_NOTEXISTS;
                 nKindFlags = 0;
-                return FALSE;
+                return sal_False;
             }
 
             if ( aDirEntry.eFlag == FSYS_FLAG_VOLUME )
@@ -905,7 +905,7 @@ BOOL FileStat::Update( const DirEntry& rDirEntry, BOOL bForceAccess )
 
             nError = ERRCODE_NONE;
 
-            return TRUE;
+            return sal_True;
         }
 
         // Statusinformation vom Betriebssystem holen
@@ -945,7 +945,7 @@ BOOL FileStat::Update( const DirEntry& rDirEntry, BOOL bForceAccess )
                 {
                     nKindFlags = FSYS_KIND_UNKNOWN;
                     nError = FSYS_ERR_NOTEXISTS;
-                    return FALSE;
+                    return sal_False;
                 }
 
                 // UNC-Volume?
@@ -959,13 +959,13 @@ BOOL FileStat::Update( const DirEntry& rDirEntry, BOOL bForceAccess )
                     {
                         nKindFlags = FSYS_KIND_DIR|FSYS_KIND_REMOTE;
                         nError = FSYS_ERR_OK;
-                        return TRUE;
+                        return sal_True;
                     }
                     else
                     {
                         nKindFlags = FSYS_KIND_UNKNOWN;
                         nError = FSYS_ERR_NOTEXISTS;
-                        return FALSE;
+                        return sal_False;
                     }
                     }
                 }
@@ -984,7 +984,7 @@ BOOL FileStat::Update( const DirEntry& rDirEntry, BOOL bForceAccess )
             {
                 nKindFlags = FSYS_KIND_WILD;
                 nError = FSYS_ERR_OK;
-                return TRUE;
+                return sal_True;
             }
 
             if ( bAccess )
@@ -1008,7 +1008,7 @@ BOOL FileStat::Update( const DirEntry& rDirEntry, BOOL bForceAccess )
 
 }
 
-BOOL IsRedirectable_Impl( const ByteString &rPath )
+sal_Bool IsRedirectable_Impl( const ByteString &rPath )
 {
     if ( rPath.Len() >= 3 && ':' == rPath.GetBuffer()[1] )
     {
@@ -1017,7 +1017,7 @@ BOOL IsRedirectable_Impl( const ByteString &rPath )
         SetLastError( ERROR_SUCCESS );
         return DRIVE_FIXED != nType;
     }
-    return FALSE;
+    return sal_False;
 }
 
 /*************************************************************************
@@ -1067,7 +1067,7 @@ ErrCode FileStat::QueryDiskSpace( const String &rPath,
 
 //=========================================================================
 
-void FSysEnableSysErrorBox( BOOL bEnable )
+void FSysEnableSysErrorBox( sal_Bool bEnable )
 {   // Preserve other Bits!!
     sal_uInt32 nErrorMode = SetErrorMode( bEnable ? 0 : SEM_FAILCRITICALERRORS|SEM_NOOPENFILEERRORBOX );
     if ( bEnable )
diff --git a/tools/source/fsys/wntmsc.hxx b/tools/source/fsys/wntmsc.hxx
index a6202cc71cc6..d84e5af9680b 100644
--- a/tools/source/fsys/wntmsc.hxx
+++ b/tools/source/fsys/wntmsc.hxx
@@ -51,7 +51,7 @@
 
 //--------------------------------------------------------------------
 
-#define FSYS_UNIX FALSE
+#define FSYS_UNIX sal_False
 
 #define DOS_DIRECT      _A_SUBDIR
 #define DOS_VOLUMEID    0x08
@@ -88,7 +88,7 @@ typedef struct
 
 #define START_DRV 'a'
 
-inline BOOL DRIVE_EXISTS(char c)
+inline sal_Bool DRIVE_EXISTS(char c)
 {
     ByteString aDriveRoot( c );
     aDriveRoot += ":\\";