diff options
Diffstat (limited to 'basic/source/sbx')
27 files changed, 805 insertions, 805 deletions
diff --git a/basic/source/sbx/sbxarray.cxx b/basic/source/sbx/sbxarray.cxx index 67e7ce71aded..7a68f2ea5a31 100644 --- a/basic/source/sbx/sbxarray.cxx +++ b/basic/source/sbx/sbxarray.cxx @@ -35,8 +35,8 @@ using namespace std; struct SbxDim { // eine Array-Dimension: SbxDim* pNext; // Link - INT32 nLbound, nUbound; // Begrenzungen - INT32 nSize; // Anzahl Elemente + sal_Int32 nLbound, nUbound; // Begrenzungen + sal_Int32 nSize; // Anzahl Elemente }; class SbxVarEntry : public SbxVariableRef { @@ -88,7 +88,7 @@ SbxArray& SbxArray::operator=( const SbxArray& rArray ) eType = rArray.eType; Clear(); SbxVarRefs* pSrc = rArray.pData; - for( UINT32 i = 0; i < pSrc->size(); i++ ) + for( sal_uInt32 i = 0; i < pSrc->size(); i++ ) { SbxVarEntryPtr pSrcRef = (*pSrc)[i]; const SbxVariable* pSrc_ = *pSrcRef; @@ -126,8 +126,8 @@ SbxClassType SbxArray::GetClass() const void SbxArray::Clear() { - UINT32 nSize = pData->size(); - for( UINT32 i = 0 ; i < nSize ; i++ ) + sal_uInt32 nSize = pData->size(); + for( sal_uInt32 i = 0 ; i < nSize ; i++ ) { SbxVarEntry* pEntry = (*pData)[i]; delete pEntry; @@ -135,19 +135,19 @@ void SbxArray::Clear() pData->clear(); } -UINT32 SbxArray::Count32() const +sal_uInt32 SbxArray::Count32() const { return pData->size(); } -USHORT SbxArray::Count() const +sal_uInt16 SbxArray::Count() const { - UINT32 nCount = pData->size(); + sal_uInt32 nCount = pData->size(); DBG_ASSERT( nCount <= SBX_MAXINDEX, "SBX: Array-Index > SBX_MAXINDEX" ); - return (USHORT)nCount; + return (sal_uInt16)nCount; } -SbxVariableRef& SbxArray::GetRef32( UINT32 nIdx ) +SbxVariableRef& SbxArray::GetRef32( sal_uInt32 nIdx ) { // Array ggf. vergroessern DBG_ASSERT( nIdx <= SBX_MAXINDEX32, "SBX: Array-Index > SBX_MAXINDEX32" ); @@ -165,7 +165,7 @@ SbxVariableRef& SbxArray::GetRef32( UINT32 nIdx ) return *((*pData)[nIdx]); } -SbxVariableRef& SbxArray::GetRef( USHORT nIdx ) +SbxVariableRef& SbxArray::GetRef( sal_uInt16 nIdx ) { // Array ggf. vergroessern DBG_ASSERT( nIdx <= SBX_MAXINDEX, "SBX: Array-Index > SBX_MAXINDEX" ); @@ -183,7 +183,7 @@ SbxVariableRef& SbxArray::GetRef( USHORT nIdx ) return *((*pData)[nIdx]); } -SbxVariable* SbxArray::Get32( UINT32 nIdx ) +SbxVariable* SbxArray::Get32( sal_uInt32 nIdx ) { if( !CanRead() ) { @@ -202,7 +202,7 @@ SbxVariable* SbxArray::Get32( UINT32 nIdx ) return rRef; } -SbxVariable* SbxArray::Get( USHORT nIdx ) +SbxVariable* SbxArray::Get( sal_uInt16 nIdx ) { if( !CanRead() ) { @@ -221,7 +221,7 @@ SbxVariable* SbxArray::Get( USHORT nIdx ) return rRef; } -void SbxArray::Put32( SbxVariable* pVar, UINT32 nIdx ) +void SbxArray::Put32( SbxVariable* pVar, sal_uInt32 nIdx ) { if( !CanWrite() ) SetError( SbxERR_PROP_READONLY ); @@ -241,7 +241,7 @@ void SbxArray::Put32( SbxVariable* pVar, UINT32 nIdx ) } } -void SbxArray::Put( SbxVariable* pVar, USHORT nIdx ) +void SbxArray::Put( SbxVariable* pVar, sal_uInt16 nIdx ) { if( !CanWrite() ) SetError( SbxERR_PROP_READONLY ); @@ -261,7 +261,7 @@ void SbxArray::Put( SbxVariable* pVar, USHORT nIdx ) } } -const XubString& SbxArray::GetAlias( USHORT nIdx ) +const XubString& SbxArray::GetAlias( sal_uInt16 nIdx ) { if( !CanRead() ) { @@ -280,7 +280,7 @@ const XubString& SbxArray::GetAlias( USHORT nIdx ) return *rRef.pAlias; } -void SbxArray::PutAlias( const XubString& rAlias, USHORT nIdx ) +void SbxArray::PutAlias( const XubString& rAlias, sal_uInt16 nIdx ) { if( !CanWrite() ) SetError( SbxERR_PROP_READONLY ); @@ -294,7 +294,7 @@ void SbxArray::PutAlias( const XubString& rAlias, USHORT nIdx ) } } -void SbxArray::Insert32( SbxVariable* pVar, UINT32 nIdx ) +void SbxArray::Insert32( SbxVariable* pVar, sal_uInt32 nIdx ) { DBG_ASSERT( pData->size() <= SBX_MAXINDEX32, "SBX: Array wird zu gross" ); if( pData->size() > SBX_MAXINDEX32 ) @@ -317,7 +317,7 @@ void SbxArray::Insert32( SbxVariable* pVar, UINT32 nIdx ) SetFlag( SBX_MODIFIED ); } -void SbxArray::Insert( SbxVariable* pVar, USHORT nIdx ) +void SbxArray::Insert( SbxVariable* pVar, sal_uInt16 nIdx ) { DBG_ASSERT( pData->size() <= 0x3FF0, "SBX: Array wird zu gross" ); if( pData->size() > 0x3FF0 ) @@ -325,7 +325,7 @@ void SbxArray::Insert( SbxVariable* pVar, USHORT nIdx ) Insert32( pVar, nIdx ); } -void SbxArray::Remove32( UINT32 nIdx ) +void SbxArray::Remove32( sal_uInt32 nIdx ) { if( nIdx < pData->size() ) { @@ -336,7 +336,7 @@ void SbxArray::Remove32( UINT32 nIdx ) } } -void SbxArray::Remove( USHORT nIdx ) +void SbxArray::Remove( sal_uInt16 nIdx ) { if( nIdx < pData->size() ) { @@ -351,7 +351,7 @@ void SbxArray::Remove( SbxVariable* pVar ) { if( pVar ) { - for( UINT32 i = 0; i < pData->size(); i++ ) + for( sal_uInt32 i = 0; i < pData->size(); i++ ) { SbxVariableRef* pRef = (*pData)[i]; // SbxVariableRef* pRef = pData->GetObject( i ); @@ -370,8 +370,8 @@ void SbxArray::Merge( SbxArray* p ) { if( p ) { - UINT32 nSize = p->Count(); - for( UINT32 i = 0; i < nSize; i++ ) + sal_uInt32 nSize = p->Count(); + for( sal_uInt32 i = 0; i < nSize; i++ ) { SbxVarEntryPtr pRef1 = (*(p->pData))[i]; // Ist das Element by name schon drin? @@ -380,8 +380,8 @@ void SbxArray::Merge( SbxArray* p ) if( pVar ) { XubString aName = pVar->GetName(); - USHORT nHash = pVar->GetHashCode(); - for( UINT32 j = 0; j < pData->size(); j++ ) + sal_uInt16 nHash = pVar->GetHashCode(); + for( sal_uInt32 j = 0; j < pData->size(); j++ ) { SbxVariableRef* pRef2 = (*pData)[j]; if( (*pRef2)->GetHashCode() == nHash @@ -408,10 +408,10 @@ void SbxArray::Merge( SbxArray* p ) // Suchen eines Elements ueber die Userdaten. Falls ein Element // ein Objekt ist, wird dieses ebenfalls durchsucht. -SbxVariable* SbxArray::FindUserData( UINT32 nData ) +SbxVariable* SbxArray::FindUserData( sal_uInt32 nData ) { SbxVariable* p = NULL; - for( UINT32 i = 0; i < pData->size(); i++ ) + for( sal_uInt32 i = 0; i < pData->size(); i++ ) { SbxVariableRef* pRef = (*pData)[i]; SbxVariable* pVar = *pRef; @@ -431,7 +431,7 @@ SbxVariable* SbxArray::FindUserData( UINT32 nData ) case SbxCLASS_OBJECT: { // Objekte duerfen ihren Parent nicht durchsuchen - USHORT nOld = pVar->GetFlags(); + sal_uInt16 nOld = pVar->GetFlags(); pVar->ResetFlag( SBX_GBLSEARCH ); p = ((SbxObject*) pVar)->FindUserData( nData ); pVar->SetFlags( nOld ); @@ -459,12 +459,12 @@ SbxVariable* SbxArray::FindUserData( UINT32 nData ) SbxVariable* SbxArray::Find( const XubString& rName, SbxClassType t ) { SbxVariable* p = NULL; - UINT32 nCount = pData->size(); + sal_uInt32 nCount = pData->size(); if( !nCount ) return NULL; - BOOL bExtSearch = IsSet( SBX_EXTSEARCH ); - USHORT nHash = SbxVariable::MakeHashCode( rName ); - for( UINT32 i = 0; i < nCount; i++ ) + sal_Bool bExtSearch = IsSet( SBX_EXTSEARCH ); + sal_uInt16 nHash = SbxVariable::MakeHashCode( rName ); + for( sal_uInt32 i = 0; i < nCount; i++ ) { SbxVariableRef* pRef = (*pData)[i]; SbxVariable* pVar = *pRef; @@ -472,7 +472,7 @@ SbxVariable* SbxArray::Find( const XubString& rName, SbxClassType t ) { // Die ganz sichere Suche klappt auch, wenn es // keinen Hascode gibt! - USHORT nVarHash = pVar->GetHashCode(); + sal_uInt16 nVarHash = pVar->GetHashCode(); if( ( !nVarHash || nVarHash == nHash ) && ( t == SbxCLASS_DONTCARE || pVar->GetClass() == t ) && ( pVar->GetName().EqualsIgnoreCaseAscii( rName ) ) ) @@ -489,7 +489,7 @@ SbxVariable* SbxArray::Find( const XubString& rName, SbxClassType t ) case SbxCLASS_OBJECT: { // Objekte duerfen ihren Parent nicht durchsuchen - USHORT nOld = pVar->GetFlags(); + sal_uInt16 nOld = pVar->GetFlags(); pVar->ResetFlag( SBX_GBLSEARCH ); p = ((SbxObject*) pVar)->Find( rName, t ); pVar->SetFlags( nOld ); @@ -511,18 +511,18 @@ SbxVariable* SbxArray::Find( const XubString& rName, SbxClassType t ) return p; } -BOOL SbxArray::LoadData( SvStream& rStrm, USHORT nVer ) +sal_Bool SbxArray::LoadData( SvStream& rStrm, sal_uInt16 nVer ) { - UINT16 nElem; + sal_uInt16 nElem; Clear(); - BOOL bRes = TRUE; - USHORT f = nFlags; + sal_Bool bRes = sal_True; + sal_uInt16 f = nFlags; nFlags |= SBX_WRITE; rStrm >> nElem; nElem &= 0x7FFF; - for( UINT32 n = 0; n < nElem; n++ ) + for( sal_uInt32 n = 0; n < nElem; n++ ) { - UINT16 nIdx; + sal_uInt16 nIdx; rStrm >> nIdx; SbxVariable* pVar = (SbxVariable*) Load( rStrm ); if( pVar ) @@ -532,7 +532,7 @@ BOOL SbxArray::LoadData( SvStream& rStrm, USHORT nVer ) } else { - bRes = FALSE; break; + bRes = sal_False; break; } } if( bRes ) @@ -541,10 +541,10 @@ BOOL SbxArray::LoadData( SvStream& rStrm, USHORT nVer ) return bRes; } -BOOL SbxArray::StoreData( SvStream& rStrm ) const +sal_Bool SbxArray::StoreData( SvStream& rStrm ) const { - UINT32 nElem = 0; - UINT32 n; + sal_uInt32 nElem = 0; + sal_uInt32 n; // Welche Elemente sind ueberhaupt definiert? for( n = 0; n < pData->size(); n++ ) { @@ -553,23 +553,23 @@ BOOL SbxArray::StoreData( SvStream& rStrm ) const if( p && !( p->GetFlags() & SBX_DONTSTORE ) ) nElem++; } - rStrm << (UINT16) nElem; + rStrm << (sal_uInt16) nElem; for( n = 0; n < pData->size(); n++ ) { SbxVariableRef* pRef = (*pData)[n]; SbxVariable* p = *pRef; if( p && !( p->GetFlags() & SBX_DONTSTORE ) ) { - rStrm << (UINT16) n; + rStrm << (sal_uInt16) n; if( !p->Store( rStrm ) ) - return FALSE; + return sal_False; } } return StorePrivateData( rStrm ); } // #100883 Method to set method directly to parameter array -void SbxArray::PutDirect( SbxVariable* pVar, UINT32 nIdx ) +void SbxArray::PutDirect( SbxVariable* pVar, sal_uInt32 nIdx ) { SbxVariableRef& rRef = GetRef32( nIdx ); rRef = pVar; @@ -632,7 +632,7 @@ void SbxDimArray::Clear() // Dimension hinzufuegen -void SbxDimArray::AddDimImpl32( INT32 lb, INT32 ub, BOOL bAllowSize0 ) +void SbxDimArray::AddDimImpl32( sal_Int32 lb, sal_Int32 ub, sal_Bool bAllowSize0 ) { SbxError eRes = SbxERR_OK; if( ub < lb && !bAllowSize0 ) @@ -656,51 +656,51 @@ void SbxDimArray::AddDimImpl32( INT32 lb, INT32 ub, BOOL bAllowSize0 ) void SbxDimArray::AddDim( short lb, short ub ) { - AddDimImpl32( lb, ub, FALSE ); + AddDimImpl32( lb, ub, sal_False ); } void SbxDimArray::unoAddDim( short lb, short ub ) { - AddDimImpl32( lb, ub, TRUE ); + AddDimImpl32( lb, ub, sal_True ); } -void SbxDimArray::AddDim32( INT32 lb, INT32 ub ) +void SbxDimArray::AddDim32( sal_Int32 lb, sal_Int32 ub ) { - AddDimImpl32( lb, ub, FALSE ); + AddDimImpl32( lb, ub, sal_False ); } -void SbxDimArray::unoAddDim32( INT32 lb, INT32 ub ) +void SbxDimArray::unoAddDim32( sal_Int32 lb, sal_Int32 ub ) { - AddDimImpl32( lb, ub, TRUE ); + AddDimImpl32( lb, ub, sal_True ); } // Dimensionsdaten auslesen -BOOL SbxDimArray::GetDim32( INT32 n, INT32& rlb, INT32& rub ) const +sal_Bool SbxDimArray::GetDim32( sal_Int32 n, sal_Int32& rlb, sal_Int32& rub ) const { if( n < 1 || n > nDim ) { - SetError( SbxERR_BOUNDS ); rub = rlb = 0; return FALSE; + SetError( SbxERR_BOUNDS ); rub = rlb = 0; return sal_False; } SbxDim* p = pFirst; while( --n ) p = p->pNext; rub = p->nUbound; rlb = p->nLbound; - return TRUE; + return sal_True; } -BOOL SbxDimArray::GetDim( short n, short& rlb, short& rub ) const +sal_Bool SbxDimArray::GetDim( short n, short& rlb, short& rub ) const { - INT32 rlb32, rub32; - BOOL bRet = GetDim32( n, rlb32, rub32 ); + sal_Int32 rlb32, rub32; + sal_Bool bRet = GetDim32( n, rlb32, rub32 ); if( bRet ) { if( rlb32 < -SBX_MAXINDEX || rub32 > SBX_MAXINDEX ) { SetError( SbxERR_BOUNDS ); - return FALSE; + return sal_False; } rub = (short)rub32; rlb = (short)rlb32; @@ -710,15 +710,15 @@ BOOL SbxDimArray::GetDim( short n, short& rlb, short& rub ) const // Element-Ptr anhand einer Index-Liste -UINT32 SbxDimArray::Offset32( const INT32* pIdx ) +sal_uInt32 SbxDimArray::Offset32( const sal_Int32* pIdx ) { - UINT32 nPos = 0; + sal_uInt32 nPos = 0; for( SbxDim* p = pFirst; p; p = p->pNext ) { - INT32 nIdx = *pIdx++; + sal_Int32 nIdx = *pIdx++; if( nIdx < p->nLbound || nIdx > p->nUbound ) { - nPos = (UINT32)SBX_MAXINDEX32 + 1; break; + nPos = (sal_uInt32)SBX_MAXINDEX32 + 1; break; } nPos = nPos * p->nSize + nIdx - p->nLbound; } @@ -729,7 +729,7 @@ UINT32 SbxDimArray::Offset32( const INT32* pIdx ) return nPos; } -USHORT SbxDimArray::Offset( const short* pIdx ) +sal_uInt16 SbxDimArray::Offset( const short* pIdx ) { long nPos = 0; for( SbxDim* p = pFirst; p; p = p->pNext ) @@ -745,7 +745,7 @@ USHORT SbxDimArray::Offset( const short* pIdx ) { SetError( SbxERR_BOUNDS ); nPos = 0; } - return (USHORT) nPos; + return (sal_uInt16) nPos; } SbxVariableRef& SbxDimArray::GetRef( const short* pIdx ) @@ -763,17 +763,17 @@ void SbxDimArray::Put( SbxVariable* p, const short* pIdx ) SbxArray::Put( p, Offset( pIdx ) ); } -SbxVariableRef& SbxDimArray::GetRef32( const INT32* pIdx ) +SbxVariableRef& SbxDimArray::GetRef32( const sal_Int32* pIdx ) { return SbxArray::GetRef32( Offset32( pIdx ) ); } -SbxVariable* SbxDimArray::Get32( const INT32* pIdx ) +SbxVariable* SbxDimArray::Get32( const sal_Int32* pIdx ) { return SbxArray::Get32( Offset32( pIdx ) ); } -void SbxDimArray::Put32( SbxVariable* p, const INT32* pIdx ) +void SbxDimArray::Put32( SbxVariable* p, const sal_Int32* pIdx ) { SbxArray::Put32( p, Offset32( pIdx ) ); } @@ -781,38 +781,38 @@ void SbxDimArray::Put32( SbxVariable* p, const INT32* pIdx ) // Element-Nr anhand eines Parameter-Arrays -UINT32 SbxDimArray::Offset32( SbxArray* pPar ) +sal_uInt32 SbxDimArray::Offset32( SbxArray* pPar ) { if( nDim == 0 || !pPar || ( ( nDim != ( pPar->Count() - 1 ) ) && SbiRuntime::isVBAEnabled() ) ) { SetError( SbxERR_BOUNDS ); return 0; } - UINT32 nPos = 0; - USHORT nOff = 1; // Nicht Element 0! + sal_uInt32 nPos = 0; + sal_uInt16 nOff = 1; // Nicht Element 0! for( SbxDim* p = pFirst; p && !IsError(); p = p->pNext ) { - INT32 nIdx = pPar->Get( nOff++ )->GetLong(); + sal_Int32 nIdx = pPar->Get( nOff++ )->GetLong(); if( nIdx < p->nLbound || nIdx > p->nUbound ) { - nPos = (UINT32) SBX_MAXINDEX32+1; break; + nPos = (sal_uInt32) SBX_MAXINDEX32+1; break; } nPos = nPos * p->nSize + nIdx - p->nLbound; } - if( nPos > (UINT32) SBX_MAXINDEX32 ) + if( nPos > (sal_uInt32) SBX_MAXINDEX32 ) { SetError( SbxERR_BOUNDS ); nPos = 0; } return nPos; } -USHORT SbxDimArray::Offset( SbxArray* pPar ) +sal_uInt16 SbxDimArray::Offset( SbxArray* pPar ) { - UINT32 nPos = Offset32( pPar ); + sal_uInt32 nPos = Offset32( pPar ); if( nPos > (long) SBX_MAXINDEX ) { SetError( SbxERR_BOUNDS ); nPos = 0; } - return (USHORT) nPos; + return (sal_uInt16) nPos; } SbxVariableRef& SbxDimArray::GetRef( SbxArray* pPar ) @@ -830,27 +830,27 @@ void SbxDimArray::Put( SbxVariable* p, SbxArray* pPar ) SbxArray::Put32( p, Offset32( pPar ) ); } -BOOL SbxDimArray::LoadData( SvStream& rStrm, USHORT nVer ) +sal_Bool SbxDimArray::LoadData( SvStream& rStrm, sal_uInt16 nVer ) { short nDimension; rStrm >> nDimension; for( short i = 0; i < nDimension && rStrm.GetError() == SVSTREAM_OK; i++ ) { - INT16 lb, ub; + sal_Int16 lb, ub; rStrm >> lb >> ub; AddDim( lb, ub ); } return SbxArray::LoadData( rStrm, nVer ); } -BOOL SbxDimArray::StoreData( SvStream& rStrm ) const +sal_Bool SbxDimArray::StoreData( SvStream& rStrm ) const { - rStrm << (INT16) nDim; + rStrm << (sal_Int16) nDim; for( short i = 0; i < nDim; i++ ) { short lb, ub; GetDim( i, lb, ub ); - rStrm << (INT16) lb << (INT16) ub; + rStrm << (sal_Int16) lb << (sal_Int16) ub; } return SbxArray::StoreData( rStrm ); } diff --git a/basic/source/sbx/sbxbase.cxx b/basic/source/sbx/sbxbase.cxx index 60bb9fe505e7..54e45c79a8d2 100644 --- a/basic/source/sbx/sbxbase.cxx +++ b/basic/source/sbx/sbxbase.cxx @@ -108,13 +108,13 @@ void SbxBase::Clear() DBG_CHKTHIS( SbxBase, 0 ); } -BOOL SbxBase::IsFixed() const +sal_Bool SbxBase::IsFixed() const { DBG_CHKTHIS( SbxBase, 0 ); return IsSet( SBX_FIXED ); } -void SbxBase::SetModified( BOOL b ) +void SbxBase::SetModified( sal_Bool b ) { DBG_CHKTHIS( SbxBase, 0 ); if( IsSet( SBX_NO_MODIFY ) ) @@ -137,9 +137,9 @@ void SbxBase::SetError( SbxError e ) p->eSbxError = e; } -BOOL SbxBase::IsError() +sal_Bool SbxBase::IsError() { - return BOOL( GetSbxData_Impl()->eSbxError != SbxERR_OK ); + return sal_Bool( GetSbxData_Impl()->eSbxError != SbxERR_OK ); } void SbxBase::ResetError() @@ -153,7 +153,7 @@ void SbxBase::AddFactory( SbxFactory* pFac ) const SbxFactory* pTemp = pFac; // AB, 6.3.96: HandleLast-Flag beruecksichtigen - USHORT nPos = p->aFacs.Count(); // Einfuege-Position + sal_uInt16 nPos = p->aFacs.Count(); // Einfuege-Position if( !pFac->IsHandleLast() ) // Nur, wenn nicht selbst HandleLast { // Neue Factory vor Factories mit HandleLast einordnen @@ -167,7 +167,7 @@ void SbxBase::AddFactory( SbxFactory* pFac ) void SbxBase::RemoveFactory( SbxFactory* pFac ) { SbxAppData* p = GetSbxData_Impl(); - for( USHORT i = 0; i < p->aFacs.Count(); i++ ) + for( sal_uInt16 i = 0; i < p->aFacs.Count(); i++ ) { if( p->aFacs.GetObject( i ) == pFac ) { @@ -177,7 +177,7 @@ void SbxBase::RemoveFactory( SbxFactory* pFac ) } -SbxBase* SbxBase::Create( UINT16 nSbxId, UINT32 nCreator ) +SbxBase* SbxBase::Create( sal_uInt16 nSbxId, sal_uInt32 nCreator ) { // #91626: Hack to skip old Basic dialogs // Problem: There does not exist a factory any more, @@ -203,7 +203,7 @@ SbxBase* SbxBase::Create( UINT16 nSbxId, UINT32 nCreator ) // Unbekanter Typ: ber die Factories gehen! SbxAppData* p = GetSbxData_Impl(); SbxBase* pNew = NULL; - for( USHORT i = 0; i < p->aFacs.Count(); i++ ) + for( sal_uInt16 i = 0; i < p->aFacs.Count(); i++ ) { SbxFactory* pFac = p->aFacs.GetObject( i ); pNew = pFac->Create( nSbxId, nCreator ); @@ -225,7 +225,7 @@ SbxObject* SbxBase::CreateObject( const XubString& rClass ) { SbxAppData* p = GetSbxData_Impl(); SbxObject* pNew = NULL; - for( USHORT i = 0; i < p->aFacs.Count(); i++ ) + for( sal_uInt16 i = 0; i < p->aFacs.Count(); i++ ) { pNew = p->aFacs.GetObject( i )->CreateObject( rClass ); if( pNew ) @@ -243,15 +243,15 @@ SbxObject* SbxBase::CreateObject( const XubString& rClass ) return pNew; } -static BOOL bStaticEnableBroadcasting = TRUE; +static sal_Bool bStaticEnableBroadcasting = sal_True; // Sbx-Loesung als Ersatz fuer SfxBroadcaster::Enable() -void SbxBase::StaticEnableBroadcasting( BOOL bEnable ) +void SbxBase::StaticEnableBroadcasting( sal_Bool bEnable ) { bStaticEnableBroadcasting = bEnable; } -BOOL SbxBase::StaticIsEnabledBroadcasting( void ) +sal_Bool SbxBase::StaticIsEnabledBroadcasting( void ) { return bStaticEnableBroadcasting; } @@ -259,15 +259,15 @@ BOOL SbxBase::StaticIsEnabledBroadcasting( void ) SbxBase* SbxBase::Load( SvStream& rStrm ) { - UINT16 nSbxId, nFlags, nVer; - UINT32 nCreator, nSize; + sal_uInt16 nSbxId, nFlags, nVer; + sal_uInt32 nCreator, nSize; rStrm >> nCreator >> nSbxId >> nFlags >> nVer; // Eine Dummheit meinerseits korrigieren: if( nFlags & SBX_RESERVED ) nFlags = ( nFlags & ~SBX_RESERVED ) | SBX_GBLSEARCH; - ULONG nOldPos = rStrm.Tell(); + sal_uIntPtr nOldPos = rStrm.Tell(); rStrm >> nSize; SbxBase* p = Create( nSbxId, nCreator ); if( p ) @@ -275,7 +275,7 @@ SbxBase* SbxBase::Load( SvStream& rStrm ) p->nFlags = nFlags; if( p->LoadData( rStrm, nVer ) ) { - ULONG nNewPos = rStrm.Tell(); + sal_uIntPtr nNewPos = rStrm.Tell(); nOldPos += nSize; DBG_ASSERT( nOldPos >= nNewPos, "SBX: Zu viele Daten eingelesen" ); if( nOldPos != nNewPos ) @@ -303,81 +303,81 @@ SbxBase* SbxBase::Load( SvStream& rStrm ) // Sbx-Objekt im Stream ueberspringen void SbxBase::Skip( SvStream& rStrm ) { - UINT16 nSbxId, nFlags, nVer; - UINT32 nCreator, nSize; + sal_uInt16 nSbxId, nFlags, nVer; + sal_uInt32 nCreator, nSize; rStrm >> nCreator >> nSbxId >> nFlags >> nVer; - ULONG nStartPos = rStrm.Tell(); + sal_uIntPtr nStartPos = rStrm.Tell(); rStrm >> nSize; rStrm.Seek( nStartPos + nSize ); } -BOOL SbxBase::Store( SvStream& rStrm ) +sal_Bool SbxBase::Store( SvStream& rStrm ) { DBG_CHKTHIS( SbxBase, 0 ); if( !( nFlags & SBX_DONTSTORE ) ) { - rStrm << (UINT32) GetCreator() - << (UINT16) GetSbxId() - << (UINT16) GetFlags() - << (UINT16) GetVersion(); - ULONG nOldPos = rStrm.Tell(); - rStrm << (UINT32) 0L; - BOOL bRes = StoreData( rStrm ); - ULONG nNewPos = rStrm.Tell(); + rStrm << (sal_uInt32) GetCreator() + << (sal_uInt16) GetSbxId() + << (sal_uInt16) GetFlags() + << (sal_uInt16) GetVersion(); + sal_uIntPtr nOldPos = rStrm.Tell(); + rStrm << (sal_uInt32) 0L; + sal_Bool bRes = StoreData( rStrm ); + sal_uIntPtr nNewPos = rStrm.Tell(); rStrm.Seek( nOldPos ); - rStrm << (UINT32) ( nNewPos - nOldPos ); + rStrm << (sal_uInt32) ( nNewPos - nOldPos ); rStrm.Seek( nNewPos ); if( rStrm.GetError() != SVSTREAM_OK ) - bRes = FALSE; + bRes = sal_False; if( bRes ) bRes = StoreCompleted(); return bRes; } else - return TRUE; + return sal_True; } -BOOL SbxBase::LoadData( SvStream&, USHORT ) +sal_Bool SbxBase::LoadData( SvStream&, sal_uInt16 ) { DBG_CHKTHIS( SbxBase, 0 ); - return FALSE; + return sal_False; } -BOOL SbxBase::StoreData( SvStream& ) const +sal_Bool SbxBase::StoreData( SvStream& ) const { DBG_CHKTHIS( SbxBase, 0 ); - return FALSE; + return sal_False; } -BOOL SbxBase::LoadPrivateData( SvStream&, USHORT ) +sal_Bool SbxBase::LoadPrivateData( SvStream&, sal_uInt16 ) { DBG_CHKTHIS( SbxBase, 0 ); - return TRUE; + return sal_True; } -BOOL SbxBase::StorePrivateData( SvStream& ) const +sal_Bool SbxBase::StorePrivateData( SvStream& ) const { DBG_CHKTHIS( SbxBase, 0 ); - return TRUE; + return sal_True; } -BOOL SbxBase::LoadCompleted() +sal_Bool SbxBase::LoadCompleted() { DBG_CHKTHIS( SbxBase, 0 ); - return TRUE; + return sal_True; } -BOOL SbxBase::StoreCompleted() +sal_Bool SbxBase::StoreCompleted() { DBG_CHKTHIS( SbxBase, 0 ); - return TRUE; + return sal_True; } //////////////////////////////// SbxFactory //////////////////////////////// -SbxBase* SbxFactory::Create( UINT16, UINT32 ) +SbxBase* SbxFactory::Create( sal_uInt16, sal_uInt32 ) { return NULL; } @@ -393,7 +393,7 @@ SbxInfo::~SbxInfo() {} void SbxInfo::AddParam - ( const XubString& rName, SbxDataType eType, USHORT nFlags ) + ( const XubString& rName, SbxDataType eType, sal_uInt16 nFlags ) { const SbxParamInfo* p = new SbxParamInfo( rName, eType, nFlags ); aParams.Insert( p, aParams.Count() ); @@ -406,7 +406,7 @@ void SbxInfo::AddParam( const SbxParamInfo& r ) aParams.Insert( p, aParams.Count() ); } -const SbxParamInfo* SbxInfo::GetParam( USHORT n ) const +const SbxParamInfo* SbxInfo::GetParam( sal_uInt16 n ) const { if( n < 1 || n > aParams.Count() ) return NULL; @@ -414,18 +414,18 @@ const SbxParamInfo* SbxInfo::GetParam( USHORT n ) const return aParams.GetObject( n-1 ); } -BOOL SbxInfo::LoadData( SvStream& rStrm, USHORT nVer ) +sal_Bool SbxInfo::LoadData( SvStream& rStrm, sal_uInt16 nVer ) { aParams.Remove( 0, aParams.Count() ); - UINT16 nParam; + sal_uInt16 nParam; rStrm.ReadByteString( aComment, RTL_TEXTENCODING_ASCII_US ); rStrm.ReadByteString( aHelpFile, RTL_TEXTENCODING_ASCII_US ); rStrm >> nHelpId >> nParam; while( nParam-- ) { XubString aName; - UINT16 nType, nFlags; - UINT32 nUserData = 0; + sal_uInt16 nType, nFlags; + sal_uInt32 nUserData = 0; rStrm.ReadByteString( aName, RTL_TEXTENCODING_ASCII_US ); rStrm >> nType >> nFlags; if( nVer > 1 ) @@ -434,22 +434,22 @@ BOOL SbxInfo::LoadData( SvStream& rStrm, USHORT nVer ) SbxParamInfo* p = aParams.GetObject( aParams.Count() - 1 ); p->nUserData = nUserData; } - return TRUE; + return sal_True; } -BOOL SbxInfo::StoreData( SvStream& rStrm ) const +sal_Bool SbxInfo::StoreData( SvStream& rStrm ) const { rStrm.WriteByteString( aComment, RTL_TEXTENCODING_ASCII_US ); rStrm.WriteByteString( aHelpFile, RTL_TEXTENCODING_ASCII_US ); rStrm << nHelpId << aParams.Count(); - for( USHORT i = 0; i < aParams.Count(); i++ ) + for( sal_uInt16 i = 0; i < aParams.Count(); i++ ) { SbxParamInfo* p = aParams.GetObject( i ); rStrm.WriteByteString( p->aName, RTL_TEXTENCODING_ASCII_US ); - rStrm << (UINT16) p->eType - << (UINT16) p->nFlags - << (UINT32) p->nUserData; + rStrm << (sal_uInt16) p->eType + << (sal_uInt16) p->nFlags + << (sal_uInt32) p->nUserData; } - return TRUE; + return sal_True; } diff --git a/basic/source/sbx/sbxbool.cxx b/basic/source/sbx/sbxbool.cxx index c3ed0d09b134..7b9ffe8a1136 100644 --- a/basic/source/sbx/sbxbool.cxx +++ b/basic/source/sbx/sbxbool.cxx @@ -94,15 +94,15 @@ enum SbxBOOL ImpGetBool( const SbxValues* p ) else if( !p->pOUString->equalsIgnoreAsciiCase( SbxRes( STRING_FALSE ) ) ) { // Jetzt kann es noch in eine Zahl konvertierbar sein - BOOL bError = TRUE; + sal_Bool bError = sal_True; double n; SbxDataType t; - USHORT nLen = 0; + sal_uInt16 nLen = 0; if( ImpScan( *p->pOUString, n, t, &nLen ) == SbxERR_OK ) { if( nLen == p->pOUString->getLength() ) { - bError = FALSE; + bError = sal_False; if( n != 0.0 ) nRes = SbxTRUE; } @@ -159,7 +159,7 @@ enum SbxBOOL ImpGetBool( const SbxValues* p ) return nRes; } -void ImpPutBool( SbxValues* p, INT16 n ) +void ImpPutBool( SbxValues* p, sal_Int16 n ) { if( n ) n = SbxTRUE; @@ -168,17 +168,17 @@ void ImpPutBool( SbxValues* p, INT16 n ) case SbxCHAR: p->nChar = (xub_Unicode) n; break; case SbxUINT: - p->nByte = (BYTE) n; break; + p->nByte = (sal_uInt8) n; break; case SbxINTEGER: case SbxBOOL: p->nInteger = n; break; case SbxLONG: p->nLong = n; break; case SbxULONG: - p->nULong = (UINT32) n; break; + p->nULong = (sal_uInt32) n; break; case SbxERROR: case SbxUSHORT: - p->nUShort = (UINT16) n; break; + p->nUShort = (sal_uInt16) n; break; case SbxSINGLE: p->nSingle = n; break; case SbxDATE: @@ -189,13 +189,13 @@ void ImpPutBool( SbxValues* p, INT16 n ) case SbxSALUINT64: p->uInt64 = n; break; case SbxULONG64: - p->nULong64.Set( (UINT32)n ); break; + p->nULong64.Set( (sal_uInt32)n ); break; case SbxLONG64: case SbxCURRENCY: - p->nLong64.Set( (INT32)n ); break; + p->nLong64.Set( (sal_Int32)n ); break; case SbxDECIMAL: case SbxBYREF | SbxDECIMAL: - ImpCreateDecimal( p )->setInt( (INT16)n ); + ImpCreateDecimal( p )->setInt( (sal_Int16)n ); break; case SbxBYREF | SbxSTRING: @@ -211,7 +211,7 @@ void ImpPutBool( SbxValues* p, INT16 n ) { SbxValue* pVal = PTR_CAST(SbxValue,p->pObj); if( pVal ) - pVal->PutBool( BOOL( n != 0 ) ); + pVal->PutBool( sal_Bool( n != 0 ) ); else SbxBase::SetError( SbxERR_NO_OBJECT ); break; @@ -219,17 +219,17 @@ void ImpPutBool( SbxValues* p, INT16 n ) case SbxBYREF | SbxCHAR: *p->pChar = (xub_Unicode) n; break; case SbxBYREF | SbxBYTE: - *p->pByte = (BYTE) n; break; + *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: - *p->pInteger = (INT16) n; break; + *p->pInteger = (sal_Int16) n; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: - *p->pUShort = (UINT16) n; break; + *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: *p->pLong = n; break; case SbxBYREF | SbxULONG: - *p->pULong = (UINT32) n; break; + *p->pULong = (sal_uInt32) n; break; case SbxBYREF | SbxSINGLE: *p->pSingle = n; break; case SbxBYREF | SbxDATE: @@ -240,10 +240,10 @@ void ImpPutBool( SbxValues* p, INT16 n ) case SbxBYREF | SbxSALUINT64: *p->puInt64 = n; break; case SbxBYREF | SbxULONG64: - p->pULong64->Set( (UINT32)n ); break; + p->pULong64->Set( (sal_uInt32)n ); break; case SbxBYREF | SbxLONG64: case SbxBYREF | SbxCURRENCY: - p->pLong64->Set( (INT32)n ); break; + p->pLong64->Set( (sal_Int32)n ); break; default: SbxBase::SetError( SbxERR_CONVERSION ); diff --git a/basic/source/sbx/sbxbyte.cxx b/basic/source/sbx/sbxbyte.cxx index e13c63967fc3..1a9c80f1dd06 100644 --- a/basic/source/sbx/sbxbyte.cxx +++ b/basic/source/sbx/sbxbyte.cxx @@ -31,10 +31,10 @@ #include <basic/sbx.hxx> #include "sbxconv.hxx" -BYTE ImpGetByte( const SbxValues* p ) +sal_uInt8 ImpGetByte( const SbxValues* p ) { SbxValues aTmp; - BYTE nRes; + sal_uInt8 nRes; start: switch( +p->eType ) { @@ -48,10 +48,10 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; } else - nRes = (BYTE) p->nChar; + nRes = (sal_uInt8) p->nChar; break; case SbxBYTE: - nRes = (BYTE) p->nByte; break; + nRes = (sal_uInt8) p->nByte; break; case SbxINTEGER: case SbxBOOL: if( p->nInteger > SbxMAXBYTE ) @@ -63,16 +63,16 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; } else - nRes = (BYTE) p->nInteger; + nRes = (sal_uInt8) p->nInteger; break; case SbxERROR: case SbxUSHORT: - if( p->nUShort > (USHORT) SbxMAXBYTE ) + if( p->nUShort > (sal_uInt16) SbxMAXBYTE ) { SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXBYTE; } else - nRes = (BYTE) p->nUShort; + nRes = (sal_uInt8) p->nUShort; break; case SbxLONG: if( p->nLong > SbxMAXBYTE ) @@ -84,7 +84,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; } else - nRes = (BYTE) p->nLong; + nRes = (sal_uInt8) p->nLong; break; case SbxULONG: if( p->nULong > SbxMAXBYTE ) @@ -92,7 +92,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXBYTE; } else - nRes = (BYTE) p->nULong; + nRes = (sal_uInt8) p->nULong; break; case SbxSALINT64: if( p->nInt64 > SbxMAXBYTE ) @@ -104,7 +104,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; } else - nRes = (BYTE) p->nInt64; + nRes = (sal_uInt8) p->nInt64; break; case SbxSALUINT64: if( p->uInt64 > SbxMAXBYTE ) @@ -112,7 +112,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXBYTE; } else - nRes = (BYTE) p->uInt64; + nRes = (sal_uInt8) p->uInt64; break; case SbxSINGLE: if( p->nSingle > SbxMAXBYTE ) @@ -124,7 +124,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; } else - nRes = (BYTE) ImpRound( p->nSingle ); + nRes = (sal_uInt8) ImpRound( p->nSingle ); break; case SbxDATE: case SbxDOUBLE: @@ -159,7 +159,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; } else - nRes = (BYTE) ImpRound( dVal ); + nRes = (sal_uInt8) ImpRound( dVal ); break; } case SbxBYREF | SbxSTRING: @@ -182,7 +182,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; } else - nRes = (BYTE) ( d + 0.5 ); + nRes = (sal_uInt8) ( d + 0.5 ); } break; case SbxOBJECT: @@ -237,7 +237,7 @@ start: return nRes; } -void ImpPutByte( SbxValues* p, BYTE n ) +void ImpPutByte( SbxValues* p, sal_uInt8 n ) { switch( +p->eType ) { diff --git a/basic/source/sbx/sbxchar.cxx b/basic/source/sbx/sbxchar.cxx index bd4ce91f451b..578f0cfb8adf 100644 --- a/basic/source/sbx/sbxchar.cxx +++ b/basic/source/sbx/sbxchar.cxx @@ -150,7 +150,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMINCHAR; } else - nRes = (BYTE) ImpRound( dVal ); + nRes = (sal_uInt8) ImpRound( dVal ); break; } case SbxBYREF | SbxSTRING: @@ -289,17 +289,17 @@ start: case SbxBYREF | SbxCHAR: *p->pChar = n; break; case SbxBYREF | SbxBYTE: - *p->pByte = (BYTE) n; break; + *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: *p->pInteger = n; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: - *p->pUShort = (UINT16) n; break; + *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: - *p->pLong = (INT32) n; break; + *p->pLong = (sal_Int32) n; break; case SbxBYREF | SbxULONG: - *p->pULong = (UINT32) n; break; + *p->pULong = (sal_uInt32) n; break; case SbxBYREF | SbxSINGLE: *p->pSingle = (float) n; break; case SbxBYREF | SbxDATE: diff --git a/basic/source/sbx/sbxcoll.cxx b/basic/source/sbx/sbxcoll.cxx index 7bd32900ecc9..1c95591e28dd 100644 --- a/basic/source/sbx/sbxcoll.cxx +++ b/basic/source/sbx/sbxcoll.cxx @@ -41,7 +41,7 @@ static const char* pCount; static const char* pAdd; static const char* pItem; static const char* pRemove; -static USHORT nCountHash = 0, nAddHash, nItemHash, nRemoveHash; +static sal_uInt16 nCountHash = 0, nAddHash, nItemHash, nRemoveHash; ///////////////////////////////////////////////////////////////////////// @@ -61,7 +61,7 @@ SbxCollection::SbxCollection( const XubString& rClass ) } Initialize(); // Fuer Zugriffe auf sich selbst - StartListening( GetBroadcaster(), TRUE ); + StartListening( GetBroadcaster(), sal_True ); } SbxCollection::SbxCollection( const SbxCollection& rColl ) @@ -101,7 +101,7 @@ void SbxCollection::Initialize() p->SetFlag( SBX_DONTSTORE ); } -SbxVariable* SbxCollection::FindUserData( UINT32 nData ) +SbxVariable* SbxCollection::FindUserData( sal_uInt32 nData ) { if( GetParameters() ) { @@ -129,9 +129,9 @@ void SbxCollection::SFX_NOTIFY( SfxBroadcaster& rCst, const TypeId& rId1, const SbxHint* p = PTR_CAST(SbxHint,&rHint); if( p ) { - ULONG nId = p->GetId(); - BOOL bRead = BOOL( nId == SBX_HINT_DATAWANTED ); - BOOL bWrite = BOOL( nId == SBX_HINT_DATACHANGED ); + sal_uIntPtr nId = p->GetId(); + sal_Bool bRead = sal_Bool( nId == SBX_HINT_DATAWANTED ); + sal_Bool bWrite = sal_Bool( nId == SBX_HINT_DATACHANGED ); SbxVariable* pVar = p->GetVar(); SbxArray* pArg = pVar->GetParameters(); if( bRead || bWrite ) @@ -191,7 +191,7 @@ void SbxCollection::CollItem( SbxArray* pPar_ ) { short n = p->GetInteger(); if( n >= 1 && n <= (short) pObjs->Count() ) - pRes = pObjs->Get( (USHORT) n - 1 ); + pRes = pObjs->Get( (sal_uInt16) n - 1 ); } if( !pRes ) SetError( SbxERR_BAD_INDEX ); @@ -211,13 +211,13 @@ void SbxCollection::CollRemove( SbxArray* pPar_ ) if( n < 1 || n > (short) pObjs->Count() ) SetError( SbxERR_BAD_INDEX ); else - Remove( pObjs->Get( (USHORT) n - 1 ) ); + Remove( pObjs->Get( (sal_uInt16) n - 1 ) ); } } -BOOL SbxCollection::LoadData( SvStream& rStrm, USHORT nVer ) +sal_Bool SbxCollection::LoadData( SvStream& rStrm, sal_uInt16 nVer ) { - BOOL bRes = SbxObject::LoadData( rStrm, nVer ); + sal_Bool bRes = SbxObject::LoadData( rStrm, nVer ); Initialize(); return bRes; } @@ -225,7 +225,7 @@ BOOL SbxCollection::LoadData( SvStream& rStrm, USHORT nVer ) ///////////////////////////////////////////////////////////////////////// SbxStdCollection::SbxStdCollection - ( const XubString& rClass, const XubString& rElem, BOOL b ) + ( const XubString& rClass, const XubString& rElem, sal_Bool b ) : SbxCollection( rClass ), aElemClass( rElem ), bAddRemoveOk( b ) {} @@ -277,9 +277,9 @@ void SbxStdCollection::CollRemove( SbxArray* pPar_ ) SbxCollection::CollRemove( pPar_ ); } -BOOL SbxStdCollection::LoadData( SvStream& rStrm, USHORT nVer ) +sal_Bool SbxStdCollection::LoadData( SvStream& rStrm, sal_uInt16 nVer ) { - BOOL bRes = SbxCollection::LoadData( rStrm, nVer ); + sal_Bool bRes = SbxCollection::LoadData( rStrm, nVer ); if( bRes ) { rStrm.ReadByteString( aElemClass, RTL_TEXTENCODING_ASCII_US ); @@ -288,9 +288,9 @@ BOOL SbxStdCollection::LoadData( SvStream& rStrm, USHORT nVer ) return bRes; } -BOOL SbxStdCollection::StoreData( SvStream& rStrm ) const +sal_Bool SbxStdCollection::StoreData( SvStream& rStrm ) const { - BOOL bRes = SbxCollection::StoreData( rStrm ); + sal_Bool bRes = SbxCollection::StoreData( rStrm ); if( bRes ) { rStrm.WriteByteString( aElemClass, RTL_TEXTENCODING_ASCII_US ); diff --git a/basic/source/sbx/sbxconv.hxx b/basic/source/sbx/sbxconv.hxx index 16fec542cded..61edeef3a4fa 100644 --- a/basic/source/sbx/sbxconv.hxx +++ b/basic/source/sbx/sbxconv.hxx @@ -33,19 +33,19 @@ class SbxArray; // SBXSCAN.CXX -extern void ImpCvtNum( double nNum, short nPrec, ::rtl::OUString& rRes, BOOL bCoreString=FALSE ); +extern void ImpCvtNum( double nNum, short nPrec, ::rtl::OUString& rRes, sal_Bool bCoreString=sal_False ); extern SbxError ImpScan - ( const ::rtl::OUString& rSrc, double& nVal, SbxDataType& rType, USHORT* pLen, - BOOL bAllowIntntl=FALSE, BOOL bOnlyIntntl=FALSE ); + ( const ::rtl::OUString& rSrc, double& nVal, SbxDataType& rType, sal_uInt16* pLen, + sal_Bool bAllowIntntl=sal_False, sal_Bool bOnlyIntntl=sal_False ); -// mit erweiterter Auswertung (International, "TRUE"/"FALSE") -extern BOOL ImpConvStringExt( ::rtl::OUString& rSrc, SbxDataType eTargetType ); +// mit erweiterter Auswertung (International, "sal_True"/"sal_False") +extern sal_Bool ImpConvStringExt( ::rtl::OUString& rSrc, SbxDataType eTargetType ); // SBXINT.CXX double ImpRound( double ); -INT16 ImpGetInteger( const SbxValues* ); -void ImpPutInteger( SbxValues*, INT16 ); +sal_Int16 ImpGetInteger( const SbxValues* ); +void ImpPutInteger( SbxValues*, sal_Int16 ); sal_Int64 ImpGetInt64( const SbxValues* ); void ImpPutInt64( SbxValues*, sal_Int64 ); sal_uInt64 ImpGetUInt64( const SbxValues* ); @@ -57,8 +57,8 @@ double ImpSalUInt64ToDouble( sal_uInt64 n ); // SBXLNG.CXX -INT32 ImpGetLong( const SbxValues* ); -void ImpPutLong( SbxValues*, INT32 ); +sal_Int32 ImpGetLong( const SbxValues* ); +void ImpPutLong( SbxValues*, sal_Int32 ); // SBXSNG.CXX @@ -68,7 +68,7 @@ void ImpPutSingle( SbxValues*, float ); // SBXDBL.CXX double ImpGetDouble( const SbxValues* ); -void ImpPutDouble( SbxValues*, double, BOOL bCoreString=FALSE ); +void ImpPutDouble( SbxValues*, double, sal_Bool bCoreString=sal_False ); #if FALSE // SBX64.CXX @@ -87,10 +87,10 @@ SbxINT64 ImpDoubleToINT64( double ); double ImpINT64ToDouble( const SbxINT64& ); #if TRUE -INT32 ImpGetCurrLong( const SbxValues* ); -void ImpPutCurrLong( SbxValues*, INT32 ); -INT32 ImpDoubleToCurrLong( double ); -double ImpCurrLongToDouble( INT32 ); +sal_Int32 ImpGetCurrLong( const SbxValues* ); +void ImpPutCurrLong( SbxValues*, sal_Int32 ); +sal_Int32 ImpDoubleToCurrLong( double ); +double ImpCurrLongToDouble( sal_Int32 ); #endif SbxINT64 ImpGetCurrency( const SbxValues* ); @@ -126,23 +126,23 @@ sal_Unicode ImpGetChar( const SbxValues* ); void ImpPutChar( SbxValues*, sal_Unicode ); // SBXBYTE.CXX -BYTE ImpGetByte( const SbxValues* ); -void ImpPutByte( SbxValues*, BYTE ); +sal_uInt8 ImpGetByte( const SbxValues* ); +void ImpPutByte( SbxValues*, sal_uInt8 ); // SBXUINT.CXX -UINT16 ImpGetUShort( const SbxValues* ); -void ImpPutUShort( SbxValues*, UINT16 ); +sal_uInt16 ImpGetUShort( const SbxValues* ); +void ImpPutUShort( SbxValues*, sal_uInt16 ); // SBXULNG.CXX -UINT32 ImpGetULong( const SbxValues* ); -void ImpPutULong( SbxValues*, UINT32 ); +sal_uInt32 ImpGetULong( const SbxValues* ); +void ImpPutULong( SbxValues*, sal_uInt32 ); // SBXBOOL.CXX enum SbxBOOL ImpGetBool( const SbxValues* ); -void ImpPutBool( SbxValues*, INT16 ); +void ImpPutBool( SbxValues*, sal_Int16 ); // ByteArry <--> String SbxArray* StringToByteArray(const ::rtl::OUString& rStr); diff --git a/basic/source/sbx/sbxcurr.cxx b/basic/source/sbx/sbxcurr.cxx index e27b11d5166c..5b6e631d174f 100644 --- a/basic/source/sbx/sbxcurr.cxx +++ b/basic/source/sbx/sbxcurr.cxx @@ -257,7 +257,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); dVal = 0; } - *p->pByte = (BYTE) dVal; break; + *p->pByte = (sal_uInt8) dVal; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: if( dVal > SbxMAXINT ) @@ -268,7 +268,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); dVal = SbxMININT; } - *p->pInteger = (INT16) dVal; break; + *p->pInteger = (sal_Int16) dVal; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: if( dVal > SbxMAXUINT ) @@ -279,7 +279,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); dVal = 0; } - *p->pUShort = (UINT16) dVal; break; + *p->pUShort = (sal_uInt16) dVal; break; case SbxBYREF | SbxLONG: if( dVal > SbxMAXLNG ) { @@ -289,7 +289,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); dVal = SbxMINLNG; } - *p->pLong = (INT32) dVal; break; + *p->pLong = (sal_Int32) dVal; break; case SbxBYREF | SbxULONG: if( dVal > SbxMAXULNG ) { @@ -299,7 +299,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); dVal = 0; } - *p->pULong = (UINT32) dVal; break; + *p->pULong = (sal_uInt32) dVal; break; case SbxBYREF | SbxSALINT64: *p->pnInt64 = ImpDoubleToSalInt64( dVal ); break; case SbxBYREF | SbxSALUINT64: diff --git a/basic/source/sbx/sbxdate.cxx b/basic/source/sbx/sbxdate.cxx index 1ac8c254ca6b..1d0b81ed98f6 100644 --- a/basic/source/sbx/sbxdate.cxx +++ b/basic/source/sbx/sbxdate.cxx @@ -125,13 +125,13 @@ double ImpGetDate( const SbxValues* p ) pFormatter->PutandConvertEntry( aStr, nCheckPos, nType, nIndex, LANGUAGE_GERMAN, eLangType ); - BOOL bSuccess = pFormatter->IsNumberFormat( *p->pOUString, nIndex, nRes ); + sal_Bool bSuccess = pFormatter->IsNumberFormat( *p->pOUString, nIndex, nRes ); if ( bSuccess ) { short nType_ = pFormatter->GetType( nIndex ); if(!(nType_ & ( NUMBERFORMAT_DATETIME | NUMBERFORMAT_DATE | NUMBERFORMAT_TIME | NUMBERFORMAT_DEFINED ))) - bSuccess = FALSE; + bSuccess = sal_False; } if ( !bSuccess ) @@ -328,7 +328,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pByte = (BYTE) n; break; + *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: if( n > SbxMAXINT ) @@ -339,7 +339,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMININT; } - *p->pInteger = (INT16) n; break; + *p->pInteger = (sal_Int16) n; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: if( n > SbxMAXUINT ) @@ -350,7 +350,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pUShort = (UINT16) n; break; + *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: if( n > SbxMAXLNG ) { @@ -360,7 +360,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINLNG; } - *p->pLong = (INT32) n; break; + *p->pLong = (sal_Int32) n; break; case SbxBYREF | SbxULONG: if( n > SbxMAXULNG ) { @@ -370,7 +370,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pULong = (UINT32) n; break; + *p->pULong = (sal_uInt32) n; break; case SbxBYREF | SbxSINGLE: if( n > SbxMAXSNG ) { diff --git a/basic/source/sbx/sbxdbl.cxx b/basic/source/sbx/sbxdbl.cxx index be55d3409131..efbad5521f3b 100644 --- a/basic/source/sbx/sbxdbl.cxx +++ b/basic/source/sbx/sbxdbl.cxx @@ -140,7 +140,7 @@ double ImpGetDouble( const SbxValues* p ) return nRes; } -void ImpPutDouble( SbxValues* p, double n, BOOL bCoreString ) +void ImpPutDouble( SbxValues* p, double n, sal_Bool bCoreString ) { SbxValues aTmp; start: @@ -220,7 +220,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pByte = (BYTE) n; break; + *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: if( n > SbxMAXINT ) @@ -231,7 +231,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMININT; } - *p->pInteger = (INT16) n; break; + *p->pInteger = (sal_Int16) n; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: if( n > SbxMAXUINT ) @@ -242,7 +242,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pUShort = (UINT16) n; break; + *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: if( n > SbxMAXLNG ) { @@ -252,7 +252,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINLNG; } - *p->pLong = (INT32) n; break; + *p->pLong = (sal_Int32) n; break; case SbxBYREF | SbxULONG: if( n > SbxMAXULNG ) { @@ -262,7 +262,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pULong = (UINT32) n; break; + *p->pULong = (sal_uInt32) n; break; case SbxBYREF | SbxSINGLE: if( n > SbxMAXSNG ) { diff --git a/basic/source/sbx/sbxdec.cxx b/basic/source/sbx/sbxdec.cxx index 2191d91c8d82..3a0e65c142e2 100644 --- a/basic/source/sbx/sbxdec.cxx +++ b/basic/source/sbx/sbxdec.cxx @@ -158,32 +158,32 @@ SbxDecimal::CmpResult compare( const SbxDecimal &rLeft, const SbxDecimal &rRight void SbxDecimal::setChar( sal_Unicode val ) { - VarDecFromUI2( (USHORT)val, &maDec ); + VarDecFromUI2( (sal_uInt16)val, &maDec ); } -void SbxDecimal::setByte( BYTE val ) +void SbxDecimal::setByte( sal_uInt8 val ) { - VarDecFromUI1( (BYTE)val, &maDec ); + VarDecFromUI1( (sal_uInt8)val, &maDec ); } -void SbxDecimal::setShort( INT16 val ) +void SbxDecimal::setShort( sal_Int16 val ) { VarDecFromI2( (short)val, &maDec ); } -void SbxDecimal::setLong( INT32 val ) +void SbxDecimal::setLong( sal_Int32 val ) { VarDecFromI4( (long)val, &maDec ); } -void SbxDecimal::setUShort( UINT16 val ) +void SbxDecimal::setUShort( sal_uInt16 val ) { - VarDecFromUI2( (USHORT)val, &maDec ); + VarDecFromUI2( (sal_uInt16)val, &maDec ); } -void SbxDecimal::setULong( UINT32 val ) +void SbxDecimal::setULong( sal_uInt32 val ) { - VarDecFromUI4( (ULONG)val, &maDec ); + VarDecFromUI4( (sal_uIntPtr)val, &maDec ); } bool SbxDecimal::setSingle( float val ) @@ -200,12 +200,12 @@ bool SbxDecimal::setDouble( double val ) void SbxDecimal::setInt( int val ) { - setLong( (INT32)val ); + setLong( (sal_Int32)val ); } void SbxDecimal::setUInt( unsigned int val ) { - setULong( (UINT32)val ); + setULong( (sal_uInt32)val ); } // sbxscan.cxx @@ -261,31 +261,31 @@ bool SbxDecimal::getChar( sal_Unicode& rVal ) return bRet; } -bool SbxDecimal::getByte( BYTE& rVal ) +bool SbxDecimal::getByte( sal_uInt8& rVal ) { bool bRet = ( VarUI1FromDec( &maDec, &rVal ) == S_OK ); return bRet; } -bool SbxDecimal::getShort( INT16& rVal ) +bool SbxDecimal::getShort( sal_Int16& rVal ) { bool bRet = ( VarI2FromDec( &maDec, &rVal ) == S_OK ); return bRet; } -bool SbxDecimal::getLong( INT32& rVal ) +bool SbxDecimal::getLong( sal_Int32& rVal ) { bool bRet = ( VarI4FromDec( &maDec, &rVal ) == S_OK ); return bRet; } -bool SbxDecimal::getUShort( UINT16& rVal ) +bool SbxDecimal::getUShort( sal_uInt16& rVal ) { bool bRet = ( VarUI2FromDec( &maDec, &rVal ) == S_OK ); return bRet; } -bool SbxDecimal::getULong( UINT32& rVal ) +bool SbxDecimal::getULong( sal_uInt32& rVal ) { bool bRet = ( VarUI4FromDec( &maDec, &rVal ) == S_OK ); return bRet; @@ -305,7 +305,7 @@ bool SbxDecimal::getDouble( double& rVal ) bool SbxDecimal::getInt( int& rVal ) { - INT32 TmpVal; + sal_Int32 TmpVal; bool bRet = getLong( TmpVal ); rVal = TmpVal; return bRet; @@ -313,7 +313,7 @@ bool SbxDecimal::getInt( int& rVal ) bool SbxDecimal::getUInt( unsigned int& rVal ) { - UINT32 TmpVal; + sal_uInt32 TmpVal; bool bRet = getULong( TmpVal ); rVal = TmpVal; return bRet; @@ -364,11 +364,11 @@ SbxDecimal::CmpResult compare( const SbxDecimal &rLeft, const SbxDecimal &rRight } void SbxDecimal::setChar( sal_Unicode val ) { (void)val; } -void SbxDecimal::setByte( BYTE val ) { (void)val; } -void SbxDecimal::setShort( INT16 val ) { (void)val; } -void SbxDecimal::setLong( INT32 val ) { (void)val; } -void SbxDecimal::setUShort( UINT16 val ) { (void)val; } -void SbxDecimal::setULong( UINT32 val ) { (void)val; } +void SbxDecimal::setByte( sal_uInt8 val ) { (void)val; } +void SbxDecimal::setShort( sal_Int16 val ) { (void)val; } +void SbxDecimal::setLong( sal_Int32 val ) { (void)val; } +void SbxDecimal::setUShort( sal_uInt16 val ) { (void)val; } +void SbxDecimal::setULong( sal_uInt32 val ) { (void)val; } bool SbxDecimal::setSingle( float val ) { (void)val; return false; } bool SbxDecimal::setDouble( double val ) { (void)val; return false; } void SbxDecimal::setInt( int val ) { (void)val; } @@ -376,11 +376,11 @@ void SbxDecimal::setUInt( unsigned int val ) { (void)val; } bool SbxDecimal::setString( ::rtl::OUString* pOUString ) { (void)pOUString; return false; } bool SbxDecimal::getChar( sal_Unicode& rVal ) { (void)rVal; return false; } -bool SbxDecimal::getByte( BYTE& rVal ) { (void)rVal; return false; } -bool SbxDecimal::getShort( INT16& rVal ) { (void)rVal; return false; } -bool SbxDecimal::getLong( INT32& rVal ) { (void)rVal; return false; } -bool SbxDecimal::getUShort( UINT16& rVal ) { (void)rVal; return false; } -bool SbxDecimal::getULong( UINT32& rVal ) { (void)rVal; return false; } +bool SbxDecimal::getByte( sal_uInt8& rVal ) { (void)rVal; return false; } +bool SbxDecimal::getShort( sal_Int16& rVal ) { (void)rVal; return false; } +bool SbxDecimal::getLong( sal_Int32& rVal ) { (void)rVal; return false; } +bool SbxDecimal::getUShort( sal_uInt16& rVal ) { (void)rVal; return false; } +bool SbxDecimal::getULong( sal_uInt32& rVal ) { (void)rVal; return false; } bool SbxDecimal::getSingle( float& rVal ) { (void)rVal; return false; } bool SbxDecimal::getDouble( double& rVal ) { (void)rVal; return false; } bool SbxDecimal::getInt( int& rVal ) { (void)rVal; return false; } diff --git a/basic/source/sbx/sbxdec.hxx b/basic/source/sbx/sbxdec.hxx index cd80bbad282e..6b8cd7e31336 100644 --- a/basic/source/sbx/sbxdec.hxx +++ b/basic/source/sbx/sbxdec.hxx @@ -61,7 +61,7 @@ class SbxDecimal #ifdef WIN32 DECIMAL maDec; #endif - INT32 mnRefCount; + sal_Int32 mnRefCount; public: SbxDecimal( void ); @@ -76,11 +76,11 @@ public: void fillAutomationDecimal( com::sun::star::bridge::oleautomation::Decimal& rAutomationDec ); void setChar( sal_Unicode val ); - void setByte( BYTE val ); - void setShort( INT16 val ); - void setLong( INT32 val ); - void setUShort( UINT16 val ); - void setULong( UINT32 val ); + void setByte( sal_uInt8 val ); + void setShort( sal_Int16 val ); + void setLong( sal_Int32 val ); + void setUShort( sal_uInt16 val ); + void setULong( sal_uInt32 val ); bool setSingle( float val ); bool setDouble( double val ); void setInt( int val ); @@ -97,11 +97,11 @@ public: } bool getChar( sal_Unicode& rVal ); - bool getByte( BYTE& rVal ); - bool getShort( INT16& rVal ); - bool getLong( INT32& rVal ); - bool getUShort( UINT16& rVal ); - bool getULong( UINT32& rVal ); + bool getByte( sal_uInt8& rVal ); + bool getShort( sal_Int16& rVal ); + bool getLong( sal_Int32& rVal ); + bool getUShort( sal_uInt16& rVal ); + bool getULong( sal_uInt32& rVal ); bool getSingle( float& rVal ); bool getDouble( double& rVal ); bool getInt( int& rVal ); diff --git a/basic/source/sbx/sbxexec.cxx b/basic/source/sbx/sbxexec.cxx index c602b130fc5e..9b43a94873f0 100644 --- a/basic/source/sbx/sbxexec.cxx +++ b/basic/source/sbx/sbxexec.cxx @@ -37,21 +37,21 @@ class SbxSimpleCharClass { public: - BOOL isAlpha( sal_Unicode c ) const + sal_Bool isAlpha( sal_Unicode c ) const { - BOOL bRet = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); + sal_Bool bRet = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'); return bRet; } - BOOL isDigit( sal_Unicode c ) const + sal_Bool isDigit( sal_Unicode c ) const { - BOOL bRet = (c >= '0' && c <= '9'); + sal_Bool bRet = (c >= '0' && c <= '9'); return bRet; } - BOOL isAlphaNumeric( sal_Unicode c ) const + sal_Bool isAlphaNumeric( sal_Unicode c ) const { - BOOL bRet = isDigit( c ) || isAlpha( c ); + sal_Bool bRet = isDigit( c ) || isAlpha( c ); return bRet; } }; @@ -73,7 +73,7 @@ static const xub_Unicode* SkipWhitespace( const xub_Unicode* p ) static const xub_Unicode* Symbol( const xub_Unicode* p, XubString& rSym, const SbxSimpleCharClass& rCharClass ) { - USHORT nLen = 0; + sal_uInt16 nLen = 0; // Haben wir ein Sondersymbol? if( *p == '[' ) { @@ -143,7 +143,7 @@ static SbxVariable* QualifiedName // eine Funktion (mit optionalen Parametern) sein. static SbxVariable* Operand - ( SbxObject* pObj, SbxObject* pGbl, const xub_Unicode** ppBuf, BOOL bVar ) + ( SbxObject* pObj, SbxObject* pGbl, const xub_Unicode** ppBuf, sal_Bool bVar ) { static SbxSimpleCharClass aCharClass; @@ -155,7 +155,7 @@ static SbxVariable* Operand || *p == '&' ) ) { // Eine Zahl kann direkt eingescant werden! - USHORT nLen; + sal_uInt16 nLen; if( !refVar->Scan( XubString( p ), &nLen ) ) refVar.Clear(); else @@ -193,12 +193,12 @@ static SbxVariable* Operand static SbxVariable* MulDiv( SbxObject* pObj, SbxObject* pGbl, const xub_Unicode** ppBuf ) { const xub_Unicode* p = *ppBuf; - SbxVariableRef refVar( Operand( pObj, pGbl, &p, FALSE ) ); + SbxVariableRef refVar( Operand( pObj, pGbl, &p, sal_False ) ); p = SkipWhitespace( p ); while( refVar.Is() && ( *p == '*' || *p == '/' ) ) { xub_Unicode cOp = *p++; - SbxVariableRef refVar2( Operand( pObj, pGbl, &p, FALSE ) ); + SbxVariableRef refVar2( Operand( pObj, pGbl, &p, sal_False ) ); if( refVar2.Is() ) { // temporaere Variable! @@ -257,7 +257,7 @@ static SbxVariable* PlusMinus( SbxObject* pObj, SbxObject* pGbl, const xub_Unico static SbxVariable* Assign( SbxObject* pObj, SbxObject* pGbl, const xub_Unicode** ppBuf ) { const xub_Unicode* p = *ppBuf; - SbxVariableRef refVar( Operand( pObj, pGbl, &p, TRUE ) ); + SbxVariableRef refVar( Operand( pObj, pGbl, &p, sal_True ) ); p = SkipWhitespace( p ); if( refVar.Is() ) { @@ -305,7 +305,7 @@ static SbxVariable* Element SbxVariableRef refVar; if( aSym.Len() ) { - USHORT nOld = pObj->GetFlags(); + sal_uInt16 nOld = pObj->GetFlags(); if( pObj == pGbl ) pObj->SetFlag( SBX_GBLSEARCH ); refVar = pObj->Find( aSym, t ); @@ -319,7 +319,7 @@ static SbxVariable* Element { p++; SbxArrayRef refPar = new SbxArray; - USHORT nArg = 0; + sal_uInt16 nArg = 0; // Wird sind mal relaxed und akzeptieren auch // das Zeilen- oder Komandoende als Begrenzer // Parameter immer global suchen! diff --git a/basic/source/sbx/sbxform.cxx b/basic/source/sbx/sbxform.cxx index b53612f1e642..46b6e6caa445 100644 --- a/basic/source/sbx/sbxform.cxx +++ b/basic/source/sbx/sbxform.cxx @@ -151,7 +151,7 @@ void SbxBasicFormater::ShowError( char * sErrMsg ) // um eine Position zu gr"osseren Indizes, d.h. es wird Platz f"ur // ein neues (einzuf"ugendes) Zeichen geschafft. // ACHTUNG: der String MUSS gross genug sein ! -inline void SbxBasicFormater::ShiftString( String& sStrg, USHORT nStartPos ) +inline void SbxBasicFormater::ShiftString( String& sStrg, sal_uInt16 nStartPos ) { sStrg.Erase( nStartPos,1 ); } @@ -174,7 +174,7 @@ void SbxBasicFormater::AppendDigit( String& sStrg, short nDigit ) // verschiebt den Dezimal-Punkt um eine Stelle nach links void SbxBasicFormater::LeftShiftDecimalPoint( String& sStrg ) { - USHORT nPos = sStrg.Search( cDecPoint ); + sal_uInt16 nPos = sStrg.Search( cDecPoint ); if( nPos!=STRING_NOTFOUND ) { @@ -188,13 +188,13 @@ void SbxBasicFormater::LeftShiftDecimalPoint( String& sStrg ) // es wird ein Flag zur"uckgeliefert, falls ein Overflow auftrat, // d.h. 99.99 --> 100.00, d.h. ein Gr"ossenordung ge"andert wurde // (geschieht beim Runden einer 9). -void SbxBasicFormater::StrRoundDigit( String& sStrg, short nPos, BOOL& bOverflow ) +void SbxBasicFormater::StrRoundDigit( String& sStrg, short nPos, sal_Bool& bOverflow ) { // wurde ggf ein falscher Index uebergeben --> Aufruf ignorieren if( nPos<0 ) return; - bOverflow = FALSE; + bOverflow = sal_False; // "uberspringe den Dezimalpunkt und Tausender-Trennzeichen sal_Unicode c = sStrg.GetChar( nPos ); if( nPos>0 && (c == cDecPoint || c == cThousandSep) ) @@ -218,7 +218,7 @@ void SbxBasicFormater::StrRoundDigit( String& sStrg, short nPos, BOOL& bOverflow ShiftString( sStrg,0 ); // f"uhrende 1 einf"ugen: z.B. 99.99 f"ur 0.0 sStrg.SetChar( 0, '1' ); - bOverflow = TRUE; + bOverflow = sal_True; } else { @@ -243,7 +243,7 @@ void SbxBasicFormater::StrRoundDigit( String& sStrg, short nPos, BOOL& bOverflow ShiftString( sStrg,nPos+1 ); // f"uhrende 1 einf"ugen sStrg.SetChar( nPos+1, '1' ); - bOverflow = TRUE; + bOverflow = sal_True; } } } @@ -251,7 +251,7 @@ void SbxBasicFormater::StrRoundDigit( String& sStrg, short nPos, BOOL& bOverflow // rundet in einem String die Ziffer an der angegebenen Stelle void SbxBasicFormater::StrRoundDigit( String& sStrg, short nPos ) { - BOOL bOverflow; + sal_Bool bOverflow; StrRoundDigit( sStrg,nPos,bOverflow ); } @@ -302,7 +302,7 @@ void SbxBasicFormater::InitExp( double _dNewExp ) // bestimmt die Ziffer an der angegebenen Stelle (gedacht zur Anwendung im // Scan-Durchlauf) -short SbxBasicFormater::GetDigitAtPosScan( short nPos, BOOL& bFoundFirstDigit ) +short SbxBasicFormater::GetDigitAtPosScan( short nPos, sal_Bool& bFoundFirstDigit ) { // Versuch eine gr"ossere Ziffer zu lesen, // z.B. Stelle 4 in 1.234, @@ -312,18 +312,18 @@ short SbxBasicFormater::GetDigitAtPosScan( short nPos, BOOL& bFoundFirstDigit ) return _NO_DIGIT; // bestimme den Index der Stelle in dem Number-String: // "uberlese das Vorzeichen - USHORT no = 1; + sal_uInt16 no = 1; // falls notwendig den Dezimal-Punkt "uberlesen: if( nPos<nNumExp ) no++; no += nNumExp-nPos; // Abfrage der ersten (g"ultigen) Ziffer der Zahl --> Flag setzen if( nPos==nNumExp ) - bFoundFirstDigit = TRUE; + bFoundFirstDigit = sal_True; return (short)(sSciNumStrg.GetChar( no ) - ASCII_0); } -short SbxBasicFormater::GetDigitAtPosExpScan( short nPos, BOOL& bFoundFirstDigit ) +short SbxBasicFormater::GetDigitAtPosExpScan( short nPos, sal_Bool& bFoundFirstDigit ) { // ist die abgefragte Stelle zu gross f"ur den Exponenten ? if( nPos>nExpExp ) @@ -331,11 +331,11 @@ short SbxBasicFormater::GetDigitAtPosExpScan( short nPos, BOOL& bFoundFirstDigit // bestimme den Index der Stelle in dem Number-String: // "uberlese das Vorzeichen - USHORT no = 1; + sal_uInt16 no = 1; no += nExpExp-nPos; // Abfrage der ersten (g"ultigen) Ziffer der Zahl --> Flag setzen if( nPos==nExpExp ) - bFoundFirstDigit = TRUE; + bFoundFirstDigit = sal_True; return (short)(sNumExpStrg.GetChar( no ) - ASCII_0); } @@ -343,7 +343,7 @@ short SbxBasicFormater::GetDigitAtPosExpScan( short nPos, BOOL& bFoundFirstDigit // Zahl ggf. NICHT normiert (z.B. 1.2345e-03) dargestellt werden soll, // sondern eventuell 123.345e-3 ! short SbxBasicFormater::GetDigitAtPosExpScan( double dNewExponent, short nPos, - BOOL& bFoundFirstDigit ) + sal_Bool& bFoundFirstDigit ) { // neuer Exponent wurde "ubergeben, aktualisiere // die tempor"aren Klassen-Variablen @@ -381,7 +381,7 @@ TODO: ggf einen 'intelligenten' Peek-Parser um Rundungsfehler bei // // ACHTUNG: anscheinend gibt es manchmal noch Probleme mit Rundungs-Fehlern! short SbxBasicFormater::GetDigitAtPos( double dNumber, short nPos, - double& dNextNumber, BOOL& bFoundFirstDigit ) + double& dNextNumber, sal_Bool& bFoundFirstDigit ) // ACHTUNG: nPos kann auch negativ werden, f"ur Stellen nach dem Dezimal-Punkt { double dTemp = dNumber; @@ -400,7 +400,7 @@ short SbxBasicFormater::GetDigitAtPos( double dNumber, short nPos, if( nMaxDigit<nPos && !bFoundFirstDigit && nPos>=0 ) return _NO_DIGIT; // Ziffer gefunden, setze Flag: - bFoundFirstDigit = TRUE; + bFoundFirstDigit = sal_True; for( short i=nMaxDigit; i>=nPos; i-- ) { double dI = (double)i; @@ -432,14 +432,14 @@ short SbxBasicFormater::RoundDigit( double dNumber ) // und liefert diesen zur"uck. // Somit wird ein neuer String erzeugt, der vom Aufrufer wieder freigegeben // werden muss -String SbxBasicFormater::GetPosFormatString( const String& sFormatStrg, BOOL & bFound ) +String SbxBasicFormater::GetPosFormatString( const String& sFormatStrg, sal_Bool & bFound ) { - bFound = FALSE; // default... - USHORT nPos = sFormatStrg.Search( FORMAT_SEPARATOR ); + bFound = sal_False; // default... + sal_uInt16 nPos = sFormatStrg.Search( FORMAT_SEPARATOR ); if( nPos!=STRING_NOTFOUND ) { - bFound = TRUE; + bFound = sal_True; // der Format-String f"ur die positiven Zahlen ist alles // vor dem ersten ';' return sFormatStrg.Copy( 0,nPos ); @@ -451,10 +451,10 @@ String SbxBasicFormater::GetPosFormatString( const String& sFormatStrg, BOOL & b } // siehe auch GetPosFormatString() -String SbxBasicFormater::GetNegFormatString( const String& sFormatStrg, BOOL & bFound ) +String SbxBasicFormater::GetNegFormatString( const String& sFormatStrg, sal_Bool & bFound ) { - bFound = FALSE; // default... - USHORT nPos = sFormatStrg.Search( FORMAT_SEPARATOR ); + bFound = sal_False; // default... + sal_uInt16 nPos = sFormatStrg.Search( FORMAT_SEPARATOR ); if( nPos!=STRING_NOTFOUND ) { @@ -464,7 +464,7 @@ String SbxBasicFormater::GetNegFormatString( const String& sFormatStrg, BOOL & b String sTempStrg = sFormatStrg.Copy( nPos+1 ); // und suche darin ggf. ein weiteres ';' nPos = sTempStrg.Search( FORMAT_SEPARATOR ); - bFound = TRUE; + bFound = sal_True; if( nPos==STRING_NOTFOUND ) // keins gefunden, liefere alles... return sTempStrg; @@ -478,10 +478,10 @@ String SbxBasicFormater::GetNegFormatString( const String& sFormatStrg, BOOL & b } // siehe auch GetPosFormatString() -String SbxBasicFormater::Get0FormatString( const String& sFormatStrg, BOOL & bFound ) +String SbxBasicFormater::Get0FormatString( const String& sFormatStrg, sal_Bool & bFound ) { - bFound = FALSE; // default... - USHORT nPos = sFormatStrg.Search( FORMAT_SEPARATOR ); + bFound = sal_False; // default... + sal_uInt16 nPos = sFormatStrg.Search( FORMAT_SEPARATOR ); if( nPos!=STRING_NOTFOUND ) { @@ -493,7 +493,7 @@ String SbxBasicFormater::Get0FormatString( const String& sFormatStrg, BOOL & bFo nPos = sTempStrg.Search( FORMAT_SEPARATOR ); if( nPos!=STRING_NOTFOUND ) { - bFound = TRUE; + bFound = sal_True; sTempStrg = sTempStrg.Copy( nPos+1 ); nPos = sTempStrg.Search( FORMAT_SEPARATOR ); if( nPos==STRING_NOTFOUND ) @@ -510,10 +510,10 @@ String SbxBasicFormater::Get0FormatString( const String& sFormatStrg, BOOL & bFo } // siehe auch GetPosFormatString() -String SbxBasicFormater::GetNullFormatString( const String& sFormatStrg, BOOL & bFound ) +String SbxBasicFormater::GetNullFormatString( const String& sFormatStrg, sal_Bool & bFound ) { - bFound = FALSE; // default... - USHORT nPos = sFormatStrg.Search( FORMAT_SEPARATOR ); + bFound = sal_False; // default... + sal_uInt16 nPos = sFormatStrg.Search( FORMAT_SEPARATOR ); if( nPos!=STRING_NOTFOUND ) { @@ -530,7 +530,7 @@ String SbxBasicFormater::GetNullFormatString( const String& sFormatStrg, BOOL & nPos = sTempStrg.Search( FORMAT_SEPARATOR ); if( nPos!=STRING_NOTFOUND ) { - bFound = TRUE; + bFound = sal_True; return sTempStrg.Copy( nPos+1 ); } } @@ -547,11 +547,11 @@ short SbxBasicFormater::AnalyseFormatString( const String& sFormatStrg, short& nNoOfDigitsLeft, short& nNoOfDigitsRight, short& nNoOfOptionalDigitsLeft, short& nNoOfExponentDigits, short& nNoOfOptionalExponentDigits, - BOOL& bPercent, BOOL& bCurrency, BOOL& bScientific, - BOOL& bGenerateThousandSeparator, + sal_Bool& bPercent, sal_Bool& bCurrency, sal_Bool& bScientific, + sal_Bool& bGenerateThousandSeparator, short& nMultipleThousandSeparators ) { - USHORT nLen; + sal_uInt16 nLen; short nState = 0; nLen = sFormatStrg.Len(); @@ -561,9 +561,9 @@ short SbxBasicFormater::AnalyseFormatString( const String& sFormatStrg, nNoOfOptionalDigitsLeft = 0; nNoOfExponentDigits = 0; nNoOfOptionalExponentDigits = 0; - bPercent = FALSE; - bCurrency = FALSE; - bScientific = FALSE; + bPercent = sal_False; + bCurrency = sal_False; + bScientific = sal_False; // ab 11.7.97: sobald ein Komma in dem Format String gefunden wird, // werden alle 3 Zehnerpotenzen markiert (d.h. tausender, milionen, ...) // bisher wurde nur an den gesetzten Position ein Tausender-Separator @@ -572,7 +572,7 @@ short SbxBasicFormater::AnalyseFormatString( const String& sFormatStrg, bGenerateThousandSeparator = sFormatStrg.Search( ',' ) != STRING_NOTFOUND; nMultipleThousandSeparators = 0; // und untersuche den Format-String nach den gew"unschten Informationen - for( USHORT i=0; i<nLen; i++ ) + for( sal_uInt16 i=0; i<nLen; i++ ) { sal_Unicode c = sFormatStrg.GetChar( i ); switch( c ) { @@ -615,7 +615,7 @@ short SbxBasicFormater::AnalyseFormatString( const String& sFormatStrg, return -1; // ERROR: zu viele Dezimal-Punkte break; case '%': - bPercent = TRUE; + bPercent = sal_True; /* old: bPercent++; if( bPercent>1 ) @@ -623,7 +623,7 @@ short SbxBasicFormater::AnalyseFormatString( const String& sFormatStrg, */ break; case '(': - bCurrency = TRUE; + bCurrency = sal_True; break; case ',': { @@ -639,7 +639,7 @@ short SbxBasicFormater::AnalyseFormatString( const String& sFormatStrg, if( nNoOfDigitsLeft > 0 || nNoOfDigitsRight > 0 ) { nState = -1; // breche jetzt das Z"ahlen der Stellen ab - bScientific = TRUE; + bScientific = sal_True; } /* old: bScientific++; @@ -654,7 +654,7 @@ short SbxBasicFormater::AnalyseFormatString( const String& sFormatStrg, i++; break; case CREATE_1000SEP_CHAR: - bGenerateThousandSeparator = TRUE; + bGenerateThousandSeparator = sal_True; break; } } @@ -665,12 +665,12 @@ short SbxBasicFormater::AnalyseFormatString( const String& sFormatStrg, // erzeugt werden soll void SbxBasicFormater::ScanFormatString( double dNumber, const String& sFormatStrg, String& sReturnStrg, - BOOL bCreateSign ) + sal_Bool bCreateSign ) { short /*nErr,*/nNoOfDigitsLeft,nNoOfDigitsRight,nNoOfOptionalDigitsLeft, nNoOfExponentDigits,nNoOfOptionalExponentDigits, nMultipleThousandSeparators; - BOOL bPercent,bCurrency,bScientific,bGenerateThousandSeparator; + sal_Bool bPercent,bCurrency,bScientific,bGenerateThousandSeparator; // Initialisiere den Return-String sReturnStrg = String(); @@ -721,12 +721,12 @@ void SbxBasicFormater::ScanFormatString( double dNumber, double dExponent; short i,nLen; short nState,nDigitPos,nExponentPos,nMaxDigit,nMaxExponentDigit; - BOOL bFirstDigit,bFirstExponentDigit,bFoundFirstDigit, + sal_Bool bFirstDigit,bFirstExponentDigit,bFoundFirstDigit, bIsNegative,bZeroSpaceOn, bSignHappend,bDigitPosNegative; // Initialisierung der Arbeits-Variablen - bSignHappend = FALSE; - bFoundFirstDigit = FALSE; + bSignHappend = sal_False; + bFoundFirstDigit = sal_False; bIsNegative = dNumber<0.0; nLen = sFormatStrg.Len(); dExponent = get_number_of_digits( dNumber ); @@ -750,8 +750,8 @@ void SbxBasicFormater::ScanFormatString( double dNumber, // hier ben"otigt man keine Exponent-Daten ! bDigitPosNegative = (nDigitPos < 0); } - bFirstDigit = TRUE; - bFirstExponentDigit = TRUE; + bFirstDigit = sal_True; + bFirstExponentDigit = sal_True; nState = 0; // 0 --> Mantisse; 1 --> Exponent bZeroSpaceOn = 0; @@ -781,14 +781,14 @@ void SbxBasicFormater::ScanFormatString( double dNumber, // Behandlung der Mantisse if( bFirstDigit ) { - //org:bFirstDigit = FALSE; + //org:bFirstDigit = sal_False; // ggf. Vorzeichen erzeugen // Bem.: bei bCurrency soll das negative // Vorzeichen durch () angezeigt werden if( bIsNegative && !bCreateSign/*!bCurrency*/ && !bSignHappend ) { // nur einmal ein Vorzeichen ausgeben - bSignHappend = TRUE; + bSignHappend = sal_True; StrAppendChar( sReturnStrg,'-' ); } // hier jetzt "uberz"ahlige Stellen ausgeben, @@ -806,7 +806,7 @@ void SbxBasicFormater::ScanFormatString( double dNumber, // wurde wirklich eine Ziffer eingefuegt ? if( nTempDigit!=_NO_DIGIT ) // jetzt wurde wirklich eine Ziffer ausgegeben, Flag setzen - bFirstDigit = FALSE; + bFirstDigit = sal_False; // muss ggf. ein Tausender-Trennzeichen erzeugt werden? if( bGenerateThousandSeparator && ( c=='0' || nMaxDigit>=nDigitPos ) && j>0 && (j % 3 == 0) ) StrAppendChar( sReturnStrg,cThousandSep ); @@ -818,7 +818,7 @@ void SbxBasicFormater::ScanFormatString( double dNumber, { AppendDigit( sReturnStrg,0 ); // Ja // jetzt wurde wirklich eine Ziffer ausgegeben, Flag setzen - bFirstDigit = FALSE; + bFirstDigit = sal_False; bZeroSpaceOn = 1; // BEM.: bei Visual-Basic schaltet die erste 0 f"ur alle // nachfolgenden # (bis zum Dezimal-Punkt) die 0 ein, @@ -838,7 +838,7 @@ void SbxBasicFormater::ScanFormatString( double dNumber, // wurde wirklich eine Ziffer eingefuegt ? if( nTempDigit!=_NO_DIGIT ) // jetzt wurde wirklich eine Ziffer ausgegeben, Flag setzen - bFirstDigit = FALSE; + bFirstDigit = sal_False; // muss ggf. ein Tausender-Trennzeichen erzeugt werden? if( bGenerateThousandSeparator && ( c=='0' || nMaxDigit>=nDigitPos ) && nDigitPos>0 && (nDigitPos % 3 == 0) ) StrAppendChar( sReturnStrg,cThousandSep ); @@ -852,7 +852,7 @@ void SbxBasicFormater::ScanFormatString( double dNumber, if( bFirstExponentDigit ) { // Vorzeichen wurde schon bei e/E ausgegeben - bFirstExponentDigit = FALSE; + bFirstExponentDigit = sal_False; if( nMaxExponentDigit>nExponentPos ) // hier jetzt "uberz"ahlige Stellen ausgeben, // d.h. vom Format-String nicht erfasste Stellen @@ -913,7 +913,7 @@ void SbxBasicFormater::ScanFormatString( double dNumber, break; } - BOOL bOverflow = FALSE; + sal_Bool bOverflow = sal_False; #ifdef _with_sprintf short nNextDigit = GetDigitAtPosScan( nDigitPos,bFoundFirstDigit ); #else @@ -1047,7 +1047,7 @@ void SbxBasicFormater::ScanFormatString( double dNumber, String SbxBasicFormater::BasicFormatNull( String sFormatStrg ) { - BOOL bNullFormatFound; + sal_Bool bNullFormatFound; String sNullFormatStrg = GetNullFormatString( sFormatStrg,bNullFormatFound ); if( bNullFormatFound ) @@ -1059,7 +1059,7 @@ String SbxBasicFormater::BasicFormatNull( String sFormatStrg ) String SbxBasicFormater::BasicFormat( double dNumber, String sFormatStrg ) { - BOOL bPosFormatFound,bNegFormatFound,b0FormatFound; + sal_Bool bPosFormatFound,bNegFormatFound,b0FormatFound; // analysiere Format-String auf vordefinierte Formate: if( sFormatStrg.EqualsIgnoreCaseAscii( BASICFORMAT_GENERALNUMBER ) ) @@ -1108,7 +1108,7 @@ String SbxBasicFormater::BasicFormat( double dNumber, String sFormatStrg ) // verwende String fuer positive Werte sTempStrg = sPosFormatStrg; } - ScanFormatString( dNumber, sTempStrg, sReturnStrg,/*bCreateSign=*/FALSE ); + ScanFormatString( dNumber, sTempStrg, sReturnStrg,/*bCreateSign=*/sal_False ); } else { @@ -1137,32 +1137,32 @@ String SbxBasicFormater::BasicFormat( double dNumber, String sFormatStrg ) { ScanFormatString( dNumber, (/*sPosFormatStrg!=EMPTYFORMATSTRING*/bPosFormatFound ? sPosFormatStrg : sFormatStrg), - sReturnStrg,/*bCreateSign=*/FALSE ); + sReturnStrg,/*bCreateSign=*/sal_False ); } } return sReturnStrg; } -BOOL SbxBasicFormater::isBasicFormat( String sFormatStrg ) +sal_Bool SbxBasicFormater::isBasicFormat( String sFormatStrg ) { if( sFormatStrg.EqualsIgnoreCaseAscii( BASICFORMAT_GENERALNUMBER ) ) - return TRUE; + return sal_True; if( sFormatStrg.EqualsIgnoreCaseAscii( BASICFORMAT_CURRENCY ) ) - return TRUE; + return sal_True; if( sFormatStrg.EqualsIgnoreCaseAscii( BASICFORMAT_FIXED ) ) - return TRUE; + return sal_True; if( sFormatStrg.EqualsIgnoreCaseAscii( BASICFORMAT_STANDARD ) ) - return TRUE; + return sal_True; if( sFormatStrg.EqualsIgnoreCaseAscii( BASICFORMAT_PERCENT ) ) - return TRUE; + return sal_True; if( sFormatStrg.EqualsIgnoreCaseAscii( BASICFORMAT_SCIENTIFIC ) ) - return TRUE; + return sal_True; if( sFormatStrg.EqualsIgnoreCaseAscii( BASICFORMAT_YESNO ) ) - return TRUE; + return sal_True; if( sFormatStrg.EqualsIgnoreCaseAscii( BASICFORMAT_TRUEFALSE ) ) - return TRUE; + return sal_True; if( sFormatStrg.EqualsIgnoreCaseAscii( BASICFORMAT_ONOFF ) ) - return TRUE; - return FALSE; + return sal_True; + return sal_False; } diff --git a/basic/source/sbx/sbxint.cxx b/basic/source/sbx/sbxint.cxx index 47c38aecb1c2..4c4b3959e7a0 100644 --- a/basic/source/sbx/sbxint.cxx +++ b/basic/source/sbx/sbxint.cxx @@ -36,10 +36,10 @@ double ImpRound( double d ) return d + ( d < 0 ? -0.5 : 0.5 ); } -INT16 ImpGetInteger( const SbxValues* p ) +sal_Int16 ImpGetInteger( const SbxValues* p ) { SbxValues aTmp; - INT16 nRes; + sal_Int16 nRes; start: switch( +p->eType ) { @@ -56,12 +56,12 @@ start: nRes = p->nInteger; break; case SbxERROR: case SbxUSHORT: - if( p->nUShort > (USHORT) SbxMAXINT ) + if( p->nUShort > (sal_uInt16) SbxMAXINT ) { SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXINT; } else - nRes = (INT16) p->nUShort; + nRes = (sal_Int16) p->nUShort; break; case SbxLONG: if( p->nLong > SbxMAXINT ) @@ -73,7 +73,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMININT; } else - nRes = (INT16) p->nLong; + nRes = (sal_Int16) p->nLong; break; case SbxULONG: if( p->nULong > SbxMAXINT ) @@ -81,7 +81,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXINT; } else - nRes = (INT16) p->nULong; + nRes = (sal_Int16) p->nULong; break; case SbxSINGLE: if( p->nSingle > SbxMAXINT ) @@ -93,7 +93,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMININT; } else - nRes = (INT16) ImpRound( p->nSingle ); + nRes = (sal_Int16) ImpRound( p->nSingle ); break; case SbxSALINT64: if( p->nInt64 > SbxMAXINT ) @@ -105,7 +105,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMININT; } else - nRes = (INT16) p->nInt64; + nRes = (sal_Int16) p->nInt64; break; case SbxSALUINT64: if( p->uInt64 > SbxMAXINT ) @@ -113,7 +113,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXINT; } else - nRes = (INT16) p->uInt64; + nRes = (sal_Int16) p->uInt64; break; case SbxDATE: case SbxDOUBLE: @@ -148,7 +148,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMININT; } else - nRes = (INT16) ImpRound( dVal ); + nRes = (sal_Int16) ImpRound( dVal ); break; } case SbxLPSTR: @@ -171,7 +171,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMININT; } else - nRes = (INT16) ImpRound( d ); + nRes = (sal_Int16) ImpRound( d ); } break; case SbxOBJECT: @@ -226,7 +226,7 @@ start: return nRes; } -void ImpPutInteger( SbxValues* p, INT16 n ) +void ImpPutInteger( SbxValues* p, sal_Int16 n ) { SbxValues aTmp; start: @@ -303,7 +303,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pByte = (BYTE) n; break; + *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: *p->pInteger = n; break; @@ -313,15 +313,15 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pUShort = (UINT16) n; break; + *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: - *p->pLong = (INT32) n; break; + *p->pLong = (sal_Int32) n; break; case SbxBYREF | SbxULONG: if( n < 0 ) { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pULong = (UINT32) n; break; + *p->pULong = (sal_uInt32) n; break; case SbxBYREF | SbxSALINT64: *p->pnInt64 = n; break; case SbxBYREF | SbxSALUINT64: @@ -610,7 +610,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pByte = (BYTE) n; break; + *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: if( n > SbxMAXINT ) @@ -621,7 +621,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMININT; } - *p->pInteger = (INT16) n; break; + *p->pInteger = (sal_Int16) n; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: if( n > SbxMAXUINT ) @@ -632,7 +632,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pUShort = (UINT16) n; break; + *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: if( n > SbxMAXLNG ) { @@ -642,7 +642,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMINLNG; } - *p->pLong = (INT32) n; break; + *p->pLong = (sal_Int32) n; break; case SbxBYREF | SbxULONG: if( n > SbxMAXULNG ) { @@ -652,7 +652,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pULong = (UINT32) n; break; + *p->pULong = (sal_uInt32) n; break; case SbxBYREF | SbxSINGLE: *p->pSingle = (float) n; break; case SbxBYREF | SbxDATE: @@ -907,33 +907,33 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXBYTE; } - *p->pByte = (BYTE) n; break; + *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: if( n > SbxMAXINT ) { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXINT; } - *p->pInteger = (INT16) n; break; + *p->pInteger = (sal_Int16) n; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: if( n > SbxMAXUINT ) { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXUINT; } - *p->pUShort = (UINT16) n; break; + *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: if( n > SbxMAXLNG ) { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXLNG; } - *p->pLong = (INT32) n; break; + *p->pLong = (sal_Int32) n; break; case SbxBYREF | SbxULONG: if( n > SbxMAXULNG ) { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXULNG; } - *p->pULong = (UINT32) n; break; + *p->pULong = (sal_uInt32) n; break; case SbxBYREF | SbxSINGLE: *p->pDouble = (float)ImpSalUInt64ToDouble( n ); break; case SbxBYREF | SbxDATE: diff --git a/basic/source/sbx/sbxlng.cxx b/basic/source/sbx/sbxlng.cxx index 1cf2d84061f9..ae873d8eba1b 100644 --- a/basic/source/sbx/sbxlng.cxx +++ b/basic/source/sbx/sbxlng.cxx @@ -31,10 +31,10 @@ #include <basic/sbx.hxx> #include "sbxconv.hxx" -INT32 ImpGetLong( const SbxValues* p ) +sal_Int32 ImpGetLong( const SbxValues* p ) { SbxValues aTmp; - INT32 nRes; + sal_Int32 nRes; start: switch( +p->eType ) { @@ -60,7 +60,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXLNG; } else - nRes = (INT32) p->nULong; + nRes = (sal_Int32) p->nULong; break; case SbxSINGLE: if( p->nSingle > SbxMAXLNG ) @@ -72,7 +72,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMINLNG; } else - nRes = (INT32) ImpRound( p->nSingle ); + nRes = (sal_Int32) ImpRound( p->nSingle ); break; case SbxDATE: case SbxDOUBLE: @@ -113,7 +113,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMINLNG; } else - nRes = (INT32) ImpRound( dVal ); + nRes = (sal_Int32) ImpRound( dVal ); break; } case SbxBYREF | SbxSTRING: @@ -136,7 +136,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMINLNG; } else - nRes = (INT32) ImpRound( d ); + nRes = (sal_Int32) ImpRound( d ); } break; case SbxOBJECT: @@ -191,7 +191,7 @@ start: return nRes; } -void ImpPutLong( SbxValues* p, INT32 n ) +void ImpPutLong( SbxValues* p, sal_Int32 n ) { SbxValues aTmp; @@ -272,7 +272,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pByte = (BYTE) n; break; + *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: if( n > SbxMAXINT ) @@ -283,7 +283,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMININT; } - *p->pInteger = (INT16) n; break; + *p->pInteger = (sal_Int16) n; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: if( n > SbxMAXUINT ) @@ -294,7 +294,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pUShort = (UINT16) n; break; + *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: *p->pLong = n; break; case SbxBYREF | SbxULONG: @@ -302,7 +302,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pULong = (UINT32) n; break; + *p->pULong = (sal_uInt32) n; break; case SbxBYREF | SbxSALINT64: *p->pnInt64 = n; break; case SbxBYREF | SbxSALUINT64: diff --git a/basic/source/sbx/sbxobj.cxx b/basic/source/sbx/sbxobj.cxx index 6628973b29e8..266e39907b66 100644 --- a/basic/source/sbx/sbxobj.cxx +++ b/basic/source/sbx/sbxobj.cxx @@ -41,7 +41,7 @@ TYPEINIT2(SbxObject,SbxVariable,SfxListener) static const char* pNameProp; // Name-Property static const char* pParentProp; // Parent-Property -static USHORT nNameHash = 0, nParentHash = 0; +static sal_uInt16 nNameHash = 0, nParentHash = 0; ///////////////////////////////////////////////////////////////////////// @@ -86,18 +86,18 @@ SbxObject& SbxObject::operator=( const SbxObject& r ) pDfltProp = r.pDfltProp; SetName( r.GetName() ); SetFlags( r.GetFlags() ); - SetModified( TRUE ); + SetModified( sal_True ); } return *this; } static void CheckParentsOnDelete( SbxObject* pObj, SbxArray* p ) { - for( USHORT i = 0; i < p->Count(); i++ ) + for( sal_uInt16 i = 0; i < p->Count(); i++ ) { SbxVariableRef& rRef = p->GetRef( i ); if( rRef->IsBroadcaster() ) - pObj->EndListening( rRef->GetBroadcaster(), TRUE ); + pObj->EndListening( rRef->GetBroadcaster(), sal_True ); // Hat das Element mehr als eine Referenz und noch einen Listener? if( rRef->GetRefCount() > 1 ) { @@ -139,7 +139,7 @@ void SbxObject::Clear() p->ResetFlag( SBX_WRITE ); p->SetFlag( SBX_DONTSTORE ); pDfltProp = NULL; - SetModified( FALSE ); + SetModified( sal_False ); } void SbxObject::SFX_NOTIFY( SfxBroadcaster&, const TypeId&, @@ -148,14 +148,14 @@ void SbxObject::SFX_NOTIFY( SfxBroadcaster&, const TypeId&, const SbxHint* p = PTR_CAST(SbxHint,&rHint); if( p ) { - ULONG nId = p->GetId(); - BOOL bRead = BOOL( nId == SBX_HINT_DATAWANTED ); - BOOL bWrite = BOOL( nId == SBX_HINT_DATACHANGED ); + sal_uIntPtr nId = p->GetId(); + sal_Bool bRead = sal_Bool( nId == SBX_HINT_DATAWANTED ); + sal_Bool bWrite = sal_Bool( nId == SBX_HINT_DATACHANGED ); SbxVariable* pVar = p->GetVar(); if( bRead || bWrite ) { XubString aVarName( pVar->GetName() ); - USHORT nHash_ = MakeHashCode( aVarName ); + sal_uInt16 nHash_ = MakeHashCode( aVarName ); if( nHash_ == nNameHash && aVarName.EqualsIgnoreCaseAscii( pNameProp ) ) { @@ -176,12 +176,12 @@ void SbxObject::SFX_NOTIFY( SfxBroadcaster&, const TypeId&, } } -BOOL SbxObject::IsClass( const XubString& rName ) const +sal_Bool SbxObject::IsClass( const XubString& rName ) const { - return BOOL( aClassName.EqualsIgnoreCaseAscii( rName ) ); + return sal_Bool( aClassName.EqualsIgnoreCaseAscii( rName ) ); } -SbxVariable* SbxObject::FindUserData( UINT32 nData ) +SbxVariable* SbxObject::FindUserData( sal_uInt32 nData ) { if( !GetAll( SbxCLASS_DONTCARE ) ) return NULL; @@ -198,10 +198,10 @@ SbxVariable* SbxObject::FindUserData( UINT32 nData ) while( !pRes && pCur->pParent ) { // Ich selbst bin schon durchsucht worden! - USHORT nOwn = pCur->GetFlags(); + sal_uInt16 nOwn = pCur->GetFlags(); pCur->ResetFlag( SBX_EXTSEARCH ); // Ich suche bereits global! - USHORT nPar = pCur->pParent->GetFlags(); + sal_uInt16 nPar = pCur->pParent->GetFlags(); pCur->pParent->ResetFlag( SBX_GBLSEARCH ); pRes = pCur->pParent->FindUserData( nData ); pCur->SetFlags( nOwn ); @@ -215,7 +215,7 @@ SbxVariable* SbxObject::FindUserData( UINT32 nData ) SbxVariable* SbxObject::Find( const XubString& rName, SbxClassType t ) { #ifdef DBG_UTIL - static USHORT nLvl = 0; + static sal_uInt16 nLvl = 0; static const char* pCls[] = { "DontCare","Array","Value","Variable","Method","Property","Object" }; ByteString aNameStr1( (const UniString&)rName, RTL_TEXTENCODING_ASCII_US ); @@ -265,10 +265,10 @@ SbxVariable* SbxObject::Find( const XubString& rName, SbxClassType t ) while( !pRes && pCur->pParent ) { // Ich selbst bin schon durchsucht worden! - USHORT nOwn = pCur->GetFlags(); + sal_uInt16 nOwn = pCur->GetFlags(); pCur->ResetFlag( SBX_EXTSEARCH ); // Ich suche bereits global! - USHORT nPar = pCur->pParent->GetFlags(); + sal_uInt16 nPar = pCur->pParent->GetFlags(); pCur->pParent->ResetFlag( SBX_GBLSEARCH ); pRes = pCur->pParent->Find( rName, t ); pCur->SetFlags( nOwn ); @@ -293,7 +293,7 @@ SbxVariable* SbxObject::Find( const XubString& rName, SbxClassType t ) // Das ganze rekursiv, da Call() ueberladen sein kann // Qualified Names sind zugelassen -BOOL SbxObject::Call( const XubString& rName, SbxArray* pParam ) +sal_Bool SbxObject::Call( const XubString& rName, SbxArray* pParam ) { SbxVariable* pMeth = FindQualified( rName, SbxCLASS_DONTCARE); if( pMeth && pMeth->ISA(SbxMethod) ) @@ -303,10 +303,10 @@ BOOL SbxObject::Call( const XubString& rName, SbxArray* pParam ) pMeth->SetParameters( pParam ); pMeth->Broadcast( SBX_HINT_DATAWANTED ); pMeth->SetParameters( NULL ); - return TRUE; + return sal_True; } SetError( SbxERR_NO_METHOD ); - return FALSE; + return sal_False; } SbxProperty* SbxObject::GetDfltProperty() @@ -324,14 +324,14 @@ void SbxObject::SetDfltProperty( const XubString& rName ) if ( rName != aDfltPropName ) pDfltProp = NULL; aDfltPropName = rName; - SetModified( TRUE ); + SetModified( sal_True ); } void SbxObject::SetDfltProperty( SbxProperty* p ) { if( p ) { - USHORT n; + sal_uInt16 n; SbxArray* pArray = FindVar( p, n ); pArray->Put( p, n ); if( p->GetParent() != this ) @@ -339,14 +339,14 @@ void SbxObject::SetDfltProperty( SbxProperty* p ) Broadcast( SBX_HINT_OBJECTCHANGED ); } pDfltProp = p; - SetModified( TRUE ); + SetModified( sal_True ); } // Suchen einer bereits vorhandenen Variablen. Falls sie gefunden wurde, // wird der Index gesetzt, sonst wird der Count des Arrays geliefert. // In jedem Fall wird das korrekte Array geliefert. -SbxArray* SbxObject::FindVar( SbxVariable* pVar, USHORT& nArrayIdx ) +SbxArray* SbxObject::FindVar( SbxVariable* pVar, sal_uInt16& nArrayIdx ) { SbxArray* pArray = NULL; if( pVar ) switch( pVar->GetClass() ) @@ -365,7 +365,7 @@ SbxArray* SbxObject::FindVar( SbxVariable* pVar, USHORT& nArrayIdx ) pArray->ResetFlag( SBX_EXTSEARCH ); SbxVariable* pOld = pArray->Find( pVar->GetName(), pVar->GetClass() ); if( pOld ) - for( USHORT i = 0; i < pArray->Count(); i++ ) + for( sal_uInt16 i = 0; i < pArray->Count(); i++ ) { SbxVariableRef& rRef = pArray->GetRef( i ); if( (SbxVariable*) rRef == pOld ) @@ -435,9 +435,9 @@ SbxVariable* SbxObject::Make( const XubString& rName, SbxClassType ct, SbxDataTy } pVar->SetParent( this ); pArray->Put( pVar, pArray->Count() ); - SetModified( TRUE ); + SetModified( sal_True ); // Das Objekt lauscht immer - StartListening( pVar->GetBroadcaster(), TRUE ); + StartListening( pVar->GetBroadcaster(), sal_True ); Broadcast( SBX_HINT_OBJECTCHANGED ); return pVar; } @@ -473,9 +473,9 @@ SbxObject* SbxObject::MakeObject( const XubString& rName, const XubString& rClas pVar->SetName( rName ); pVar->SetParent( this ); pObjs->Put( pVar, pObjs->Count() ); - SetModified( TRUE ); + SetModified( sal_True ); // Das Objekt lauscht immer - StartListening( pVar->GetBroadcaster(), TRUE ); + StartListening( pVar->GetBroadcaster(), sal_True ); Broadcast( SBX_HINT_OBJECTCHANGED ); } return pVar; @@ -483,7 +483,7 @@ SbxObject* SbxObject::MakeObject( const XubString& rName, const XubString& rClas void SbxObject::Insert( SbxVariable* pVar ) { - USHORT nIdx; + sal_uInt16 nIdx; SbxArray* pArray = FindVar( pVar, nIdx ); if( pArray ) { @@ -515,7 +515,7 @@ void SbxObject::Insert( SbxVariable* pVar ) } #endif */ - EndListening( pOld->GetBroadcaster(), TRUE ); + EndListening( pOld->GetBroadcaster(), sal_True ); if( pVar->GetClass() == SbxCLASS_PROPERTY ) { if( pOld == pDfltProp ) @@ -523,11 +523,11 @@ void SbxObject::Insert( SbxVariable* pVar ) } } } - StartListening( pVar->GetBroadcaster(), TRUE ); + StartListening( pVar->GetBroadcaster(), sal_True ); pArray->Put( pVar, nIdx ); if( pVar->GetParent() != this ) pVar->SetParent( this ); - SetModified( TRUE ); + SetModified( sal_True ); Broadcast( SBX_HINT_OBJECTCHANGED ); #ifdef DBG_UTIL static const char* pCls[] = @@ -564,11 +564,11 @@ void SbxObject::QuickInsert( SbxVariable* pVar ) } if( pArray ) { - StartListening( pVar->GetBroadcaster(), TRUE ); + StartListening( pVar->GetBroadcaster(), sal_True ); pArray->Put( pVar, pArray->Count() ); if( pVar->GetParent() != this ) pVar->SetParent( this ); - SetModified( TRUE ); + SetModified( sal_True ); #ifdef DBG_UTIL static const char* pCls[] = { "DontCare","Array","Value","Variable","Method","Property","Object" }; @@ -603,11 +603,11 @@ void SbxObject::VCPtrInsert( SbxVariable* pVar ) } if( pArray ) { - StartListening( pVar->GetBroadcaster(), TRUE ); + StartListening( pVar->GetBroadcaster(), sal_True ); pArray->Put( pVar, pArray->Count() ); if( pVar->GetParent() != this ) pVar->SetParent( this ); - SetModified( TRUE ); + SetModified( sal_True ); Broadcast( SBX_HINT_OBJECTCHANGED ); } } @@ -619,7 +619,7 @@ void SbxObject::Remove( const XubString& rName, SbxClassType t ) void SbxObject::Remove( SbxVariable* pVar ) { - USHORT nIdx; + sal_uInt16 nIdx; SbxArray* pArray = FindVar( pVar, nIdx ); if( pArray && nIdx < pArray->Count() ) { @@ -632,13 +632,13 @@ void SbxObject::Remove( SbxVariable* pVar ) #endif SbxVariableRef pVar_ = pArray->Get( nIdx ); if( pVar_->IsBroadcaster() ) - EndListening( pVar_->GetBroadcaster(), TRUE ); + EndListening( pVar_->GetBroadcaster(), sal_True ); if( (SbxVariable*) pVar_ == pDfltProp ) pDfltProp = NULL; pArray->Remove( nIdx ); if( pVar_->GetParent() == this ) pVar_->SetParent( NULL ); - SetModified( TRUE ); + SetModified( sal_True ); Broadcast( SBX_HINT_OBJECTCHANGED ); } } @@ -646,26 +646,26 @@ void SbxObject::Remove( SbxVariable* pVar ) // AB 23.3.1997, Loeschen per Pointer fuer Controls (doppelte Namen!) void SbxObject::VCPtrRemove( SbxVariable* pVar ) { - USHORT nIdx; + sal_uInt16 nIdx; // Neu FindVar-Methode, sonst identisch mit normaler Methode SbxArray* pArray = VCPtrFindVar( pVar, nIdx ); if( pArray && nIdx < pArray->Count() ) { SbxVariableRef xVar = pArray->Get( nIdx ); if( xVar->IsBroadcaster() ) - EndListening( xVar->GetBroadcaster(), TRUE ); + EndListening( xVar->GetBroadcaster(), sal_True ); if( (SbxVariable*) xVar == pDfltProp ) pDfltProp = NULL; pArray->Remove( nIdx ); if( xVar->GetParent() == this ) xVar->SetParent( NULL ); - SetModified( TRUE ); + SetModified( sal_True ); Broadcast( SBX_HINT_OBJECTCHANGED ); } } // AB 23.3.1997, Zugehoerige Spezial-Methode, nur ueber Pointer suchen -SbxArray* SbxObject::VCPtrFindVar( SbxVariable* pVar, USHORT& nArrayIdx ) +SbxArray* SbxObject::VCPtrFindVar( SbxVariable* pVar, sal_uInt16& nArrayIdx ) { SbxArray* pArray = NULL; if( pVar ) switch( pVar->GetClass() ) @@ -680,7 +680,7 @@ SbxArray* SbxObject::VCPtrFindVar( SbxVariable* pVar, USHORT& nArrayIdx ) if( pArray ) { nArrayIdx = pArray->Count(); - for( USHORT i = 0; i < pArray->Count(); i++ ) + for( sal_uInt16 i = 0; i < pArray->Count(); i++ ) { SbxVariableRef& rRef = pArray->GetRef( i ); if( (SbxVariable*) rRef == pVar ) @@ -694,9 +694,9 @@ SbxArray* SbxObject::VCPtrFindVar( SbxVariable* pVar, USHORT& nArrayIdx ) -void SbxObject::SetPos( SbxVariable* pVar, USHORT nPos ) +void SbxObject::SetPos( SbxVariable* pVar, sal_uInt16 nPos ) { - USHORT nIdx; + sal_uInt16 nIdx; SbxArray* pArray = FindVar( pVar, nIdx ); if( pArray ) { @@ -709,41 +709,41 @@ void SbxObject::SetPos( SbxVariable* pVar, USHORT nPos ) pArray->Insert( refVar, nPos ); } } -// SetModified( TRUE ); +// SetModified( sal_True ); // Broadcast( SBX_HINT_OBJECTCHANGED ); } -static BOOL LoadArray( SvStream& rStrm, SbxObject* pThis, SbxArray* pArray ) +static sal_Bool LoadArray( SvStream& rStrm, SbxObject* pThis, SbxArray* pArray ) { SbxArrayRef p = (SbxArray*) SbxBase::Load( rStrm ); if( !p.Is() ) - return FALSE; - for( USHORT i = 0; i < p->Count(); i++ ) + return sal_False; + for( sal_uInt16 i = 0; i < p->Count(); i++ ) { SbxVariableRef& r = p->GetRef( i ); SbxVariable* pVar = r; if( pVar ) { pVar->SetParent( pThis ); - pThis->StartListening( pVar->GetBroadcaster(), TRUE ); + pThis->StartListening( pVar->GetBroadcaster(), sal_True ); } } pArray->Merge( p ); - return TRUE; + return sal_True; } // Der Load eines Objekts ist additiv! -BOOL SbxObject::LoadData( SvStream& rStrm, USHORT nVer ) +sal_Bool SbxObject::LoadData( SvStream& rStrm, sal_uInt16 nVer ) { - // Hilfe fuer das Einlesen alter Objekte: einfach TRUE zurueck, + // Hilfe fuer das Einlesen alter Objekte: einfach sal_True zurueck, // LoadPrivateData() muss Default-Zustand herstellen if( !nVer ) - return TRUE; + return sal_True; pDfltProp = NULL; if( !SbxVariable::LoadData( rStrm, nVer ) ) - return FALSE; + return sal_False; // Wenn kein fremdes Objekt enthalten ist, uns selbst eintragen if( aData.eType == SbxOBJECT && !aData.pObj ) aData.pObj = this; @@ -751,11 +751,11 @@ BOOL SbxObject::LoadData( SvStream& rStrm, USHORT nVer ) XubString aDfltProp; rStrm.ReadByteString( aClassName, RTL_TEXTENCODING_ASCII_US ); rStrm.ReadByteString( aDfltProp, RTL_TEXTENCODING_ASCII_US ); - ULONG nPos = rStrm.Tell(); + sal_uIntPtr nPos = rStrm.Tell(); rStrm >> nSize; if( !LoadPrivateData( rStrm, nVer ) ) - return FALSE; - ULONG nNewPos = rStrm.Tell(); + return sal_False; + sal_uIntPtr nNewPos = rStrm.Tell(); nPos += nSize; DBG_ASSERT( nPos >= nNewPos, "SBX: Zu viele Daten eingelesen" ); if( nPos != nNewPos ) @@ -763,39 +763,39 @@ BOOL SbxObject::LoadData( SvStream& rStrm, USHORT nVer ) if( !LoadArray( rStrm, this, pMethods ) || !LoadArray( rStrm, this, pProps ) || !LoadArray( rStrm, this, pObjs ) ) - return FALSE; + return sal_False; // Properties setzen if( aDfltProp.Len() ) pDfltProp = (SbxProperty*) pProps->Find( aDfltProp, SbxCLASS_PROPERTY ); - SetModified( FALSE ); - return TRUE; + SetModified( sal_False ); + return sal_True; } -BOOL SbxObject::StoreData( SvStream& rStrm ) const +sal_Bool SbxObject::StoreData( SvStream& rStrm ) const { if( !SbxVariable::StoreData( rStrm ) ) - return FALSE; + return sal_False; XubString aDfltProp; if( pDfltProp ) aDfltProp = pDfltProp->GetName(); rStrm.WriteByteString( aClassName, RTL_TEXTENCODING_ASCII_US ); rStrm.WriteByteString( aDfltProp, RTL_TEXTENCODING_ASCII_US ); - ULONG nPos = rStrm.Tell(); - rStrm << (UINT32) 0L; + sal_uIntPtr nPos = rStrm.Tell(); + rStrm << (sal_uInt32) 0L; if( !StorePrivateData( rStrm ) ) - return FALSE; - ULONG nNew = rStrm.Tell(); + return sal_False; + sal_uIntPtr nNew = rStrm.Tell(); rStrm.Seek( nPos ); - rStrm << (UINT32) ( nNew - nPos ); + rStrm << (sal_uInt32) ( nNew - nPos ); rStrm.Seek( nNew ); if( !pMethods->Store( rStrm ) ) - return FALSE; + return sal_False; if( !pProps->Store( rStrm ) ) - return FALSE; + return sal_False; if( !pObjs->Store( rStrm ) ) - return FALSE; - ((SbxObject*) this)->SetModified( FALSE ); - return TRUE; + return sal_False; + ((SbxObject*) this)->SetModified( sal_False ); + return sal_True; } XubString SbxObject::GenerateSource( const XubString &rLinePrefix, @@ -804,8 +804,8 @@ XubString SbxObject::GenerateSource( const XubString &rLinePrefix, // Properties in einem String einsammeln XubString aSource; SbxArrayRef xProps( GetProperties() ); - FASTBOOL bLineFeed = FALSE; - for ( USHORT nProp = 0; nProp < xProps->Count(); ++nProp ) + bool bLineFeed = false; + for ( sal_uInt16 nProp = 0; nProp < xProps->Count(); ++nProp ) { SbxPropertyRef xProp = (SbxProperty*) xProps->Get(nProp); XubString aPropName( xProp->GetName() ); @@ -817,7 +817,7 @@ XubString SbxObject::GenerateSource( const XubString &rLinePrefix, if ( bLineFeed ) aSource.AppendAscii( "\n" ); else - bLineFeed = TRUE; + bLineFeed = true; aSource += rLinePrefix; aSource += '.'; @@ -853,7 +853,7 @@ XubString SbxObject::GenerateSource( const XubString &rLinePrefix, return aSource; } -static BOOL CollectAttrs( const SbxBase* p, XubString& rRes ) +static sal_Bool CollectAttrs( const SbxBase* p, XubString& rRes ) { XubString aAttrs; if( p->IsHidden() ) @@ -881,19 +881,19 @@ static BOOL CollectAttrs( const SbxBase* p, XubString& rRes ) rRes.AssignAscii( " (" ); rRes += aAttrs; rRes += ')'; - return TRUE; + return sal_True; } else { rRes.Erase(); - return FALSE; + return sal_False; } } -void SbxObject::Dump( SvStream& rStrm, BOOL bFill ) +void SbxObject::Dump( SvStream& rStrm, sal_Bool bFill ) { // Einr"uckung - static USHORT nLevel = 0; + static sal_uInt16 nLevel = 0; if ( nLevel > 10 ) { rStrm << "<too deep>" << endl; @@ -901,7 +901,7 @@ void SbxObject::Dump( SvStream& rStrm, BOOL bFill ) } ++nLevel; String aIndent; - for ( USHORT n = 1; n < nLevel; ++n ) + for ( sal_uInt16 n = 1; n < nLevel; ++n ) aIndent.AppendAscii( " " ); // ggf. Objekt vervollst"andigen @@ -912,7 +912,7 @@ void SbxObject::Dump( SvStream& rStrm, BOOL bFill ) ByteString aNameStr( (const UniString&)GetName(), RTL_TEXTENCODING_ASCII_US ); ByteString aClassNameStr( (const UniString&)aClassName, RTL_TEXTENCODING_ASCII_US ); rStrm << "Object( " - << ByteString::CreateFromInt64( (ULONG) this ).GetBuffer() << "=='" + << ByteString::CreateFromInt64( (sal_uIntPtr) this ).GetBuffer() << "=='" << ( aNameStr.Len() ? aNameStr.GetBuffer() : "<unnamed>" ) << "', " << "of class '" << aClassNameStr.GetBuffer() << "', " << "counts " @@ -922,7 +922,7 @@ void SbxObject::Dump( SvStream& rStrm, BOOL bFill ) { ByteString aParentNameStr( (const UniString&)GetName(), RTL_TEXTENCODING_ASCII_US ); rStrm << "in parent " - << ByteString::CreateFromInt64( (ULONG) GetParent() ).GetBuffer() + << ByteString::CreateFromInt64( (sal_uIntPtr) GetParent() ).GetBuffer() << "=='" << ( aParentNameStr.Len() ? aParentNameStr.GetBuffer() : "<unnamed>" ) << "'"; } else @@ -941,7 +941,7 @@ void SbxObject::Dump( SvStream& rStrm, BOOL bFill ) // Methods rStrm << aIndentNameStr.GetBuffer() << "- Methods:" << endl; - for( USHORT i = 0; i < pMethods->Count(); i++ ) + for( sal_uInt16 i = 0; i < pMethods->Count(); i++ ) { SbxVariableRef& r = pMethods->GetRef( i ); SbxVariable* pVar = r; @@ -974,7 +974,7 @@ void SbxObject::Dump( SvStream& rStrm, BOOL bFill ) // Properties rStrm << aIndentNameStr.GetBuffer() << "- Properties:" << endl; { - for( USHORT i = 0; i < pProps->Count(); i++ ) + for( sal_uInt16 i = 0; i < pProps->Count(); i++ ) { SbxVariableRef& r = pProps->GetRef( i ); SbxVariable* pVar = r; @@ -1008,7 +1008,7 @@ void SbxObject::Dump( SvStream& rStrm, BOOL bFill ) // Objects rStrm << aIndentNameStr.GetBuffer() << "- Objects:" << endl; { - for( USHORT i = 0; i < pObjs->Count(); i++ ) + for( sal_uInt16 i = 0; i < pObjs->Count(); i++ ) { SbxVariableRef& r = pObjs->GetRef( i ); SbxVariable* pVar = r; @@ -1032,7 +1032,7 @@ SvDispatch* SbxObject::GetSvDispatch() return NULL; } -BOOL SbxMethod::Run( SbxValues* pValues ) +sal_Bool SbxMethod::Run( SbxValues* pValues ) { SbxValues aRes; if( !pValues ) @@ -1051,7 +1051,7 @@ SbxClassType SbxProperty::GetClass() const return SbxCLASS_PROPERTY; } -void SbxObject::GarbageCollection( ULONG nObjects ) +void SbxObject::GarbageCollection( sal_uIntPtr nObjects ) /* [Beschreibung] @@ -1066,14 +1066,14 @@ void SbxObject::GarbageCollection( ULONG nObjects ) { (void)nObjects; - static BOOL bInGarbageCollection = FALSE; + static sal_Bool bInGarbageCollection = sal_False; if ( bInGarbageCollection ) return; - bInGarbageCollection = TRUE; + bInGarbageCollection = sal_True; #if 0 // erstes Object dieser Runde anspringen - BOOL bAll = !nObjects; + sal_Bool bAll = !nObjects; if ( bAll ) rObjects.First(); SbxObject *pObj = rObjects.GetCurObject(); @@ -1088,7 +1088,7 @@ void SbxObject::GarbageCollection( ULONG nObjects ) { // dann alle Properies des Objects durchsuchen SbxArray *pProps = pObj->GetProperties(); - for ( USHORT n = 0; n < pProps->Count(); ++n ) + for ( sal_uInt16 n = 0; n < pProps->Count(); ++n ) { // verweist die Property auf den Parent des Object? SbxVariable *pProp = pProps->Get(n); @@ -1126,12 +1126,12 @@ void SbxObject::GarbageCollection( ULONG nObjects ) if ( rVars.Count() > 200 && rVars.Count() < 210 ) { SvFileStream aStream( "d:\\tmp\\dump.sbx", STREAM_STD_WRITE ); - SfxBroadcaster::Enable(FALSE); - for ( ULONG n = 0; n < rVars.Count(); ++n ) + SfxBroadcaster::Enable(sal_False); + for ( sal_uIntPtr n = 0; n < rVars.Count(); ++n ) { SbxVariable *pVar = rVars.GetObject(n); SbxObject *pObj = PTR_CAST(SbxObject, pVar); - USHORT nFlags = pVar->GetFlags(); + sal_uInt16 nFlags = pVar->GetFlags(); pVar->SetFlag(SBX_NO_BROADCAST); if ( pObj ) pObj->Dump(aStream); @@ -1139,10 +1139,10 @@ void SbxObject::GarbageCollection( ULONG nObjects ) pVar->Dump(aStream); pVar->SetFlags(nFlags); } - SfxBroadcaster::Enable(TRUE); + SfxBroadcaster::Enable(sal_True); } #endif #endif - bInGarbageCollection = FALSE; + bInGarbageCollection = sal_False; } diff --git a/basic/source/sbx/sbxres.cxx b/basic/source/sbx/sbxres.cxx index 369349e72069..ec1e1f4c900e 100644 --- a/basic/source/sbx/sbxres.cxx +++ b/basic/source/sbx/sbxres.cxx @@ -80,12 +80,12 @@ static const char* pSbxRes[] = { "True" }; -const char* GetSbxRes( USHORT nId ) +const char* GetSbxRes( sal_uInt16 nId ) { return ( ( nId > SBXRES_MAX ) ? "???" : pSbxRes[ nId ] ); } -SbxRes::SbxRes( USHORT nId ) +SbxRes::SbxRes( sal_uInt16 nId ) : ::rtl::OUString( ::rtl::OUString::createFromAscii( GetSbxRes( nId ) ) ) {} diff --git a/basic/source/sbx/sbxres.hxx b/basic/source/sbx/sbxres.hxx index 8ed3c7054278..75fddc0d90fe 100644 --- a/basic/source/sbx/sbxres.hxx +++ b/basic/source/sbx/sbxres.hxx @@ -78,10 +78,10 @@ class SbxRes : public ::rtl::OUString { public: - SbxRes( USHORT ); + SbxRes( sal_uInt16 ); }; -const char* GetSbxRes( USHORT ); +const char* GetSbxRes( sal_uInt16 ); #endif diff --git a/basic/source/sbx/sbxscan.cxx b/basic/source/sbx/sbxscan.cxx index b8aad9bbf2e4..d1bf716234a8 100644 --- a/basic/source/sbx/sbxscan.cxx +++ b/basic/source/sbx/sbxscan.cxx @@ -72,7 +72,7 @@ void ImpGetIntntlSep( sal_Unicode& rcDecimalSep, sal_Unicode& rcThousandSep ) // Fixed ist und das ganze nicht hineinpasst! SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType, - USHORT* pLen, BOOL bAllowIntntl, BOOL bOnlyIntntl ) + sal_uInt16* pLen, sal_Bool bAllowIntntl, sal_Bool bOnlyIntntl ) { ::rtl::OString aBStr( ::rtl::OUStringToOString( rWSrc, RTL_TEXTENCODING_ASCII_US ) ); @@ -103,15 +103,15 @@ SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType const char* pStart = aBStr.getStr(); const char* p = pStart; char buf[ 80 ], *q = buf; - BOOL bRes = TRUE; - BOOL bMinus = FALSE; + sal_Bool bRes = sal_True; + sal_Bool bMinus = sal_False; nVal = 0; SbxDataType eScanType = SbxSINGLE; // Whitespace wech while( *p &&( *p == ' ' || *p == '\t' ) ) p++; // Zahl? Dann einlesen und konvertieren. if( *p == '-' ) - p++, bMinus = TRUE; + p++, bMinus = sal_True; if( isdigit( *p ) ||( (*p == cNonIntntlComma || *p == cIntntlComma || *p == cIntntl1000) && isdigit( *(p+1 ) ) ) ) { @@ -172,7 +172,7 @@ SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType *q = 0; // Komma, Exponent mehrfach vorhanden? if( comma > 1 || exp > 1 ) - bRes = FALSE; + bRes = sal_False; // Kann auf Integer gefaltet werden? if( !comma && !exp ) { @@ -204,7 +204,7 @@ SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType { case 'O': cmp = "01234567"; base = 8; ndig = 11; break; case 'H': break; - default : bRes = FALSE; + default : bRes = sal_False; } long l = 0; int i; @@ -213,7 +213,7 @@ SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType char ch = sal::static_int_cast< char >( toupper( *p ) ); p++; if( strchr( cmp, ch ) ) *q++ = ch; - else bRes = FALSE; + else bRes = sal_False; } *q = 0; for( q = buf; *q; q++ ) @@ -222,7 +222,7 @@ SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType if( i > 9 ) i -= 7; l =( l * base ) + i; if( !ndig-- ) - bRes = FALSE; + bRes = sal_False; } if( *p == '&' ) p++; nVal = (double) l; @@ -235,7 +235,7 @@ SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType return SbxERR_CONVERSION; } if( pLen ) - *pLen = (USHORT) ( p - pStart ); + *pLen = (sal_uInt16) ( p - pStart ); if( !bRes ) return SbxERR_CONVERSION; if( bMinus ) @@ -245,12 +245,12 @@ SbxError ImpScan( const ::rtl::OUString& rWSrc, double& nVal, SbxDataType& rType } // Schnittstelle fuer CDbl im Basic -SbxError SbxValue::ScanNumIntnl( const String& rSrc, double& nVal, BOOL bSingle ) +SbxError SbxValue::ScanNumIntnl( const String& rSrc, double& nVal, sal_Bool bSingle ) { SbxDataType t; - USHORT nLen = 0; + sal_uInt16 nLen = 0; SbxError nRetError = ImpScan( rSrc, nVal, t, &nLen, - /*bAllowIntntl*/FALSE, /*bOnlyIntntl*/TRUE ); + /*bAllowIntntl*/sal_False, /*bOnlyIntntl*/sal_True ); // Komplett gelesen? if( nRetError == SbxERR_OK && nLen != rSrc.Len() ) nRetError = SbxERR_CONVERSION; @@ -271,20 +271,20 @@ static double roundArray[] = { /*************************************************************************** |* -|* void myftoa( double, char *, short, short, BOOL, BOOL ) +|* void myftoa( double, char *, short, short, sal_Bool, sal_Bool ) |* |* Beschreibung: Konversion double --> ASCII |* Parameter: double die Zahl. |* char * der Zielpuffer |* short Anzahl Nachkommastellen |* short Weite des Exponenten( 0=kein E ) -|* BOOL TRUE: mit 1000er Punkten -|* BOOL TRUE: formatfreie Ausgabe +|* sal_Bool sal_True: mit 1000er Punkten +|* sal_Bool sal_True: formatfreie Ausgabe |* ***************************************************************************/ static void myftoa( double nNum, char * pBuf, short nPrec, short nExpWidth, - BOOL bPt, BOOL bFix, sal_Unicode cForceThousandSep = 0 ) + sal_Bool bPt, sal_Bool bFix, sal_Unicode cForceThousandSep = 0 ) { short nExp = 0; // Exponent @@ -391,7 +391,7 @@ static void myftoa( double nNum, char * pBuf, short nPrec, short nExpWidth, #pragma warning(disable: 4748) // "... because optimizations are disabled ..." #endif -void ImpCvtNum( double nNum, short nPrec, ::rtl::OUString& rRes, BOOL bCoreString ) +void ImpCvtNum( double nNum, short nPrec, ::rtl::OUString& rRes, sal_Bool bCoreString ) { char *q; char cBuf[ 40 ], *p = cBuf; @@ -407,7 +407,7 @@ void ImpCvtNum( double nNum, short nPrec, ::rtl::OUString& rRes, BOOL bCoreStrin } double dMaxNumWithoutExp = (nPrec == 6) ? 1E6 : 1E14; myftoa( nNum, p, nPrec,( nNum &&( nNum < 1E-1 || nNum > dMaxNumWithoutExp ) ) ? 4:0, - FALSE, TRUE, cDecimalSep ); + sal_False, sal_True, cDecimalSep ); // Trailing Zeroes weg: for( p = cBuf; *p &&( *p != 'E' ); p++ ) {} q = p; p--; @@ -422,10 +422,10 @@ void ImpCvtNum( double nNum, short nPrec, ::rtl::OUString& rRes, BOOL bCoreStrin #pragma optimize( "", on ) #endif -BOOL ImpConvStringExt( ::rtl::OUString& rSrc, SbxDataType eTargetType ) +sal_Bool ImpConvStringExt( ::rtl::OUString& rSrc, SbxDataType eTargetType ) { // Merken, ob ueberhaupt was geaendert wurde - BOOL bChanged = FALSE; + sal_Bool bChanged = sal_False; ::rtl::OUString aNewString; // Nur Spezial-Flle behandeln, als Default tun wir nichts @@ -451,25 +451,25 @@ BOOL ImpConvStringExt( ::rtl::OUString& rSrc, SbxDataType eTargetType ) { sal_Unicode* pStr = (sal_Unicode*)aNewString.getStr(); pStr[nPos] = (sal_Unicode)'.'; - bChanged = TRUE; + bChanged = sal_True; } } break; } - // Bei BOOL TRUE und FALSE als String pruefen + // Bei sal_Bool sal_True und sal_False als String pruefen case SbxBOOL: { if( rSrc.equalsIgnoreAsciiCaseAscii( "true" ) ) { aNewString = ::rtl::OUString::valueOf( (sal_Int32)SbxTRUE ); - bChanged = TRUE; + bChanged = sal_True; } else if( rSrc.equalsIgnoreAsciiCaseAscii( "false" ) ) { aNewString = ::rtl::OUString::valueOf( (sal_Int32)SbxFALSE ); - bChanged = TRUE; + bChanged = sal_True; } break; } @@ -490,7 +490,7 @@ BOOL ImpConvStringExt( ::rtl::OUString& rSrc, SbxDataType eTargetType ) // lasse diesen Code vorl"aufig drin, zum 'abgucken' // der bisherigen Implementation -static USHORT printfmtnum( double nNum, XubString& rRes, const XubString& rWFmt ) +static sal_uInt16 printfmtnum( double nNum, XubString& rRes, const XubString& rWFmt ) { const String& rFmt = rWFmt; char cFill = ' '; // Fuellzeichen @@ -499,10 +499,10 @@ static USHORT printfmtnum( double nNum, XubString& rRes, const XubString& rWFmt short nPrec = 0; // Anzahl Nachkommastellen short nWidth = 0; // Zahlenweite gesamnt short nLen; // Laenge konvertierte Zahl - BOOL bPoint = FALSE; // TRUE: mit 1000er Kommas - BOOL bTrail = FALSE; // TRUE, wenn folgendes Minus - BOOL bSign = FALSE; // TRUE: immer mit Vorzeichen - BOOL bNeg = FALSE; // TRUE: Zahl ist negativ + sal_Bool bPoint = sal_False; // sal_True: mit 1000er Kommas + sal_Bool bTrail = sal_False; // sal_True, wenn folgendes Minus + sal_Bool bSign = sal_False; // sal_True: immer mit Vorzeichen + sal_Bool bNeg = sal_False; // sal_True: Zahl ist negativ char cBuf [1024]; // Zahlenpuffer char * p; const char* pFmt = rFmt; @@ -518,7 +518,7 @@ static USHORT printfmtnum( double nNum, XubString& rRes, const XubString& rWFmt case 0: break; case '+': - bSign = TRUE; nWidth++; break; + bSign = sal_True; nWidth++; break; case '*': nWidth++; cFill = '*'; if( *pFmt == '$' ) nWidth++, pFmt++, cPre = '$'; @@ -537,7 +537,7 @@ static USHORT printfmtnum( double nNum, XubString& rRes, const XubString& rWFmt // 1000er Kommas? if( *pFmt == ',' ) { - nWidth++; pFmt++; bPoint = TRUE; + nWidth++; pFmt++; bPoint = sal_True; } else break; } // Nachkomma: @@ -551,14 +551,14 @@ static USHORT printfmtnum( double nNum, XubString& rRes, const XubString& rWFmt pFmt++, nExpDig++, nWidth++; // Folgendes Minus: if( !bSign && *pFmt == '-' ) - pFmt++, bTrail = TRUE; + pFmt++, bTrail = sal_True; // Zahl konvertieren: if( nPrec > 15 ) nPrec = 15; - if( nNum < 0.0 ) nNum = -nNum, bNeg = TRUE; + if( nNum < 0.0 ) nNum = -nNum, bNeg = sal_True; p = cBuf; if( bSign ) *p++ = bNeg ? '-' : '+'; - myftoa( nNum, p, nPrec, nExpDig, bPoint, FALSE ); + myftoa( nNum, p, nPrec, nExpDig, bPoint, sal_False ); nLen = strlen( cBuf ); // Ueberlauf? @@ -573,12 +573,12 @@ static USHORT printfmtnum( double nNum, XubString& rRes, const XubString& rWFmt if( bTrail ) rRes += bNeg ? '-' : ' '; - return (USHORT) ( pFmt - (const char*) rFmt ); + return (sal_uInt16) ( pFmt - (const char*) rFmt ); } #endif //_old_format_code_ -static USHORT printfmtstr( const XubString& rStr, XubString& rRes, const XubString& rFmt ) +static sal_uInt16 printfmtstr( const XubString& rStr, XubString& rRes, const XubString& rFmt ) { const xub_Unicode* pStr = rStr.GetBuffer(); const xub_Unicode* pFmtStart = rFmt.GetBuffer(); @@ -603,12 +603,12 @@ static USHORT printfmtstr( const XubString& rStr, XubString& rRes, const XubStri rRes = rStr; break; } - return (USHORT) ( pFmt - pFmtStart ); + return (sal_uInt16) ( pFmt - pFmtStart ); } ///////////////////////////////////////////////////////////////////////// -BOOL SbxValue::Scan( const XubString& rSrc, USHORT* pLen ) +sal_Bool SbxValue::Scan( const XubString& rSrc, sal_uInt16* pLen ) { SbxError eRes = SbxERR_OK; if( !CanWrite() ) @@ -627,10 +627,10 @@ BOOL SbxValue::Scan( const XubString& rSrc, USHORT* pLen ) } if( eRes ) { - SetError( eRes ); return FALSE; + SetError( eRes ); return sal_False; } else - return TRUE; + return sal_True; } @@ -648,7 +648,7 @@ ResMgr* implGetResMgr( void ) class SbxValueFormatResId : public ResId { public: - SbxValueFormatResId( USHORT nId ) + SbxValueFormatResId( sal_uInt16 nId ) : ResId( nId, *implGetResMgr() ) {} }; @@ -693,7 +693,7 @@ static VbaFormatInfo pFormatInfoTable[] = VbaFormatInfo* getFormatInfo( const String& rFmt ) { VbaFormatInfo* pInfo = NULL; - INT16 i = 0; + sal_Int16 i = 0; while( (pInfo = pFormatInfoTable + i )->mpVbaFormat != NULL ) { if( rFmt.EqualsIgnoreCaseAscii( pInfo->mpVbaFormat ) ) @@ -713,11 +713,11 @@ VbaFormatInfo* getFormatInfo( const String& rFmt ) #define VBAFORMAT_UPPERCASE ">" // From methods1.cxx -INT16 implGetWeekDay( double aDate, bool bFirstDayParam = false, INT16 nFirstDay = 0 ); +sal_Int16 implGetWeekDay( double aDate, bool bFirstDayParam = false, sal_Int16 nFirstDay = 0 ); // from methods.cxx -INT16 implGetMinute( double dDate ); -INT16 implGetDateYear( double aDate ); -BOOL implDateSerial( INT16 nYear, INT16 nMonth, INT16 nDay, double& rdRet ); +sal_Int16 implGetMinute( double dDate ); +sal_Int16 implGetDateYear( double aDate ); +sal_Bool implDateSerial( sal_Int16 nYear, sal_Int16 nMonth, sal_Int16 nDay, double& rdRet ); void SbxValue::Format( XubString& rRes, const XubString* pFmt ) const { @@ -753,7 +753,7 @@ void SbxValue::Format( XubString& rRes, const XubString* pFmt ) const double nNumber; Color* pCol; - BOOL bSuccess = aFormatter.IsNumberFormat( aStr, nIndex, nNumber ); + sal_Bool bSuccess = aFormatter.IsNumberFormat( aStr, nIndex, nNumber ); // number format, use SvNumberFormatter to handle it. if( bSuccess ) @@ -804,7 +804,7 @@ void SbxValue::Format( XubString& rRes, const XubString* pFmt ) const else if( aFmtStr.EqualsIgnoreCaseAscii( VBAFORMAT_N ) || aFmtStr.EqualsIgnoreCaseAscii( VBAFORMAT_NN )) { - INT32 nMin = implGetMinute( nNumber ); + sal_Int32 nMin = implGetMinute( nNumber ); if( nMin < 10 && aFmtStr.EqualsIgnoreCaseAscii( VBAFORMAT_NN ) ) { // Minute in two digits @@ -819,15 +819,15 @@ void SbxValue::Format( XubString& rRes, const XubString* pFmt ) const } else if( aFmtStr.EqualsIgnoreCaseAscii( VBAFORMAT_W )) { - INT32 nWeekDay = implGetWeekDay( nNumber ); + sal_Int32 nWeekDay = implGetWeekDay( nNumber ); rRes = String::CreateFromInt32( nWeekDay ); } else if( aFmtStr.EqualsIgnoreCaseAscii( VBAFORMAT_Y )) { - INT16 nYear = implGetDateYear( nNumber ); + sal_Int16 nYear = implGetDateYear( nNumber ); double dBaseDate; implDateSerial( nYear, 1, 1, dBaseDate ); - INT32 nYear32 = 1 + INT32( nNumber - dBaseDate ); + sal_Int32 nYear32 = 1 + sal_Int32( nNumber - dBaseDate ); rRes = String::CreateFromInt32( nYear32 ); } else @@ -948,7 +948,7 @@ void SbxValue::Format( XubString& rRes, const XubString* pFmt ) const // #45355 wenn es numerisch ist, muss gewandelt werden if( IsNumericRTL() ) { - ScanNumIntnl( GetString(), d, /*bSingle*/FALSE ); + ScanNumIntnl( GetString(), d, /*bSingle*/sal_False ); goto cvt2; } else diff --git a/basic/source/sbx/sbxsng.cxx b/basic/source/sbx/sbxsng.cxx index 70ef1653666b..50313cfe1780 100644 --- a/basic/source/sbx/sbxsng.cxx +++ b/basic/source/sbx/sbxsng.cxx @@ -270,7 +270,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pByte = (BYTE) n; break; + *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: if( n > SbxMAXINT ) @@ -281,7 +281,7 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMININT; } - *p->pInteger = (INT16) n; break; + *p->pInteger = (sal_Int16) n; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: if( n > SbxMAXUINT ) @@ -292,10 +292,10 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = 0; } - *p->pUShort = (UINT16) n; break; + *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: { - INT32 i; + sal_Int32 i; if( n > SbxMAXLNG ) { SbxBase::SetError( SbxERR_OVERFLOW ); i = SbxMAXLNG; @@ -306,13 +306,13 @@ start: } else { - i = sal::static_int_cast< INT32 >(n); + i = sal::static_int_cast< sal_Int32 >(n); } *p->pLong = i; break; } case SbxBYREF | SbxULONG: { - UINT32 i; + sal_uInt32 i; if( n > SbxMAXULNG ) { SbxBase::SetError( SbxERR_OVERFLOW ); i = SbxMAXULNG; @@ -323,7 +323,7 @@ start: } else { - i = sal::static_int_cast< UINT32 >(n); + i = sal::static_int_cast< sal_uInt32 >(n); } *p->pULong = i; break; } diff --git a/basic/source/sbx/sbxstr.cxx b/basic/source/sbx/sbxstr.cxx index b4156a116ddc..3a73c2757579 100644 --- a/basic/source/sbx/sbxstr.cxx +++ b/basic/source/sbx/sbxstr.cxx @@ -154,9 +154,9 @@ using namespace rtl; XubString aRes; aTmp.eType = SbxSTRING; if( p->eType == SbxDOUBLE ) - ImpPutDouble( &aTmp, p->nDouble, /*bCoreString=*/TRUE ); + ImpPutDouble( &aTmp, p->nDouble, /*bCoreString=*/sal_True ); else - ImpPutDouble( &aTmp, *p->pDouble, /*bCoreString=*/TRUE ); + ImpPutDouble( &aTmp, *p->pDouble, /*bCoreString=*/sal_True ); return aRes; } else @@ -234,7 +234,7 @@ void ImpPutString( SbxValues* p, const ::rtl::OUString* n ) case SbxBYREF | SbxINTEGER: *p->pInteger = ImpGetInteger( p ); break; case SbxBYREF | SbxBOOL: - *p->pUShort = sal::static_int_cast< UINT16 >( ImpGetBool( p ) ); + *p->pUShort = sal::static_int_cast< sal_uInt16 >( ImpGetBool( p ) ); break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: @@ -276,10 +276,10 @@ SbxArray* StringToByteArray(const ::rtl::OUString& rStr) pArray->unoAddDim( 0, -1 ); } - for( USHORT i=0; i< nArraySize; i++) + for( sal_uInt16 i=0; i< nArraySize; i++) { SbxVariable* pNew = new SbxVariable( SbxBYTE ); - BYTE aByte = static_cast< BYTE >( i%2 ? ((*pSrc) >> 8) & 0xff : (*pSrc) & 0xff ); + sal_uInt8 aByte = static_cast< sal_uInt8 >( i%2 ? ((*pSrc) >> 8) & 0xff : (*pSrc) & 0xff ); pNew->PutByte( aByte ); pNew->SetFlag( SBX_WRITE ); pArray->Put( pNew, i ); @@ -292,10 +292,10 @@ SbxArray* StringToByteArray(const ::rtl::OUString& rStr) // Convert an array of bytes to string (2bytes per character) ::rtl::OUString ByteArrayToString(SbxArray* pArr) { - USHORT nCount = pArr->Count(); + sal_uInt16 nCount = pArr->Count(); OUStringBuffer aStrBuf; sal_Unicode aChar = 0; - for( USHORT i = 0 ; i < nCount ; i++ ) + for( sal_uInt16 i = 0 ; i < nCount ; i++ ) { sal_Unicode aTempChar = pArr->Get(i)->GetByte(); if( i%2 ) diff --git a/basic/source/sbx/sbxuint.cxx b/basic/source/sbx/sbxuint.cxx index 5b75a24d6d26..6bfc0c39d260 100644 --- a/basic/source/sbx/sbxuint.cxx +++ b/basic/source/sbx/sbxuint.cxx @@ -31,10 +31,10 @@ #include <basic/sbx.hxx> #include "sbxconv.hxx" -UINT16 ImpGetUShort( const SbxValues* p ) +sal_uInt16 ImpGetUShort( const SbxValues* p ) { SbxValues aTmp; - UINT16 nRes; + sal_uInt16 nRes; start: switch( +p->eType ) { @@ -70,7 +70,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; } else - nRes = (UINT16) p->nLong; + nRes = (sal_uInt16) p->nLong; break; case SbxULONG: if( p->nULong > SbxMAXUINT ) @@ -78,7 +78,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXUINT; } else - nRes = (UINT16) p->nULong; + nRes = (sal_uInt16) p->nULong; break; case SbxSALINT64: if( p->nInt64 > SbxMAXUINT ) @@ -90,7 +90,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; } else - nRes = (UINT16) p->nInt64; + nRes = (sal_uInt16) p->nInt64; break; case SbxSALUINT64: if( p->uInt64 > SbxMAXUINT ) @@ -98,7 +98,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = SbxMAXUINT; } else - nRes = (UINT16) p->uInt64; + nRes = (sal_uInt16) p->uInt64; break; case SbxSINGLE: if( p->nSingle > SbxMAXUINT ) @@ -110,7 +110,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; } else - nRes = (UINT16) ( p->nSingle + 0.5 ); + nRes = (sal_uInt16) ( p->nSingle + 0.5 ); break; case SbxDATE: case SbxDOUBLE: @@ -145,7 +145,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; } else - nRes = (UINT16) ( dVal + 0.5 ); + nRes = (sal_uInt16) ( dVal + 0.5 ); break; } case SbxBYREF | SbxSTRING: @@ -168,7 +168,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; } else - nRes = (UINT16) ( d + 0.5 ); + nRes = (sal_uInt16) ( d + 0.5 ); } break; case SbxOBJECT: @@ -223,7 +223,7 @@ start: return nRes; } -void ImpPutUShort( SbxValues* p, UINT16 n ) +void ImpPutUShort( SbxValues* p, sal_uInt16 n ) { SbxValues aTmp; @@ -293,14 +293,14 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXBYTE; } - *p->pByte = (BYTE) n; break; + *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: if( n > SbxMAXINT ) { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXINT; } - *p->pInteger = (INT16) n; break; + *p->pInteger = (sal_Int16) n; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: *p->pUShort = n; break; diff --git a/basic/source/sbx/sbxulng.cxx b/basic/source/sbx/sbxulng.cxx index e0f6f3fa421d..7322863f3475 100644 --- a/basic/source/sbx/sbxulng.cxx +++ b/basic/source/sbx/sbxulng.cxx @@ -31,10 +31,10 @@ #include <basic/sbx.hxx> #include "sbxconv.hxx" -UINT32 ImpGetULong( const SbxValues* p ) +sal_uInt32 ImpGetULong( const SbxValues* p ) { SbxValues aTmp; - UINT32 nRes; + sal_uInt32 nRes; start: switch( +p->eType ) { @@ -80,7 +80,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; } else - nRes = (UINT32) ( p->nSingle + 0.5 ); + nRes = (sal_uInt32) ( p->nSingle + 0.5 ); break; case SbxDATE: case SbxDOUBLE: @@ -121,7 +121,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; } else - nRes = (UINT32) ( dVal + 0.5 ); + nRes = (sal_uInt32) ( dVal + 0.5 ); break; } case SbxBYREF | SbxSTRING: @@ -144,7 +144,7 @@ start: SbxBase::SetError( SbxERR_OVERFLOW ); nRes = 0; } else - nRes = (UINT32) ( d + 0.5 ); + nRes = (sal_uInt32) ( d + 0.5 ); } break; case SbxOBJECT: @@ -199,7 +199,7 @@ start: return nRes; } -void ImpPutULong( SbxValues* p, UINT32 n ) +void ImpPutULong( SbxValues* p, sal_uInt32 n ) { SbxValues aTmp; start: @@ -270,27 +270,27 @@ start: { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXBYTE; } - *p->pByte = (BYTE) n; break; + *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: if( n > SbxMAXINT ) { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXINT; } - *p->pInteger = (INT16) n; break; + *p->pInteger = (sal_Int16) n; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: if( n > SbxMAXUINT ) { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXUINT; } - *p->pUShort = (UINT16) n; break; + *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: if( n > SbxMAXLNG ) { SbxBase::SetError( SbxERR_OVERFLOW ); n = SbxMAXLNG; } - *p->pLong = (INT32) n; break; + *p->pLong = (sal_Int32) n; break; case SbxBYREF | SbxULONG: *p->pULong = n; break; case SbxBYREF | SbxSINGLE: diff --git a/basic/source/sbx/sbxvals.cxx b/basic/source/sbx/sbxvals.cxx index e63a352879ed..71a3bfc7f0d8 100644 --- a/basic/source/sbx/sbxvals.cxx +++ b/basic/source/sbx/sbxvals.cxx @@ -48,21 +48,21 @@ SbxValues::SbxValues( const BigInt &rBig ) : eType(SbxCURRENCY) #pragma warning(disable: 4273) #endif -BOOL BigInt::INT64( SbxINT64 *p ) const +sal_Bool BigInt::INT64( SbxINT64 *p ) const { if( bIsBig ) { if( nLen > 4 || (nNum[3] & 0x8000) ) - return FALSE; + return sal_False; - p->nLow = ((UINT32)nNum[1] << 16) | (UINT32)nNum[0]; - p->nHigh = ((UINT32)nNum[3] << 16) | (UINT32)nNum[2]; + p->nLow = ((sal_uInt32)nNum[1] << 16) | (sal_uInt32)nNum[0]; + p->nHigh = ((sal_uInt32)nNum[3] << 16) | (sal_uInt32)nNum[2]; if( bIsNeg ) p->CHS(); } else - p->Set( (INT32)nVal ); + p->Set( (sal_Int32)nVal ); - return TRUE; + return sal_True; } BigInt::BigInt( const SbxINT64 &r ) @@ -72,28 +72,28 @@ BigInt::BigInt( const SbxINT64 &r ) *this = r.nHigh; if( r.nHigh ) *this *= a10000; - *this += (USHORT)(r.nLow >> 16); + *this += (sal_uInt16)(r.nLow >> 16); *this *= a10000; - *this += (USHORT)r.nLow; + *this += (sal_uInt16)r.nLow; } -BOOL BigInt::UINT64( SbxUINT64 *p ) const +sal_Bool BigInt::UINT64( SbxUINT64 *p ) const { if( bIsBig ) { if( bIsNeg || nLen > 4 ) - return FALSE; + return sal_False; - p->nLow = ((UINT32)nNum[1] << 16) | (UINT32)nNum[0]; - p->nHigh = ((UINT32)nNum[3] << 16) | (UINT32)nNum[2]; + p->nLow = ((sal_uInt32)nNum[1] << 16) | (sal_uInt32)nNum[0]; + p->nHigh = ((sal_uInt32)nNum[3] << 16) | (sal_uInt32)nNum[2]; } else { if( nVal < 0 ) - return FALSE; + return sal_False; - p->Set( (UINT32)nVal ); + p->Set( (sal_uInt32)nVal ); } - return TRUE; + return sal_True; } BigInt::BigInt( const SbxUINT64 &r ) @@ -103,7 +103,7 @@ BigInt::BigInt( const SbxUINT64 &r ) *this = BigInt(r.nHigh); if( r.nHigh ) *this *= a10000; - *this += (USHORT)(r.nLow >> 16); + *this += (sal_uInt16)(r.nLow >> 16); *this *= a10000; - *this += (USHORT)r.nLow; + *this += (sal_uInt16)r.nLow; } diff --git a/basic/source/sbx/sbxvalue.cxx b/basic/source/sbx/sbxvalue.cxx index a5e80e8921c6..d7a3e27603ab 100755 --- a/basic/source/sbx/sbxvalue.cxx +++ b/basic/source/sbx/sbxvalue.cxx @@ -202,7 +202,7 @@ int matherr( struct _exception* p ) #endif default: SbxBase::SetError( SbxERR_NOTIMP ); break; } - return TRUE; + return sal_True; } #endif @@ -228,21 +228,21 @@ SbxValue::SbxValue( SbxDataType t, void* p ) : SbxBase() if( p ) switch( t & 0x0FFF ) { - case SbxINTEGER: n |= SbxBYREF; aData.pInteger = (INT16*) p; break; + case SbxINTEGER: n |= SbxBYREF; aData.pInteger = (sal_Int16*) p; break; case SbxULONG64: n |= SbxBYREF; aData.pULong64 = (SbxUINT64*) p; break; case SbxLONG64: case SbxCURRENCY: n |= SbxBYREF; aData.pLong64 = (SbxINT64*) p; break; - case SbxLONG: n |= SbxBYREF; aData.pLong = (INT32*) p; break; + case SbxLONG: n |= SbxBYREF; aData.pLong = (sal_Int32*) p; break; case SbxSINGLE: n |= SbxBYREF; aData.pSingle = (float*) p; break; case SbxDATE: case SbxDOUBLE: n |= SbxBYREF; aData.pDouble = (double*) p; break; case SbxSTRING: n |= SbxBYREF; aData.pOUString = (::rtl::OUString*) p; break; case SbxERROR: case SbxUSHORT: - case SbxBOOL: n |= SbxBYREF; aData.pUShort = (UINT16*) p; break; - case SbxULONG: n |= SbxBYREF; aData.pULong = (UINT32*) p; break; + case SbxBOOL: n |= SbxBYREF; aData.pUShort = (sal_uInt16*) p; break; + case SbxULONG: n |= SbxBYREF; aData.pULong = (sal_uInt32*) p; break; case SbxCHAR: n |= SbxBYREF; aData.pChar = (xub_Unicode*) p; break; - case SbxBYTE: n |= SbxBYREF; aData.pByte = (BYTE*) p; break; + case SbxBYTE: n |= SbxBYREF; aData.pByte = (sal_uInt8*) p; break; case SbxINT: n |= SbxBYREF; aData.pInt = (int*) p; break; case SbxOBJECT: aData.pObj = (SbxBase*) p; @@ -363,8 +363,8 @@ SbxValue::~SbxValue() { HACK(nicht bei Parent-Prop - sonst CyclicRef) SbxVariable *pThisVar = PTR_CAST(SbxVariable, this); - BOOL bParentProp = pThisVar && 5345 == - ( (INT16) ( pThisVar->GetUserData() & 0xFFFF ) ); + sal_Bool bParentProp = pThisVar && 5345 == + ( (sal_Int16) ( pThisVar->GetUserData() & 0xFFFF ) ); if ( !bParentProp ) aData.pObj->ReleaseRef(); } @@ -394,8 +394,8 @@ void SbxValue::Clear() { HACK(nicht bei Parent-Prop - sonst CyclicRef) SbxVariable *pThisVar = PTR_CAST(SbxVariable, this); - BOOL bParentProp = pThisVar && 5345 == - ( (INT16) ( pThisVar->GetUserData() & 0xFFFF ) ); + sal_Bool bParentProp = pThisVar && 5345 == + ( (sal_Int16) ( pThisVar->GetUserData() & 0xFFFF ) ); if ( !bParentProp ) aData.pObj->ReleaseRef(); } @@ -420,7 +420,7 @@ void SbxValue::Clear() // Dummy -void SbxValue::Broadcast( ULONG ) +void SbxValue::Broadcast( sal_uIntPtr ) {} //////////////////////////// Daten auslesen ////////////////////////////// @@ -432,13 +432,13 @@ void SbxValue::Broadcast( ULONG ) SbxValue* SbxValue::TheRealValue() const { - return TheRealValue( TRUE ); + return TheRealValue( sal_True ); } // #55226 Zusaetzliche Info transportieren bool handleToStringForCOMObjects( SbxObject* pObj, SbxValue* pVal ); // sbunoobj.cxx -SbxValue* SbxValue::TheRealValue( BOOL bObjInObjError ) const +SbxValue* SbxValue::TheRealValue( sal_Bool bObjInObjError ) const { SbxValue* p = (SbxValue*) this; for( ;; ) @@ -511,9 +511,9 @@ SbxValue* SbxValue::TheRealValue( BOOL bObjInObjError ) const return p; } -BOOL SbxValue::Get( SbxValues& rRes ) const +sal_Bool SbxValue::Get( SbxValues& rRes ) const { - BOOL bRes = FALSE; + sal_Bool bRes = sal_False; SbxError eOld = GetError(); if( eOld != SbxERR_OK ) ResetError(); @@ -548,7 +548,7 @@ BOOL SbxValue::Get( SbxValues& rRes ) const case SbxDECIMAL: rRes.pDecimal = ImpGetDecimal( &p->aData ); break; case SbxDATE: rRes.nDouble = ImpGetDate( &p->aData ); break; case SbxBOOL: - rRes.nUShort = sal::static_int_cast< UINT16 >( + rRes.nUShort = sal::static_int_cast< sal_uInt16 >( ImpGetBool( &p->aData ) ); break; case SbxCHAR: rRes.nChar = ImpGetChar( &p->aData ); break; @@ -603,18 +603,18 @@ BOOL SbxValue::Get( SbxValues& rRes ) const } if( !IsError() ) { - bRes = TRUE; + bRes = sal_True; if( eOld != SbxERR_OK ) SetError( eOld ); } return bRes; } -BOOL SbxValue::GetNoBroadcast( SbxValues& rRes ) +sal_Bool SbxValue::GetNoBroadcast( SbxValues& rRes ) { - USHORT nFlags_ = GetFlags(); + sal_uInt16 nFlags_ = GetFlags(); SetFlag( SBX_NO_BROADCAST ); - BOOL bRes = Get( rRes ); + sal_Bool bRes = Get( rRes ); SetFlags( nFlags_ ); return bRes; } @@ -654,7 +654,7 @@ const XubString& SbxValue::GetCoreString() const return aResult; } -BOOL SbxValue::HasObject() const +sal_Bool SbxValue::HasObject() const { ErrCode eErr = GetError(); SbxValues aRes; @@ -664,33 +664,33 @@ BOOL SbxValue::HasObject() const return 0 != aRes.pObj; } -BOOL SbxValue::GetBool() const +sal_Bool SbxValue::GetBool() const { SbxValues aRes; aRes.eType = SbxBOOL; Get( aRes ); - return BOOL( aRes.nUShort != 0 ); + return sal_Bool( aRes.nUShort != 0 ); } #define GET( g, e, t, m ) \ t SbxValue::g() const { SbxValues aRes(e); Get( aRes ); return aRes.m; } -GET( GetByte, SbxBYTE, BYTE, nByte ) +GET( GetByte, SbxBYTE, sal_uInt8, nByte ) GET( GetChar, SbxCHAR, xub_Unicode, nChar ) GET( GetCurrency, SbxCURRENCY, SbxINT64, nLong64 ) GET( GetDate, SbxDATE, double, nDouble ) GET( GetData, SbxDATAOBJECT, void*, pData ) GET( GetDouble, SbxDOUBLE, double, nDouble ) -GET( GetErr, SbxERROR, UINT16, nUShort ) +GET( GetErr, SbxERROR, sal_uInt16, nUShort ) GET( GetInt, SbxINT, int, nInt ) -GET( GetInteger, SbxINTEGER, INT16, nInteger ) -GET( GetLong, SbxLONG, INT32, nLong ) +GET( GetInteger, SbxINTEGER, sal_Int16, nInteger ) +GET( GetLong, SbxLONG, sal_Int32, nLong ) GET( GetLong64, SbxLONG64, SbxINT64, nLong64 ) GET( GetObject, SbxOBJECT, SbxBase*, pObj ) GET( GetSingle, SbxSINGLE, float, nSingle ) -GET( GetULong, SbxULONG, UINT32, nULong ) +GET( GetULong, SbxULONG, sal_uInt32, nULong ) GET( GetULong64, SbxULONG64, SbxUINT64, nULong64 ) -GET( GetUShort, SbxUSHORT, UINT16, nUShort ) +GET( GetUShort, SbxUSHORT, sal_uInt16, nUShort ) GET( GetInt64, SbxSALINT64, sal_Int64, nInt64 ) GET( GetUInt64, SbxSALUINT64, sal_uInt64, uInt64 ) GET( GetDecimal, SbxDECIMAL, SbxDecimal*, pDecimal ) @@ -698,9 +698,9 @@ GET( GetDecimal, SbxDECIMAL, SbxDecimal*, pDecimal ) //////////////////////////// Daten schreiben ///////////////////////////// -BOOL SbxValue::Put( const SbxValues& rVal ) +sal_Bool SbxValue::Put( const SbxValues& rVal ) { - BOOL bRes = FALSE; + sal_Bool bRes = sal_False; SbxError eOld = GetError(); if( eOld != SbxERR_OK ) ResetError(); @@ -714,7 +714,7 @@ BOOL SbxValue::Put( const SbxValues& rVal ) // die wahren Werte suchen SbxValue* p = this; if( rVal.eType != SbxOBJECT ) - p = TheRealValue( FALSE ); // #55226 Hier keinen Fehler erlauben + p = TheRealValue( sal_False ); // #55226 Hier keinen Fehler erlauben if( p ) { if( !p->CanWrite() ) @@ -743,16 +743,16 @@ BOOL SbxValue::Put( const SbxValues& rVal ) case SbxSTRING: ImpPutString( &p->aData, rVal.pOUString ); break; case SbxINT: #if SAL_TYPES_SIZEOFINT == 2 - ImpPutInteger( &p->aData, (INT16) rVal.nInt ); + ImpPutInteger( &p->aData, (sal_Int16) rVal.nInt ); #else - ImpPutLong( &p->aData, (INT32) rVal.nInt ); + ImpPutLong( &p->aData, (sal_Int32) rVal.nInt ); #endif break; case SbxUINT: #if SAL_TYPES_SIZEOFINT == 2 - ImpPutUShort( &p->aData, (UINT16) rVal.nUInt ); + ImpPutUShort( &p->aData, (sal_uInt16) rVal.nUInt ); #else - ImpPutULong( &p->aData, (UINT32) rVal.nUInt ); + ImpPutULong( &p->aData, (sal_uInt32) rVal.nUInt ); #endif break; case SbxOBJECT: @@ -777,8 +777,8 @@ BOOL SbxValue::Put( const SbxValues& rVal ) } HACK(nicht bei Parent-Prop - sonst CyclicRef) SbxVariable *pThisVar = PTR_CAST(SbxVariable, this); - BOOL bParentProp = pThisVar && 5345 == - ( (INT16) ( pThisVar->GetUserData() & 0xFFFF ) ); + sal_Bool bParentProp = pThisVar && 5345 == + ( (sal_Int16) ( pThisVar->GetUserData() & 0xFFFF ) ); if ( !bParentProp ) p->aData.pObj->AddRef(); } @@ -798,11 +798,11 @@ BOOL SbxValue::Put( const SbxValues& rVal ) } if( !IsError() ) { - p->SetModified( TRUE ); + p->SetModified( sal_True ); p->Broadcast( SBX_HINT_DATACHANGED ); if( eOld != SbxERR_OK ) SetError( eOld ); - bRes = TRUE; + bRes = sal_True; } } } @@ -816,7 +816,7 @@ BOOL SbxValue::Put( const SbxValues& rVal ) // werden koennen, wenn Floats mit ',' als Dezimaltrenner oder BOOLs // explizit mit "TRUE" oder "FALSE" angegeben werden. // Implementierung in ImpConvStringExt (SBXSCAN.CXX) -BOOL SbxValue::PutStringExt( const ::rtl::OUString& r ) +sal_Bool SbxValue::PutStringExt( const ::rtl::OUString& r ) { // Kopieren, bei Unicode gleich konvertieren ::rtl::OUString aStr( r ); @@ -831,7 +831,7 @@ BOOL SbxValue::PutStringExt( const ::rtl::OUString& r ) // Nur, wenn wirklich was konvertiert wurde, Kopie nehmen, // sonst Original (Unicode bleibt erhalten) - BOOL bRet; + sal_Bool bRet; if( ImpConvStringExt( aStr, eTargetType ) ) aRes.pOUString = (::rtl::OUString*)&aStr; else @@ -839,7 +839,7 @@ BOOL SbxValue::PutStringExt( const ::rtl::OUString& r ) // #34939: Bei Strings. die eine Zahl enthalten und wenn this einen // Num-Typ hat, Fixed-Flag setzen, damit der Typ nicht veraendert wird - USHORT nFlags_ = GetFlags(); + sal_uInt16 nFlags_ = GetFlags(); if( ( eTargetType >= SbxINTEGER && eTargetType <= SbxCURRENCY ) || ( eTargetType >= SbxCHAR && eTargetType <= SbxUINT ) || eTargetType == SbxBOOL ) @@ -851,7 +851,7 @@ BOOL SbxValue::PutStringExt( const ::rtl::OUString& r ) } Put( aRes ); - bRet = BOOL( !IsError() ); + bRet = sal_Bool( !IsError() ); // Falls das mit dem FIXED einen Error gegeben hat, zuruecksetzen // (UI-Aktion sollte keinen Error ergeben, sondern nur scheitern) @@ -862,104 +862,104 @@ BOOL SbxValue::PutStringExt( const ::rtl::OUString& r ) return bRet; } -BOOL SbxValue::PutString( const xub_Unicode* p ) +sal_Bool SbxValue::PutString( const xub_Unicode* p ) { ::rtl::OUString aVal( p ); SbxValues aRes; aRes.eType = SbxSTRING; aRes.pOUString = &aVal; Put( aRes ); - return BOOL( !IsError() ); + return sal_Bool( !IsError() ); } -BOOL SbxValue::PutBool( BOOL b ) +sal_Bool SbxValue::PutBool( sal_Bool b ) { SbxValues aRes; aRes.eType = SbxBOOL; - aRes.nUShort = sal::static_int_cast< UINT16 >(b ? SbxTRUE : SbxFALSE); + aRes.nUShort = sal::static_int_cast< sal_uInt16 >(b ? SbxTRUE : SbxFALSE); Put( aRes ); - return BOOL( !IsError() ); + return sal_Bool( !IsError() ); } -BOOL SbxValue::PutEmpty() +sal_Bool SbxValue::PutEmpty() { - BOOL bRet = SetType( SbxEMPTY ); - SetModified( TRUE ); + sal_Bool bRet = SetType( SbxEMPTY ); + SetModified( sal_True ); return bRet; } -BOOL SbxValue::PutNull() +sal_Bool SbxValue::PutNull() { - BOOL bRet = SetType( SbxNULL ); + sal_Bool bRet = SetType( SbxNULL ); if( bRet ) - SetModified( TRUE ); + SetModified( sal_True ); return bRet; } // Special decimal methods -BOOL SbxValue::PutDecimal( com::sun::star::bridge::oleautomation::Decimal& rAutomationDec ) +sal_Bool SbxValue::PutDecimal( com::sun::star::bridge::oleautomation::Decimal& rAutomationDec ) { SbxValue::Clear(); aData.pDecimal = new SbxDecimal( rAutomationDec ); aData.pDecimal->addRef(); aData.eType = SbxDECIMAL; - return TRUE; + return sal_True; } -BOOL SbxValue::fillAutomationDecimal +sal_Bool SbxValue::fillAutomationDecimal ( com::sun::star::bridge::oleautomation::Decimal& rAutomationDec ) { SbxDecimal* pDecimal = GetDecimal(); if( pDecimal != NULL ) { pDecimal->fillAutomationDecimal( rAutomationDec ); - return TRUE; + return sal_True; } - return FALSE; + return sal_False; } -BOOL SbxValue::PutpChar( const xub_Unicode* p ) +sal_Bool SbxValue::PutpChar( const xub_Unicode* p ) { ::rtl::OUString aVal( p ); SbxValues aRes; aRes.eType = SbxLPSTR; aRes.pOUString = &aVal; Put( aRes ); - return BOOL( !IsError() ); + return sal_Bool( !IsError() ); } -BOOL SbxValue::PutString( const ::rtl::OUString& r ) +sal_Bool SbxValue::PutString( const ::rtl::OUString& r ) { SbxValues aRes; aRes.eType = SbxSTRING; aRes.pOUString = (::rtl::OUString*) &r; Put( aRes ); - return BOOL( !IsError() ); + return sal_Bool( !IsError() ); } #define PUT( p, e, t, m ) \ -BOOL SbxValue::p( t n ) \ -{ SbxValues aRes(e); aRes.m = n; Put( aRes ); return BOOL( !IsError() ); } +sal_Bool SbxValue::p( t n ) \ +{ SbxValues aRes(e); aRes.m = n; Put( aRes ); return sal_Bool( !IsError() ); } -PUT( PutByte, SbxBYTE, BYTE, nByte ) +PUT( PutByte, SbxBYTE, sal_uInt8, nByte ) PUT( PutChar, SbxCHAR, xub_Unicode, nChar ) PUT( PutCurrency, SbxCURRENCY, const SbxINT64&, nLong64 ) PUT( PutDate, SbxDATE, double, nDouble ) PUT( PutData, SbxDATAOBJECT, void*, pData ) PUT( PutDouble, SbxDOUBLE, double, nDouble ) -PUT( PutErr, SbxERROR, UINT16, nUShort ) +PUT( PutErr, SbxERROR, sal_uInt16, nUShort ) PUT( PutInt, SbxINT, int, nInt ) -PUT( PutInteger, SbxINTEGER, INT16, nInteger ) -PUT( PutLong, SbxLONG, INT32, nLong ) +PUT( PutInteger, SbxINTEGER, sal_Int16, nInteger ) +PUT( PutLong, SbxLONG, sal_Int32, nLong ) PUT( PutLong64, SbxLONG64, const SbxINT64&, nLong64 ) PUT( PutObject, SbxOBJECT, SbxBase*, pObj ) PUT( PutSingle, SbxSINGLE, float, nSingle ) -PUT( PutULong, SbxULONG, UINT32, nULong ) +PUT( PutULong, SbxULONG, sal_uInt32, nULong ) PUT( PutULong64, SbxULONG64, const SbxUINT64&, nULong64 ) -PUT( PutUShort, SbxUSHORT, UINT16, nUShort ) +PUT( PutUShort, SbxUSHORT, sal_uInt16, nUShort ) PUT( PutInt64, SbxSALINT64, sal_Int64, nInt64 ) PUT( PutUInt64, SbxSALUINT64, sal_uInt64, uInt64 ) PUT( PutDecimal, SbxDECIMAL, SbxDecimal*, pDecimal ) @@ -967,7 +967,7 @@ PUT( PutDecimal, SbxDECIMAL, SbxDecimal*, pDecimal ) ////////////////////////// Setzen des Datentyps /////////////////////////// -BOOL SbxValue::IsFixed() const +sal_Bool SbxValue::IsFixed() const { return ( (GetFlags() & SBX_FIXED) | (aData.eType & SbxBYREF) ) != 0; } @@ -976,22 +976,22 @@ BOOL SbxValue::IsFixed() const // oder einen vollstaendig konvertierbaren String enthaelt // #41692, fuer RTL und Basic-Core getrennt implementieren -BOOL SbxValue::IsNumeric() const +sal_Bool SbxValue::IsNumeric() const { - return ImpIsNumeric( /*bOnlyIntntl*/FALSE ); + return ImpIsNumeric( /*bOnlyIntntl*/sal_False ); } -BOOL SbxValue::IsNumericRTL() const +sal_Bool SbxValue::IsNumericRTL() const { - return ImpIsNumeric( /*bOnlyIntntl*/TRUE ); + return ImpIsNumeric( /*bOnlyIntntl*/sal_True ); } -BOOL SbxValue::ImpIsNumeric( BOOL bOnlyIntntl ) const +sal_Bool SbxValue::ImpIsNumeric( sal_Bool bOnlyIntntl ) const { if( !CanRead() ) { - SetError( SbxERR_PROP_WRITEONLY ); return FALSE; + SetError( SbxERR_PROP_WRITEONLY ); return sal_False; } // Downcast pruefen!!! if( this->ISA(SbxVariable) ) @@ -1004,14 +1004,14 @@ BOOL SbxValue::ImpIsNumeric( BOOL bOnlyIntntl ) const ::rtl::OUString s( *aData.pOUString ); double n; SbxDataType t2; - USHORT nLen = 0; - if( ImpScan( s, n, t2, &nLen, /*bAllowIntntl*/FALSE, bOnlyIntntl ) == SbxERR_OK ) - return BOOL( nLen == s.getLength() ); + sal_uInt16 nLen = 0; + if( ImpScan( s, n, t2, &nLen, /*bAllowIntntl*/sal_False, bOnlyIntntl ) == SbxERR_OK ) + return sal_Bool( nLen == s.getLength() ); } - return FALSE; + return sal_False; } else - return BOOL( t == SbxEMPTY + return sal_Bool( t == SbxEMPTY || ( t >= SbxINTEGER && t <= SbxCURRENCY ) || ( t >= SbxCHAR && t <= SbxUINT ) ); } @@ -1031,19 +1031,19 @@ SbxDataType SbxValue::GetFullType() const return aData.eType; } -BOOL SbxValue::SetType( SbxDataType t ) +sal_Bool SbxValue::SetType( SbxDataType t ) { DBG_ASSERT( !( t & 0xF000 ), "Setzen von BYREF|ARRAY verboten!" ); if( ( t == SbxEMPTY && aData.eType == SbxVOID ) || ( aData.eType == SbxEMPTY && t == SbxVOID ) ) - return TRUE; + return sal_True; if( ( t & 0x0FFF ) == SbxVARIANT ) { // Versuch, den Datentyp auf Variant zu setzen ResetFlag( SBX_FIXED ); if( IsFixed() ) { - SetError( SbxERR_CONVERSION ); return FALSE; + SetError( SbxERR_CONVERSION ); return sal_False; } t = SbxEMPTY; } @@ -1051,7 +1051,7 @@ BOOL SbxValue::SetType( SbxDataType t ) { if( !CanWrite() || IsFixed() ) { - SetError( SbxERR_CONVERSION ); return FALSE; + SetError( SbxERR_CONVERSION ); return sal_False; } else { @@ -1066,12 +1066,12 @@ BOOL SbxValue::SetType( SbxDataType t ) { HACK(nicht bei Parent-Prop - sonst CyclicRef) SbxVariable *pThisVar = PTR_CAST(SbxVariable, this); - UINT16 nSlotId = pThisVar - ? ( (INT16) ( pThisVar->GetUserData() & 0xFFFF ) ) + sal_uInt16 nSlotId = pThisVar + ? ( (sal_Int16) ( pThisVar->GetUserData() & 0xFFFF ) ) : 0; DBG_ASSERT( nSlotId != 5345 || pThisVar->GetName() == UniString::CreateFromAscii( "Parent" ), "SID_PARENTOBJECT heisst nicht 'Parent'" ); - BOOL bParentProp = 5345 == nSlotId; + sal_Bool bParentProp = 5345 == nSlotId; if ( !bParentProp ) aData.pObj->ReleaseRef(); } @@ -1083,31 +1083,31 @@ BOOL SbxValue::SetType( SbxDataType t ) aData.eType = t; } } - return TRUE; + return sal_True; } -BOOL SbxValue::Convert( SbxDataType eTo ) +sal_Bool SbxValue::Convert( SbxDataType eTo ) { eTo = SbxDataType( eTo & 0x0FFF ); if( ( aData.eType & 0x0FFF ) == eTo ) - return TRUE; + return sal_True; if( !CanWrite() ) - return FALSE; + return sal_False; if( eTo == SbxVARIANT ) { // Versuch, den Datentyp auf Variant zu setzen ResetFlag( SBX_FIXED ); if( IsFixed() ) { - SetError( SbxERR_CONVERSION ); return FALSE; + SetError( SbxERR_CONVERSION ); return sal_False; } else - return TRUE; + return sal_True; } // Convert from Null geht niemals. Einmal Null, immer Null! if( aData.eType == SbxNULL ) { - SetError( SbxERR_CONVERSION ); return FALSE; + SetError( SbxERR_CONVERSION ); return sal_False; } // Konversion der Daten: @@ -1121,17 +1121,17 @@ BOOL SbxValue::Convert( SbxDataType eTo ) { SetType( eTo ); Put( aNew ); - SetModified( TRUE ); + SetModified( sal_True ); } Broadcast( SBX_HINT_CONVERTED ); - return TRUE; + return sal_True; } else - return FALSE; + return sal_False; } ////////////////////////////////// Rechnen ///////////////////////////////// -BOOL SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp ) +sal_Bool SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp ) { bool bVBAInterop = SbiRuntime::isVBAEnabled(); @@ -1457,19 +1457,19 @@ Lbl_OpIsDouble: } Lbl_OpIsEmpty: - BOOL bRes = BOOL( !IsError() ); + sal_Bool bRes = sal_Bool( !IsError() ); if( bRes && eOld != SbxERR_OK ) SetError( eOld ); return bRes; } -// Die Vergleichs-Routine liefert TRUE oder FALSE. +// Die Vergleichs-Routine liefert sal_True oder sal_False. -BOOL SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const +sal_Bool SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const { bool bVBAInterop = SbiRuntime::isVBAEnabled(); - BOOL bRes = FALSE; + sal_Bool bRes = sal_False; SbxError eOld = GetError(); if( eOld != SbxERR_OK ) ResetError(); @@ -1477,24 +1477,24 @@ BOOL SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const SetError( SbxERR_PROP_WRITEONLY ); else if( GetType() == SbxNULL && rOp.GetType() == SbxNULL && !bVBAInterop ) { - bRes = TRUE; + bRes = sal_True; } else if( GetType() == SbxEMPTY && rOp.GetType() == SbxEMPTY ) - bRes = !bVBAInterop ? TRUE : ( eOp == SbxEQ ? TRUE : FALSE ); + bRes = !bVBAInterop ? sal_True : ( eOp == SbxEQ ? sal_True : sal_False ); // Sonderregel 1: Ist ein Operand Null, ist das Ergebnis FALSE else if( GetType() == SbxNULL || rOp.GetType() == SbxNULL ) - bRes = FALSE; + bRes = sal_False; // Sonderregel 2: Wenn beide Variant sind und einer ist numerisch, // und der andere ein String, ist num < str else if( !IsFixed() && !rOp.IsFixed() && ( rOp.GetType() == SbxSTRING && GetType() != SbxSTRING && IsNumeric() ) && !bVBAInterop ) - bRes = BOOL( eOp == SbxLT || eOp == SbxLE || eOp == SbxNE ); + bRes = sal_Bool( eOp == SbxLT || eOp == SbxLE || eOp == SbxNE ); else if( !IsFixed() && !rOp.IsFixed() && ( GetType() == SbxSTRING && rOp.GetType() != SbxSTRING && rOp.IsNumeric() ) && !bVBAInterop ) - bRes = BOOL( eOp == SbxGT || eOp == SbxGE || eOp == SbxNE ); + bRes = sal_Bool( eOp == SbxGT || eOp == SbxGE || eOp == SbxNE ); else { SbxValues aL, aR; @@ -1506,17 +1506,17 @@ BOOL SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const if( Get( aL ) && rOp.Get( aR ) ) switch( eOp ) { case SbxEQ: - bRes = BOOL( *aL.pOUString == *aR.pOUString ); break; + bRes = sal_Bool( *aL.pOUString == *aR.pOUString ); break; case SbxNE: - bRes = BOOL( *aL.pOUString != *aR.pOUString ); break; + bRes = sal_Bool( *aL.pOUString != *aR.pOUString ); break; case SbxLT: - bRes = BOOL( *aL.pOUString < *aR.pOUString ); break; + bRes = sal_Bool( *aL.pOUString < *aR.pOUString ); break; case SbxGT: - bRes = BOOL( *aL.pOUString > *aR.pOUString ); break; + bRes = sal_Bool( *aL.pOUString > *aR.pOUString ); break; case SbxLE: - bRes = BOOL( *aL.pOUString <= *aR.pOUString ); break; + bRes = sal_Bool( *aL.pOUString <= *aR.pOUString ); break; case SbxGE: - bRes = BOOL( *aL.pOUString >= *aR.pOUString ); break; + bRes = sal_Bool( *aL.pOUString >= *aR.pOUString ); break; default: SetError( SbxERR_NOTIMP ); } @@ -1530,17 +1530,17 @@ BOOL SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const switch( eOp ) { case SbxEQ: - bRes = BOOL( aL.nSingle == aR.nSingle ); break; + bRes = sal_Bool( aL.nSingle == aR.nSingle ); break; case SbxNE: - bRes = BOOL( aL.nSingle != aR.nSingle ); break; + bRes = sal_Bool( aL.nSingle != aR.nSingle ); break; case SbxLT: - bRes = BOOL( aL.nSingle < aR.nSingle ); break; + bRes = sal_Bool( aL.nSingle < aR.nSingle ); break; case SbxGT: - bRes = BOOL( aL.nSingle > aR.nSingle ); break; + bRes = sal_Bool( aL.nSingle > aR.nSingle ); break; case SbxLE: - bRes = BOOL( aL.nSingle <= aR.nSingle ); break; + bRes = sal_Bool( aL.nSingle <= aR.nSingle ); break; case SbxGE: - bRes = BOOL( aL.nSingle >= aR.nSingle ); break; + bRes = sal_Bool( aL.nSingle >= aR.nSingle ); break; default: SetError( SbxERR_NOTIMP ); } @@ -1556,17 +1556,17 @@ BOOL SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const switch( eOp ) { case SbxEQ: - bRes = BOOL( eRes == SbxDecimal::EQ ); break; + bRes = sal_Bool( eRes == SbxDecimal::EQ ); break; case SbxNE: - bRes = BOOL( eRes != SbxDecimal::EQ ); break; + bRes = sal_Bool( eRes != SbxDecimal::EQ ); break; case SbxLT: - bRes = BOOL( eRes == SbxDecimal::LT ); break; + bRes = sal_Bool( eRes == SbxDecimal::LT ); break; case SbxGT: - bRes = BOOL( eRes == SbxDecimal::GT ); break; + bRes = sal_Bool( eRes == SbxDecimal::GT ); break; case SbxLE: - bRes = BOOL( eRes != SbxDecimal::GT ); break; + bRes = sal_Bool( eRes != SbxDecimal::GT ); break; case SbxGE: - bRes = BOOL( eRes != SbxDecimal::LT ); break; + bRes = sal_Bool( eRes != SbxDecimal::LT ); break; default: SetError( SbxERR_NOTIMP ); } @@ -1589,17 +1589,17 @@ BOOL SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const switch( eOp ) { case SbxEQ: - bRes = BOOL( aL.nDouble == aR.nDouble ); break; + bRes = sal_Bool( aL.nDouble == aR.nDouble ); break; case SbxNE: - bRes = BOOL( aL.nDouble != aR.nDouble ); break; + bRes = sal_Bool( aL.nDouble != aR.nDouble ); break; case SbxLT: - bRes = BOOL( aL.nDouble < aR.nDouble ); break; + bRes = sal_Bool( aL.nDouble < aR.nDouble ); break; case SbxGT: - bRes = BOOL( aL.nDouble > aR.nDouble ); break; + bRes = sal_Bool( aL.nDouble > aR.nDouble ); break; case SbxLE: - bRes = BOOL( aL.nDouble <= aR.nDouble ); break; + bRes = sal_Bool( aL.nDouble <= aR.nDouble ); break; case SbxGE: - bRes = BOOL( aL.nDouble >= aR.nDouble ); break; + bRes = sal_Bool( aL.nDouble >= aR.nDouble ); break; default: SetError( SbxERR_NOTIMP ); } @@ -1611,7 +1611,7 @@ BOOL SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const if ( bVBAInterop && eOp == SbxEQ && GetError() == SbxERR_CONVERSION ) { ResetError(); - bRes = FALSE; + bRes = sal_False; } } } @@ -1623,10 +1623,10 @@ BOOL SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const ///////////////////////////// Lesen/Schreiben //////////////////////////// -BOOL SbxValue::LoadData( SvStream& r, USHORT ) +sal_Bool SbxValue::LoadData( SvStream& r, sal_uInt16 ) { SbxValue::Clear(); - UINT16 nType; + sal_uInt16 nType; r >> nType; aData.eType = SbxDataType( nType ); switch( nType ) @@ -1646,7 +1646,7 @@ BOOL SbxValue::LoadData( SvStream& r, USHORT ) if( ImpScan( aVal, d, t, NULL ) != SbxERR_OK || t == SbxDOUBLE ) { aData.nSingle = 0.0F; - return FALSE; + return sal_False; } aData.nSingle = (float) d; break; @@ -1661,7 +1661,7 @@ BOOL SbxValue::LoadData( SvStream& r, USHORT ) if( ImpScan( aVal, aData.nDouble, t, NULL ) != SbxERR_OK ) { aData.nDouble = 0.0; - return FALSE; + return sal_False; } break; } @@ -1691,7 +1691,7 @@ BOOL SbxValue::LoadData( SvStream& r, USHORT ) r >> aData.nUShort; break; case SbxOBJECT: { - BYTE nMode; + sal_uInt8 nMode; r >> nMode; switch( nMode ) { @@ -1700,7 +1700,7 @@ BOOL SbxValue::LoadData( SvStream& r, USHORT ) break; case 1: aData.pObj = SbxBase::Load( r ); - return BOOL( aData.pObj != NULL ); + return sal_Bool( aData.pObj != NULL ); case 2: aData.pObj = this; break; @@ -1720,7 +1720,7 @@ BOOL SbxValue::LoadData( SvStream& r, USHORT ) r >> aData.nULong; break; case SbxINT: { - BYTE n; + sal_uInt8 n; r >> n; // Passt der Int auf diesem System? if( n > SAL_TYPES_SIZEOFINT ) @@ -1731,7 +1731,7 @@ BOOL SbxValue::LoadData( SvStream& r, USHORT ) } case SbxUINT: { - BYTE n; + sal_uInt8 n; r >> n; // Passt der UInt auf diesem System? if( n > SAL_TYPES_SIZEOFINT ) @@ -1756,14 +1756,14 @@ BOOL SbxValue::LoadData( SvStream& r, USHORT ) ResetFlag(SBX_FIXED); aData.eType = SbxNULL; DBG_ASSERT( !this, "Nicht unterstuetzer Datentyp geladen" ); - return FALSE; + return sal_False; } - return TRUE; + return sal_True; } -BOOL SbxValue::StoreData( SvStream& r ) const +sal_Bool SbxValue::StoreData( SvStream& r ) const { - UINT16 nType = sal::static_int_cast< UINT16 >(aData.eType); + sal_uInt16 nType = sal::static_int_cast< sal_uInt16 >(aData.eType); r << nType; switch( nType & 0x0FFF ) { @@ -1813,14 +1813,14 @@ BOOL SbxValue::StoreData( SvStream& r ) const { if( PTR_CAST(SbxValue,aData.pObj) != this ) { - r << (BYTE) 1; + r << (sal_uInt8) 1; return aData.pObj->Store( r ); } else - r << (BYTE) 2; + r << (sal_uInt8) 2; } else - r << (BYTE) 0; + r << (sal_uInt8) 0; break; case SbxCHAR: { @@ -1834,13 +1834,13 @@ BOOL SbxValue::StoreData( SvStream& r ) const r << aData.nULong; break; case SbxINT: { - BYTE n = SAL_TYPES_SIZEOFINT; + sal_uInt8 n = SAL_TYPES_SIZEOFINT; r << n << (sal_Int32)aData.nInt; break; } case SbxUINT: { - BYTE n = SAL_TYPES_SIZEOFINT; + sal_uInt8 n = SAL_TYPES_SIZEOFINT; r << n << (sal_uInt32)aData.nUInt; break; } @@ -1857,8 +1857,8 @@ BOOL SbxValue::StoreData( SvStream& r ) const break; default: DBG_ASSERT( !this, "Speichern eines nicht unterstuetzten Datentyps" ); - return FALSE; + return sal_False; } - return TRUE; + return sal_True; } diff --git a/basic/source/sbx/sbxvar.cxx b/basic/source/sbx/sbxvar.cxx index 12a6d29672a9..1f33cc8acfd2 100644 --- a/basic/source/sbx/sbxvar.cxx +++ b/basic/source/sbx/sbxvar.cxx @@ -47,9 +47,9 @@ using namespace com::sun::star::uno; TYPEINIT1(SbxVariable,SbxValue) TYPEINIT1(SbxHint,SfxSimpleHint) -extern UINT32 nVarCreator; // in SBXBASE.CXX, fuer LoadData() +extern sal_uInt32 nVarCreator; // in SBXBASE.CXX, fuer LoadData() #ifdef DBG_UTIL -static ULONG nVar = 0; +static sal_uIntPtr nVar = 0; #endif ///////////////////////////// SbxVariableImpl //////////////////////////// @@ -166,7 +166,7 @@ SfxBroadcaster& SbxVariable::GetBroadcaster() // Eines Tages kann man vielleicht den Parameter 0 schleifen, // dann entfaellt die Kopiererei... -void SbxVariable::Broadcast( ULONG nHintId ) +void SbxVariable::Broadcast( sal_uIntPtr nHintId ) { if( pCst && !IsSet( SBX_NO_BROADCAST ) && StaticIsEnabledBroadcasting() ) { @@ -181,7 +181,7 @@ void SbxVariable::Broadcast( ULONG nHintId ) // Weitere Broadcasts verhindern SfxBroadcaster* pSave = pCst; pCst = NULL; - USHORT nSaveFlags = GetFlags(); + sal_uInt16 nSaveFlags = GetFlags(); SetFlag( SBX_READWRITE ); if( mpPar.Is() ) // this, als Element 0 eintragen, aber den Parent nicht umsetzen! @@ -199,7 +199,7 @@ SbxInfo* SbxVariable::GetInfo() { Broadcast( SBX_HINT_INFOWANTED ); if( pInfo.Is() ) - SetModified( TRUE ); + SetModified( sal_True ); } return pInfo; } @@ -246,7 +246,7 @@ const XubString& SbxVariable::GetName( SbxNameType t ) const aTmp += cType; } aTmp += '('; - for( USHORT i = 0; i < pInfo->aParams.Count(); i++ ) + for( sal_uInt16 i = 0; i < pInfo->aParams.Count(); i++ ) { const SbxParamInfo* q = pInfo->aParams.GetObject( i ); int nt = q->eType & 0x0FFF; @@ -280,7 +280,7 @@ const XubString& SbxVariable::GetName( SbxNameType t ) const aTmp += String( SbxRes( STRING_AS ) ); if( nt < 32 ) aTmp += String( SbxRes( - sal::static_int_cast< USHORT >( STRING_TYPES + nt ) ) ); + sal::static_int_cast< sal_uInt16 >( STRING_TYPES + nt ) ) ); else aTmp += String( SbxRes( STRING_ANY ) ); } @@ -293,7 +293,7 @@ const XubString& SbxVariable::GetName( SbxNameType t ) const aTmp += String( SbxRes( STRING_AS ) ); if( et < 32 ) aTmp += String( SbxRes( - sal::static_int_cast< USHORT >( STRING_TYPES + et ) ) ); + sal::static_int_cast< sal_uInt16 >( STRING_TYPES + et ) ) ); else aTmp += String( SbxRes( STRING_ANY ) ); } @@ -303,21 +303,21 @@ const XubString& SbxVariable::GetName( SbxNameType t ) const // Einen simplen Hashcode erzeugen: Es werden die ersten 6 Zeichen gewertet. -USHORT SbxVariable::MakeHashCode( const XubString& rName ) +sal_uInt16 SbxVariable::MakeHashCode( const XubString& rName ) { - USHORT n = 0; - USHORT nLen = rName.Len(); + sal_uInt16 n = 0; + sal_uInt16 nLen = rName.Len(); if( nLen > 6 ) nLen = 6; const xub_Unicode* p = rName.GetBuffer(); while( nLen-- ) { - BYTE c = (BYTE)*p; + sal_uInt8 c = (sal_uInt8)*p; p++; // Falls wir ein Schweinezeichen haben, abbrechen!! if( c >= 0x80 ) return 0; - n = sal::static_int_cast< USHORT >( ( n << 3 ) + toupper( c ) ); + n = sal::static_int_cast< sal_uInt16 >( ( n << 3 ) + toupper( c ) ); } return n; } @@ -356,7 +356,7 @@ SbxClassType SbxVariable::GetClass() const return SbxCLASS_VARIABLE; } -void SbxVariable::SetModified( BOOL b ) +void SbxVariable::SetModified( sal_Bool b ) { if( IsSet( SBX_NO_MODIFY ) ) return; @@ -372,11 +372,11 @@ void SbxVariable::SetParent( SbxObject* p ) if ( p && ISA(SbxObject) ) { // dann mu\s dieses auch Child vom neuen Parent sein - BOOL bFound = FALSE; + sal_Bool bFound = sal_False; SbxArray *pChilds = p->GetObjects(); if ( pChilds ) { - for ( USHORT nIdx = 0; !bFound && nIdx < pChilds->Count(); ++nIdx ) + for ( sal_uInt16 nIdx = 0; !bFound && nIdx < pChilds->Count(); ++nIdx ) bFound = ( this == pChilds->Get(nIdx) ); } if ( !bFound ) @@ -432,17 +432,17 @@ void SbxVariable::ClearComListener( void ) ////////////////////////////// Laden/Speichern ///////////////////////////// -BOOL SbxVariable::LoadData( SvStream& rStrm, USHORT nVer ) +sal_Bool SbxVariable::LoadData( SvStream& rStrm, sal_uInt16 nVer ) { - UINT16 nType; - BYTE cMark; + sal_uInt16 nType; + sal_uInt8 cMark; rStrm >> cMark; if( cMark == 0xFF ) { if( !SbxValue::LoadData( rStrm, nVer ) ) - return FALSE; + return sal_False; rStrm.ReadByteString( maName, RTL_TEXTENCODING_ASCII_US ); - UINT32 nTemp; + sal_uInt32 nTemp; rStrm >> nTemp; nUserData = nTemp; } @@ -451,7 +451,7 @@ BOOL SbxVariable::LoadData( SvStream& rStrm, USHORT nVer ) rStrm.SeekRel( -1L ); rStrm >> nType; rStrm.ReadByteString( maName, RTL_TEXTENCODING_ASCII_US ); - UINT32 nTemp; + sal_uInt32 nTemp; rStrm >> nTemp; nUserData = nTemp; // Korrektur: Alte Methoden haben statt SbxNULL jetzt SbxEMPTY @@ -479,7 +479,7 @@ BOOL SbxVariable::LoadData( SvStream& rStrm, USHORT nVer ) if( ImpScan( aTmpString, d, t, NULL ) != SbxERR_OK || t == SbxDOUBLE ) { aTmp.nSingle = 0; - return FALSE; + return sal_False; } aTmp.nSingle = (float) d; break; @@ -493,7 +493,7 @@ BOOL SbxVariable::LoadData( SvStream& rStrm, USHORT nVer ) if( ImpScan( aTmpString, aTmp.nDouble, t, NULL ) != SbxERR_OK ) { aTmp.nDouble = 0; - return FALSE; + return sal_False; } break; } @@ -507,11 +507,11 @@ BOOL SbxVariable::LoadData( SvStream& rStrm, USHORT nVer ) default: aData.eType = SbxNULL; DBG_ASSERT( !this, "Nicht unterstuetzer Datentyp geladen" ); - return FALSE; + return sal_False; } // Wert putten if( nType != SbxNULL && nType != SbxEMPTY && !Put( aTmp ) ) - return FALSE; + return sal_False; } rStrm >> cMark; // cMark ist auch eine Versionsnummer! @@ -520,29 +520,29 @@ BOOL SbxVariable::LoadData( SvStream& rStrm, USHORT nVer ) if( cMark ) { if( cMark > 2 ) - return FALSE; + return sal_False; pInfo = new SbxInfo; - pInfo->LoadData( rStrm, (USHORT) cMark ); + pInfo->LoadData( rStrm, (sal_uInt16) cMark ); } // Privatdaten nur laden, wenn es eine SbxVariable ist if( GetClass() == SbxCLASS_VARIABLE && !LoadPrivateData( rStrm, nVer ) ) - return FALSE; + return sal_False; ((SbxVariable*) this)->Broadcast( SBX_HINT_DATACHANGED ); nHash = MakeHashCode( maName ); - SetModified( TRUE ); - return TRUE; + SetModified( sal_True ); + return sal_True; } -BOOL SbxVariable::StoreData( SvStream& rStrm ) const +sal_Bool SbxVariable::StoreData( SvStream& rStrm ) const { - rStrm << (BYTE) 0xFF; // Marker - BOOL bValStore; + rStrm << (sal_uInt8) 0xFF; // Marker + sal_Bool bValStore; if( this->IsA( TYPE(SbxMethod) ) ) { // #50200 Verhindern, dass Objekte, die zur Laufzeit als Return-Wert // in der Methode als Value gespeichert sind, mit gespeichert werden SbxVariable* pThis = (SbxVariable*)this; - USHORT nSaveFlags = GetFlags(); + sal_uInt16 nSaveFlags = GetFlags(); pThis->SetFlag( SBX_WRITE ); pThis->SbxValue::Clear(); pThis->SetFlags( nSaveFlags ); @@ -556,23 +556,23 @@ BOOL SbxVariable::StoreData( SvStream& rStrm ) const else bValStore = SbxValue::StoreData( rStrm ); if( !bValStore ) - return FALSE; + return sal_False; // if( !SbxValue::StoreData( rStrm ) ) - // return FALSE; + // return sal_False; rStrm.WriteByteString( maName, RTL_TEXTENCODING_ASCII_US ); - rStrm << (UINT32)nUserData; + rStrm << (sal_uInt32)nUserData; if( pInfo.Is() ) { - rStrm << (BYTE) 2; // Version 2: mit UserData! + rStrm << (sal_uInt8) 2; // Version 2: mit UserData! pInfo->StoreData( rStrm ); } else - rStrm << (BYTE) 0; + rStrm << (sal_uInt8) 0; // Privatdaten nur speichern, wenn es eine SbxVariable ist if( GetClass() == SbxCLASS_VARIABLE ) return StorePrivateData( rStrm ); else - return TRUE; + return sal_True; } ////////////////////////////// SbxInfo /////////////////////////////////// @@ -580,7 +580,7 @@ BOOL SbxVariable::StoreData( SvStream& rStrm ) const SbxInfo::SbxInfo() : aHelpFile(), nHelpId( 0 ), aParams() {} -SbxInfo::SbxInfo( const String& r, UINT32 n ) +SbxInfo::SbxInfo( const String& r, sal_uInt32 n ) : aHelpFile( r ), nHelpId( n ), aParams() {} @@ -613,7 +613,7 @@ SbxAlias::~SbxAlias() EndListening( xAlias->GetBroadcaster() ); } -void SbxAlias::Broadcast( ULONG nHt ) +void SbxAlias::Broadcast( sal_uIntPtr nHt ) { if( xAlias.Is() && StaticIsEnabledBroadcasting() ) { @@ -643,11 +643,11 @@ void SbxAlias::SFX_NOTIFY( SfxBroadcaster&, const TypeId&, } } -void SbxVariable::Dump( SvStream& rStrm, BOOL bFill ) +void SbxVariable::Dump( SvStream& rStrm, sal_Bool bFill ) { ByteString aBNameStr( (const UniString&)GetName( SbxNAME_SHORT_TYPES ), RTL_TEXTENCODING_ASCII_US ); rStrm << "Variable( " - << ByteString::CreateFromInt64( (ULONG) this ).GetBuffer() << "==" + << ByteString::CreateFromInt64( (sal_uIntPtr) this ).GetBuffer() << "==" << aBNameStr.GetBuffer(); ByteString aBParentNameStr( (const UniString&)GetParent()->GetName(), RTL_TEXTENCODING_ASCII_US ); if ( GetParent() ) |