rebase to DEV300_m100

13 files changed, 457 insertions, 457 deletions

diff --git a/basic/source/comp/buffer.cxx b/basic/source/comp/buffer.cxx
index 74559bf0e6c4..46df47cbd665 100644
--- a/basic/source/comp/buffer.cxx
+++ b/basic/source/comp/buffer.cxx
@@ -32,7 +32,7 @@
 #include "buffer.hxx"
 #include <string.h>
 
-const static UINT32 UP_LIMIT=0xFFFFFF00L;
+const static sal_uInt32 UP_LIMIT=0xFFFFFF00L;
 
 // Der SbiBuffer wird in Inkrements von mindestens 16 Bytes erweitert.
 // Dies ist notwendig, da viele Klassen von einer Pufferlaenge
@@ -69,24 +69,24 @@ char* SbiBuffer::GetBuffer()
 // Test, ob der Puffer n Bytes aufnehmen kann.
 // Im Zweifelsfall wird er vergroessert
 
-BOOL SbiBuffer::Check( USHORT n )
+sal_Bool SbiBuffer::Check( sal_uInt16 n )
 {
-    if( !n ) return TRUE;
-    if( ( static_cast<UINT32>( nOff )+ n ) >  static_cast<UINT32>( nSize ) )
+    if( !n ) return sal_True;
+    if( ( static_cast<sal_uInt32>( nOff )+ n ) >  static_cast<sal_uInt32>( nSize ) )
     {
         if( nInc == 0 )
-            return FALSE;
-        USHORT nn = 0;
+            return sal_False;
+        sal_uInt16 nn = 0;
         while( nn < n ) nn = nn + nInc;
         char* p;
-        if( ( static_cast<UINT32>( nSize ) + nn ) > UP_LIMIT ) p = NULL;
+        if( ( static_cast<sal_uInt32>( nSize ) + nn ) > UP_LIMIT ) p = NULL;
         else p = new char [nSize + nn];
         if( !p )
         {
             pParser->Error( SbERR_PROG_TOO_LARGE );
             nInc = 0;
             delete[] pBuf; pBuf = NULL;
-            return FALSE;
+            return sal_False;
         }
         else
         {
@@ -97,19 +97,19 @@ BOOL SbiBuffer::Check( USHORT n )
             nSize = nSize + nn;
         }
     }
-    return TRUE;
+    return sal_True;
 }
 
 // Angleich des Puffers auf die uebergebene Byte-Grenze
 
-void SbiBuffer::Align( INT32 n )
+void SbiBuffer::Align( sal_Int32 n )
 {
     if( nOff % n ) {
-        UINT32 nn =( ( nOff + n ) / n ) * n;
+        sal_uInt32 nn =( ( nOff + n ) / n ) * n;
         if( nn <= UP_LIMIT )
         {
             nn = nn - nOff;
-            if( Check( static_cast<USHORT>(nn) ) )
+            if( Check( static_cast<sal_uInt16>(nn) ) )
             {
                 memset( pCur, 0, nn );
                 pCur += nn;
@@ -121,13 +121,13 @@ void SbiBuffer::Align( INT32 n )
 
 // Patch einer Location
 
-void SbiBuffer::Patch( UINT32 off, UINT32 val )
+void SbiBuffer::Patch( sal_uInt32 off, sal_uInt32 val )
 {
-    if( ( off + sizeof( UINT32 ) ) < nOff )
+    if( ( off + sizeof( sal_uInt32 ) ) < nOff )
     {
-        UINT16 val1 = static_cast<UINT16>( val & 0xFFFF );
-        UINT16 val2 = static_cast<UINT16>( val >> 16 );
-        BYTE* p = (BYTE*) pBuf + off;
+        sal_uInt16 val1 = static_cast<sal_uInt16>( val & 0xFFFF );
+        sal_uInt16 val2 = static_cast<sal_uInt16>( val >> 16 );
+        sal_uInt8* p = (sal_uInt8*) pBuf + off;
         *p++ = (char) ( val1 & 0xFF );
         *p++ = (char) ( val1 >> 8 );
         *p++ = (char) ( val2 & 0xFF );
@@ -139,18 +139,18 @@ void SbiBuffer::Patch( UINT32 off, UINT32 val )
 // bauen eine Kette auf. Der Anfang der Kette ist beim uebergebenen
 // Parameter, das Ende der Kette ist 0.
 
-void SbiBuffer::Chain( UINT32 off )
+void SbiBuffer::Chain( sal_uInt32 off )
 {
     if( off && pBuf )
     {
-        BYTE *ip;
-        UINT32 i = off;
-        UINT32 val1 = (nOff & 0xFFFF);
-        UINT32 val2 = (nOff >> 16);
+        sal_uInt8 *ip;
+        sal_uInt32 i = off;
+        sal_uInt32 val1 = (nOff & 0xFFFF);
+        sal_uInt32 val2 = (nOff >> 16);
         do
         {
-            ip = (BYTE*) pBuf + i;
-            BYTE* pTmp = ip;
+            ip = (sal_uInt8*) pBuf + i;
+            sal_uInt8* pTmp = ip;
                      i =  *pTmp++; i |= *pTmp++ << 8; i |= *pTmp++ << 16; i |= *pTmp++ << 24;
 
             if( i >= nOff )
@@ -166,84 +166,84 @@ void SbiBuffer::Chain( UINT32 off )
     }
 }
 
-BOOL SbiBuffer::operator +=( INT8 n )
+sal_Bool SbiBuffer::operator +=( sal_Int8 n )
 {
     if( Check( 1 ) )
     {
-        *pCur++ = (char) n; nOff++; return TRUE;
-    } else return FALSE;
+        *pCur++ = (char) n; nOff++; return sal_True;
+    } else return sal_False;
 }
 
-BOOL SbiBuffer::operator +=( UINT8 n )
+sal_Bool SbiBuffer::operator +=( sal_uInt8 n )
 {
     if( Check( 1 ) )
     {
-        *pCur++ = (char) n; nOff++; return TRUE;
-    } else return FALSE;
+        *pCur++ = (char) n; nOff++; return sal_True;
+    } else return sal_False;
 }
 
-BOOL SbiBuffer::operator +=( INT16 n )
+sal_Bool SbiBuffer::operator +=( sal_Int16 n )
 {
     if( Check( 2 ) )
     {
         *pCur++ = (char) ( n & 0xFF );
         *pCur++ = (char) ( n >> 8 );
-        nOff += 2; return TRUE;
-    } else return FALSE;
+        nOff += 2; return sal_True;
+    } else return sal_False;
 }
 
-BOOL SbiBuffer::operator +=( UINT16 n )
+sal_Bool SbiBuffer::operator +=( sal_uInt16 n )
 {
     if( Check( 2 ) )
     {
         *pCur++ = (char) ( n & 0xFF );
         *pCur++ = (char) ( n >> 8 );
-        nOff += 2; return TRUE;
-    } else return FALSE;
+        nOff += 2; return sal_True;
+    } else return sal_False;
 }
 
-BOOL SbiBuffer::operator +=( UINT32 n )
+sal_Bool SbiBuffer::operator +=( sal_uInt32 n )
 {
     if( Check( 4 ) )
     {
-        UINT16 n1 = static_cast<UINT16>( n & 0xFFFF );
-        UINT16 n2 = static_cast<UINT16>( n >> 16 );
+        sal_uInt16 n1 = static_cast<sal_uInt16>( n & 0xFFFF );
+        sal_uInt16 n2 = static_cast<sal_uInt16>( n >> 16 );
         if ( operator +=( n1 ) && operator +=( n2 ) )
-            return TRUE;
-        return TRUE;
+            return sal_True;
+        return sal_True;
     }
-    return FALSE;
+    return sal_False;
 }
 
-BOOL SbiBuffer::operator +=( INT32 n )
+sal_Bool SbiBuffer::operator +=( sal_Int32 n )
 {
-    return operator +=( (UINT32) n );
+    return operator +=( (sal_uInt32) n );
 }
 
 
-BOOL SbiBuffer::operator +=( const String& n )
+sal_Bool SbiBuffer::operator +=( const String& n )
 {
-    USHORT l = n.Len() + 1;
+    sal_uInt16 l = n.Len() + 1;
     if( Check( l ) )
     {
         ByteString aByteStr( n, gsl_getSystemTextEncoding() );
         memcpy( pCur, aByteStr.GetBuffer(), l );
         pCur += l;
         nOff = nOff + l;
-        return TRUE;
+        return sal_True;
     }
-    else return FALSE;
+    else return sal_False;
 }
 
-BOOL SbiBuffer::Add( const void* p, USHORT len )
+sal_Bool SbiBuffer::Add( const void* p, sal_uInt16 len )
 {
     if( Check( len ) )
     {
         memcpy( pCur, p, len );
         pCur += len;
         nOff = nOff + len;
-        return TRUE;
-    } else return FALSE;
+        return sal_True;
+    } else return sal_False;
 }
 
 
diff --git a/basic/source/comp/codegen.cxx b/basic/source/comp/codegen.cxx
index 93fb18baf86e..a8c7e3f5330f 100644
--- a/basic/source/comp/codegen.cxx
+++ b/basic/source/comp/codegen.cxx
@@ -40,13 +40,13 @@ SbiCodeGen::SbiCodeGen( SbModule& r, SbiParser* p, short nInc )
          : rMod( r ), aCode( p, nInc )
 {
     pParser = p;
-    bStmnt = FALSE;
+    bStmnt = sal_False;
     nLine = 0;
     nCol = 0;
     nForLevel = 0;
 }
 
-UINT32 SbiCodeGen::GetPC()
+sal_uInt32 SbiCodeGen::GetPC()
 {
     return aCode.GetSize();
 }
@@ -55,7 +55,7 @@ UINT32 SbiCodeGen::GetPC()
 
 void SbiCodeGen::Statement()
 {
-    bStmnt = TRUE;
+    bStmnt = sal_True;
 
     nLine = pParser->GetLine();
     nCol  = pParser->GetCol1();
@@ -71,7 +71,7 @@ void SbiCodeGen::GenStmnt()
 {
     if( bStmnt )
     {
-        bStmnt = FALSE;
+        bStmnt = sal_False;
         Gen( _STMNT, nLine, nCol );
     }
 }
@@ -79,39 +79,39 @@ void SbiCodeGen::GenStmnt()
 // Die Gen-Routinen returnen den Offset des 1. Operanden,
 // damit Jumps dort ihr Backchain versenken koennen
 
-UINT32 SbiCodeGen::Gen( SbiOpcode eOpcode )
+sal_uInt32 SbiCodeGen::Gen( SbiOpcode eOpcode )
 {
 #ifdef DBG_UTIL
     if( eOpcode < SbOP0_START || eOpcode > SbOP0_END )
         pParser->Error( SbERR_INTERNAL_ERROR, "OPCODE1" );
 #endif
     GenStmnt();
-    aCode += (UINT8) eOpcode;
+    aCode += (sal_uInt8) eOpcode;
     return GetPC();
 }
 
-UINT32 SbiCodeGen::Gen( SbiOpcode eOpcode, UINT32 nOpnd )
+sal_uInt32 SbiCodeGen::Gen( SbiOpcode eOpcode, sal_uInt32 nOpnd )
 {
 #ifdef DBG_UTIL
     if( eOpcode < SbOP1_START || eOpcode > SbOP1_END )
         pParser->Error( SbERR_INTERNAL_ERROR, "OPCODE2" );
 #endif
     GenStmnt();
-    aCode += (UINT8) eOpcode;
-    UINT32 n = GetPC();
+    aCode += (sal_uInt8) eOpcode;
+    sal_uInt32 n = GetPC();
     aCode += nOpnd;
     return n;
 }
 
-UINT32 SbiCodeGen::Gen( SbiOpcode eOpcode, UINT32 nOpnd1, UINT32 nOpnd2 )
+sal_uInt32 SbiCodeGen::Gen( SbiOpcode eOpcode, sal_uInt32 nOpnd1, sal_uInt32 nOpnd2 )
 {
 #ifdef DBG_UTIL
     if( eOpcode < SbOP2_START || eOpcode > SbOP2_END )
         pParser->Error( SbERR_INTERNAL_ERROR, "OPCODE3" );
 #endif
     GenStmnt();
-    aCode += (UINT8) eOpcode;
-    UINT32 n = GetPC();
+    aCode += (sal_uInt8) eOpcode;
+    sal_uInt32 n = GetPC();
     aCode += nOpnd1;
     aCode += nOpnd2;
     return n;
@@ -178,7 +178,7 @@ void SbiCodeGen::Save()
             String aProcName = pProc->GetName();
             String aIfaceProcName;
             String aIfaceName;
-            USHORT nPassCount = 1;
+            sal_uInt16 nPassCount = 1;
             if( nIfaceCount )
             {
                 int nPropPrefixFound =
@@ -206,7 +206,7 @@ void SbiCodeGen::Save()
                 }
             }
             SbMethod* pMeth = NULL;
-            for( USHORT nPass = 0 ; nPass < nPassCount ; nPass++ )
+            for( sal_uInt16 nPass = 0 ; nPass < nPassCount ; nPass++ )
             {
                 if( nPass == 1 )
                     aProcName = aIfaceProcName;
@@ -269,7 +269,7 @@ void SbiCodeGen::Save()
                     // Die Parameter:
                     SbxInfo* pInfo = pMeth->GetInfo();
                     String aHelpFile, aComment;
-                    ULONG nHelpId = 0;
+                    sal_uIntPtr nHelpId = 0;
                     if( pInfo )
                     {
                         // Die Zusatzdaten retten
@@ -282,7 +282,7 @@ void SbiCodeGen::Save()
                     pInfo->SetComment( aComment );
                     SbiSymPool* pPool = &pProc->GetParams();
                     // Das erste Element ist immer der Funktionswert!
-                    for( USHORT i = 1; i < pPool->GetSize(); i++ )
+                    for( sal_uInt16 i = 1; i < pPool->GetSize(); i++ )
                     {
                         SbiSymDef* pPar = pPool->Get( i );
                         SbxDataType t = pPar->GetType();
@@ -291,14 +291,14 @@ void SbiCodeGen::Save()
                         if( pPar->GetDims() )
                             t = (SbxDataType) ( t | SbxARRAY );
                         // #33677 Optional-Info durchreichen
-                        USHORT nFlags = SBX_READ;
+                        sal_uInt16 nFlags = SBX_READ;
                         if( pPar->IsOptional() )
                             nFlags |= SBX_OPTIONAL;
 
                         pInfo->AddParam( pPar->GetName(), t, nFlags );
 
-                        UINT32 nUserData = 0;
-                        USHORT nDefaultId = pPar->GetDefaultId();
+                        sal_uInt32 nUserData = 0;
+                        sal_uInt16 nDefaultId = pPar->GetDefaultId();
                         if( nDefaultId )
                             nUserData |= nDefaultId;
                         if( pPar->IsParamArray() )
@@ -320,14 +320,14 @@ void SbiCodeGen::Save()
 
     // Der globale StringPool. 0 ist nicht belegt.
     SbiStringPool* pPool = &pParser->aGblStrings;
-    USHORT nSize = pPool->GetSize();
+    sal_uInt16 nSize = pPool->GetSize();
     p->MakeStrings( nSize );
-    USHORT i;
+    sal_uInt16 i;
     for( i = 1; i <= nSize; i++ )
         p->AddString( pPool->Find( i ) );
 
     // Typen einfuegen
-    USHORT nCount = pParser->rTypeArray->Count();
+    sal_uInt16 nCount = pParser->rTypeArray->Count();
     for (i = 0; i < nCount; i++)
          p->AddType((SbxObject *)pParser->rTypeArray->Get(i));
 
@@ -350,7 +350,7 @@ class PCodeVisitor
 public:
     virtual ~PCodeVisitor();
 
-    virtual void start( BYTE* pStart ) = 0;
+    virtual void start( sal_uInt8* pStart ) = 0;
     virtual void processOpCode0( SbiOpcode eOp ) = 0;
     virtual void processOpCode1( SbiOpcode eOp, T nOp1 ) = 0;
     virtual void processOpCode2( SbiOpcode eOp, T nOp1, T nOp2 ) = 0;
@@ -366,8 +366,8 @@ class PCodeBufferWalker
 {
 private:
     T  m_nBytes;
-    BYTE* m_pCode;
-    T readParam( BYTE*& pCode )
+    sal_uInt8* m_pCode;
+    T readParam( sal_uInt8*& pCode )
     {
         short nBytes = sizeof( T );
         T nOp1=0;
@@ -376,15 +376,15 @@ private:
         return nOp1;
     }
 public:
-    PCodeBufferWalker( BYTE* pCode, T nBytes ): m_nBytes( nBytes ), m_pCode( pCode )
+    PCodeBufferWalker( sal_uInt8* pCode, T nBytes ): m_nBytes( nBytes ), m_pCode( pCode )
     {
     }
     void visitBuffer( PCodeVisitor< T >& visitor )
     {
-        BYTE* pCode = m_pCode;
+        sal_uInt8* pCode = m_pCode;
         if ( !pCode )
             return;
-        BYTE* pEnd = pCode + m_nBytes;
+        sal_uInt8* pEnd = pCode + m_nBytes;
         visitor.start( m_pCode );
         T nOp1 = 0, nOp2 = 0;
         for( ; pCode < pEnd; )
@@ -426,7 +426,7 @@ class OffSetAccumulator : public PCodeVisitor< T >
 public:
 
     OffSetAccumulator() : m_nNumOp0(0), m_nNumSingleParams(0), m_nNumDoubleParams(0){}
-    virtual void start( BYTE* /*pStart*/ ){}
+    virtual void start( sal_uInt8* /*pStart*/ ){}
     virtual void processOpCode0( SbiOpcode /*eOp*/ ){ ++m_nNumOp0; }
     virtual void processOpCode1( SbiOpcode /*eOp*/, T /*nOp1*/ ){  ++m_nNumSingleParams; }
     virtual void processOpCode2( SbiOpcode /*eOp*/, T /*nOp1*/, T /*nOp2*/ ) { ++m_nNumDoubleParams; }
@@ -450,18 +450,18 @@ template < class T, class S >
 
 class BufferTransformer : public PCodeVisitor< T >
 {
-    BYTE* m_pStart;
+    sal_uInt8* m_pStart;
     SbiBuffer m_ConvertedBuf;
 public:
     BufferTransformer():m_pStart(NULL), m_ConvertedBuf( NULL, 1024 ) {}
-    virtual void start( BYTE* pStart ){ m_pStart = pStart; }
+    virtual void start( sal_uInt8* pStart ){ m_pStart = pStart; }
     virtual void processOpCode0( SbiOpcode eOp )
     {
-        m_ConvertedBuf += (UINT8)eOp;
+        m_ConvertedBuf += (sal_uInt8)eOp;
     }
     virtual void processOpCode1( SbiOpcode eOp, T nOp1 )
     {
-        m_ConvertedBuf += (UINT8)eOp;
+        m_ConvertedBuf += (sal_uInt8)eOp;
         switch( eOp )
         {
             case _JUMP:
@@ -486,7 +486,7 @@ public:
     }
     virtual void processOpCode2( SbiOpcode eOp, T nOp1, T nOp2 )
     {
-        m_ConvertedBuf += (UINT8)eOp;
+        m_ConvertedBuf += (sal_uInt8)eOp;
         if ( eOp == _CASEIS )
                 if ( nOp1 )
                     nOp1 = static_cast<T>( convertBufferOffSet(m_pStart, nOp1) );
@@ -503,7 +503,7 @@ public:
     {
         return m_ConvertedBuf;
     }
-    static S convertBufferOffSet( BYTE* pStart, T nOp1 )
+    static S convertBufferOffSet( sal_uInt8* pStart, T nOp1 )
     {
         PCodeBufferWalker< T > aBuff( pStart, nOp1);
         OffSetAccumulator< T, S > aVisitor;
@@ -512,16 +512,16 @@ public:
     }
 };
 
-UINT32
-SbiCodeGen::calcNewOffSet( BYTE* pCode, UINT16 nOffset )
+sal_uInt32
+SbiCodeGen::calcNewOffSet( sal_uInt8* pCode, sal_uInt16 nOffset )
 {
-    return BufferTransformer< UINT16, UINT32 >::convertBufferOffSet( pCode, nOffset );
+    return BufferTransformer< sal_uInt16, sal_uInt32 >::convertBufferOffSet( pCode, nOffset );
 }
 
-UINT16
-SbiCodeGen::calcLegacyOffSet( BYTE* pCode, UINT32 nOffset )
+sal_uInt16
+SbiCodeGen::calcLegacyOffSet( sal_uInt8* pCode, sal_uInt32 nOffset )
 {
-    return BufferTransformer< UINT32, UINT16 >::convertBufferOffSet( pCode, nOffset );
+    return BufferTransformer< sal_uInt32, sal_uInt16 >::convertBufferOffSet( pCode, nOffset );
 }
 
 template <class T, class S>
@@ -531,9 +531,9 @@ PCodeBuffConvertor<T,S>::convert()
     PCodeBufferWalker< T > aBuf( m_pStart, m_nSize );
     BufferTransformer< T, S > aTrnsfrmer;
     aBuf.visitBuffer( aTrnsfrmer );
-    m_pCnvtdBuf = (BYTE*)aTrnsfrmer.buffer().GetBuffer();
+    m_pCnvtdBuf = (sal_uInt8*)aTrnsfrmer.buffer().GetBuffer();
     m_nCnvtdSize = static_cast<S>( aTrnsfrmer.buffer().GetSize() );
 }
 
-template class PCodeBuffConvertor< UINT16, UINT32 >;
-template class PCodeBuffConvertor< UINT32, UINT16 >;
+template class PCodeBuffConvertor< sal_uInt16, sal_uInt32 >;
+template class PCodeBuffConvertor< sal_uInt32, sal_uInt16 >;
diff --git a/basic/source/comp/dim.cxx b/basic/source/comp/dim.cxx
index 4d188ec1ca8a..1ba8982404e4 100644
--- a/basic/source/comp/dim.cxx
+++ b/basic/source/comp/dim.cxx
@@ -37,7 +37,7 @@ SbxObject* cloneTypeObjectImpl( const SbxObject& rTypeObj );
 // Returnwert: eine neue Instanz, die eingefuegt und dann geloescht wird.
 // Array-Indexe werden als SbiDimList zurueckgegeben
 
-SbiSymDef* SbiParser::VarDecl( SbiDimList** ppDim, BOOL bStatic, BOOL bConst )
+SbiSymDef* SbiParser::VarDecl( SbiDimList** ppDim, sal_Bool bStatic, sal_Bool bConst )
 {
     bool bWithEvents = false;
     if( Peek() == WITHEVENTS )
@@ -72,7 +72,7 @@ SbiSymDef* SbiParser::VarDecl( SbiDimList** ppDim, BOOL bStatic, BOOL bConst )
 // Aufloesen einer AS-Typdeklaration
 // Der Datentyp wird in die uebergebene Variable eingetragen
 
-void SbiParser::TypeDecl( SbiSymDef& rDef, BOOL bAsNewAlreadyParsed )
+void SbiParser::TypeDecl( SbiSymDef& rDef, sal_Bool bAsNewAlreadyParsed )
 {
     SbxDataType eType = rDef.GetType();
     short nSize = 0;
@@ -193,34 +193,34 @@ void SbiParser::TypeDecl( SbiSymDef& rDef, BOOL bAsNewAlreadyParsed )
 
 void SbiParser::Dim()
 {
-    DefVar( _DIM, ( pProc && bVBASupportOn ) ? pProc->IsStatic() : FALSE );
+    DefVar( _DIM, ( pProc && bVBASupportOn ) ? pProc->IsStatic() : sal_False );
 }
 
-void SbiParser::DefVar( SbiOpcode eOp, BOOL bStatic )
+void SbiParser::DefVar( SbiOpcode eOp, sal_Bool bStatic )
 {
     SbiSymPool* pOldPool = pPool;
-    BOOL bSwitchPool = FALSE;
-    BOOL bPersistantGlobal = FALSE;
+    sal_Bool bSwitchPool = sal_False;
+    sal_Bool bPersistantGlobal = sal_False;
     SbiToken eFirstTok = eCurTok;
     if( pProc && ( eCurTok == GLOBAL || eCurTok == PUBLIC || eCurTok == PRIVATE ) )
         Error( SbERR_NOT_IN_SUBR, eCurTok );
     if( eCurTok == PUBLIC || eCurTok == GLOBAL )
     {
-        bSwitchPool = TRUE;     // im richtigen Moment auf globalen Pool schalten
+        bSwitchPool = sal_True;     // im richtigen Moment auf globalen Pool schalten
         if( eCurTok == GLOBAL )
-            bPersistantGlobal = TRUE;
+            bPersistantGlobal = sal_True;
     }
     // behavior in VBA is that a module scope variable's lifetime is
     // tied to the document. e.g. a module scope variable is global
        if(  GetBasic()->IsDocBasic() && bVBASupportOn && !pProc )
-        bPersistantGlobal = TRUE;
+        bPersistantGlobal = sal_True;
     // PRIVATE ist Synonym fuer DIM
     // _CONST_?
-    BOOL bConst = FALSE;
+    sal_Bool bConst = sal_False;
     if( eCurTok == _CONST_ )
-        bConst = TRUE;
+        bConst = sal_True;
     else if( Peek() == _CONST_ )
-        Next(), bConst = TRUE;
+        Next(), bConst = sal_True;
 
     // #110004 It can also be a sub/function
     if( !bConst && (eCurTok == SUB || eCurTok == FUNCTION || eCurTok == PROPERTY ||
@@ -241,10 +241,10 @@ void SbiParser::DefVar( SbiOpcode eOp, BOOL bStatic )
             if( bNewGblDefs && nGblChain == 0 )
             {
                 nGblChain = aGen.Gen( _JUMP, 0 );
-                bNewGblDefs = FALSE;
+                bNewGblDefs = sal_False;
             }
             Next();
-            DefProc( FALSE, bPrivate );
+            DefProc( sal_False, bPrivate );
             return;
         }
         else if( eCurTok == ENUM )
@@ -291,14 +291,14 @@ void SbiParser::DefVar( SbiOpcode eOp, BOOL bStatic )
     SbiDimList* pDim;
 
     // AB 9.7.97, #40689, Statics -> Modul-Initialisierung, in Sub ueberspringen
-    UINT32 nEndOfStaticLbl = 0;
+    sal_uInt32 nEndOfStaticLbl = 0;
     if( !bVBASupportOn && bStatic )
     {
         nEndOfStaticLbl = aGen.Gen( _JUMP, 0 );
         aGen.Statement();   // bei static hier nachholen
     }
 
-    BOOL bDefined = FALSE;
+    sal_Bool bDefined = sal_False;
     while( ( pDef = VarDecl( &pDim, bStatic, bConst ) ) != NULL )
     {
         EnableErrors();
@@ -307,12 +307,12 @@ void SbiParser::DefVar( SbiOpcode eOp, BOOL bStatic )
             pPool = &aGlobals;
         SbiSymDef* pOld = pPool->Find( pDef->GetName() );
         // AB 31.3.1996, #25651#, auch in Runtime-Library suchen
-        BOOL bRtlSym = FALSE;
+        sal_Bool bRtlSym = sal_False;
         if( !pOld )
         {
             pOld = CheckRTLForSym( pDef->GetName(), SbxVARIANT );
             if( pOld )
-                bRtlSym = TRUE;
+                bRtlSym = sal_True;
         }
         if( pOld && !(eOp == _REDIM || eOp == _REDIMP) )
         {
@@ -321,7 +321,7 @@ void SbiParser::DefVar( SbiOpcode eOp, BOOL bStatic )
         }
         if( pOld )
         {
-            bDefined = TRUE;
+            bDefined = sal_True;
             // Bei RTL-Symbol immer Fehler
             if( !bRtlSym && (eOp == _REDIM || eOp == _REDIMP) )
             {
@@ -367,11 +367,11 @@ void SbiParser::DefVar( SbiOpcode eOp, BOOL bStatic )
                                 }
                 global:         aGen.BackChain( nGblChain );
                                 nGblChain = 0;
-                                bGblDefs = bNewGblDefs = TRUE;
+                                bGblDefs = bNewGblDefs = sal_True;
                                 break;
                 default:        eOp2 = _LOCAL;
             }
-            UINT32 nOpnd2 = sal::static_int_cast< UINT16 >( pDef->GetType() );
+            sal_uInt32 nOpnd2 = sal::static_int_cast< sal_uInt16 >( pDef->GetType() );
             if( pDef->IsWithEvents() )
                 nOpnd2 |= SBX_TYPE_WITH_EVENTS_FLAG;
 
@@ -380,7 +380,7 @@ void SbiParser::DefVar( SbiOpcode eOp, BOOL bStatic )
 
             short nFixedStringLength = pDef->GetFixedStringLength();
             if( nFixedStringLength >= 0 )
-                nOpnd2 |= (SBX_FIXED_LEN_STRING_FLAG + (UINT32(nFixedStringLength) << 17));     // len = all bits above 0x10000
+                nOpnd2 |= (SBX_FIXED_LEN_STRING_FLAG + (sal_uInt32(nFixedStringLength) << 17));     // len = all bits above 0x10000
 
             aGen.Gen( eOp2, pDef->GetId(), nOpnd2 );
         }
@@ -487,10 +487,10 @@ void SbiParser::DefVar( SbiOpcode eOp, BOOL bStatic )
                 }
                 pDef->SetDims( pDim->GetDims() );
                 if( bPersistantGlobal )
-                    pDef->SetGlobal( TRUE );
+                    pDef->SetGlobal( sal_True );
                 SbiExpression aExpr( this, *pDef, pDim );
                 aExpr.Gen();
-                pDef->SetGlobal( FALSE );
+                pDef->SetGlobal( sal_False );
                 aGen.Gen( (eOp == _STATIC) ? _DIM : eOp );
             }
         }
@@ -515,7 +515,7 @@ void SbiParser::DefVar( SbiOpcode eOp, BOOL bStatic )
     {
         // globalen Chain pflegen
         nGblChain = aGen.Gen( _JUMP, 0 );
-        bGblDefs = bNewGblDefs = TRUE;
+        bGblDefs = bNewGblDefs = sal_True;
 
         // fuer Sub Sprung auf Ende der statics eintragen
         aGen.BackChain( nEndOfStaticLbl );
@@ -528,7 +528,7 @@ void SbiParser::DefVar( SbiOpcode eOp, BOOL bStatic )
 
 void SbiParser::ReDim()
 {
-    DefVar( _REDIM, (  pProc && bVBASupportOn ) ? pProc->IsStatic() : FALSE );
+    DefVar( _REDIM, (  pProc && bVBASupportOn ) ? pProc->IsStatic() : sal_False );
 }
 
 // ERASE array, ...
@@ -548,10 +548,10 @@ void SbiParser::Erase()
 
 void SbiParser::Type()
 {
-    DefType( FALSE );
+    DefType( sal_False );
 }
 
-void SbiParser::DefType( BOOL bPrivate )
+void SbiParser::DefType( sal_Bool bPrivate )
 {
     // TODO: Use bPrivate
     (void)bPrivate;
@@ -570,7 +570,7 @@ void SbiParser::DefType( BOOL bPrivate )
 
     SbiSymDef* pElem;
     SbiDimList* pDim = NULL;
-    BOOL bDone = FALSE;
+    sal_Bool bDone = sal_False;
 
     while( !bDone && !IsEof() )
     {
@@ -578,7 +578,7 @@ void SbiParser::DefType( BOOL bPrivate )
         {
             case ENDTYPE :
                 pElem = NULL;
-                bDone = TRUE;
+                bDone = sal_True;
                 Next();
             break;
 
@@ -590,9 +590,9 @@ void SbiParser::DefType( BOOL bPrivate )
 
             default:
                 pDim = NULL;
-                pElem = VarDecl(&pDim,FALSE,FALSE);
+                pElem = VarDecl(&pDim,sal_False,sal_False);
                 if( !pElem )
-                    bDone = TRUE;   // Error occured
+                    bDone = sal_True;   // Error occured
         }
         if( pElem )
         {
@@ -613,8 +613,8 @@ void SbiParser::DefType( BOOL bPrivate )
 
                         for ( short i=0; i<pDim->GetSize();++i )
                         {
-                            INT32 ub = -1;
-                            INT32 lb = nBase;
+                            sal_Int32 ub = -1;
+                            sal_Int32 lb = nBase;
                             SbiExprNode* pNode =  pDim->Get(i)->GetExprNode();
                             ub = pNode->GetNumber();
                             if ( !pDim->Get( i )->IsBased() ) // each dim is low/up
@@ -633,7 +633,7 @@ void SbiParser::DefType( BOOL bPrivate )
                     }
                     else
                         pArray->unoAddDim( 0, -1 ); // variant array
-                    USHORT nSavFlags = pTypeElem->GetFlags();
+                    sal_uInt16 nSavFlags = pTypeElem->GetFlags();
                     // need to reset the FIXED flag
                     // when calling PutObject ( because the type will not match Object )
                     pTypeElem->ResetFlag( SBX_FIXED );
@@ -643,7 +643,7 @@ void SbiParser::DefType( BOOL bPrivate )
                 // Nested user type?
                 if( eElemType == SbxOBJECT )
                 {
-                    USHORT nElemTypeId = pElem->GetTypeId();
+                    sal_uInt16 nElemTypeId = pElem->GetTypeId();
                     if( nElemTypeId != 0 )
                     {
                         String aTypeName( aGblStrings.Find( nElemTypeId ) );
@@ -673,10 +673,10 @@ void SbiParser::DefType( BOOL bPrivate )
 
 void SbiParser::Enum()
 {
-    DefEnum( FALSE );
+    DefEnum( sal_False );
 }
 
-void SbiParser::DefEnum( BOOL bPrivate )
+void SbiParser::DefEnum( sal_Bool bPrivate )
 {
     // Neues Token lesen, es muss ein Symbol sein
     if (!TestSymbol())
@@ -695,7 +695,7 @@ void SbiParser::DefEnum( BOOL bPrivate )
 
     SbiSymDef* pElem;
     SbiDimList* pDim;
-    BOOL bDone = FALSE;
+    sal_Bool bDone = sal_False;
 
     // Starting with -1 to make first default value 0 after ++
     sal_Int32 nCurrentEnumValue = -1;
@@ -705,7 +705,7 @@ void SbiParser::DefEnum( BOOL bPrivate )
         {
             case ENDENUM :
                 pElem = NULL;
-                bDone = TRUE;
+                bDone = sal_True;
                 Next();
             break;
 
@@ -718,20 +718,20 @@ void SbiParser::DefEnum( BOOL bPrivate )
             default:
             {
                 // TODO: Check existing!
-                BOOL bDefined = FALSE;
+                sal_Bool bDefined = sal_False;
 
                 pDim = NULL;
-                pElem = VarDecl( &pDim, FALSE, TRUE );
+                pElem = VarDecl( &pDim, sal_False, sal_True );
                 if( !pElem )
                 {
-                    bDone = TRUE;   // Error occured
+                    bDone = sal_True;   // Error occured
                     break;
                 }
                 else if( pDim )
                 {
                     delete pDim;
                     Error( SbERR_SYNTAX );
-                    bDone = TRUE;   // Error occured
+                    bDone = sal_True;   // Error occured
                     break;
                 }
 
@@ -761,7 +761,7 @@ void SbiParser::DefEnum( BOOL bPrivate )
                 if( pOld )
                 {
                     Error( SbERR_VAR_DEFINED, pElem->GetName() );
-                    bDone = TRUE;   // Error occured
+                    bDone = sal_True;   // Error occured
                     break;
                 }
 
@@ -772,13 +772,13 @@ void SbiParser::DefEnum( BOOL bPrivate )
                     SbiOpcode eOp = _GLOBAL;
                     aGen.BackChain( nGblChain );
                     nGblChain = 0;
-                    bGblDefs = bNewGblDefs = TRUE;
+                    bGblDefs = bNewGblDefs = sal_True;
                     aGen.Gen(
                         eOp, pElem->GetId(),
-                        sal::static_int_cast< UINT16 >( pElem->GetType() ) );
+                        sal::static_int_cast< sal_uInt16 >( pElem->GetType() ) );
 
                     aVar.Gen();
-                    USHORT nStringId = aGen.GetParser()->aGblStrings.Add( nCurrentEnumValue, SbxLONG );
+                    sal_uInt16 nStringId = aGen.GetParser()->aGblStrings.Add( nCurrentEnumValue, SbxLONG );
                     aGen.Gen( _NUMBER, nStringId );
                     aGen.Gen( _PUTC );
                 }
@@ -809,10 +809,10 @@ void SbiParser::DefEnum( BOOL bPrivate )
 // das erste Token ist bereits eingelesen (SUB/FUNCTION)
 // xxx Name [LIB "name"[ALIAS "name"]][(Parameter)][AS TYPE]
 
-SbiProcDef* SbiParser::ProcDecl( BOOL bDecl )
+SbiProcDef* SbiParser::ProcDecl( sal_Bool bDecl )
 {
-    BOOL bFunc = BOOL( eCurTok == FUNCTION );
-    BOOL bProp = BOOL( eCurTok == GET || eCurTok == SET || eCurTok == LET );
+    sal_Bool bFunc = sal_Bool( eCurTok == FUNCTION );
+    sal_Bool bProp = sal_Bool( eCurTok == GET || eCurTok == SET || eCurTok == LET );
     if( !TestSymbol() ) return NULL;
     String aName( aSym );
     SbxDataType eType = eScanType;
@@ -847,7 +847,7 @@ SbiProcDef* SbiParser::ProcDecl( BOOL bDecl )
             Error( SbERR_UNEXPECTED, ALIAS );
         if( pDef->IsCdecl() )
             Error( SbERR_UNEXPECTED, _CDECL_ );
-        pDef->SetCdecl( FALSE );
+        pDef->SetCdecl( sal_False );
         pDef->GetLib().Erase();
         pDef->GetAlias().Erase();
     }
@@ -858,7 +858,7 @@ SbiProcDef* SbiParser::ProcDecl( BOOL bDecl )
             Error( SbERR_UNEXPECTED, ALIAS );
         if( pDef->IsCdecl() )
             Error( SbERR_UNEXPECTED, _CDECL_ );
-        pDef->SetCdecl( FALSE );
+        pDef->SetCdecl( sal_False );
         pDef->GetAlias().Erase();
     }
     // Klammern?
@@ -869,23 +869,23 @@ SbiProcDef* SbiParser::ProcDecl( BOOL bDecl )
             Next();
         else
           for(;;) {
-            BOOL bByVal = FALSE;
-            BOOL bOptional = FALSE;
-            BOOL bParamArray = FALSE;
+            sal_Bool bByVal = sal_False;
+            sal_Bool bOptional = sal_False;
+            sal_Bool bParamArray = sal_False;
             while( Peek() == BYVAL || Peek() == BYREF || Peek() == _OPTIONAL_ )
             {
-                if      ( Peek() == BYVAL )     Next(), bByVal = TRUE;
-                else if ( Peek() == BYREF )     Next(), bByVal = FALSE;
-                else if ( Peek() == _OPTIONAL_ )    Next(), bOptional = TRUE;
+                if      ( Peek() == BYVAL )     Next(), bByVal = sal_True;
+                else if ( Peek() == BYREF )     Next(), bByVal = sal_False;
+                else if ( Peek() == _OPTIONAL_ )    Next(), bOptional = sal_True;
             }
             if( bCompatible && Peek() == PARAMARRAY )
             {
                 if( bByVal || bOptional )
                     Error( SbERR_UNEXPECTED, PARAMARRAY );
                 Next();
-                bParamArray = TRUE;
+                bParamArray = sal_True;
             }
-            SbiSymDef* pPar = VarDecl( NULL, FALSE, FALSE );
+            SbiSymDef* pPar = VarDecl( NULL, sal_False, sal_False );
             if( !pPar )
                 break;
             if( bByVal )
@@ -898,13 +898,13 @@ SbiProcDef* SbiParser::ProcDecl( BOOL bDecl )
             SbiToken eTok = Next();
             if( eTok != COMMA && eTok != RPAREN )
             {
-                BOOL bError2 = TRUE;
+                sal_Bool bError2 = sal_True;
                 if( bOptional && bCompatible && eTok == EQ )
                 {
                     SbiConstExpression* pDefaultExpr = new SbiConstExpression( this );
                     SbxDataType eType2 = pDefaultExpr->GetType();
 
-                    USHORT nStringId;
+                    sal_uInt16 nStringId;
                     if( eType2 == SbxSTRING )
                         nStringId = aGblStrings.Add( pDefaultExpr->GetString() );
                     else
@@ -915,7 +915,7 @@ SbiProcDef* SbiParser::ProcDecl( BOOL bDecl )
 
                     eTok = Next();
                     if( eTok == COMMA || eTok == RPAREN )
-                        bError2 = FALSE;
+                        bError2 = sal_False;
                 }
                 if( bError2 )
                 {
@@ -942,10 +942,10 @@ SbiProcDef* SbiParser::ProcDecl( BOOL bDecl )
 
 void SbiParser::Declare()
 {
-    DefDeclare( FALSE );
+    DefDeclare( sal_False );
 }
 
-void SbiParser::DefDeclare( BOOL bPrivate )
+void SbiParser::DefDeclare( sal_Bool bPrivate )
 {
     Next();
     if( eCurTok != SUB && eCurTok != FUNCTION )
@@ -954,7 +954,7 @@ void SbiParser::DefDeclare( BOOL bPrivate )
     {
         bool bFunction = (eCurTok == FUNCTION);
 
-        SbiProcDef* pDef = ProcDecl( TRUE );
+        SbiProcDef* pDef = ProcDecl( sal_True );
         if( pDef )
         {
             if( !pDef->GetLib().Len() )
@@ -987,39 +987,39 @@ void SbiParser::DefDeclare( BOOL bPrivate )
                     if( bNewGblDefs && nGblChain == 0 )
                     {
                         nGblChain = aGen.Gen( _JUMP, 0 );
-                        bNewGblDefs = FALSE;
+                        bNewGblDefs = sal_False;
                     }
 
-                    USHORT nSavLine = nLine;
+                    sal_uInt16 nSavLine = nLine;
                     aGen.Statement();
                     pDef->Define();
                     pDef->SetLine1( nSavLine );
                     pDef->SetLine2( nSavLine );
 
                     SbiSymPool& rPool = pDef->GetParams();
-                    USHORT nParCount = rPool.GetSize();
+                    sal_uInt16 nParCount = rPool.GetSize();
 
                     SbxDataType eType = pDef->GetType();
                     if( bFunction )
-                        aGen.Gen( _PARAM, 0, sal::static_int_cast< UINT16 >( eType ) );
+                        aGen.Gen( _PARAM, 0, sal::static_int_cast< sal_uInt16 >( eType ) );
 
                     if( nParCount > 1 )
                     {
                         aGen.Gen( _ARGC );
 
-                        for( USHORT i = 1 ; i < nParCount ; ++i )
+                        for( sal_uInt16 i = 1 ; i < nParCount ; ++i )
                         {
                             SbiSymDef* pParDef = rPool.Get( i );
                             SbxDataType eParType = pParDef->GetType();
 
-                            aGen.Gen( _PARAM, i, sal::static_int_cast< UINT16 >( eParType ) );
+                            aGen.Gen( _PARAM, i, sal::static_int_cast< sal_uInt16 >( eParType ) );
                             aGen.Gen( _ARGV );
 
-                            USHORT nTyp = sal::static_int_cast< USHORT >( pParDef->GetType() );
+                            sal_uInt16 nTyp = sal::static_int_cast< sal_uInt16 >( pParDef->GetType() );
                             if( pParDef->IsByVal() )
                             {
                                 // Reset to avoid additional byval in call to wrapper function
-                                pParDef->SetByVal( FALSE );
+                                pParDef->SetByVal( sal_False );
                                 nTyp |= 0x8000;
                             }
                             aGen.Gen( _ARGTYP, nTyp );
@@ -1029,12 +1029,12 @@ void SbiParser::DefDeclare( BOOL bPrivate )
                     aGen.Gen( _LIB, aGblStrings.Add( pDef->GetLib() ) );
 
                     SbiOpcode eOp = pDef->IsCdecl() ? _CALLC : _CALL;
-                    USHORT nId = pDef->GetId();
+                    sal_uInt16 nId = pDef->GetId();
                     if( pDef->GetAlias().Len() )
                         nId = ( nId & 0x8000 ) | aGblStrings.Add( pDef->GetAlias() );
                     if( nParCount > 1 )
                         nId |= 0x8000;
-                    aGen.Gen( eOp, nId, sal::static_int_cast< UINT16 >( eType ) );
+                    aGen.Gen( eOp, nId, sal::static_int_cast< sal_uInt16 >( eType ) );
 
                     if( bFunction )
                         aGen.Gen( _PUT );
@@ -1060,18 +1060,18 @@ void SbiParser::Call()
 
 void SbiParser::SubFunc()
 {
-    DefProc( FALSE, FALSE );
+    DefProc( sal_False, sal_False );
 }
 
 // Einlesen einer Prozedur
 
-BOOL runsInSetup( void );
+sal_Bool runsInSetup( void );
 
-void SbiParser::DefProc( BOOL bStatic, BOOL bPrivate )
+void SbiParser::DefProc( sal_Bool bStatic, sal_Bool bPrivate )
 {
-    USHORT l1 = nLine, l2 = nLine;
-    BOOL bSub = BOOL( eCurTok == SUB );
-    BOOL bProperty = BOOL( eCurTok == PROPERTY );
+    sal_uInt16 l1 = nLine, l2 = nLine;
+    sal_Bool bSub = sal_Bool( eCurTok == SUB );
+    sal_Bool bProperty = sal_Bool( eCurTok == PROPERTY );
     PropertyMode ePropertyMode = PROPERTY_MODE_NONE;
     if( bProperty )
     {
@@ -1087,7 +1087,7 @@ void SbiParser::DefProc( BOOL bStatic, BOOL bPrivate )
     }
 
     SbiToken eExit = eCurTok;
-    SbiProcDef* pDef = ProcDecl( FALSE );
+    SbiProcDef* pDef = ProcDecl( sal_False );
     if( !pDef )
         return;
     pDef->setPropertyMode( ePropertyMode );
@@ -1141,13 +1141,13 @@ void SbiParser::DefProc( BOOL bStatic, BOOL bPrivate )
     if( bStatic )
         {
         if ( bVBASupportOn )
-            pProc->SetStatic( TRUE );
+            pProc->SetStatic( sal_True );
         else
             Error( SbERR_NOT_IMPLEMENTED ); // STATIC SUB ...
         }
      else
     {
-        pProc->SetStatic( FALSE );
+        pProc->SetStatic( sal_False );
         }
     // Normalfall: Lokale Variable->Parameter->Globale Variable
     pProc->GetLocals().SetParent( &pProc->GetParams() );
@@ -1172,10 +1172,10 @@ void SbiParser::DefProc( BOOL bStatic, BOOL bPrivate )
 
 void SbiParser::Static()
 {
-    DefStatic( FALSE );
+    DefStatic( sal_False );
 }
 
-void SbiParser::DefStatic( BOOL bPrivate )
+void SbiParser::DefStatic( sal_Bool bPrivate )
 {
     switch( Peek() )
     {
@@ -1187,10 +1187,10 @@ void SbiParser::DefStatic( BOOL bPrivate )
             if( bNewGblDefs && nGblChain == 0 )
             {
                 nGblChain = aGen.Gen( _JUMP, 0 );
-                bNewGblDefs = FALSE;
+                bNewGblDefs = sal_False;
             }
             Next();
-            DefProc( TRUE, bPrivate );
+            DefProc( sal_True, bPrivate );
             break;
         default: {
             if( !pProc )
@@ -1198,7 +1198,7 @@ void SbiParser::DefStatic( BOOL bPrivate )
             // Pool umsetzen, damit STATIC-Deklarationen im globalen
             // Pool landen
             SbiSymPool* p = pPool; pPool = &aPublics;
-            DefVar( _STATIC, TRUE );
+            DefVar( _STATIC, sal_True );
             pPool = p;
             } break;
     }
diff --git a/basic/source/comp/exprgen.cxx b/basic/source/comp/exprgen.cxx
index 3e034af204f5..c77123493916 100644
--- a/basic/source/comp/exprgen.cxx
+++ b/basic/source/comp/exprgen.cxx
@@ -75,12 +75,12 @@ void SbiExprNode::Gen( RecursiveMode eRecMode )
             case SbxINTEGER: pGen->Gen( _CONST,  (short) nVal ); break;
             case SbxSTRING:
             {
-                USHORT nStringId = pGen->GetParser()->aGblStrings.Add( aStrVal, TRUE );
+                sal_uInt16 nStringId = pGen->GetParser()->aGblStrings.Add( aStrVal, sal_True );
                 pGen->Gen( _SCONST, nStringId ); break;
             }
             default:
             {
-                USHORT nStringId = pGen->GetParser()->aGblStrings.Add( nVal, eType );
+                sal_uInt16 nStringId = pGen->GetParser()->aGblStrings.Add( nVal, eType );
                 pGen->Gen( _NUMBER, nStringId );
             }
         }
@@ -174,7 +174,7 @@ void SbiExprNode::GenElement( SbiOpcode eOp )
     // Das ID ist entweder die Position oder das String-ID
     // Falls das Bit 0x8000 gesetzt ist, hat die Variable
     // eine Parameterliste.
-    USHORT nId = ( eOp == _PARAM ) ? pDef->GetPos() : pDef->GetId();
+    sal_uInt16 nId = ( eOp == _PARAM ) ? pDef->GetPos() : pDef->GetId();
     // Parameterliste aufbauen
     if( aVar.pPar && aVar.pPar->GetSize() )
     {
@@ -182,7 +182,7 @@ void SbiExprNode::GenElement( SbiOpcode eOp )
         aVar.pPar->Gen();
     }
 
-    pGen->Gen( eOp, nId, sal::static_int_cast< UINT16 >( GetType() ) );
+    pGen->Gen( eOp, nId, sal::static_int_cast< sal_uInt16 >( GetType() ) );
 
     if( aVar.pvMorePar )
     {
@@ -207,7 +207,7 @@ void SbiExprList::Gen()
     {
         pParser->aGen.Gen( _ARGC );
         // AB 10.1.96: Typ-Anpassung bei DECLARE
-        USHORT nCount = 1 /*, nParAnz = 0*/;
+        sal_uInt16 nCount = 1 /*, nParAnz = 0*/;
 //      SbiSymPool* pPool = NULL;
         for( SbiExpression* pExpr = pFirst; pExpr; pExpr = pExpr->pNext,nCount++ )
         {
@@ -215,7 +215,7 @@ void SbiExprList::Gen()
             if( pExpr->GetName().Len() )
             {
                 // named arg
-                USHORT nSid = pParser->aGblStrings.Add( pExpr->GetName() );
+                sal_uInt16 nSid = pParser->aGblStrings.Add( pExpr->GetName() );
                 pParser->aGen.Gen( _ARGN, nSid );
 
                 /* TODO: Check after Declare concept change
@@ -226,7 +226,7 @@ void SbiExprList::Gen()
                     pParser->Error( SbERR_NO_NAMED_ARGS );
 
                     // Spaeter, wenn Named Args bei DECLARE moeglich
-                    //for( USHORT i = 1 ; i < nParAnz ; i++ )
+                    //for( sal_uInt16 i = 1 ; i < nParAnz ; i++ )
                     //{
                     //  SbiSymDef* pDef = pPool->Get( i );
                     //  const String& rName = pDef->GetName();
@@ -260,7 +260,7 @@ void SbiExpression::Gen( RecursiveMode eRecMode )
         pParser->aGen.Gen( _BYVAL );
     if( bBased )
     {
-        USHORT uBase = pParser->nBase;
+        sal_uInt16 uBase = pParser->nBase;
         if( pParser->IsCompatible() )
             uBase |= 0x8000;        // #109275 Flag compatiblity
         pParser->aGen.Gen( _BASED, uBase );
diff --git a/basic/source/comp/exprnode.cxx b/basic/source/comp/exprnode.cxx
index d47c86f86ea8..f516513d7589 100644
--- a/basic/source/comp/exprnode.cxx
+++ b/basic/source/comp/exprnode.cxx
@@ -53,7 +53,7 @@ SbiExprNode::SbiExprNode( SbiParser* p, SbiExprNode* l, SbiToken t, SbiExprNode*
     nVal      = 0;
     eType     = SbxVARIANT;     // Nodes sind immer Variant
     eNodeType = SbxNODE;
-    bComposite= TRUE;
+    bComposite= sal_True;
 }
 
 SbiExprNode::SbiExprNode( SbiParser* p, double n, SbxDataType t )
@@ -86,11 +86,11 @@ SbiExprNode::SbiExprNode( SbiParser* p, const SbiSymDef& r, SbxDataType t, SbiEx
     aVar.pNext= NULL;
 
     // Funktionsergebnisse sind nie starr
-    bComposite= BOOL( aVar.pDef->GetProcDef() != NULL );
+    bComposite= sal_Bool( aVar.pDef->GetProcDef() != NULL );
 }
 
 // #120061 TypeOf
-SbiExprNode::SbiExprNode( SbiParser* p, SbiExprNode* l, USHORT nId )
+SbiExprNode::SbiExprNode( SbiParser* p, SbiExprNode* l, sal_uInt16 nId )
 {
     BaseInit( p );
 
@@ -101,7 +101,7 @@ SbiExprNode::SbiExprNode( SbiParser* p, SbiExprNode* l, USHORT nId )
 }
 
 // new <type>
-SbiExprNode::SbiExprNode( SbiParser* p, USHORT nId )
+SbiExprNode::SbiExprNode( SbiParser* p, sal_uInt16 nId )
 {
     BaseInit( p );
 
@@ -118,8 +118,8 @@ void SbiExprNode::BaseInit( SbiParser* p )
     pLeft       = NULL;
     pRight      = NULL;
     pWithParent = NULL;
-    bComposite  = FALSE;
-    bError      = FALSE;
+    bComposite  = sal_False;
+    bError      = sal_False;
 }
 
 SbiExprNode::~SbiExprNode()
@@ -174,7 +174,7 @@ SbiExprNode* SbiExprNode::GetRealNode()
 
 // Diese Methode setzt den Typ um, falls er in den Integer-Bereich hineinpasst
 
-BOOL SbiExprNode::IsIntConst()
+sal_Bool SbiExprNode::IsIntConst()
 {
     if( eNodeType == SbxNUMVAL )
     {
@@ -185,29 +185,29 @@ BOOL SbiExprNode::IsIntConst()
             {
                 nVal = (double) (short) nVal;
                 eType = SbxINTEGER;
-                return TRUE;
+                return sal_True;
             }
         }
     }
-    return FALSE;
+    return sal_False;
 }
 
-BOOL SbiExprNode::IsNumber()
+sal_Bool SbiExprNode::IsNumber()
 {
-    return BOOL( eNodeType == SbxNUMVAL );
+    return sal_Bool( eNodeType == SbxNUMVAL );
 }
 
-BOOL SbiExprNode::IsString()
+sal_Bool SbiExprNode::IsString()
 {
-    return BOOL( eNodeType == SbxSTRVAL );
+    return sal_Bool( eNodeType == SbxSTRVAL );
 }
 
-BOOL SbiExprNode::IsVariable()
+sal_Bool SbiExprNode::IsVariable()
 {
-    return BOOL( eNodeType == SbxVARVAL );
+    return sal_Bool( eNodeType == SbxVARVAL );
 }
 
-BOOL SbiExprNode::IsLvalue()
+sal_Bool SbiExprNode::IsLvalue()
 {
     return IsVariable();
 }
@@ -256,7 +256,7 @@ void SbiExprNode::CollectBits()
     }
 }
 
-// Kann ein Zweig umgeformt werden, wird TRUE zurueckgeliefert. In diesem
+// Kann ein Zweig umgeformt werden, wird sal_True zurueckgeliefert. In diesem
 // Fall ist das Ergebnis im linken Zweig.
 
 void SbiExprNode::FoldConstants()
@@ -283,7 +283,7 @@ void SbiExprNode::FoldConstants()
                 String rr( pRight->GetString() );
                 delete pLeft; pLeft = NULL;
                 delete pRight; pRight = NULL;
-                bComposite = FALSE;
+                bComposite = sal_False;
                 if( eTok == PLUS || eTok == CAT )
                 {
                     eTok = CAT;
@@ -320,7 +320,7 @@ void SbiExprNode::FoldConstants()
                             break;
                         default:
                             pGen->GetParser()->Error( SbERR_CONVERSION );
-                            bError = TRUE;
+                            bError = sal_True;
                     }
                 }
             }
@@ -334,50 +334,50 @@ void SbiExprNode::FoldConstants()
                    || eTok == IDIV || eTok == MOD )
                 {
                     // Integer-Operationen
-                    BOOL err = FALSE;
-                    if( nl > SbxMAXLNG ) err = TRUE, nl = SbxMAXLNG;
+                    sal_Bool err = sal_False;
+                    if( nl > SbxMAXLNG ) err = sal_True, nl = SbxMAXLNG;
                     else
-                    if( nl < SbxMINLNG ) err = TRUE, nl = SbxMINLNG;
-                    if( nr > SbxMAXLNG ) err = TRUE, nr = SbxMAXLNG;
+                    if( nl < SbxMINLNG ) err = sal_True, nl = SbxMINLNG;
+                    if( nr > SbxMAXLNG ) err = sal_True, nr = SbxMAXLNG;
                     else
-                    if( nr < SbxMINLNG ) err = TRUE, nr = SbxMINLNG;
+                    if( nr < SbxMINLNG ) err = sal_True, nr = SbxMINLNG;
                     ll = (long) nl; lr = (long) nr;
                     llMod = (long) (nl < 0 ? nl - 0.5 : nl + 0.5);
                     lrMod = (long) (nr < 0 ? nr - 0.5 : nr + 0.5);
                     if( err )
                     {
                         pGen->GetParser()->Error( SbERR_MATH_OVERFLOW );
-                        bError = TRUE;
+                        bError = sal_True;
                     }
                 }
-                BOOL bBothInt = BOOL( pLeft->eType < SbxSINGLE
+                sal_Bool bBothInt = sal_Bool( pLeft->eType < SbxSINGLE
                                    && pRight->eType < SbxSINGLE );
                 delete pLeft; pLeft = NULL;
                 delete pRight; pRight = NULL;
                 nVal = 0;
                 eType = SbxDOUBLE;
                 eNodeType = SbxNUMVAL;
-                bComposite = FALSE;
-                BOOL bCheckType = FALSE;
+                bComposite = sal_False;
+                sal_Bool bCheckType = sal_False;
                 switch( eTok )
                 {
                     case EXPON:
                         nVal = pow( nl, nr ); break;
                     case MUL:
-                        bCheckType = TRUE;
+                        bCheckType = sal_True;
                         nVal = nl * nr; break;
                     case DIV:
                         if( !nr )
                         {
                             pGen->GetParser()->Error( SbERR_ZERODIV ); nVal = HUGE_VAL;
-                            bError = TRUE;
+                            bError = sal_True;
                         } else nVal = nl / nr;
                         break;
                     case PLUS:
-                        bCheckType = TRUE;
+                        bCheckType = sal_True;
                         nVal = nl + nr; break;
                     case MINUS:
-                        bCheckType = TRUE;
+                        bCheckType = sal_True;
                         nVal = nl - nr; break;
                     case EQ:
                         nVal = ( nl == nr ) ? SbxTRUE : SbxFALSE;
@@ -401,14 +401,14 @@ void SbiExprNode::FoldConstants()
                         if( !lr )
                         {
                             pGen->GetParser()->Error( SbERR_ZERODIV ); nVal = HUGE_VAL;
-                            bError = TRUE;
+                            bError = sal_True;
                         } else nVal = ll / lr;
                         eType = SbxLONG; break;
                     case MOD:
                         if( !lr )
                         {
                             pGen->GetParser()->Error( SbERR_ZERODIV ); nVal = HUGE_VAL;
-                            bError = TRUE;
+                            bError = sal_True;
                         } else nVal = llMod % lrMod;
                         eType = SbxLONG; break;
                     case AND:
@@ -448,21 +448,21 @@ void SbiExprNode::FoldConstants()
         pLeft = NULL;
         eType = SbxDOUBLE;
         eNodeType = SbxNUMVAL;
-        bComposite = FALSE;
+        bComposite = sal_False;
         switch( eTok )
         {
             case NEG:
                 nVal = -nVal; break;
             case NOT: {
                 // Integer-Operation!
-                BOOL err = FALSE;
-                if( nVal > SbxMAXLNG ) err = TRUE, nVal = SbxMAXLNG;
+                sal_Bool err = sal_False;
+                if( nVal > SbxMAXLNG ) err = sal_True, nVal = SbxMAXLNG;
                 else
-                if( nVal < SbxMINLNG ) err = TRUE, nVal = SbxMINLNG;
+                if( nVal < SbxMINLNG ) err = sal_True, nVal = SbxMINLNG;
                 if( err )
                 {
                     pGen->GetParser()->Error( SbERR_MATH_OVERFLOW );
-                    bError = TRUE;
+                    bError = sal_True;
                 }
                 nVal = (double) ~((long) nVal);
                 eType = SbxLONG;
diff --git a/basic/source/comp/exprtree.cxx b/basic/source/comp/exprtree.cxx
index 69f9ea553529..42b4bfa06aaf 100644
--- a/basic/source/comp/exprtree.cxx
+++ b/basic/source/comp/exprtree.cxx
@@ -42,7 +42,7 @@ SbiExpression::SbiExpression( SbiParser* p, SbiExprType t,
     SbiExprMode eMode, const KeywordSymbolInfo* pKeywordSymbolInfo )
 {
     pParser = p;
-    bError = bByVal = bBased = bBracket = FALSE;
+    bError = bByVal = bBased = bBracket = sal_False;
     nParenLevel = 0;
     eCurExpr = t;
     m_eMode = eMode;
@@ -61,7 +61,7 @@ SbiExpression::SbiExpression( SbiParser* p, double n, SbxDataType t )
     pParser = p;
     eCurExpr = SbOPERAND;
     pNext = NULL;
-    bError = bByVal = bBased = bBracket = FALSE;
+    bError = bByVal = bBased = bBracket = sal_False;
     pExpr = new SbiExprNode( pParser, n, t );
     pExpr->Optimize();
 }
@@ -70,7 +70,7 @@ SbiExpression::SbiExpression( SbiParser* p, const String& r )
 {
     pParser = p;
     pNext = NULL;
-    bError = bByVal = bBased = bBracket = FALSE;
+    bError = bByVal = bBased = bBracket = sal_False;
     eCurExpr = SbOPERAND;
     pExpr = new SbiExprNode( pParser, r );
 }
@@ -79,7 +79,7 @@ SbiExpression::SbiExpression( SbiParser* p, const SbiSymDef& r, SbiExprList* pPa
 {
     pParser = p;
     pNext = NULL;
-    bError = bByVal = bBased = bBracket = FALSE;
+    bError = bByVal = bBased = bBracket = sal_False;
     eCurExpr = SbOPERAND;
     pExpr = new SbiExprNode( pParser, r, SbxVARIANT, pPar );
 }
@@ -88,7 +88,7 @@ SbiExpression::SbiExpression( SbiParser* p, SbiToken t )
 {
     pParser = p;
     pNext = NULL;
-    bError = bByVal = bBased = bBracket = FALSE;
+    bError = bByVal = bBased = bBracket = sal_False;
     eCurExpr = SbOPERAND;
     pExpr = new SbiExprNode( pParser, NULL, t, NULL );
 }
@@ -107,17 +107,17 @@ SbiExpression::~SbiExpression()
 // Folgen Parameter ohne Klammer? Dies kann eine Zahl, ein String,
 // ein Symbol oder auch ein Komma sein (wenn der 1. Parameter fehlt)
 
-static BOOL DoParametersFollow( SbiParser* p, SbiExprType eCurExpr, SbiToken eTok )
+static sal_Bool DoParametersFollow( SbiParser* p, SbiExprType eCurExpr, SbiToken eTok )
 {
     if( eTok == LPAREN )
-        return TRUE;
+        return sal_True;
     // Aber nur, wenn CALL-aehnlich!
     if( !p->WhiteSpace() || eCurExpr != SbSYMBOL )
-        return FALSE;
+        return sal_False;
     if (   eTok == NUMBER || eTok == MINUS || eTok == FIXSTRING
         || eTok == SYMBOL || eTok == COMMA  || eTok == DOT || eTok == NOT || eTok == BYVAL )
     {
-        return TRUE;
+        return sal_True;
     }
     else // check for default params with reserved names ( e.g. names of tokens )
     {
@@ -125,9 +125,9 @@ static BOOL DoParametersFollow( SbiParser* p, SbiExprType eCurExpr, SbiToken eTo
         // Urk the Next() / Peek() symantics are... weird
         tokens.Next();
         if ( tokens.Peek() == ASSIGN )
-            return TRUE;
+            return sal_True;
     }
-    return FALSE;
+    return sal_False;
 }
 
 // Definition eines neuen Symbols
@@ -138,7 +138,7 @@ static SbiSymDef* AddSym
 {
     SbiSymDef* pDef;
     // A= ist keine Prozedur
-    BOOL bHasType = BOOL( eTok == EQ || eTok == DOT );
+    sal_Bool bHasType = sal_Bool( eTok == EQ || eTok == DOT );
     if( ( !bHasType && eCurExpr == SbSYMBOL ) || pPar )
     {
         // Dies ist also eine Prozedur
@@ -151,14 +151,14 @@ static SbiSymDef* AddSym
 
         // Sonderbehandlung fuer Colls wie Documents(1)
         if( eCurExpr == SbSTDEXPR )
-            bHasType = TRUE;
+            bHasType = sal_True;
 
         pDef = pProc;
         pDef->SetType( bHasType ? eType : SbxEMPTY );
         if( pPar )
         {
             // Dummy-Parameter generieren
-            USHORT n = 1;
+            sal_uInt16 n = 1;
             for( short i = 0; i < pPar->GetSize(); i++ )
             {
                 String aPar = String::CreateFromAscii( "PAR" );
@@ -232,7 +232,7 @@ SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
         else
         {
             pParser->Error( SbERR_SYNTAX );
-            bError = TRUE;
+            bError = sal_True;
         }
     }
 
@@ -259,18 +259,18 @@ SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
     // Es koennte ein Objektteil sein, wenn . oder ! folgt
     // Bei . muss aber die Variable bereits definiert sein; wenn pDef
     // nach der Suche NULL ist, isses ein Objekt!
-    BOOL bObj = BOOL( ( eTok == DOT || eTok == EXCLAM )
+    sal_Bool bObj = sal_Bool( ( eTok == DOT || eTok == EXCLAM )
                     && !pParser->WhiteSpace() );
     if( bObj )
     {
-        bBracket = FALSE;   // Now the bracket for the first term is obsolete
+        bBracket = sal_False;   // Now the bracket for the first term is obsolete
         if( eType == SbxVARIANT )
             eType = SbxOBJECT;
         else
         {
             // Name%. geht wirklich nicht!
             pParser->Error( SbERR_BAD_DECLARATION, aSym );
-            bError = TRUE;
+            bError = sal_True;
         }
     }
     // Suche:
@@ -330,7 +330,7 @@ SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
             {
                 // Wie? Erst mit AS definieren und dann einen Suffix nehmen?
                 pParser->Error( SbERR_BAD_DECLARATION, aSym );
-                bError = TRUE;
+                bError = sal_True;
             }
             else if ( eType == SbxVARIANT )
                 // Falls nix angegeben, den Typ des Eintrags nehmen
@@ -355,13 +355,13 @@ SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
             else
             {
                 pParser->Error( SbERR_BAD_DECLARATION, aSym );
-                bError = TRUE;
+                bError = sal_True;
             }
         }
     }
     SbiExprNode* pNd = new SbiExprNode( pParser, *pDef, eType );
     if( !pPar )
-        pPar = new SbiParameters( pParser,FALSE,FALSE );
+        pPar = new SbiParameters( pParser,sal_False,sal_False );
     pNd->aVar.pPar = pPar;
     pNd->aVar.pvMorePar = pvMoreParLcl;
     if( bObj )
@@ -374,7 +374,7 @@ SbiExprNode* SbiExpression::Term( const KeywordSymbolInfo* pKeywordSymbolInfo )
         if( pDef->GetType() != SbxOBJECT && pDef->GetType() != SbxVARIANT )
         {
             pParser->Error( SbERR_BAD_DECLARATION, aSym );
-            bError = TRUE;
+            bError = sal_True;
         }
         if( !bError )
             pNd->aVar.pNext = ObjTerm( *pDef );
@@ -399,14 +399,14 @@ SbiExprNode* SbiExpression::ObjTerm( SbiSymDef& rObj )
             eTok != XOR && eTok != EQV && eTok != IMP && eTok != IS )
         {
             pParser->Error( SbERR_VAR_EXPECTED );
-            bError = TRUE;
+            bError = sal_True;
         }
     }
     /* #118410 Allow type for Class methods and RTL object, e.g. RTL.Chr$(97)
     else
     {
         if( pParser->GetType() != SbxVARIANT )
-            pParser->Error( SbERR_SYNTAX ), bError = TRUE;
+            pParser->Error( SbERR_SYNTAX ), bError = sal_True;
     }
     */
     if( bError )
@@ -437,7 +437,7 @@ SbiExprNode* SbiExpression::ObjTerm( SbiSymDef& rObj )
         }
 
     }
-    BOOL bObj = BOOL( ( eTok == DOT || eTok == EXCLAM ) && !pParser->WhiteSpace() );
+    sal_Bool bObj = sal_Bool( ( eTok == DOT || eTok == EXCLAM ) && !pParser->WhiteSpace() );
     if( bObj )
     {
         if( eType == SbxVARIANT )
@@ -446,7 +446,7 @@ SbiExprNode* SbiExpression::ObjTerm( SbiSymDef& rObj )
         {
             // Name%. geht wirklich nicht!
             pParser->Error( SbERR_BAD_DECLARATION, aSym );
-            bError = TRUE;
+            bError = sal_True;
         }
     }
 
@@ -477,7 +477,7 @@ SbiExprNode* SbiExpression::ObjTerm( SbiSymDef& rObj )
         if( pDef->GetType() != SbxOBJECT )
         {
             pParser->Error( SbERR_BAD_DECLARATION, aSym );
-            bError = TRUE;
+            bError = sal_True;
         }
         if( !bError )
         {
@@ -554,7 +554,7 @@ SbiExprNode* SbiExpression::Operand( bool bUsedForTypeOf )
                 }
             }
             nParenLevel--;
-            pRes->bComposite = TRUE;
+            pRes->bComposite = sal_True;
             break;
         default:
             // Zur Zeit sind Keywords hier OK!
@@ -604,7 +604,7 @@ SbiExprNode* SbiExpression::Unary()
             pParser->TestToken( IS );
             String aDummy;
             SbiSymDef* pTypeDef = new SbiSymDef( aDummy );
-            pParser->TypeDecl( *pTypeDef, TRUE );
+            pParser->TypeDecl( *pTypeDef, sal_True );
             pNd = new SbiExprNode( pParser, pObjNode, pTypeDef->GetTypeId() );
             break;
         }
@@ -613,7 +613,7 @@ SbiExprNode* SbiExpression::Unary()
             pParser->Next();
             String aStr;
             SbiSymDef* pTypeDef = new SbiSymDef( aStr );
-            pParser->TypeDecl( *pTypeDef, TRUE );
+            pParser->TypeDecl( *pTypeDef, sal_True );
             pNd = new SbiExprNode( pParser, pTypeDef->GetTypeId() );
             break;
         }
@@ -766,7 +766,7 @@ SbiExprNode* SbiExpression::Like()
         if( nCount > 1 )
         {
             pParser->Error( SbERR_SYNTAX );
-            bError = TRUE;
+            bError = sal_True;
         }
     }
     return pNd;
@@ -816,28 +816,28 @@ SbiConstExpression::SbiConstExpression( SbiParser* p ) : SbiExpression( p )
     }
     else
     {
-        // #40204 Spezialbehandlung fuer BOOL-Konstanten
-        BOOL bIsBool = FALSE;
+        // #40204 Spezialbehandlung fuer sal_Bool-Konstanten
+        sal_Bool bIsBool = sal_False;
         if( pExpr->eNodeType == SbxVARVAL )
         {
             SbiSymDef* pVarDef = pExpr->GetVar();
 
-            // Ist es eine BOOL-Konstante?
-            BOOL bBoolVal = FALSE;
+            // Ist es eine sal_Bool-Konstante?
+            sal_Bool bBoolVal = sal_False;
             if( pVarDef->GetName().EqualsIgnoreCaseAscii( "true" ) )
             //if( pVarDef->GetName().ICompare( "true" ) == COMPARE_EQUAL )
             {
-                bIsBool = TRUE;
-                bBoolVal = TRUE;
+                bIsBool = sal_True;
+                bBoolVal = sal_True;
             }
             else if( pVarDef->GetName().EqualsIgnoreCaseAscii( "false" ) )
             //else if( pVarDef->GetName().ICompare( "false" ) == COMPARE_EQUAL )
             {
-                bIsBool = TRUE;
-                bBoolVal = FALSE;
+                bIsBool = sal_True;
+                bBoolVal = sal_False;
             }
 
-            // Wenn es ein BOOL ist, Node austauschen
+            // Wenn es ein sal_Bool ist, Node austauschen
             if( bIsBool )
             {
                 delete pExpr;
@@ -889,7 +889,7 @@ SbiExprList::SbiExprList( SbiParser* p )
     nExpr  =
     nDim   = 0;
     bError =
-    bBracket = FALSE;
+    bBracket = sal_False;
 }
 
 SbiExprList::~SbiExprList()
@@ -937,8 +937,8 @@ void SbiExprList::addExpression( SbiExpression* pExpr )
 
 // #i79918/#i80532: bConst has never been set to true
 // -> reused as bStandaloneExpression
-//SbiParameters::SbiParameters( SbiParser* p, BOOL bConst, BOOL bPar) :
-SbiParameters::SbiParameters( SbiParser* p, BOOL bStandaloneExpression, BOOL bPar) :
+//SbiParameters::SbiParameters( SbiParser* p, sal_Bool bConst, sal_Bool bPar) :
+SbiParameters::SbiParameters( SbiParser* p, sal_Bool bStandaloneExpression, sal_Bool bPar) :
     SbiExprList( p )
 {
     if( !bPar )
@@ -958,7 +958,7 @@ SbiParameters::SbiParameters( SbiParser* p, BOOL bStandaloneExpression, BOOL bPa
         }
         else
         {
-            bBracket = TRUE;
+            bBracket = sal_True;
             pParser->Next();
             eTok = pParser->Peek();
         }
@@ -982,7 +982,7 @@ SbiParameters::SbiParameters( SbiParser* p, BOOL bStandaloneExpression, BOOL bPa
         {
             pExpr = new SbiExpression( pParser, 0, SbxEMPTY );
             //if( bConst )
-            //  pParser->Error( SbERR_SYNTAX ), bError = TRUE;
+            //  pParser->Error( SbERR_SYNTAX ), bError = sal_True;
         }
         // Benannte Argumente: entweder .name= oder name:=
         else
@@ -998,25 +998,25 @@ SbiParameters::SbiParameters( SbiParser* p, BOOL bStandaloneExpression, BOOL bPa
             if( bAssumeExprLParenMode )
             {
                 pExpr = new SbiExpression( pParser, SbSTDEXPR, EXPRMODE_LPAREN_PENDING );
-                bAssumeExprLParenMode = FALSE;
+                bAssumeExprLParenMode = sal_False;
 
                 SbiExprMode eModeAfter = pExpr->m_eMode;
                 if( eModeAfter == EXPRMODE_LPAREN_NOT_NEEDED )
                 {
-                    bBracket = TRUE;
+                    bBracket = sal_True;
                 }
                 else if( eModeAfter == EXPRMODE_ARRAY_OR_OBJECT )
                 {
                     // Expression "looks" like an array assignment
                     // a(...)[(...)] = ? or a(...).b(...)
                     // RPAREN is already parsed
-                    bBracket = TRUE;
+                    bBracket = sal_True;
                     bAssumeArrayMode = true;
                     eTok = NIL;
                 }
                 else if( eModeAfter == EXPRMODE_EMPTY_PAREN )
                 {
-                    bBracket = TRUE;
+                    bBracket = sal_True;
                     delete pExpr;
                     if( bByVal )
                         pParser->Error( SbERR_LVALUE_EXPECTED );
@@ -1042,7 +1042,7 @@ SbiParameters::SbiParameters( SbiParser* p, BOOL bStandaloneExpression, BOOL bPa
                     pParser->Next();
                     pExpr = new SbiExpression( pParser );
                     //if( bConst )
-                    //  pParser->Error( SbERR_SYNTAX ), bError = TRUE;
+                    //  pParser->Error( SbERR_SYNTAX ), bError = sal_True;
                 }
                 pExpr->GetName() = aName;
             }
@@ -1067,7 +1067,7 @@ SbiParameters::SbiParameters( SbiParser* p, BOOL bStandaloneExpression, BOOL bPa
             pParser->Error( bBracket
                             ? SbERR_BAD_BRACKETS
                             : SbERR_EXPECTED, COMMA );
-            bError = TRUE;
+            bError = sal_True;
         }
         else
         {
@@ -1085,7 +1085,7 @@ SbiParameters::SbiParameters( SbiParser* p, BOOL bStandaloneExpression, BOOL bPa
         if( !bBracket )
         {
             pParser->Error( SbERR_BAD_BRACKETS );
-            bError = TRUE;
+            bError = sal_True;
         }
     }
     nDim = nExpr;
@@ -1104,12 +1104,12 @@ SbiParameters::SbiParameters( SbiParser* p, BOOL bStandaloneExpression, BOOL bPa
 
 SbiDimList::SbiDimList( SbiParser* p ) : SbiExprList( p )
 {
-    bConst = TRUE;
+    bConst = sal_True;
 
     if( pParser->Next() != LPAREN )
     {
         pParser->Error( SbERR_EXPECTED, LPAREN );
-        bError = TRUE; return;
+        bError = sal_True; return;
     }
 
     if( pParser->Peek() != RPAREN )
diff --git a/basic/source/comp/io.cxx b/basic/source/comp/io.cxx
index b211ea0b7b08..958b34ee57ff 100644
--- a/basic/source/comp/io.cxx
+++ b/basic/source/comp/io.cxx
@@ -35,9 +35,9 @@
 
 // Test, ob ein I/O-Channel angegeben wurde
 
-BOOL SbiParser::Channel( BOOL bAlways )
+sal_Bool SbiParser::Channel( sal_Bool bAlways )
 {
-    BOOL bRes = FALSE;
+    sal_Bool bRes = sal_False;
     Peek();
     if( IsHash() )
     {
@@ -46,7 +46,7 @@ BOOL SbiParser::Channel( BOOL bAlways )
             Next();
         aExpr.Gen();
         aGen.Gen( _CHANNEL );
-        bRes = TRUE;
+        bRes = sal_True;
     }
     else if( bAlways )
         Error( SbERR_EXPECTED, "#" );
@@ -60,7 +60,7 @@ BOOL SbiParser::Channel( BOOL bAlways )
 
 void SbiParser::Print()
 {
-    BOOL bChan = Channel();
+    sal_Bool bChan = Channel();
     // Die Ausdruecke zum Drucken:
     while( !bAbort )
     {
@@ -91,7 +91,7 @@ void SbiParser::Print()
 
 void SbiParser::Write()
 {
-    BOOL bChan = Channel();
+    sal_Bool bChan = Channel();
     // Die Ausdruecke zum Drucken:
     while( !bAbort )
     {
@@ -143,8 +143,8 @@ void SbiParser::Line()
 
 void SbiParser::LineInput()
 {
-    Channel( TRUE );
-    // BOOL bChan = Channel( TRUE );
+    Channel( sal_True );
+    // sal_Bool bChan = Channel( sal_True );
     SbiExpression* pExpr = new SbiExpression( this, SbOPERAND );
     /* AB 15.1.96: Keinen allgemeinen Ausdruck mehr zulassen
     SbiExpression* pExpr = new SbiExpression( this );
@@ -180,8 +180,8 @@ void SbiParser::LineInput()
 void SbiParser::Input()
 {
     aGen.Gen( _RESTART );
-    Channel( TRUE );
-    // BOOL bChan = Channel( TRUE );
+    Channel( sal_True );
+    // sal_Bool bChan = Channel( sal_True );
     SbiExpression* pExpr = new SbiExpression( this, SbOPERAND );
     /* ALT: Jetzt keinen allgemeinen Ausdruck mehr zulassen
     SbiExpression* pExpr = new SbiExpression( this );
diff --git a/basic/source/comp/loops.cxx b/basic/source/comp/loops.cxx
index bd4540a8ffde..02feb685c11f 100644
--- a/basic/source/comp/loops.cxx
+++ b/basic/source/comp/loops.cxx
@@ -34,7 +34,7 @@
 
 void SbiParser::If()
 {
-    UINT32 nEndLbl;
+    sal_uInt32 nEndLbl;
     SbiToken eTok = NIL;
     // Ende-Tokens ignorieren:
     SbiExpression aCond( this );
@@ -46,8 +46,8 @@ void SbiParser::If()
         // eingefuegt werden, damit bei ELSEIF nicht erneut die Bedingung
         // ausgewertet wird. Die Tabelle nimmt alle Absprungstellen auf.
 #define JMP_TABLE_SIZE 100
-        UINT32 pnJmpToEndLbl[JMP_TABLE_SIZE];   // 100 ELSEIFs zulaessig
-        USHORT iJmp = 0;                        // aktueller Tabellen-Index
+        sal_uInt32 pnJmpToEndLbl[JMP_TABLE_SIZE];   // 100 ELSEIFs zulaessig
+        sal_uInt16 iJmp = 0;                        // aktueller Tabellen-Index
 
         // multiline IF
         nEndLbl = aGen.Gen( _JUMPF, 0 );
@@ -58,7 +58,7 @@ void SbiParser::If()
             eTok = Peek();
             if( IsEof() )
             {
-                Error( SbERR_BAD_BLOCK, IF ); bAbort = TRUE; return;
+                Error( SbERR_BAD_BLOCK, IF ); bAbort = sal_True; return;
             }
         }
         // ELSEIF?
@@ -67,7 +67,7 @@ void SbiParser::If()
             // #27720# Bei erfolgreichem IF/ELSEIF auf ENDIF springen
             if( iJmp >= JMP_TABLE_SIZE )
             {
-                Error( SbERR_PROG_TOO_LARGE );  bAbort = TRUE;  return;
+                Error( SbERR_PROG_TOO_LARGE );  bAbort = sal_True;  return;
             }
             pnJmpToEndLbl[iJmp++] = aGen.Gen( _JUMP, 0 );
 
@@ -87,14 +87,14 @@ void SbiParser::If()
                 eTok = Peek();
                 if( IsEof() )
                 {
-                    Error( SbERR_BAD_BLOCK, ELSEIF );  bAbort = TRUE; return;
+                    Error( SbERR_BAD_BLOCK, ELSEIF );  bAbort = sal_True; return;
                 }
             }
         }
         if( eTok == ELSE )
         {
             Next();
-            UINT32 nElseLbl = nEndLbl;
+            sal_uInt32 nElseLbl = nEndLbl;
             nEndLbl = aGen.Gen( _JUMP, 0 );
             aGen.BackChain( nElseLbl );
 
@@ -114,7 +114,7 @@ void SbiParser::If()
     else
     {
         // single line IF
-        bSingleLineIf = TRUE;
+        bSingleLineIf = sal_True;
         nEndLbl = aGen.Gen( _JUMPF, 0 );
         Push( eCurTok );
         while( !bAbort )
@@ -127,7 +127,7 @@ void SbiParser::If()
         if( eTok == ELSE )
         {
             Next();
-            UINT32 nElseLbl = nEndLbl;
+            sal_uInt32 nElseLbl = nEndLbl;
             nEndLbl = aGen.Gen( _JUMP, 0 );
             aGen.BackChain( nElseLbl );
             while( !bAbort )
@@ -138,7 +138,7 @@ void SbiParser::If()
                     break;
             }
         }
-        bSingleLineIf = FALSE;
+        bSingleLineIf = sal_False;
     }
     aGen.BackChain( nEndLbl );
 }
@@ -156,7 +156,7 @@ void SbiParser::NoIf()
 
 void SbiParser::DoLoop()
 {
-    UINT32 nStartLbl = aGen.GetPC();
+    sal_uInt32 nStartLbl = aGen.GetPC();
     OpenBlock( DO );
     SbiToken eTok = Next();
     if( IsEoln( eTok ) )
@@ -183,7 +183,7 @@ void SbiParser::DoLoop()
             SbiExpression aCond( this );
             aCond.Gen();
         }
-        UINT32 nEndLbl = aGen.Gen( eTok == UNTIL ? _JUMPT : _JUMPF, 0 );
+        sal_uInt32 nEndLbl = aGen.Gen( eTok == UNTIL ? _JUMPT : _JUMPF, 0 );
         StmntBlock( LOOP );
         TestEoln();
         aGen.Gen( _JUMP, nStartLbl );
@@ -197,9 +197,9 @@ void SbiParser::DoLoop()
 void SbiParser::While()
 {
     SbiExpression aCond( this );
-    UINT32 nStartLbl = aGen.GetPC();
+    sal_uInt32 nStartLbl = aGen.GetPC();
     aCond.Gen();
-    UINT32 nEndLbl = aGen.Gen( _JUMPF, 0 );
+    sal_uInt32 nEndLbl = aGen.Gen( _JUMPF, 0 );
     StmntBlock( WEND );
     aGen.Gen( _JUMP, nStartLbl );
     aGen.BackChain( nEndLbl );
@@ -248,9 +248,9 @@ void SbiParser::For()
         aGen.Gen( _INITFOR );
     }
 
-    UINT32 nLoop = aGen.GetPC();
+    sal_uInt32 nLoop = aGen.GetPC();
     // Test durchfuehren, evtl. Stack freigeben
-    UINT32 nEndTarget = aGen.Gen( _TESTFOR, 0 );
+    sal_uInt32 nEndTarget = aGen.Gen( _TESTFOR, 0 );
     OpenBlock( FOR );
     StmntBlock( NEXT );
     aGen.Gen( _NEXT );
@@ -305,7 +305,7 @@ void SbiParser::OnGoto()
 {
     SbiExpression aCond( this );
     aCond.Gen();
-    UINT32 nLabelsTarget = aGen.Gen( _ONJUMP, 0 );
+    sal_uInt32 nLabelsTarget = aGen.Gen( _ONJUMP, 0 );
     SbiToken eTok = Next();
     if( eTok != GOTO && eTok != GOSUB )
     {
@@ -313,14 +313,14 @@ void SbiParser::OnGoto()
         eTok = GOTO;
     }
     // Label-Tabelle einlesen:
-    UINT32 nLbl = 0;
+    sal_uInt32 nLbl = 0;
     do
     {
         SbiToken eTok2 = NIL;
         eTok2 = Next(); // Label holen
         if( MayBeLabel() )
         {
-            UINT32 nOff = pProc->GetLabels().Reference( aSym );
+            sal_uInt32 nOff = pProc->GetLabels().Reference( aSym );
             aGen.Gen( _JUMP, nOff );
             nLbl++;
         }
@@ -340,7 +340,7 @@ void SbiParser::Goto()
     Next();
     if( MayBeLabel() )
     {
-        UINT32 nOff = pProc->GetLabels().Reference( aSym );
+        sal_uInt32 nOff = pProc->GetLabels().Reference( aSym );
         aGen.Gen( eOp, nOff );
     }
     else Error( SbERR_LABEL_EXPECTED );
@@ -353,7 +353,7 @@ void SbiParser::Return()
     Next();
     if( MayBeLabel() )
     {
-        UINT32 nOff = pProc->GetLabels().Reference( aSym );
+        sal_uInt32 nOff = pProc->GetLabels().Reference( aSym );
         aGen.Gen( _RETURN, nOff );
     }
     else aGen.Gen( _RETURN, 0 );
@@ -369,9 +369,9 @@ void SbiParser::Select()
     aCase.Gen();
     aGen.Gen( _CASE );
     TestEoln();
-    UINT32 nNextTarget = 0;
-    UINT32 nDoneTarget = 0;
-    BOOL bElse = FALSE;
+    sal_uInt32 nNextTarget = 0;
+    sal_uInt32 nDoneTarget = 0;
+    sal_Bool bElse = sal_False;
     // Die Cases einlesen:
     while( !bAbort )
     {
@@ -382,13 +382,13 @@ void SbiParser::Select()
                 aGen.BackChain( nNextTarget ), nNextTarget = 0;
             aGen.Statement();
             // Jeden Case einlesen
-            BOOL bDone = FALSE;
-            UINT32 nTrueTarget = 0;
+            sal_Bool bDone = sal_False;
+            sal_uInt32 nTrueTarget = 0;
             if( Peek() == ELSE )
             {
                 // CASE ELSE
                 Next();
-                bElse = TRUE;
+                bElse = sal_True;
             }
             else while( !bDone )
             {
@@ -407,7 +407,7 @@ void SbiParser::Select()
                     aCompare.Gen();
                     nTrueTarget = aGen.Gen(
                         _CASEIS, nTrueTarget,
-                        sal::static_int_cast< UINT16 >(
+                        sal::static_int_cast< sal_uInt16 >(
                             SbxEQ + ( eTok2 - EQ ) ) );
                 }
                 else
@@ -428,7 +428,7 @@ void SbiParser::Select()
 
                 }
                 if( Peek() == COMMA ) Next();
-                else TestEoln(), bDone = TRUE;
+                else TestEoln(), bDone = sal_True;
             }
             // Alle Cases abgearbeitet
             if( !bElse )
@@ -493,7 +493,7 @@ void SbiParser::On()
                     aGen.Gen( _STDERROR );
                 else
                 {
-                    UINT32 nOff = pProc->GetLabels().Reference( aSym );
+                    sal_uInt32 nOff = pProc->GetLabels().Reference( aSym );
                     aGen.Gen( _ERRHDL, nOff );
                 }
             }
@@ -525,7 +525,7 @@ void SbiParser::On()
 
 void SbiParser::Resume()
 {
-    UINT32 nLbl;
+    sal_uInt32 nLbl;
 
     switch( Next() )
     {
diff --git a/basic/source/comp/parser.cxx b/basic/source/comp/parser.cxx
index 3d7178ae7688..670ca7384767 100644
--- a/basic/source/comp/parser.cxx
+++ b/basic/source/comp/parser.cxx
@@ -35,18 +35,18 @@ struct SbiParseStack {              // "Stack" fuer Statement-Blocks
     SbiParseStack* pNext;           // Chain
     SbiExprNode* pWithVar;          // Variable fuer WITH
     SbiToken eExitTok;              // Exit-Token
-    UINT32  nChain;                 // JUMP-Chain
+    sal_uInt32  nChain;                 // JUMP-Chain
 };
 
 struct SbiStatement {
     SbiToken eTok;
     void( SbiParser::*Func )();     // Verarbeitungsroutine
-    BOOL  bMain;                    // TRUE: ausserhalb SUBs OK
-    BOOL  bSubr;                    // TRUE: in SUBs OK
+    sal_Bool  bMain;                    // sal_True: ausserhalb SUBs OK
+    sal_Bool  bSubr;                    // sal_True: in SUBs OK
 };
 
-#define Y   TRUE
-#define N   FALSE
+#define Y   sal_True
+#define N   sal_False
 
 static SbiStatement StmntTable [] = {
 { CALL,     &SbiParser::Call,       N, Y, }, // CALL
@@ -141,7 +141,7 @@ SbiParser::SbiParser( StarBASIC* pb, SbModule* pm )
     bGblDefs =
     bNewGblDefs =
     bSingleLineIf =
-    bExplicit = FALSE;
+    bExplicit = sal_False;
     bClassModule = ( pm->GetModuleType() == com::sun::star::script::ModuleType::CLASS );
     OSL_TRACE("Parser - %s, bClassModule %d", rtl::OUStringToOString( pm->GetName(), RTL_TEXTENCODING_UTF8 ).getStr(), bClassModule );
     pPool    = &aPublics;
@@ -187,7 +187,7 @@ SbiSymDef* SbiParser::CheckRTLForSym( const String& rSym, SbxDataType eType )
 
 // Globale Chainkette schliessen
 
-BOOL SbiParser::HasGlobalCode()
+sal_Bool SbiParser::HasGlobalCode()
 {
     if( bGblDefs && nGblChain )
     {
@@ -252,49 +252,49 @@ void SbiParser::Exit()
         Error( SbERR_BAD_EXIT );
 }
 
-BOOL SbiParser::TestSymbol( BOOL bKwdOk )
+sal_Bool SbiParser::TestSymbol( sal_Bool bKwdOk )
 {
     Peek();
     if( eCurTok == SYMBOL || ( bKwdOk && IsKwd( eCurTok ) ) )
     {
-        Next(); return TRUE;
+        Next(); return sal_True;
     }
     Error( SbERR_SYMBOL_EXPECTED );
-    return FALSE;
+    return sal_False;
 }
 
 // Testen auf ein bestimmtes Token
 
-BOOL SbiParser::TestToken( SbiToken t )
+sal_Bool SbiParser::TestToken( SbiToken t )
 {
     if( Peek() == t )
     {
-        Next(); return TRUE;
+        Next(); return sal_True;
     }
     else
     {
         Error( SbERR_EXPECTED, t );
-        return FALSE;
+        return sal_False;
     }
 }
 
 // Testen auf Komma oder EOLN
 
-BOOL SbiParser::TestComma()
+sal_Bool SbiParser::TestComma()
 {
     SbiToken eTok = Peek();
     if( IsEoln( eTok ) )
     {
         Next();
-        return FALSE;
+        return sal_False;
     }
     else if( eTok != COMMA )
     {
         Error( SbERR_EXPECTED, COMMA );
-        return FALSE;
+        return sal_False;
     }
     Next();
-    return TRUE;
+    return sal_True;
 }
 
 // Testen, ob EOLN vorliegt
@@ -320,16 +320,16 @@ void SbiParser::StmntBlock( SbiToken eEnd )
     if( IsEof() )
     {
         Error( SbERR_BAD_BLOCK, eEnd );
-        bAbort = TRUE;
+        bAbort = sal_True;
     }
 }
 
 // Die Hauptroutine. Durch wiederholten Aufrufs dieser Routine wird
-// die Quelle geparst. Returnwert FALSE bei Ende/Fehlern.
+// die Quelle geparst. Returnwert sal_False bei Ende/Fehlern.
 
-BOOL SbiParser::Parse()
+sal_Bool SbiParser::Parse()
 {
-    if( bAbort ) return FALSE;
+    if( bAbort ) return sal_False;
 
     EnableErrors();
 
@@ -345,16 +345,16 @@ BOOL SbiParser::Parse()
         // ein nGblChain vorhanden sein, daher vorher abfragen
         if( bNewGblDefs && nGblChain == 0 )
             nGblChain = aGen.Gen( _JUMP, 0 );
-        return FALSE;
+        return sal_False;
     }
 
     // Leerstatement?
     if( IsEoln( eCurTok ) )
     {
-        Next(); return TRUE;
+        Next(); return sal_True;
     }
 
-    if( !bSingleLineIf && MayBeLabel( TRUE ) )
+    if( !bSingleLineIf && MayBeLabel( sal_True ) )
     {
         // Ist ein Label
         if( !pProc )
@@ -365,7 +365,7 @@ BOOL SbiParser::Parse()
         // Leerstatement?
         if( IsEoln( eCurTok ) )
         {
-            Next(); return TRUE;
+            Next(); return sal_True;
         }
     }
 
@@ -378,13 +378,13 @@ BOOL SbiParser::Parse()
         Next();
         if( eCurTok != NIL )
             aGen.Statement();
-        return FALSE;
+        return sal_False;
     }
 
     // Kommentar?
     if( eCurTok == REM )
     {
-        Next(); return TRUE;
+        Next(); return sal_True;
     }
 
     // Kommt ein Symbol, ist es entweder eine Variable( LET )
@@ -428,7 +428,7 @@ BOOL SbiParser::Parse()
                     ( eCurTok == SUB || eCurTok == FUNCTION || eCurTok == PROPERTY ) )
                 {
                     nGblChain = aGen.Gen( _JUMP, 0 );
-                    bNewGblDefs = FALSE;
+                    bNewGblDefs = sal_False;
                 }
                 // Statement-Opcode bitte auch am Anfang einer Sub
                 if( ( p->bSubr && (eCurTok != STATIC || Peek() == SUB || Peek() == FUNCTION ) ) ||
@@ -459,7 +459,7 @@ BOOL SbiParser::Parse()
     }
     // Der Parser bricht am Ende ab, das naechste Token ist noch nicht
     // geholt!
-    return TRUE;
+    return sal_True;
 }
 
 // Innerste With-Variable liefern
@@ -564,7 +564,7 @@ void SbiParser::Assign()
     SbiExpression aExpr( this );
     aLvalue.Gen();
     aExpr.Gen();
-    USHORT nLen = 0;
+    sal_uInt16 nLen = 0;
     SbiSymDef* pDef = aLvalue.GetRealVar();
     {
         if( pDef->GetConstDef() )
@@ -595,7 +595,7 @@ void SbiParser::Set()
         Next();
         String aStr;
         SbiSymDef* pTypeDef = new SbiSymDef( aStr );
-        TypeDecl( *pTypeDef, TRUE );
+        TypeDecl( *pTypeDef, sal_True );
 
         aLvalue.Gen();
         // aGen.Gen( _CLASS, pDef->GetTypeId() | 0x8000 );
@@ -747,7 +747,7 @@ void SbiParser::EnableCompatibility()
 {
     if( !bCompatible )
         AddConstants();
-    bCompatible = TRUE;
+    bCompatible = sal_True;
 }
 
 // OPTION
@@ -757,7 +757,7 @@ void SbiParser::Option()
     switch( Next() )
     {
         case EXPLICIT:
-            bExplicit = TRUE; break;
+            bExplicit = sal_True; break;
         case BASE:
             if( Next() == NUMBER )
             {
@@ -780,9 +780,9 @@ void SbiParser::Option()
         {
             SbiToken eTok = Next();
             if( eTok == BINARY )
-                bText = FALSE;
+                bText = sal_False;
             else if( eTok == SYMBOL && GetSym().EqualsIgnoreCaseAscii("text") )
-                bText = TRUE;
+                bText = sal_True;
             else
                 Error( SbERR_EXPECTED, "Text/Binary" );
             break;
@@ -792,7 +792,7 @@ void SbiParser::Option()
             break;
 
         case CLASSMODULE:
-            bClassModule = TRUE;
+            bClassModule = sal_True;
             aGen.GetModule().SetModuleType( com::sun::star::script::ModuleType::CLASS );
             break;
         case VBASUPPORT:
diff --git a/basic/source/comp/sbcomp.cxx b/basic/source/comp/sbcomp.cxx
index c8fe782487e3..12e368d1c7eb 100755
--- a/basic/source/comp/sbcomp.cxx
+++ b/basic/source/comp/sbcomp.cxx
@@ -271,7 +271,7 @@ String lcl_dumpMethodParameters( SbMethod* pMethod )
     {
         aStr += '(';
         // 0 is sub itself
-        for ( USHORT nParam = 1; nParam < pParams->Count(); nParam++ )
+        for ( sal_uInt16 nParam = 1; nParam < pParams->Count(); nParam++ )
         {
             SbxVariable* pVar = pParams->Get( nParam );
             DBG_ASSERT( pVar, "Parameter?!" );
@@ -324,9 +324,9 @@ void dbg_DeInitTrace( void )
     GbTraceOn = GbSavTraceOn;
 }
 
-static INT32 GnLastCallLvl = 0;
+static sal_Int32 GnLastCallLvl = 0;
 
-void dbg_traceStep( SbModule* pModule, UINT32 nPC, INT32 nCallLvl )
+void dbg_traceStep( SbModule* pModule, sal_uInt32 nPC, sal_Int32 nCallLvl )
 {
     if( !GbTraceOn )
         return;
@@ -383,7 +383,7 @@ void dbg_traceStep( SbModule* pModule, UINT32 nPC, INT32 nCallLvl )
         lcl_lineOut( GpTraceFileName, rStr_PCode.getStr(), lcl_getSpaces( nIndent ) );
 }
 
-void dbg_traceNotifyCall( SbModule* pModule, SbMethod* pMethod, INT32 nCallLvl, bool bLeave )
+void dbg_traceNotifyCall( SbModule* pModule, SbMethod* pMethod, sal_Int32 nCallLvl, bool bLeave )
 {
     static const char* pSeparator = "' ================================================================================";
 
@@ -448,7 +448,7 @@ void dbg_traceNotifyCall( SbModule* pModule, SbMethod* pMethod, INT32 nCallLvl,
         lcl_lineOut( GpTraceFileName, "" );
 }
 
-void dbg_traceNotifyError( SbError nTraceErr, const String& aTraceErrMsg, bool bTraceErrHandled, INT32 nCallLvl )
+void dbg_traceNotifyError( SbError nTraceErr, const String& aTraceErrMsg, bool bTraceErrHandled, sal_Int32 nCallLvl )
 {
     if( !GbTraceOn )
         return;
@@ -463,7 +463,7 @@ void dbg_traceNotifyError( SbError nTraceErr, const String& aTraceErrMsg, bool b
     lcl_lineOut( GpTraceFileName, Buffer, lcl_getSpaces( nIndent ) );
 }
 
-void dbg_RegisterTraceTextForPC( SbModule* pModule, UINT32 nPC,
+void dbg_RegisterTraceTextForPC( SbModule* pModule, sal_uInt32 nPC,
     const String& aTraceStr_STMNT, const String& aTraceStr_PCode )
 {
     String aModuleName = pModule->GetName();
@@ -490,7 +490,7 @@ void dbg_RegisterTraceTextForPC( SbModule* pModule, UINT32 nPC,
     (*pInnerMap)[nPC] = aData;
 }
 
-void RTL_Impl_TraceCommand( StarBASIC* pBasic, SbxArray& rPar, BOOL bWrite )
+void RTL_Impl_TraceCommand( StarBASIC* pBasic, SbxArray& rPar, sal_Bool bWrite )
 {
     (void)pBasic;
     (void)bWrite;
@@ -621,13 +621,13 @@ void dbg_SaveDisassembly( SbModule* pModule )
 // Diese Routine ist hier definiert, damit der Compiler als eigenes Segment
 // geladen werden kann.
 
-BOOL SbModule::Compile()
+sal_Bool SbModule::Compile()
 {
     if( pImage )
-        return TRUE;
+        return sal_True;
     StarBASIC* pBasic = PTR_CAST(StarBASIC,GetParent());
     if( !pBasic )
-        return FALSE;
+        return sal_False;
     SbxBase::ResetError();
     // Aktuelles Modul!
     SbModule* pOld = pCMOD;
@@ -646,14 +646,14 @@ BOOL SbModule::Compile()
 
     // Beim Compilieren eines Moduls werden die Modul-globalen
     // Variablen aller Module ungueltig
-    BOOL bRet = IsCompiled();
+    sal_Bool bRet = IsCompiled();
     if( bRet )
     {
         if( !this->ISA(SbObjModule) )
             pBasic->ClearAllModuleVars();
         RemoveVars(); // remove 'this' Modules variables
         // clear all method statics
-        for( USHORT i = 0; i < pMethods->Count(); i++ )
+        for( sal_uInt16 i = 0; i < pMethods->Count(); i++ )
         {
             SbMethod* p = PTR_CAST(SbMethod,pMethods->Get( i ) );
             if( p )
diff --git a/basic/source/comp/scanner.cxx b/basic/source/comp/scanner.cxx
index 26c6af53cc56..e518779b78d5 100644
--- a/basic/source/comp/scanner.cxx
+++ b/basic/source/comp/scanner.cxx
@@ -66,9 +66,9 @@ SbiScanner::SbiScanner( const ::rtl::OUString& rBuf, StarBASIC* p ) : aBuf( rBuf
     bUsedForHilite =
     bCompatible =
     bVBASupportOn =
-    bPrevLineExtentsComment = FALSE;
+    bPrevLineExtentsComment = sal_False;
     bHash    =
-    bErrors  = TRUE;
+    bErrors  = sal_True;
 }
 
 SbiScanner::~SbiScanner()
@@ -90,19 +90,19 @@ void SbiScanner::GenError( SbError code )
 {
     if( GetSbData()->bBlockCompilerError )
     {
-        bAbort = TRUE;
+        bAbort = sal_True;
         return;
     }
     if( !bError && bErrors )
     {
-        BOOL bRes = TRUE;
+        sal_Bool bRes = sal_True;
         // Nur einen Fehler pro Statement reporten
-        bError = TRUE;
+        bError = sal_True;
         if( pBasic )
         {
             // Falls EXPECTED oder UNEXPECTED kommen sollte, bezieht es sich
             // immer auf das letzte Token, also die Col1 uebernehmen
-            USHORT nc = nColLock ? nSavedCol1 : nCol1;
+            sal_uInt16 nc = nColLock ? nSavedCol1 : nCol1;
             switch( code )
             {
                 case SbERR_EXPECTED:
@@ -122,16 +122,16 @@ void SbiScanner::GenError( SbError code )
         nErrors++;
 }
 
-// Falls sofort ein Doppelpunkt folgt, wird TRUE zurueckgeliefert.
+// Falls sofort ein Doppelpunkt folgt, wird sal_True zurueckgeliefert.
 // Wird von SbiTokenizer::MayBeLabel() verwendet, um einen Label zu erkennen
 
-BOOL SbiScanner::DoesColonFollow()
+sal_Bool SbiScanner::DoesColonFollow()
 {
     if( pLine && *pLine == ':' )
     {
-        pLine++; nCol++; return TRUE;
+        pLine++; nCol++; return sal_True;
     }
-    else return FALSE;
+    else return sal_False;
 }
 
 // Testen auf ein legales Suffix
@@ -143,36 +143,36 @@ static SbxDataType GetSuffixType( sal_Unicode c )
     {
         sal_uInt32 n = aSuffixesStr.Search( c );
         if( STRING_NOTFOUND != n && c != ' ' )
-            return SbxDataType( (USHORT) n + SbxINTEGER );
+            return SbxDataType( (sal_uInt16) n + SbxINTEGER );
     }
     return SbxVARIANT;
 }
 
 // Einlesen des naechsten Symbols in die Variablen aSym, nVal und eType
-// Returnwert ist FALSE bei EOF oder Fehlern
+// Returnwert ist sal_False bei EOF oder Fehlern
 #define BUF_SIZE 80
 
-BOOL SbiScanner::NextSym()
+sal_Bool SbiScanner::NextSym()
 {
     // Fuer den EOLN-Fall merken
-    USHORT nOldLine = nLine;
-    USHORT nOldCol1 = nCol1;
-    USHORT nOldCol2 = nCol2;
+    sal_uInt16 nOldLine = nLine;
+    sal_uInt16 nOldCol1 = nCol1;
+    sal_uInt16 nOldCol2 = nCol2;
     sal_Unicode buf[ BUF_SIZE ], *p = buf;
-    bHash = FALSE;
+    bHash = sal_False;
 
     eScanType = SbxVARIANT;
     aSym.Erase();
     bSymbol =
-    bNumber = bSpaces = FALSE;
+    bNumber = bSpaces = sal_False;
 
     // Zeile einlesen?
     if( !pLine )
     {
-        INT32 n = nBufPos;
-        INT32 nLen = aBuf.getLength();
+        sal_Int32 n = nBufPos;
+        sal_Int32 nLen = aBuf.getLength();
         if( nBufPos >= nLen )
-            return FALSE;
+            return sal_False;
         const sal_Unicode* p2 = aBuf.getStr();
         p2 += n;
         while( ( n < nLen ) && ( *p2 != '\n' ) && ( *p2 != '\r' ) )
@@ -194,7 +194,7 @@ BOOL SbiScanner::NextSym()
 
     // Leerstellen weg:
     while( *pLine && (( *pLine == ' ' ) || ( *pLine == '\t' ) || ( *pLine == '\f' )) )
-        pLine++, nCol++, bSpaces = TRUE;
+        pLine++, nCol++, bSpaces = sal_True;
 
     nCol1 = nCol;
 
@@ -209,7 +209,7 @@ BOOL SbiScanner::NextSym()
     {
         pLine++;
         nCol++;
-        bHash = TRUE;
+        bHash = sal_True;
     }
 
     // Symbol? Dann Zeichen kopieren.
@@ -219,7 +219,7 @@ BOOL SbiScanner::NextSym()
         if( *pLine == '_' && !*(pLine+1) )
         {   pLine++;
             goto eoln;  }
-        bSymbol = TRUE;
+        bSymbol = sal_True;
         short n = nCol;
         for ( ; (BasicSimpleCharClass::isAlphaNumeric( *pLine, bCompatible ) || ( *pLine == '_' ) ); pLine++ )
             nCol++;
@@ -279,13 +279,13 @@ BOOL SbiScanner::NextSym()
         short ndig = 0;
         short ncdig = 0;
         eScanType = SbxDOUBLE;
-        BOOL bBufOverflow = FALSE;
+        sal_Bool bBufOverflow = sal_False;
         while( strchr( "0123456789.DEde", *pLine ) && *pLine )
         {
             // AB 4.1.1996: Buffer voll? -> leer weiter scannen
             if( (p-buf) == (BUF_SIZE-1) )
             {
-                bBufOverflow = TRUE;
+                bBufOverflow = sal_True;
                 pLine++, nCol++;
                 continue;
             }
@@ -322,7 +322,7 @@ BOOL SbiScanner::NextSym()
             if (!exp) ndig++;
         }
         *p = 0;
-        aSym = p; bNumber = TRUE;
+        aSym = p; bNumber = sal_True;
         // Komma, Exponent mehrfach vorhanden?
         if( comma > 1 || exp > 1 )
         {   aError = '.';
@@ -382,10 +382,10 @@ BOOL SbiScanner::NextSym()
                 // Wird als Operator angesehen
                 pLine--; nCol--; nCol1 = nCol-1; aSym = '&'; return SYMBOL;
         }
-        bNumber = TRUE;
+        bNumber = sal_True;
         long l = 0;
         int i;
-        BOOL bBufOverflow = FALSE;
+        sal_Bool bBufOverflow = sal_False;
         while( BasicSimpleCharClass::isAlphaNumeric( *pLine & 0xFF, bCompatible ) )
         {
             sal_Unicode ch = sal::static_int_cast< sal_Unicode >(
@@ -393,7 +393,7 @@ BOOL SbiScanner::NextSym()
             pLine++; nCol++;
             // AB 4.1.1996: Buffer voll, leer weiter scannen
             if( (p-buf) == (BUF_SIZE-1) )
-                bBufOverflow = TRUE;
+                bBufOverflow = sal_True;
             else if( String( cmp ).Search( ch ) != STRING_NOTFOUND )
             //else if( strchr( cmp, ch ) )
                 *p++ = ch;
@@ -426,7 +426,7 @@ BOOL SbiScanner::NextSym()
     {
         sal_Unicode cSep = *pLine;
         if( cSep == '[' )
-            bSymbol = TRUE, cSep = ']';
+            bSymbol = sal_True, cSep = ']';
         short n = nCol+1;
         while( *pLine )
         {
@@ -446,7 +446,7 @@ BOOL SbiScanner::NextSym()
         // Doppelte Stringbegrenzer raus
         String s( cSep );
         s += cSep;
-        USHORT nIdx = 0;
+        sal_uInt16 nIdx = 0;
         do
         {
             nIdx = aSym.Search( s, nIdx );
@@ -485,15 +485,15 @@ PrevLineCommentLbl:
     if( bPrevLineExtentsComment || (eScanType != SbxSTRING &&
         ( aSym.GetBuffer()[0] == '\'' || aSym.EqualsIgnoreCaseAscii( "REM" ) ) ) )
     {
-        bPrevLineExtentsComment = FALSE;
+        bPrevLineExtentsComment = sal_False;
         aSym = String::CreateFromAscii( "REM" );
-        USHORT nLen = String( pLine ).Len();
+        sal_uInt16 nLen = String( pLine ).Len();
         if( bCompatible && pLine[ nLen - 1 ] == '_' && pLine[ nLen - 2 ] == ' ' )
-            bPrevLineExtentsComment = TRUE;
+            bPrevLineExtentsComment = sal_True;
         nCol2 = nCol2 + nLen;
         pLine = NULL;
     }
-    return TRUE;
+    return sal_True;
 
     // Sonst Zeilen-Ende: aber bitte auf '_' testen, ob die
     // Zeile nicht weitergeht!
@@ -508,7 +508,7 @@ eoln:
             //    .Method
             // ^^^  <- spaces is legal in MSO VBA
             OSL_TRACE("*** resetting bSpaces***");
-            bSpaces = FALSE;
+            bSpaces = sal_False;
         }
         return bRes;
     }
@@ -520,7 +520,7 @@ eoln:
         nCol2 = nOldCol2;
         aSym = '\n';
         nColLock = 0;
-        return TRUE;
+        return sal_True;
     }
 }
 
diff --git a/basic/source/comp/symtbl.cxx b/basic/source/comp/symtbl.cxx
index 9df91a5748b9..2688b5be28cf 100644
--- a/basic/source/comp/symtbl.cxx
+++ b/basic/source/comp/symtbl.cxx
@@ -58,7 +58,7 @@ SbiStringPool::~SbiStringPool()
 
 // Suchen
 
-const String& SbiStringPool::Find( USHORT n ) const
+const String& SbiStringPool::Find( sal_uInt16 n ) const
 {
     if( !n || n > aData.Count() )
         return aEmpty;
@@ -69,10 +69,10 @@ const String& SbiStringPool::Find( USHORT n ) const
 // Hinzufuegen eines Strings. Der String wird Case-Insensitiv
 // verglichen.
 
-short SbiStringPool::Add( const String& rVal, BOOL bNoCase )
+short SbiStringPool::Add( const String& rVal, sal_Bool bNoCase )
 {
-    USHORT n = aData.Count();
-    for( USHORT i = 0; i < n; i++ )
+    sal_uInt16 n = aData.Count();
+    for( sal_uInt16 i = 0; i < n; i++ )
     {
         String* p = aData.GetObject( i );
         if( (  bNoCase && p->Equals( rVal ) )
@@ -125,7 +125,7 @@ void SbiSymPool::Clear()
 
 SbiSymDef* SbiSymPool::First()
 {
-    nCur = (USHORT) -1;
+    nCur = (sal_uInt16) -1;
     return Next();
 }
 
@@ -206,8 +206,8 @@ void SbiSymPool::Add( SbiSymDef* pDef )
 
 SbiSymDef* SbiSymPool::Find( const String& rName ) const
 {
-    USHORT nCount = aData.Count();
-    for( USHORT i = 0; i < nCount; i++ )
+    sal_uInt16 nCount = aData.Count();
+    for( sal_uInt16 i = 0; i < nCount; i++ )
     {
         SbiSymDef* p = aData.GetObject( nCount - i - 1 );
         if( ( !p->nProcId || ( p->nProcId == nProcId ) )
@@ -222,9 +222,9 @@ SbiSymDef* SbiSymPool::Find( const String& rName ) const
 
 // Suchen ueber ID-Nummer
 
-SbiSymDef* SbiSymPool::FindId( USHORT n ) const
+SbiSymDef* SbiSymPool::FindId( sal_uInt16 n ) const
 {
-    for( USHORT i = 0; i < aData.Count(); i++ )
+    for( sal_uInt16 i = 0; i < aData.Count(); i++ )
     {
         SbiSymDef* p = aData.GetObject( i );
         if( p->nId == n && ( !p->nProcId || ( p->nProcId == nProcId ) ) )
@@ -238,7 +238,7 @@ SbiSymDef* SbiSymPool::FindId( USHORT n ) const
 
 // Suchen ueber Position (ab 0)
 
-SbiSymDef* SbiSymPool::Get( USHORT n ) const
+SbiSymDef* SbiSymPool::Get( sal_uInt16 n ) const
 {
     if( n >= aData.Count() )
         return NULL;
@@ -246,7 +246,7 @@ SbiSymDef* SbiSymPool::Get( USHORT n ) const
         return aData.GetObject( n );
 }
 
-UINT32 SbiSymPool::Define( const String& rName )
+sal_uInt32 SbiSymPool::Define( const String& rName )
 {
     SbiSymDef* p = Find( rName );
     if( p )
@@ -258,7 +258,7 @@ UINT32 SbiSymPool::Define( const String& rName )
     return p->Define();
 }
 
-UINT32 SbiSymPool::Reference( const String& rName )
+sal_uInt32 SbiSymPool::Reference( const String& rName )
 {
     SbiSymDef* p = Find( rName );
     if( !p )
@@ -272,7 +272,7 @@ UINT32 SbiSymPool::Reference( const String& rName )
 
 void SbiSymPool::CheckRefs()
 {
-    for( USHORT i = 0; i < aData.Count(); i++ )
+    for( sal_uInt16 i = 0; i < aData.Count(); i++ )
     {
         SbiSymDef* p = aData.GetObject( i );
         if( !p->IsDefined() )
@@ -304,7 +304,7 @@ SbiSymDef::SbiSymDef( const String& rName ) : aName( rName )
     bWithEvents =
     bByVal   =
     bChained =
-    bGlobal  = FALSE;
+    bGlobal  = sal_False;
     pIn      =
     pPool    = NULL;
     nDefaultId = 0;
@@ -360,11 +360,11 @@ void SbiSymDef::SetType( SbxDataType t )
 // Es wird der Wert zurueckgeliefert, der als Operand gespeichert
 // werden soll.
 
-UINT32 SbiSymDef::Reference()
+sal_uInt32 SbiSymDef::Reference()
 {
     if( !bChained )
     {
-        UINT32 n = nChain;
+        sal_uInt32 n = nChain;
         nChain = pIn->pParser->aGen.GetOffset();
         return n;
     }
@@ -374,13 +374,13 @@ UINT32 SbiSymDef::Reference()
 // Definition eines Symbols.
 // Hier wird der Backchain aufgeloest, falls vorhanden
 
-UINT32 SbiSymDef::Define()
+sal_uInt32 SbiSymDef::Define()
 {
-    UINT32 n = pIn->pParser->aGen.GetPC();
+    sal_uInt32 n = pIn->pParser->aGen.GetPC();
     pIn->pParser->aGen.GenStmnt();
     if( nChain ) pIn->pParser->aGen.BackChain( nChain );
     nChain = n;
-    bChained = TRUE;
+    bChained = sal_True;
     return nChain;
 }
 
@@ -409,7 +409,7 @@ SbiSymScope SbiSymDef::GetScope() const
 // 3) aLabels: Labels
 
 SbiProcDef::SbiProcDef( SbiParser* pParser, const String& rName,
-                        BOOL bProcDecl )
+                        sal_Bool bProcDecl )
          : SbiSymDef( rName )
          , aParams( pParser->aGblStrings, SbPARAM )  // wird gedumpt
          , aLabels( pParser->aLclStrings, SbLOCAL )  // wird nicht gedumpt
@@ -421,9 +421,9 @@ SbiProcDef::SbiProcDef( SbiParser* pParser, const String& rName,
     nLine1  =
     nLine2  = 0;
     mePropMode = PROPERTY_MODE_NONE;
-    bPublic = TRUE;
-    bCdecl  = FALSE;
-    bStatic = FALSE;
+    bPublic = sal_True;
+    bCdecl  = sal_False;
+    bStatic = sal_False;
     // Fuer Returnwerte ist das erste Element der Parameterliste
     // immer mit dem Namen und dem Typ der Proc definiert
     aParams.AddSym( aName );
@@ -451,7 +451,7 @@ void SbiProcDef::Match( SbiProcDef* pOld )
 {
     SbiSymDef* po, *pn=NULL;
     // Parameter 0 ist der Funktionsname
-    USHORT i;
+    sal_uInt16 i;
     for( i = 1; i < aParams.GetSize(); i++ )
     {
         po = pOld->aParams.Get( i );
diff --git a/basic/source/comp/token.cxx b/basic/source/comp/token.cxx
index 8cb3126f03f1..8700ae4129ba 100644
--- a/basic/source/comp/token.cxx
+++ b/basic/source/comp/token.cxx
@@ -386,10 +386,10 @@ SbiTokenizer::SbiTokenizer( const ::rtl::OUString& rSrc, StarBASIC* pb )
     //if( StarBASIC::GetGlobalLanguageMode() == SB_LANG_JAVASCRIPT )
     //  pTokTable = aTokTable_Java;
     TokenTable *tp;
-    bEof = bAs = FALSE;
+    bEof = bAs = sal_False;
     eCurTok = NIL;
     ePush = NIL;
-    bEos = bKeywords = bErrorIsSymbol = TRUE;
+    bEos = bKeywords = bErrorIsSymbol = sal_True;
     if( !nToken )
         for( nToken = 0, tp = pTokTable; tp->t; nToken++, tp++ ) {}
 }
@@ -431,9 +431,9 @@ SbiToken SbiTokenizer::Peek()
 {
     if( ePush == NIL )
     {
-        USHORT nOldLine = nLine;
-        USHORT nOldCol1 = nCol1;
-        USHORT nOldCol2 = nCol2;
+        sal_uInt16 nOldLine = nLine;
+        sal_uInt16 nOldCol1 = nCol1;
+        sal_uInt16 nOldCol2 = nCol2;
         ePush = Next();
         nPLine = nLine; nLine = nOldLine;
         nPCol1 = nCol1; nCol1 = nOldCol1;
@@ -498,15 +498,15 @@ SbiToken SbiTokenizer::Next()
     // Sonst einlesen:
     if( !NextSym() )
     {
-        bEof = bEos = TRUE;
+        bEof = bEos = sal_True;
         return eCurTok = EOLN;
     }
     // Zeilenende?
     if( aSym.GetBuffer()[0] == '\n' )
     {
-        bEos = TRUE; return eCurTok = EOLN;
+        bEos = sal_True; return eCurTok = EOLN;
     }
-    bEos = FALSE;
+    bEos = sal_False;
 
     // Zahl?
     if( bNumber )
@@ -573,10 +573,10 @@ special:
     {
         // AB, 15.3.96, Spezialbehandlung fuer END, beim Peek() geht die
         // aktuelle Zeile verloren, daher alles merken und danach restaurieren
-        USHORT nOldLine = nLine;
-        USHORT nOldCol  = nCol;
-        USHORT nOldCol1 = nCol1;
-        USHORT nOldCol2 = nCol2;
+        sal_uInt16 nOldLine = nLine;
+        sal_uInt16 nOldCol  = nCol;
+        sal_uInt16 nOldCol1 = nCol1;
+        sal_uInt16 nOldCol2 = nCol2;
         String aOldSym = aSym;
         SaveLine();             // pLine im Scanner sichern
 
@@ -612,11 +612,11 @@ special:
     eCurTok = tp->t;
     // AS: Datentypen sind Keywords
     if( tp->t == AS )
-        bAs = TRUE;
+        bAs = sal_True;
     else
     {
         if( bAs )
-            bAs = FALSE;
+            bAs = sal_False;
         else if( eCurTok >= DATATYPE1 && eCurTok <= DATATYPE2 && (bErrorIsSymbol || eCurTok != _ERROR_) )
             eCurTok = SYMBOL;
     }
@@ -653,12 +653,12 @@ special:
 
 // Kann das aktuell eingelesene Token ein Label sein?
 
-BOOL SbiTokenizer::MayBeLabel( BOOL bNeedsColon )
+sal_Bool SbiTokenizer::MayBeLabel( sal_Bool bNeedsColon )
 {
     if( eCurTok == SYMBOL || m_aTokenLabelInfo.canTokenBeLabel( eCurTok ) )
-        return bNeedsColon ? DoesColonFollow() : TRUE;
+        return bNeedsColon ? DoesColonFollow() : sal_True;
     else
-        return BOOL( eCurTok == NUMBER
+        return sal_Bool( eCurTok == NUMBER
                   && eScanType == SbxINTEGER
                   && nVal >= 0 );
 }
@@ -670,8 +670,8 @@ BOOL SbiTokenizer::MayBeLabel( BOOL bNeedsColon )
 
 void SbiTokenizer::Hilite( SbTextPortions& rList )
 {
-    bErrors = FALSE;
-    bUsedForHilite = TRUE;
+    bErrors = sal_False;
+    bUsedForHilite = sal_True;
     SbiToken eLastTok = NIL;
     for( ;; )
     {
@@ -709,6 +709,6 @@ void SbiTokenizer::Hilite( SbTextPortions& rList )
             break;
         eLastTok = eCurTok;
     }
-    bUsedForHilite = FALSE;
+    bUsedForHilite = sal_False;
 }