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

1 files changed, 56 insertions, 56 deletions

diff --git a/svl/source/memtools/svarray.cxx b/svl/source/memtools/svarray.cxx
index b2184442ea0e..4dbedc1e5642 100644
--- a/svl/source/memtools/svarray.cxx
+++ b/svl/source/memtools/svarray.cxx
@@ -63,27 +63,27 @@
 SV_IMPL_VARARR(SvPtrarr,VoidPtr)
 SV_IMPL_VARARR_PLAIN(SvPtrarrPlain,VoidPtr)
 
-USHORT SvPtrarr::GetPos( const VoidPtr& aElement ) const
-{   USHORT n;
+sal_uInt16 SvPtrarr::GetPos( const VoidPtr& aElement ) const
+{   sal_uInt16 n;
     for( n=0; n < nA && *(GetData()+n) != aElement; ) n++;
     return ( n >= nA ? USHRT_MAX : n );
 }
 
-USHORT SvPtrarrPlain::GetPos( const VoidPtr aElement ) const
-{   USHORT n;
+sal_uInt16 SvPtrarrPlain::GetPos( const VoidPtr aElement ) const
+{   sal_uInt16 n;
     for( n=0; n < nA && *(GetData()+n) != aElement; ) n++;
     return ( n >= nA ? USHRT_MAX : n );
 }
 
 
-SV_IMPL_VARARR( SvBools, BOOL )
-SV_IMPL_VARARR( SvBytes, BYTE )
-SV_IMPL_VARARR( SvULongs, ULONG )
-SV_IMPL_VARARR( SvUShorts, USHORT )
+SV_IMPL_VARARR( SvBools, sal_Bool )
+SV_IMPL_VARARR( SvBytes, sal_uInt8 )
+SV_IMPL_VARARR( SvULongs, sal_uIntPtr )
+SV_IMPL_VARARR( SvUShorts, sal_uInt16 )
 SV_IMPL_VARARR( SvLongs, long)
 SV_IMPL_VARARR( SvShorts, short )
 
-SV_IMPL_VARARR_SORT( SvULongsSort, ULONG )
+SV_IMPL_VARARR_SORT( SvULongsSort, sal_uIntPtr )
 SV_IMPL_VARARR_SORT( SvLongsSort, long )
 SV_IMPL_VARARR_SORT( SvXub_StrLensSort, xub_StrLen )
 
@@ -105,19 +105,19 @@ SV_IMPL_OP_PTRARR_SORT( SvByteStringsSortDtor, ByteStringPtr )
 
 // Array mit anderer Seek-Methode!
 _SV_IMPL_SORTAR_ALG( SvStringsISort, StringPtr )
-void SvStringsISort::DeleteAndDestroy( USHORT nP, USHORT nL )
+void SvStringsISort::DeleteAndDestroy( sal_uInt16 nP, sal_uInt16 nL )
 {
     if( nL )
     {
         DBG_ASSERT( nP < nA && nP + nL <= nA, "ERR_VAR_DEL" );
-        for( USHORT n=nP; n < nP + nL; n++ )
+        for( sal_uInt16 n=nP; n < nP + nL; n++ )
             delete *((StringPtr*)pData+n);
         SvPtrarr::Remove( nP, nL );
     }
 }
-BOOL SvStringsISort::Seek_Entry( const StringPtr aE, USHORT* pP ) const
+sal_Bool SvStringsISort::Seek_Entry( const StringPtr aE, sal_uInt16* pP ) const
 {
-    register USHORT nO  = SvStringsISort_SAR::Count(),
+    register sal_uInt16 nO  = SvStringsISort_SAR::Count(),
             nM,
             nU = 0;
     if( nO > 0 )
@@ -131,40 +131,40 @@ BOOL SvStringsISort::Seek_Entry( const StringPtr aE, USHORT* pP ) const
             if( COMPARE_EQUAL == eCmp )
             {
                 if( pP ) *pP = nM;
-                return TRUE;
+                return sal_True;
             }
             else if( COMPARE_LESS == eCmp )
                 nU = nM + 1;
             else if( nM == 0 )
             {
                 if( pP ) *pP = nU;
-                return FALSE;
+                return sal_False;
             }
             else
                 nO = nM - 1;
         }
     }
     if( pP ) *pP = nU;
-    return FALSE;
+    return sal_False;
 }
 
 // ---------------- strings -------------------------------------
 
 // Array mit anderer Seek-Methode!
 _SV_IMPL_SORTAR_ALG( SvStringsISortDtor, StringPtr )
-void SvStringsISortDtor::DeleteAndDestroy( USHORT nP, USHORT nL )
+void SvStringsISortDtor::DeleteAndDestroy( sal_uInt16 nP, sal_uInt16 nL )
 {
     if( nL )
     {
         DBG_ASSERT( nP < nA && nP + nL <= nA, "ERR_VAR_DEL" );
-        for( USHORT n=nP; n < nP + nL; n++ )
+        for( sal_uInt16 n=nP; n < nP + nL; n++ )
             delete *((StringPtr*)pData+n);
         SvPtrarr::Remove( nP, nL );
     }
 }
-BOOL SvStringsISortDtor::Seek_Entry( const StringPtr aE, USHORT* pP ) const
+sal_Bool SvStringsISortDtor::Seek_Entry( const StringPtr aE, sal_uInt16* pP ) const
 {
-    register USHORT nO  = SvStringsISortDtor_SAR::Count(),
+    register sal_uInt16 nO  = SvStringsISortDtor_SAR::Count(),
             nM,
             nU = 0;
     if( nO > 0 )
@@ -178,29 +178,29 @@ BOOL SvStringsISortDtor::Seek_Entry( const StringPtr aE, USHORT* pP ) const
             if( COMPARE_EQUAL == eCmp )
             {
                 if( pP ) *pP = nM;
-                return TRUE;
+                return sal_True;
             }
             else if( COMPARE_LESS == eCmp )
                 nU = nM + 1;
             else if( nM == 0 )
             {
                 if( pP ) *pP = nU;
-                return FALSE;
+                return sal_False;
             }
             else
                 nO = nM - 1;
         }
     }
     if( pP ) *pP = nU;
-    return FALSE;
+    return sal_False;
 }
 
 // ---------------- Ushorts -------------------------------------
 
 /* SortArray fuer UShorts */
-BOOL SvUShortsSort::Seek_Entry( const USHORT aE, USHORT* pP ) const
+sal_Bool SvUShortsSort::Seek_Entry( const sal_uInt16 aE, sal_uInt16* pP ) const
 {
-    register USHORT nO  = SvUShorts::Count(),
+    register sal_uInt16 nO  = SvUShorts::Count(),
             nM,
             nU = 0;
     if( nO > 0 )
@@ -212,29 +212,29 @@ BOOL SvUShortsSort::Seek_Entry( const USHORT aE, USHORT* pP ) const
             if( *(pData + nM) == aE )
             {
                 if( pP ) *pP = nM;
-                return TRUE;
+                return sal_True;
             }
             else if( *(pData + nM) < aE )
                 nU = nM + 1;
             else if( nM == 0 )
             {
                 if( pP ) *pP = nU;
-                return FALSE;
+                return sal_False;
             }
             else
                 nO = nM - 1;
         }
     }
     if( pP ) *pP = nU;
-    return FALSE;
+    return sal_False;
 }
 
-void SvUShortsSort::Insert( const SvUShortsSort * pI, USHORT nS, USHORT nE )
+void SvUShortsSort::Insert( const SvUShortsSort * pI, sal_uInt16 nS, sal_uInt16 nE )
 {
     if( USHRT_MAX == nE )
         nE = pI->Count();
-    USHORT nP;
-    const USHORT * pIArr = pI->GetData();
+    sal_uInt16 nP;
+    const sal_uInt16 * pIArr = pI->GetData();
     for( ; nS < nE; ++nS )
     {
         if( ! Seek_Entry( *(pIArr+nS), &nP) )
@@ -247,42 +247,42 @@ void SvUShortsSort::Insert( const SvUShortsSort * pI, USHORT nS, USHORT nE )
     }
 }
 
-BOOL SvUShortsSort::Insert( const USHORT aE )
+sal_Bool SvUShortsSort::Insert( const sal_uInt16 aE )
 {
-    USHORT nP;
-    BOOL bExist = Seek_Entry( aE, &nP );
+    sal_uInt16 nP;
+    sal_Bool bExist = Seek_Entry( aE, &nP );
     if( !bExist )
         SvUShorts::Insert( aE, nP );
     return !bExist;
 }
 
-BOOL SvUShortsSort::Insert( const USHORT aE, USHORT& rP )
+sal_Bool SvUShortsSort::Insert( const sal_uInt16 aE, sal_uInt16& rP )
 {
-    BOOL bExist = Seek_Entry( aE, &rP );
+    sal_Bool bExist = Seek_Entry( aE, &rP );
     if( !bExist )
         SvUShorts::Insert( aE, rP );
     return !bExist;
 }
 
-void SvUShortsSort::Insert( const USHORT* pE, USHORT nL)
+void SvUShortsSort::Insert( const sal_uInt16* pE, sal_uInt16 nL)
 {
-    USHORT nP;
-    for( USHORT n = 0; n < nL; ++n )
+    sal_uInt16 nP;
+    for( sal_uInt16 n = 0; n < nL; ++n )
         if( ! Seek_Entry( *(pE+n), &nP ))
             SvUShorts::Insert( *(pE+n), nP );
 }
 
 // remove ab Pos
-void SvUShortsSort::RemoveAt( const USHORT nP, USHORT nL )
+void SvUShortsSort::RemoveAt( const sal_uInt16 nP, sal_uInt16 nL )
 {
     if( nL )
         SvUShorts::Remove( nP, nL);
 }
 
 // remove ab dem Eintrag
-void SvUShortsSort::Remove( const USHORT aE, USHORT nL )
+void SvUShortsSort::Remove( const sal_uInt16 aE, sal_uInt16 nL )
 {
-    USHORT nP;
+    sal_uInt16 nP;
     if( nL && Seek_Entry( aE, &nP ) )
         SvUShorts::Remove( nP, nL);
 }
@@ -291,19 +291,19 @@ void SvUShortsSort::Remove( const USHORT aE, USHORT nL )
 
 // Array mit anderer Seek-Methode!
 _SV_IMPL_SORTAR_ALG( SvByteStringsISort, ByteStringPtr )
-void SvByteStringsISort::DeleteAndDestroy( USHORT nP, USHORT nL )
+void SvByteStringsISort::DeleteAndDestroy( sal_uInt16 nP, sal_uInt16 nL )
 {
     if( nL )
     {
         DBG_ASSERT( nP < nA && nP + nL <= nA, "ERR_VAR_DEL" );
-        for( USHORT n=nP; n < nP + nL; n++ )
+        for( sal_uInt16 n=nP; n < nP + nL; n++ )
             delete *((ByteStringPtr*)pData+n);
         SvPtrarr::Remove( nP, nL );
     }
 }
-BOOL SvByteStringsISort::Seek_Entry( const ByteStringPtr aE, USHORT* pP ) const
+sal_Bool SvByteStringsISort::Seek_Entry( const ByteStringPtr aE, sal_uInt16* pP ) const
 {
-    register USHORT nO  = SvByteStringsISort_SAR::Count(),
+    register sal_uInt16 nO  = SvByteStringsISort_SAR::Count(),
             nM,
             nU = 0;
     if( nO > 0 )
@@ -317,39 +317,39 @@ BOOL SvByteStringsISort::Seek_Entry( const ByteStringPtr aE, USHORT* pP ) const
             if( COMPARE_EQUAL == eCmp )
             {
                 if( pP ) *pP = nM;
-                return TRUE;
+                return sal_True;
             }
             else if( COMPARE_LESS == eCmp )
                 nU = nM + 1;
             else if( nM == 0 )
             {
                 if( pP ) *pP = nU;
-                return FALSE;
+                return sal_False;
             }
             else
                 nO = nM - 1;
         }
     }
     if( pP ) *pP = nU;
-    return FALSE;
+    return sal_False;
 }
 
 
 // Array mit anderer Seek-Methode!
 _SV_IMPL_SORTAR_ALG( SvByteStringsISortDtor, ByteStringPtr )
-void SvByteStringsISortDtor::DeleteAndDestroy( USHORT nP, USHORT nL )
+void SvByteStringsISortDtor::DeleteAndDestroy( sal_uInt16 nP, sal_uInt16 nL )
 {
     if( nL )
     {
         DBG_ASSERT( nP < nA && nP + nL <= nA, "ERR_VAR_DEL" );
-        for( USHORT n=nP; n < nP + nL; n++ )
+        for( sal_uInt16 n=nP; n < nP + nL; n++ )
             delete *((ByteStringPtr*)pData+n);
         SvPtrarr::Remove( nP, nL );
     }
 }
-BOOL SvByteStringsISortDtor::Seek_Entry( const ByteStringPtr aE, USHORT* pP ) const
+sal_Bool SvByteStringsISortDtor::Seek_Entry( const ByteStringPtr aE, sal_uInt16* pP ) const
 {
-    register USHORT nO  = SvByteStringsISortDtor_SAR::Count(),
+    register sal_uInt16 nO  = SvByteStringsISortDtor_SAR::Count(),
             nM,
             nU = 0;
     if( nO > 0 )
@@ -363,20 +363,20 @@ BOOL SvByteStringsISortDtor::Seek_Entry( const ByteStringPtr aE, USHORT* pP ) co
             if( COMPARE_EQUAL == eCmp )
             {
                 if( pP ) *pP = nM;
-                return TRUE;
+                return sal_True;
             }
             else if( COMPARE_LESS == eCmp )
                 nU = nM + 1;
             else if( nM == 0 )
             {
                 if( pP ) *pP = nU;
-                return FALSE;
+                return sal_False;
             }
             else
                 nO = nM - 1;
         }
     }
     if( pP ) *pP = nU;
-    return FALSE;
+    return sal_False;
 }