rebase to DEV300_m100

1 files changed, 32 insertions, 32 deletions

diff --git a/idl/source/cmptools/hash.cxx b/idl/source/cmptools/hash.cxx
index 4d5427f3875c..f919a1074efa 100644..100755
--- a/idl/source/cmptools/hash.cxx
+++ b/idl/source/cmptools/hash.cxx
@@ -34,7 +34,7 @@
 #include <stdio.h>
 #include <ctype.h>
 
-// Programmabh�ngige Includes.
+// Programmabh�ngige Includes.
 #include <hash.hxx>
 #include <tools/debug.hxx>
 
@@ -55,7 +55,7 @@ SvStringHashEntry::~SvStringHashEntry() { };
 |*    Beschreibung
 |*
 *************************************************************************/
-SvHashTable::SvHashTable( UINT32 nMaxEntries )
+SvHashTable::SvHashTable( sal_uInt32 nMaxEntries )
 {
     nMax = nMaxEntries;     // set max entries
     nFill = 0;              // no entries
@@ -73,8 +73,8 @@ SvHashTable::SvHashTable( UINT32 nMaxEntries )
 SvHashTable::~SvHashTable()
 {
 #ifdef DOS_NIE
-    printf( "Maximum: %ld, F�llung: %ld\n", (ULONG)nMax, (ULONG)nFill );
-    printf( "Anfragen: %ld, Versuche: %ld", (ULONG)lAsk, (ULONG)lTry );
+    printf( "Maximum: %ld, F�llung: %ld\n", (sal_uLong)nMax, (sal_uLong)nFill );
+    printf( "Anfragen: %ld, Versuche: %ld", (sal_uLong)lAsk, (sal_uLong)lTry );
     if( lTry != 0 )
         printf( ", V/E = %ld\n", lTry / lAsk );
 #endif
@@ -87,12 +87,12 @@ SvHashTable::~SvHashTable()
 |*    Beschreibung
 |*
 *************************************************************************/
-BOOL SvHashTable::Test_Insert( const void * pElement, BOOL bInsert,
-                               UINT32 * pInsertPos )
+sal_Bool SvHashTable::Test_Insert( const void * pElement, sal_Bool bInsert,
+                               sal_uInt32 * pInsertPos )
 {
-    UINT32    nHash;
-    UINT32    nIndex;
-    UINT32    nLoop;
+    sal_uInt32    nHash;
+    sal_uInt32    nIndex;
+    sal_uInt32    nLoop;
 
     lAsk++;
     lTry++;
@@ -110,11 +110,11 @@ BOOL SvHashTable::Test_Insert( const void * pElement, BOOL bInsert,
         {
             if( pInsertPos )
                 *pInsertPos = nIndex;               // place of Element
-            return TRUE;
+            return sal_True;
         }
         nLoop++;
         lTry++;
-        nIndex = (USHORT)(nIndex + nHash + 7) % nMax;
+        nIndex = (sal_uInt16)(nIndex + nHash + 7) % nMax;
     }
 
     if( bInsert )
@@ -124,10 +124,10 @@ BOOL SvHashTable::Test_Insert( const void * pElement, BOOL bInsert,
         {
             nFill++;
             *pInsertPos = nIndex;                       // return free place
-            return TRUE;
+            return sal_True;
         }
     }
-    return( FALSE );
+    return( sal_False );
 }
 
 /************************************************************************/
@@ -138,7 +138,7 @@ BOOL SvHashTable::Test_Insert( const void * pElement, BOOL bInsert,
 |*    Beschreibung
 |*
 *************************************************************************/
-SvStringHashTable::SvStringHashTable( UINT32 nMaxEntries )
+SvStringHashTable::SvStringHashTable( sal_uInt32 nMaxEntries )
         : SvHashTable( nMaxEntries )
 {
     pEntries = new SvStringHashEntry[ nMaxEntries ];
@@ -177,7 +177,7 @@ SvStringHashTable::~SvStringHashTable()
 
 #ifdef MPW
     // der MPW-Compiler ruft sonst keine Dtoren!
-    for ( USHORT n = 0; n < GetMax(); ++n )
+    for ( sal_uInt16 n = 0; n < GetMax(); ++n )
         (pEntries+n)->SvStringHashEntry::~SvStringHashEntry();
     delete (void*) pEntries;
 #else
@@ -192,18 +192,18 @@ SvStringHashTable::~SvStringHashTable()
 |*    Beschreibung
 |*
 *************************************************************************/
-UINT32 SvStringHashTable::HashFunc( const void * pElement ) const
+sal_uInt32 SvStringHashTable::HashFunc( const void * pElement ) const
 {
-    UINT32          nHash = 0;  // hash value
+    sal_uInt32          nHash = 0;  // hash value
     const char *    pStr = ((const ByteString * )pElement)->GetBuffer();
 
     int nShift = 0;
     while( *pStr )
     {
         if( isupper( *pStr ) )
-            nHash ^= UINT32(*pStr - 'A' + 26) << nShift;
+            nHash ^= sal_uInt32(*pStr - 'A' + 26) << nShift;
         else
-            nHash ^= UINT32(*pStr - 'a') << nShift;
+            nHash ^= sal_uInt32(*pStr - 'a') << nShift;
         if( nShift == 28 )
             nShift = 0;
         else
@@ -222,7 +222,7 @@ UINT32 SvStringHashTable::HashFunc( const void * pElement ) const
 *************************************************************************/
 ByteString SvStringHashTable::GetNearString( const ByteString & rName ) const
 {
-    for( UINT32 i = 0; i < GetMax(); i++ )
+    for( sal_uInt32 i = 0; i < GetMax(); i++ )
     {
         SvStringHashEntry * pE = Get( i );
         if( pE )
@@ -241,10 +241,10 @@ ByteString SvStringHashTable::GetNearString( const ByteString & rName ) const
 |*    Beschreibung
 |*
 *************************************************************************/
-BOOL SvStringHashTable::IsEntry( UINT32 nIndex ) const
+sal_Bool SvStringHashTable::IsEntry( sal_uInt32 nIndex ) const
 {
     if( nIndex >= GetMax() )
-        return FALSE;
+        return sal_False;
     return pEntries[ nIndex ].HasId();
 }
 
@@ -255,18 +255,18 @@ BOOL SvStringHashTable::IsEntry( UINT32 nIndex ) const
 |*    Beschreibung
 |*
 *************************************************************************/
-BOOL SvStringHashTable::Insert( const ByteString & rName, UINT32 * pIndex )
+sal_Bool SvStringHashTable::Insert( const ByteString & rName, sal_uInt32 * pIndex )
 {
-    UINT32 nIndex;
+    sal_uInt32 nIndex;
 
     if( !pIndex ) pIndex = &nIndex;
 
-    if( !SvHashTable::Test_Insert( &rName, TRUE, pIndex ) )
-        return FALSE;
+    if( !SvHashTable::Test_Insert( &rName, sal_True, pIndex ) )
+        return sal_False;
 
     if( !IsEntry( *pIndex ) )
         pEntries[ *pIndex ] = SvStringHashEntry( rName, *pIndex );
-    return TRUE;
+    return sal_True;
 }
 
 /*************************************************************************
@@ -276,10 +276,10 @@ BOOL SvStringHashTable::Insert( const ByteString & rName, UINT32 * pIndex )
 |*    Beschreibung
 |*
 *************************************************************************/
-BOOL SvStringHashTable::Test( const ByteString & rName, UINT32 * pPos ) const
+sal_Bool SvStringHashTable::Test( const ByteString & rName, sal_uInt32 * pPos ) const
 {
     return ((SvStringHashTable *)this)->SvHashTable::
-                Test_Insert( &rName, FALSE, pPos );
+                Test_Insert( &rName, sal_False, pPos );
 }
 
 /*************************************************************************
@@ -289,7 +289,7 @@ BOOL SvStringHashTable::Test( const ByteString & rName, UINT32 * pPos ) const
 |*    Beschreibung
 |*
 *************************************************************************/
-SvStringHashEntry * SvStringHashTable::Get( UINT32 nIndex ) const
+SvStringHashEntry * SvStringHashTable::Get( sal_uInt32 nIndex ) const
 {
     if( IsEntry( nIndex ) )
         return pEntries + nIndex;
@@ -304,7 +304,7 @@ SvStringHashEntry * SvStringHashTable::Get( UINT32 nIndex ) const
 |*
 *************************************************************************/
 StringCompare SvStringHashTable::Compare( const void * pElement,
-                                          UINT32 nIndex ) const
+                                          sal_uInt32 nIndex ) const
 {
     return ((const ByteString *)pElement)->CompareTo( pEntries[ nIndex ].GetName() );
 }
@@ -318,7 +318,7 @@ StringCompare SvStringHashTable::Compare( const void * pElement,
 *************************************************************************/
 void SvStringHashTable::FillHashList( SvStringHashList * pList ) const
 {
-    for( UINT32 n = 0; n < GetMax(); n++ )
+    for( sal_uInt32 n = 0; n < GetMax(); n++ )
     {
         if( IsEntry( n ) )
             pList->Insert( Get( n ), LIST_APPEND );