From 4e70d0b6bf4c07734b11bc2df155ccdc9fc6874b Mon Sep 17 00:00:00 2001 From: Noel Grandin Date: Mon, 28 Aug 2017 17:03:09 +0200 Subject: rename SBX errorcodes to BASIC Change-Id: Ia6c2d2379a2f6e9b1109e2c04edd5cdd9dcf242f Reviewed-on: https://gerrit.libreoffice.org/41706 Tested-by: Jenkins Reviewed-by: Noel Grandin --- basic/source/classes/sb.cxx | 6 +- basic/source/classes/sbxmod.cxx | 4 +- basic/source/runtime/methods.cxx | 8 +-- basic/source/sbx/sbxarray.cxx | 30 ++++----- basic/source/sbx/sbxbool.cxx | 12 ++-- basic/source/sbx/sbxbyte.cxx | 42 ++++++------ basic/source/sbx/sbxchar.cxx | 36 +++++------ basic/source/sbx/sbxcoll.cxx | 20 +++--- basic/source/sbx/sbxcurr.cxx | 48 +++++++------- basic/source/sbx/sbxdate.cxx | 46 ++++++------- basic/source/sbx/sbxdbl.cxx | 56 ++++++++-------- basic/source/sbx/sbxdec.cxx | 42 ++++++------ basic/source/sbx/sbxexec.cxx | 14 ++-- basic/source/sbx/sbxint.cxx | 136 +++++++++++++++++++-------------------- basic/source/sbx/sbxlng.cxx | 46 ++++++------- basic/source/sbx/sbxobj.cxx | 2 +- basic/source/sbx/sbxscan.cxx | 8 +-- basic/source/sbx/sbxsng.cxx | 52 +++++++-------- basic/source/sbx/sbxstr.cxx | 10 +-- basic/source/sbx/sbxuint.cxx | 44 ++++++------- basic/source/sbx/sbxulng.cxx | 36 +++++------ basic/source/sbx/sbxvalue.cxx | 98 ++++++++++++++-------------- 22 files changed, 398 insertions(+), 398 deletions(-) (limited to 'basic') diff --git a/basic/source/classes/sb.cxx b/basic/source/classes/sb.cxx index f06dd5b36971..810eaaaf2e56 100644 --- a/basic/source/classes/sb.cxx +++ b/basic/source/classes/sb.cxx @@ -2129,7 +2129,7 @@ void BasicCollection::CollAdd( SbxArray* pPar_ ) sal_uInt16 nCount = pPar_->Count(); if( nCount < 2 || nCount > 5 ) { - SetError( ERRCODE_SBX_WRONG_ARGS ); + SetError( ERRCODE_BASIC_WRONG_ARGS ); return; } @@ -2206,7 +2206,7 @@ void BasicCollection::CollItem( SbxArray* pPar_ ) { if( pPar_->Count() != 2 ) { - SetError( ERRCODE_SBX_WRONG_ARGS ); + SetError( ERRCODE_BASIC_WRONG_ARGS ); return; } SbxVariable* pRes = nullptr; @@ -2230,7 +2230,7 @@ void BasicCollection::CollRemove( SbxArray* pPar_ ) { if( pPar_ == nullptr || pPar_->Count() != 2 ) { - SetError( ERRCODE_SBX_WRONG_ARGS ); + SetError( ERRCODE_BASIC_WRONG_ARGS ); return; } diff --git a/basic/source/classes/sbxmod.cxx b/basic/source/classes/sbxmod.cxx index 6cfb13b110ac..29e182fff05c 100644 --- a/basic/source/classes/sbxmod.cxx +++ b/basic/source/classes/sbxmod.cxx @@ -787,7 +787,7 @@ void SbModule::Notify( SfxBroadcaster& rBC, const SfxHint& rHint ) if( pProp ) { if( pProp->GetModule() != this ) - SetError( ERRCODE_SBX_BAD_ACTION ); + SetError( ERRCODE_BASIC_BAD_ACTION ); } else if( pMeth ) { @@ -1065,7 +1065,7 @@ void SbModule::Run( SbMethod* pMeth ) // i80726 The Find below will generate an error in Testtool so we reset it unless there was one before already bool bWasError = SbxBase::GetError() != ERRCODE_NONE; SbxVariable* pMSOMacroRuntimeLibVar = Find( "Launcher", SbxClassType::Object ); - if ( !bWasError && (SbxBase::GetError() == ERRCODE_SBX_PROC_UNDEFINED) ) + if ( !bWasError && (SbxBase::GetError() == ERRCODE_BASIC_PROC_UNDEFINED) ) SbxBase::ResetError(); if( pMSOMacroRuntimeLibVar ) { diff --git a/basic/source/runtime/methods.cxx b/basic/source/runtime/methods.cxx index 680b65a6f817..2be00d232ebd 100644 --- a/basic/source/runtime/methods.cxx +++ b/basic/source/runtime/methods.cxx @@ -1765,7 +1765,7 @@ void SbRtl_CDateFromUnoDate(StarBASIC *, SbxArray & rPar, bool) if(aAny >>= aUnoDate) SbxDateFromUNODate(rPar.Get(0), aUnoDate); else - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } css::util::Time SbxDateToUNOTime( const SbxValue* const pVal ) @@ -1812,7 +1812,7 @@ void SbRtl_CDateFromUnoTime(StarBASIC *, SbxArray & rPar, bool) if(aAny >>= aUnoTime) SbxDateFromUNOTime(rPar.Get(0), aUnoTime); else - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } css::util::DateTime SbxDateToUNODateTime( const SbxValue* const pVal ) @@ -1868,7 +1868,7 @@ void SbRtl_CDateFromUnoDateTime(StarBASIC *, SbxArray & rPar, bool) if(aAny >>= aUnoDT) SbxDateFromUNODateTime(rPar.Get(0), aUnoDT); else - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } // Function to convert date to ISO 8601 date format YYYYMMDD @@ -1972,7 +1972,7 @@ void SbRtl_CDateFromIso(StarBASIC *, SbxArray & rPar, bool) } while (false); - SbxBase::SetError( ERRCODE_SBX_BAD_PARAMETER ); + SbxBase::SetError( ERRCODE_BASIC_BAD_PARAMETER ); } else { diff --git a/basic/source/sbx/sbxarray.cxx b/basic/source/sbx/sbxarray.cxx index 2900ef70ac22..b1a9c56b65a4 100644 --- a/basic/source/sbx/sbxarray.cxx +++ b/basic/source/sbx/sbxarray.cxx @@ -116,7 +116,7 @@ SbxVariableRef& SbxArray::GetRef32( sal_uInt32 nIdx ) // Very Hot Fix if( nIdx > SBX_MAXINDEX32 ) { - SetError( ERRCODE_SBX_BOUNDS ); + SetError( ERRCODE_BASIC_OUT_OF_RANGE ); nIdx = 0; } if ( mVarEntries.size() <= nIdx ) @@ -132,7 +132,7 @@ SbxVariableRef& SbxArray::GetRef( sal_uInt16 nIdx ) // Very Hot Fix if( nIdx > SBX_MAXINDEX ) { - SetError( ERRCODE_SBX_BOUNDS ); + SetError( ERRCODE_BASIC_OUT_OF_RANGE ); nIdx = 0; } if ( mVarEntries.size() <= nIdx ) @@ -145,7 +145,7 @@ SbxVariable* SbxArray::Get32( sal_uInt32 nIdx ) { if( !CanRead() ) { - SetError( ERRCODE_SBX_PROP_WRITEONLY ); + SetError( ERRCODE_BASIC_PROP_WRITEONLY ); return nullptr; } SbxVariableRef& rRef = GetRef32( nIdx ); @@ -160,7 +160,7 @@ SbxVariable* SbxArray::Get( sal_uInt16 nIdx ) { if( !CanRead() ) { - SetError( ERRCODE_SBX_PROP_WRITEONLY ); + SetError( ERRCODE_BASIC_PROP_WRITEONLY ); return nullptr; } SbxVariableRef& rRef = GetRef( nIdx ); @@ -174,7 +174,7 @@ SbxVariable* SbxArray::Get( sal_uInt16 nIdx ) void SbxArray::Put32( SbxVariable* pVar, sal_uInt32 nIdx ) { if( !CanWrite() ) - SetError( ERRCODE_SBX_PROP_READONLY ); + SetError( ERRCODE_BASIC_PROP_READONLY ); else { if( pVar ) @@ -194,7 +194,7 @@ void SbxArray::Put32( SbxVariable* pVar, sal_uInt32 nIdx ) void SbxArray::Put( SbxVariable* pVar, sal_uInt16 nIdx ) { if( !CanWrite() ) - SetError( ERRCODE_SBX_PROP_READONLY ); + SetError( ERRCODE_BASIC_PROP_READONLY ); else { if( pVar ) @@ -215,7 +215,7 @@ OUString SbxArray::GetAlias( sal_uInt16 nIdx ) { if( !CanRead() ) { - SetError( ERRCODE_SBX_PROP_WRITEONLY ); + SetError( ERRCODE_BASIC_PROP_WRITEONLY ); return OUString(); } SbxVarEntry& rRef = reinterpret_cast(GetRef( nIdx )); @@ -230,7 +230,7 @@ void SbxArray::PutAlias( const OUString& rAlias, sal_uInt16 nIdx ) { if( !CanWrite() ) { - SetError( ERRCODE_SBX_PROP_READONLY ); + SetError( ERRCODE_BASIC_PROP_READONLY ); } else { @@ -554,7 +554,7 @@ void SbxDimArray::AddDimImpl32( sal_Int32 lb, sal_Int32 ub, bool bAllowSize0 ) ErrCode eRes = ERRCODE_NONE; if( ub < lb && !bAllowSize0 ) { - eRes = ERRCODE_SBX_BOUNDS; + eRes = ERRCODE_BASIC_OUT_OF_RANGE; ub = lb; } SbxDim d; @@ -594,7 +594,7 @@ bool SbxDimArray::GetDim32( sal_Int32 n, sal_Int32& rlb, sal_Int32& rub ) const { if( n < 1 || n > static_cast(m_vDimensions.size()) ) { - SetError( ERRCODE_SBX_BOUNDS ); + SetError( ERRCODE_BASIC_OUT_OF_RANGE ); rub = rlb = 0; return false; } @@ -614,7 +614,7 @@ bool SbxDimArray::GetDim( short n, short& rlb, short& rub ) const { if( rlb32 < -SBX_MAXINDEX || rub32 > SBX_MAXINDEX ) { - SetError( ERRCODE_SBX_BOUNDS ); + SetError( ERRCODE_BASIC_OUT_OF_RANGE ); return false; } } @@ -637,7 +637,7 @@ sal_uInt32 SbxDimArray::Offset32( const sal_Int32* pIdx ) } if( m_vDimensions.empty() || nPos > SBX_MAXINDEX32 ) { - SetError( ERRCODE_SBX_BOUNDS ); + SetError( ERRCODE_BASIC_OUT_OF_RANGE ); nPos = 0; } return nPos; @@ -659,7 +659,7 @@ sal_uInt16 SbxDimArray::Offset( const short* pIdx ) } if( m_vDimensions.empty() || nPos > SBX_MAXINDEX ) { - SetError( ERRCODE_SBX_BOUNDS ); + SetError( ERRCODE_BASIC_OUT_OF_RANGE ); nPos = 0; } return (sal_uInt16) nPos; @@ -693,7 +693,7 @@ sal_uInt32 SbxDimArray::Offset32( SbxArray* pPar ) ((m_vDimensions.size() != sal::static_int_cast(pPar->Count() - 1)) && SbiRuntime::isVBAEnabled())) { - SetError( ERRCODE_SBX_BOUNDS ); + SetError( ERRCODE_BASIC_OUT_OF_RANGE ); return 0; } #endif @@ -712,7 +712,7 @@ sal_uInt32 SbxDimArray::Offset32( SbxArray* pPar ) } if( nPos > (sal_uInt32) SBX_MAXINDEX32 ) { - SetError( ERRCODE_SBX_BOUNDS ); + SetError( ERRCODE_BASIC_OUT_OF_RANGE ); nPos = 0; } return nPos; diff --git a/basic/source/sbx/sbxbool.cxx b/basic/source/sbx/sbxbool.cxx index cb8e0c3eba37..f199373165b1 100644 --- a/basic/source/sbx/sbxbool.cxx +++ b/basic/source/sbx/sbxbool.cxx @@ -29,7 +29,7 @@ enum SbxBOOL ImpGetBool( const SbxValues* p ) switch( +p->eType ) { case SbxNULL: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); SAL_FALLTHROUGH; case SbxEMPTY: nRes = SbxFALSE; break; @@ -91,7 +91,7 @@ enum SbxBOOL ImpGetBool( const SbxValues* p ) } } if( bError ) - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } } break; @@ -102,7 +102,7 @@ enum SbxBOOL ImpGetBool( const SbxValues* p ) nRes = pVal->GetBool() ? SbxTRUE : SbxFALSE; else { - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); nRes = SbxFALSE; + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = SbxFALSE; } break; } @@ -132,7 +132,7 @@ enum SbxBOOL ImpGetBool( const SbxValues* p ) case SbxBYREF | SbxSALUINT64: nRes = ( *p->puInt64 ) ? SbxTRUE : SbxFALSE; break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); nRes = SbxFALSE; + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = SbxFALSE; } return nRes; } @@ -187,7 +187,7 @@ void ImpPutBool( SbxValues* p, sal_Int16 n ) if( pVal ) pVal->PutBool( n != 0 ); else - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); break; } case SbxBYREF | SbxCHAR: @@ -215,7 +215,7 @@ void ImpPutBool( SbxValues* p, sal_Int16 n ) case SbxBYREF | SbxSALUINT64: *p->puInt64 = (sal_uInt64) n; break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } } diff --git a/basic/source/sbx/sbxbyte.cxx b/basic/source/sbx/sbxbyte.cxx index 423611ac9b98..4e1e47c54218 100644 --- a/basic/source/sbx/sbxbyte.cxx +++ b/basic/source/sbx/sbxbyte.cxx @@ -32,14 +32,14 @@ start: switch( +p->eType ) { case SbxNULL: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); SAL_FALLTHROUGH; case SbxEMPTY: nRes = 0; break; case SbxCHAR: if( p->nChar > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt8) p->nChar; @@ -50,11 +50,11 @@ start: case SbxBOOL: if( p->nInteger > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXBYTE; } else if( p->nInteger < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt8) p->nInteger; @@ -63,7 +63,7 @@ start: case SbxUSHORT: if( p->nUShort > (sal_uInt16) SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXBYTE; } else nRes = (sal_uInt8) p->nUShort; @@ -71,11 +71,11 @@ start: case SbxLONG: if( p->nLong > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXBYTE; } else if( p->nLong < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt8) p->nLong; @@ -83,7 +83,7 @@ start: case SbxULONG: if( p->nULong > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXBYTE; } else nRes = (sal_uInt8) p->nULong; @@ -96,11 +96,11 @@ start: val = val / CURRENCY_FACTOR; if( val > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXBYTE; } else if( p->nInt64 < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt8) val; @@ -109,7 +109,7 @@ start: case SbxSALUINT64: if( p->uInt64 > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXBYTE; } else nRes = (sal_uInt8) p->uInt64; @@ -117,11 +117,11 @@ start: case SbxSINGLE: if( p->nSingle > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXBYTE; } else if( p->nSingle < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt8) rtl::math::round( p->nSingle ); @@ -143,11 +143,11 @@ start: if( dVal > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXBYTE; } else if( dVal < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt8) rtl::math::round( dVal ); @@ -166,11 +166,11 @@ start: nRes = 0; else if( d > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXBYTE; } else if( d < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt8) ( d + 0.5 ); @@ -183,7 +183,7 @@ start: nRes = pVal->GetByte(); else { - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = 0; } break; } @@ -219,7 +219,7 @@ start: p = &aTmp; goto start; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0; } return nRes; } @@ -272,7 +272,7 @@ void ImpPutByte( SbxValues* p, sal_uInt8 n ) if( pVal ) pVal->PutByte( n ); else - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); break; } case SbxBYREF | SbxCHAR: @@ -302,7 +302,7 @@ void ImpPutByte( SbxValues* p, sal_uInt8 n ) *p->puInt64 = n; break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } } diff --git a/basic/source/sbx/sbxchar.cxx b/basic/source/sbx/sbxchar.cxx index 593c22799b5c..37ce49dc3e06 100644 --- a/basic/source/sbx/sbxchar.cxx +++ b/basic/source/sbx/sbxchar.cxx @@ -32,7 +32,7 @@ start: switch( +p->eType ) { case SbxNULL: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); SAL_FALLTHROUGH; case SbxEMPTY: nRes = 0; break; @@ -45,7 +45,7 @@ start: case SbxBOOL: if( p->nInteger < SbxMINCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMINCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMINCHAR; } else nRes = (sal_Unicode) p->nInteger; @@ -57,11 +57,11 @@ start: case SbxLONG: if( p->nLong > SbxMAXCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXCHAR; } else if( p->nLong < SbxMINCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMINCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMINCHAR; } else nRes = (sal_Unicode) p->nLong; @@ -69,7 +69,7 @@ start: case SbxULONG: if( p->nULong > SbxMAXCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXCHAR; } else nRes = (sal_Unicode) p->nULong; @@ -84,11 +84,11 @@ start: if( val > SbxMAXCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXCHAR; } else if( p->nInt64 < SbxMINCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMINCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMINCHAR; } else nRes = (sal_Unicode) val; @@ -97,7 +97,7 @@ start: case SbxSALUINT64: if( p->uInt64 > SbxMAXCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXCHAR; } else nRes = (sal_Unicode) p->uInt64; @@ -105,11 +105,11 @@ start: case SbxSINGLE: if( p->nSingle > SbxMAXCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXCHAR; } else if( p->nSingle < SbxMINCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMINCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMINCHAR; } else nRes = (sal_Unicode) rtl::math::round( p->nSingle ); @@ -131,11 +131,11 @@ start: if( dVal > SbxMAXCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXCHAR; } else if( dVal < SbxMINCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMINCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMINCHAR; } else nRes = (sal_uInt8) rtl::math::round( dVal ); @@ -152,11 +152,11 @@ start: nRes = 0; else if( d > SbxMAXCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXCHAR; } else if( d < SbxMINCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMINCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMINCHAR; } else nRes = (sal_Unicode) rtl::math::round( d ); @@ -169,7 +169,7 @@ start: nRes = pVal->GetChar(); else { - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = 0; } break; } @@ -204,7 +204,7 @@ start: p = &aTmp; goto start; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0; } return nRes; } @@ -263,7 +263,7 @@ start: if( pVal ) pVal->PutChar( n ); else - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); break; } case SbxBYREF | SbxCHAR: @@ -293,7 +293,7 @@ start: *p->puInt64 = n; break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } } diff --git a/basic/source/sbx/sbxcoll.cxx b/basic/source/sbx/sbxcoll.cxx index 9b41cb2a18b3..71da6cc8bee0 100644 --- a/basic/source/sbx/sbxcoll.cxx +++ b/basic/source/sbx/sbxcoll.cxx @@ -166,14 +166,14 @@ void SbxCollection::CollAdd( SbxArray* pPar_ ) { if( pPar_->Count() != 2 ) { - SetError( ERRCODE_SBX_WRONG_ARGS ); + SetError( ERRCODE_BASIC_WRONG_ARGS ); } else { SbxBase* pObj = pPar_->Get( 1 )->GetObject(); if( !pObj || dynamic_cast(pObj) == nullptr ) { - SetError( ERRCODE_SBX_NOTIMP ); + SetError( ERRCODE_BASIC_BAD_ARGUMENT ); } else { @@ -188,7 +188,7 @@ void SbxCollection::CollItem( SbxArray* pPar_ ) { if( pPar_->Count() != 2 ) { - SetError( ERRCODE_SBX_WRONG_ARGS ); + SetError( ERRCODE_BASIC_WRONG_ARGS ); } else { @@ -208,7 +208,7 @@ void SbxCollection::CollItem( SbxArray* pPar_ ) } if( !pRes ) { - SetError( ERRCODE_SBX_BAD_INDEX ); + SetError( ERRCODE_BASIC_BAD_INDEX ); } pPar_->Get( 0 )->PutObject( pRes ); } @@ -219,12 +219,12 @@ void SbxCollection::CollItem( SbxArray* pPar_ ) void SbxCollection::CollRemove( SbxArray* pPar_ ) { if( pPar_->Count() != 2 ) - SetError( ERRCODE_SBX_WRONG_ARGS ); + SetError( ERRCODE_BASIC_WRONG_ARGS ); else { short n = pPar_->Get( 1 )->GetInteger(); if( n < 1 || n > (short) pObjs->Count() ) - SetError( ERRCODE_SBX_BAD_INDEX ); + SetError( ERRCODE_BASIC_BAD_INDEX ); else Remove( pObjs->Get( (sal_uInt16) n - 1 ) ); } @@ -253,7 +253,7 @@ SbxStdCollection& SbxStdCollection::operator=( const SbxStdCollection& r ) { if( !r.aElemClass.equalsIgnoreAsciiCase( aElemClass ) ) { - SetError( ERRCODE_SBX_CONVERSION ); + SetError( ERRCODE_BASIC_CONVERSION ); } else { @@ -272,7 +272,7 @@ void SbxStdCollection::Insert( SbxVariable* p ) { SbxObject* pObj = dynamic_cast( p ); if( pObj && !pObj->IsClass( aElemClass ) ) - SetError( ERRCODE_SBX_BAD_ACTION ); + SetError( ERRCODE_BASIC_BAD_ACTION ); else SbxCollection::Insert( p ); } @@ -280,7 +280,7 @@ void SbxStdCollection::Insert( SbxVariable* p ) void SbxStdCollection::CollAdd( SbxArray* pPar_ ) { if( !bAddRemoveOk ) - SetError( ERRCODE_SBX_BAD_ACTION ); + SetError( ERRCODE_BASIC_BAD_ACTION ); else SbxCollection::CollAdd( pPar_ ); } @@ -288,7 +288,7 @@ void SbxStdCollection::CollAdd( SbxArray* pPar_ ) void SbxStdCollection::CollRemove( SbxArray* pPar_ ) { if( !bAddRemoveOk ) - SetError( ERRCODE_SBX_BAD_ACTION ); + SetError( ERRCODE_BASIC_BAD_ACTION ); else SbxCollection::CollRemove( pPar_ ); } diff --git a/basic/source/sbx/sbxcurr.cxx b/basic/source/sbx/sbxcurr.cxx index ed0badced771..ed1d1db2c546 100644 --- a/basic/source/sbx/sbxcurr.cxx +++ b/basic/source/sbx/sbxcurr.cxx @@ -146,7 +146,7 @@ static sal_Int64 ImpStringToCurrency( const OUString &rStr ) // complains. if ( p != sTmp.getStr() + sTmp.getLength() ) - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); while( nFractDigit ) { sNormalisedNumString.append( '0' ); @@ -170,7 +170,7 @@ start: { case SbxERROR: case SbxNULL: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0; break; case SbxEMPTY: nRes = 0; break; @@ -206,7 +206,7 @@ start: // you know for sure the 'break' above is intentional. if ( nRes > SbxMAXSALINT64 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXSALINT64; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXSALINT64; } #endif } @@ -216,11 +216,11 @@ start: // As above if ( nRes > SbxMAXSALINT64 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXSALINT64; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXSALINT64; } else if ( nRes < SbxMINSALINT64 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMINSALINT64; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMINSALINT64; } break; #endif @@ -232,7 +232,7 @@ start: nRes = SAL_MAX_INT64; if( p->nSingle * CURRENCY_FACTOR - 0.5 < (float)SAL_MIN_INT64 ) nRes = SAL_MIN_INT64; - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); break; } nRes = ImpDoubleToCurrency( (double)p->nSingle ); @@ -246,7 +246,7 @@ start: nRes = SAL_MAX_INT64; if( p->nDouble * CURRENCY_FACTOR - 0.5 < (double)SAL_MIN_INT64 ) nRes = SAL_MIN_INT64; - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); break; } nRes = ImpDoubleToCurrency( p->nDouble ); @@ -278,7 +278,7 @@ start: nRes = pVal->GetCurrency(); else { - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes=0; } break; @@ -319,7 +319,7 @@ start: p = &aTmp; goto start; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes=0; } return nRes; @@ -370,7 +370,7 @@ start: { SbxDecimal* pDec = ImpCreateDecimal( p ); if( !pDec->setDouble( ImpCurrencyToDouble( r ) / CURRENCY_FACTOR ) ) - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); break; } case SbxBYREF | SbxSTRING: @@ -387,7 +387,7 @@ start: if( pVal ) pVal->PutCurrency( r ); else - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); break; } case SbxBYREF | SbxCHAR: @@ -395,11 +395,11 @@ start: sal_Int64 val = r / CURRENCY_FACTOR; if( val > SbxMAXCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); val = SbxMAXCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); val = SbxMAXCHAR; } else if( val < SbxMINCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); val = SbxMINCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); val = SbxMINCHAR; } *p->pChar = (sal_Unicode) val; break; } @@ -408,11 +408,11 @@ start: sal_Int64 val = r / CURRENCY_FACTOR; if( val > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); val = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); val = SbxMAXBYTE; } else if( val < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); val = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); val = 0; } *p->pByte = (sal_uInt8) val; break; } @@ -422,11 +422,11 @@ start: sal_Int64 val = r / CURRENCY_FACTOR; if( r > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); val = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); val = SbxMAXINT; } else if( r < SbxMININT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); val = SbxMININT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); val = SbxMININT; } *p->pInteger = (sal_uInt16) val; break; } @@ -436,11 +436,11 @@ start: sal_Int64 val = r / CURRENCY_FACTOR; if( val > SbxMAXUINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); val = SbxMAXUINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); val = SbxMAXUINT; } else if( val < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); val = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); val = 0; } *p->pUShort = (sal_uInt16) val; break; } @@ -449,11 +449,11 @@ start: sal_Int64 val = r / CURRENCY_FACTOR; if( val > SbxMAXLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); val = SbxMAXLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); val = SbxMAXLNG; } else if( val < SbxMINLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); val = SbxMINLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); val = SbxMINLNG; } *p->pLong = (sal_Int32) val; break; } @@ -462,11 +462,11 @@ start: sal_Int64 val = r / CURRENCY_FACTOR; if( val > SbxMAXULNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); val = SbxMAXULNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); val = SbxMAXULNG; } else if( val < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); val = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); val = 0; } *p->pULong = (sal_uInt32) val; break; } @@ -482,7 +482,7 @@ start: case SbxBYREF | SbxDOUBLE: *p->pDouble = ImpCurrencyToDouble( r ); break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } } diff --git a/basic/source/sbx/sbxdate.cxx b/basic/source/sbx/sbxdate.cxx index bf85af3f7c80..9dc76f3d78f4 100644 --- a/basic/source/sbx/sbxdate.cxx +++ b/basic/source/sbx/sbxdate.cxx @@ -39,7 +39,7 @@ double ImpGetDate( const SbxValues* p ) switch( +p->eType ) { case SbxNULL: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); SAL_FALLTHROUGH; case SbxEMPTY: nRes = 0; @@ -144,7 +144,7 @@ double ImpGetDate( const SbxValues* p ) if ( !bSuccess ) { - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0; } } break; @@ -156,7 +156,7 @@ double ImpGetDate( const SbxValues* p ) } else { - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = 0; } break; case SbxBYREF | SbxCHAR: @@ -196,7 +196,7 @@ double ImpGetDate( const SbxValues* p ) nRes = ImpSalUInt64ToDouble( *p->puInt64 ); break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0; break; } return nRes; @@ -251,7 +251,7 @@ start: pDec = ImpCreateDecimal( p ); if( !pDec->setDouble( n ) ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); } break; direct: @@ -324,28 +324,28 @@ start: } else { - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); } break; case SbxBYREF | SbxCHAR: if( n > SbxMAXCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXCHAR; } else if( n < SbxMINCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMINCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINCHAR; } *p->pChar = (sal_Unicode) n; break; case SbxBYREF | SbxBYTE: if( n > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXBYTE; } else if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pByte = (sal_uInt8) n; break; @@ -353,11 +353,11 @@ start: case SbxBYREF | SbxBOOL: if( n > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXINT; } else if( n < SbxMININT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMININT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMININT; } *p->pInteger = (sal_Int16) n; break; @@ -365,44 +365,44 @@ start: case SbxBYREF | SbxUSHORT: if( n > SbxMAXUINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXUINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXUINT; } else if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: if( n > SbxMAXLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXLNG; } else if( n < SbxMINLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMINLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINLNG; } *p->pLong = (sal_Int32) n; break; case SbxBYREF | SbxULONG: if( n > SbxMAXULNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXULNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXULNG; } else if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pULong = (sal_uInt32) n; break; case SbxBYREF | SbxSINGLE: if( n > SbxMAXSNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXSNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXSNG; } else if( n < SbxMINSNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMINSNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINSNG; } *p->pSingle = (float) n; break; @@ -419,16 +419,16 @@ start: case SbxBYREF | SbxCURRENCY: if( n > SbxMAXCURR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXCURR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXCURR; } else if( n < SbxMINCURR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMINCURR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINCURR; } *p->pnInt64 = ImpDoubleToCurrency( n ); break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); break; } } diff --git a/basic/source/sbx/sbxdbl.cxx b/basic/source/sbx/sbxdbl.cxx index e4f8b16a9d9c..ac753a5633cc 100644 --- a/basic/source/sbx/sbxdbl.cxx +++ b/basic/source/sbx/sbxdbl.cxx @@ -30,7 +30,7 @@ double ImpGetDouble( const SbxValues* p ) switch( +p->eType ) { case SbxNULL: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); SAL_FALLTHROUGH; case SbxEMPTY: nRes = 0; break; @@ -74,7 +74,7 @@ double ImpGetDouble( const SbxValues* p ) nRes = 0; #if HAVE_FEATURE_SCRIPTING if ( SbiRuntime::isVBAEnabled() )// VBA only behaviour - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); #endif } else @@ -86,7 +86,7 @@ double ImpGetDouble( const SbxValues* p ) nRes = 0; #if HAVE_FEATURE_SCRIPTING if ( SbiRuntime::isVBAEnabled() )// VBA only behaviour - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); #endif } else @@ -100,7 +100,7 @@ double ImpGetDouble( const SbxValues* p ) nRes = pVal->GetDouble(); else { - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = 0; } break; } @@ -132,7 +132,7 @@ double ImpGetDouble( const SbxValues* p ) nRes = ImpSalUInt64ToDouble( *p->puInt64 ); break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0; } return nRes; } @@ -165,7 +165,7 @@ start: { SbxDecimal* pDec = ImpCreateDecimal( p ); if( !pDec->setDouble( n ) ) - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); break; } direct: @@ -175,11 +175,11 @@ start: case SbxCURRENCY: if( n > SbxMAXCURR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXCURR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXCURR; } else if( n < SbxMINCURR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMINCURR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINCURR; } p->nInt64 = ImpDoubleToCurrency( n ); break; @@ -206,87 +206,87 @@ start: if( pVal ) pVal->PutDouble( n ); else - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); break; } case SbxBYREF | SbxCHAR: if( n > SbxMAXCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXCHAR; } else if( n < SbxMINCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMINCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINCHAR; } *p->pChar = (sal_Unicode) n; break; case SbxBYREF | SbxBYTE: if( n > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXBYTE; } else if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: if( n > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXINT; } else if( n < SbxMININT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMININT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMININT; } *p->pInteger = (sal_Int16) n; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: if( n > SbxMAXUINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXUINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXUINT; } else if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: if( n > SbxMAXLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXLNG; } else if( n < SbxMINLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMINLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINLNG; } *p->pLong = (sal_Int32) n; break; case SbxBYREF | SbxULONG: if( n > SbxMAXULNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXULNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXULNG; } else if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pULong = (sal_uInt32) n; break; case SbxBYREF | SbxSINGLE: if( n > SbxMAXSNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXSNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXSNG; } else if( n < SbxMINSNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMINSNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINSNG; } else if( n > 0 && n < SbxMAXSNG2 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXSNG2; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXSNG2; } else if( n < 0 && n > SbxMINSNG2 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMINSNG2; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINSNG2; } *p->pSingle = (float) n; break; case SbxBYREF | SbxSALINT64: @@ -299,16 +299,16 @@ start: case SbxBYREF | SbxCURRENCY: if( n > SbxMAXCURR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXCURR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXCURR; } else if( n < SbxMINCURR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMINCURR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINCURR; } *p->pnInt64 = ImpDoubleToCurrency( n ); break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } } diff --git a/basic/source/sbx/sbxdec.cxx b/basic/source/sbx/sbxdec.cxx index 7060e3a4db35..99d46128c9da 100644 --- a/basic/source/sbx/sbxdec.cxx +++ b/basic/source/sbx/sbxdec.cxx @@ -421,7 +421,7 @@ start: switch( +eType ) { case SbxNULL: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); SAL_FALLTHROUGH; case SbxEMPTY: pnDecRes->setShort( 0 ); break; @@ -441,24 +441,24 @@ start: pnDecRes->setULong( p->nULong ); break; case SbxSINGLE: if( !pnDecRes->setSingle( p->nSingle ) ) - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); break; case SbxCURRENCY: { if( !pnDecRes->setDouble( ImpCurrencyToDouble( p->nInt64 ) ) ) - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); break; } case SbxSALINT64: { if( !pnDecRes->setDouble( (double)p->nInt64 ) ) - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); break; } case SbxSALUINT64: { if( !pnDecRes->setDouble( (double)p->uInt64 ) ) - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); break; } case SbxDATE: @@ -466,7 +466,7 @@ start: { double dVal = p->nDouble; if( !pnDecRes->setDouble( dVal ) ) - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); break; } case SbxLPSTR: @@ -482,7 +482,7 @@ start: pnDecRes->setDecimal( pVal->GetDecimal() ); else { - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); pnDecRes->setShort( 0 ); } break; @@ -519,7 +519,7 @@ start: p = &aTmp; goto start; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); pnDecRes->setShort( 0 ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); pnDecRes->setShort( 0 ); } return pnDecRes; } @@ -600,21 +600,21 @@ start: if( pVal ) pVal->PutDecimal( pDec ); else - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); break; } case SbxBYREF | SbxCHAR: if( !pDec->getChar( *p->pChar ) ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); *p->pChar = 0; } break; case SbxBYREF | SbxBYTE: if( !pDec->getChar( *p->pChar ) ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); *p->pByte = 0; } break; @@ -622,7 +622,7 @@ start: case SbxBYREF | SbxBOOL: if( !pDec->getShort( *p->pInteger ) ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); *p->pInteger = 0; } break; @@ -630,21 +630,21 @@ start: case SbxBYREF | SbxUSHORT: if( !pDec->getUShort( *p->pUShort ) ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); *p->pUShort = 0; } break; case SbxBYREF | SbxLONG: if( !pDec->getLong( *p->pLong ) ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); *p->pLong = 0; } break; case SbxBYREF | SbxULONG: if( !pDec->getULong( *p->pULong ) ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); *p->pULong = 0; } break; @@ -652,7 +652,7 @@ start: { double d(0.0); if( !pDec->getDouble( d ) ) - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); *p->pnInt64 = ImpDoubleToCurrency( d ); } break; @@ -660,7 +660,7 @@ start: { double d(0.0); if( !pDec->getDouble( d ) ) - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); else *p->pnInt64 = ImpDoubleToSalInt64( d ); } @@ -669,7 +669,7 @@ start: { double d(0.0); if( !pDec->getDouble( d ) ) - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); else *p->puInt64 = ImpDoubleToSalUInt64( d ); } @@ -677,7 +677,7 @@ start: case SbxBYREF | SbxSINGLE: if( !pDec->getSingle( *p->pSingle ) ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); *p->pSingle = 0; } break; @@ -685,12 +685,12 @@ start: case SbxBYREF | SbxDOUBLE: if( !pDec->getDouble( *p->pDouble ) ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); *p->pDouble = 0; } break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } } diff --git a/basic/source/sbx/sbxexec.cxx b/basic/source/sbx/sbxexec.cxx index b33905ba20f9..a74cdf5c2655 100644 --- a/basic/source/sbx/sbxexec.cxx +++ b/basic/source/sbx/sbxexec.cxx @@ -57,7 +57,7 @@ static const sal_Unicode* Symbol( const sal_Unicode* p, OUString& rSym ) // A symbol had to begin with a alphabetic character or an underline if( !rtl::isAsciiAlpha( *p ) && *p != '_' ) { - SbxBase::SetError( ERRCODE_SBX_SYNTAX ); + SbxBase::SetError( ERRCODE_BASIC_SYNTAX ); } else { @@ -108,7 +108,7 @@ static SbxVariableRef QualifiedName } } else - SbxBase::SetError( ERRCODE_SBX_SYNTAX ); + SbxBase::SetError( ERRCODE_BASIC_SYNTAX ); *ppBuf = p; return refVar; } @@ -244,7 +244,7 @@ static SbxVariableRef Assign( SbxObject* pObj, SbxObject* pGbl, const sal_Unicod // Assign only onto properties! if( refVar->GetClass() != SbxClassType::Property ) { - SbxBase::SetError( ERRCODE_SBX_BAD_ACTION ); + SbxBase::SetError( ERRCODE_BASIC_BAD_ACTION ); refVar.clear(); } else @@ -327,7 +327,7 @@ static SbxVariableRef Element } } else - SbxBase::SetError( ERRCODE_SBX_NO_METHOD ); + SbxBase::SetError( ERRCODE_BASIC_NO_METHOD ); } *ppBuf = p; return refVar; @@ -348,7 +348,7 @@ SbxVariable* SbxObject::Execute( const OUString& rTxt ) } if( *p++ != '[' ) { - SetError( ERRCODE_SBX_SYNTAX ); break; + SetError( ERRCODE_BASIC_SYNTAX ); break; } pVar = Assign( this, this, &p ); if( !pVar.is() ) @@ -358,7 +358,7 @@ SbxVariable* SbxObject::Execute( const OUString& rTxt ) p = SkipWhitespace( p ); if( *p++ != ']' ) { - SetError( ERRCODE_SBX_SYNTAX ); break; + SetError( ERRCODE_BASIC_SYNTAX ); break; } } return pVar.get(); @@ -377,7 +377,7 @@ SbxVariable* SbxObject::FindQualified( const OUString& rName, SbxClassType t ) p = SkipWhitespace( p ); if( *p ) { - SetError( ERRCODE_SBX_SYNTAX ); + SetError( ERRCODE_BASIC_SYNTAX ); } return pVar.get(); } diff --git a/basic/source/sbx/sbxint.cxx b/basic/source/sbx/sbxint.cxx index 7edef31d48d3..e43d6e5d8442 100644 --- a/basic/source/sbx/sbxint.cxx +++ b/basic/source/sbx/sbxint.cxx @@ -32,7 +32,7 @@ start: switch( +p->eType ) { case SbxNULL: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); SAL_FALLTHROUGH; case SbxEMPTY: nRes = 0; break; @@ -47,7 +47,7 @@ start: case SbxUSHORT: if( p->nUShort > (sal_uInt16) SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXINT; } else nRes = (sal_Int16) p->nUShort; @@ -55,11 +55,11 @@ start: case SbxLONG: if( p->nLong > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXINT; } else if( p->nLong < SbxMININT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMININT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMININT; } else nRes = (sal_Int16) p->nLong; @@ -67,7 +67,7 @@ start: case SbxULONG: if( p->nULong > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXINT; } else nRes = (sal_Int16) p->nULong; @@ -75,11 +75,11 @@ start: case SbxSINGLE: if( p->nSingle > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXINT; } else if( p->nSingle < SbxMININT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMININT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMININT; } else nRes = (sal_Int16) rtl::math::round( p->nSingle ); @@ -90,11 +90,11 @@ start: if( tstVal > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXINT; } else if( tstVal < SbxMININT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMININT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMININT; } else nRes = (sal_Int16) tstVal; @@ -103,11 +103,11 @@ start: case SbxSALINT64: if( p->nInt64 > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXINT; } else if( p->nInt64 < SbxMININT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMININT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMININT; } else nRes = (sal_Int16) p->nInt64; @@ -115,7 +115,7 @@ start: case SbxSALUINT64: if( p->uInt64 > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXINT; } else nRes = (sal_Int16) p->uInt64; @@ -136,11 +136,11 @@ start: if( dVal > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXINT; } else if( dVal < SbxMININT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMININT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMININT; } else nRes = (sal_Int16) rtl::math::round( dVal ); @@ -159,11 +159,11 @@ start: nRes = 0; else if( d > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXINT; } else if( d < SbxMININT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMININT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMININT; } else nRes = (sal_Int16) rtl::math::round( d ); @@ -176,7 +176,7 @@ start: nRes = pVal->GetInteger(); else { - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = 0; } break; } @@ -212,7 +212,7 @@ start: p = &aTmp; goto start; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0; } return nRes; } @@ -272,23 +272,23 @@ start: if( pVal ) pVal->PutInteger( n ); else - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); break; } case SbxBYREF | SbxCHAR: if( n < SbxMINCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMINCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINCHAR; } *p->pChar = (char) n; break; case SbxBYREF | SbxBYTE: if( n > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXBYTE; } else if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: @@ -298,7 +298,7 @@ start: case SbxBYREF | SbxUSHORT: if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: @@ -306,7 +306,7 @@ start: case SbxBYREF | SbxULONG: if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pULong = (sal_uInt32) n; break; case SbxBYREF | SbxCURRENCY: @@ -316,7 +316,7 @@ start: case SbxBYREF | SbxSALUINT64: if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); *p->puInt64 = 0; } else @@ -329,7 +329,7 @@ start: *p->pDouble = (double) n; break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } } @@ -341,11 +341,11 @@ sal_Int64 ImpDoubleToSalInt64( double d ) sal_Int64 nRes; if( d > SbxMAXSALINT64 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXSALINT64; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXSALINT64; } else if( d < SbxMINSALINT64 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMINSALINT64; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMINSALINT64; } else nRes = (sal_Int64) rtl::math::round( d ); @@ -357,11 +357,11 @@ sal_uInt64 ImpDoubleToSalUInt64( double d ) sal_uInt64 nRes; if( d > SbxMAXSALUINT64 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXSALUINT64; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXSALUINT64; } else if( d < 0.0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt64) rtl::math::round( d ); @@ -373,7 +373,7 @@ double ImpSalUInt64ToDouble( sal_uInt64 n ) { double d = 0.0; if( n > SbxMAXSALINT64 ) - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); else d = (double)(sal_Int64) n; return d; @@ -388,7 +388,7 @@ start: switch( +p->eType ) { case SbxNULL: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); SAL_FALLTHROUGH; case SbxEMPTY: nRes = 0; break; @@ -420,7 +420,7 @@ start: case SbxSALUINT64: if( p->uInt64 > SbxMAXSALINT64 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXSALINT64; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXSALINT64; } else nRes = (sal_Int64) p->uInt64; @@ -455,7 +455,7 @@ start: nRes = pVal->GetInt64(); else { - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = 0; } break; } @@ -493,7 +493,7 @@ start: p = &aTmp; goto start; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0; } return nRes; } @@ -554,69 +554,69 @@ start: if( pVal ) pVal->PutInt64( n ); else - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); break; } case SbxBYREF | SbxCHAR: if( n > SbxMAXCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXCHAR; } else if( n < SbxMINCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMINCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINCHAR; } *p->pChar = (sal_Unicode) n; break; case SbxBYREF | SbxBYTE: if( n > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXBYTE; } else if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: if( n > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXINT; } else if( n < SbxMININT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMININT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMININT; } *p->pInteger = (sal_Int16) n; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: if( n > SbxMAXUINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXUINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXUINT; } else if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: if( n > SbxMAXLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXLNG; } else if( n < SbxMINLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMINLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINLNG; } *p->pLong = (sal_Int32) n; break; case SbxBYREF | SbxULONG: if( n > SbxMAXULNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXULNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXULNG; } else if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pULong = (sal_uInt32) n; break; case SbxBYREF | SbxSINGLE: @@ -631,12 +631,12 @@ start: case SbxBYREF | SbxSALUINT64: if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->puInt64 = n; break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } } @@ -648,7 +648,7 @@ start: switch( +p->eType ) { case SbxNULL: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); SAL_FALLTHROUGH; case SbxEMPTY: nRes = 0; break; @@ -680,7 +680,7 @@ start: case SbxSALINT64: if( p->nInt64 < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt64) p->nInt64; @@ -707,18 +707,18 @@ start: nRes = 0; else if( d > SbxMAXSALUINT64 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXSALUINT64; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXSALUINT64; } else if( d < 0.0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt64) rtl::math::round( d ); } else if( n64 < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else { @@ -733,7 +733,7 @@ start: nRes = pVal->GetUInt64(); else { - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = 0; } break; } @@ -769,7 +769,7 @@ start: p = &aTmp; goto start; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0; } return nRes; } @@ -819,7 +819,7 @@ start: if( !p->pOUString ) p->pOUString = new OUString; if( n > SbxMAXSALINT64 ) - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); else { ::OString aOStr = OString::number( n ); @@ -833,45 +833,45 @@ start: if( pVal ) pVal->PutUInt64( n ); else - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); break; } case SbxBYREF | SbxCHAR: if( n > SbxMAXCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXCHAR; } *p->pChar = (sal_Unicode) n; break; case SbxBYREF | SbxBYTE: if( n > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXBYTE; } *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: if( n > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXINT; } *p->pInteger = (sal_Int16) n; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: if( n > SbxMAXUINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXUINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXUINT; } *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: if( n > SbxMAXLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXLNG; } *p->pLong = (sal_Int32) n; break; case SbxBYREF | SbxULONG: if( n > SbxMAXULNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXULNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXULNG; } *p->pULong = (sal_uInt32) n; break; case SbxBYREF | SbxSINGLE: @@ -883,7 +883,7 @@ start: case SbxBYREF | SbxCURRENCY: if ( n > ( SbxMAXSALINT64 / CURRENCY_FACTOR ) ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXSALINT64; } *p->pnInt64 = ( sal_Int64) ( n * CURRENCY_FACTOR ); break; @@ -892,12 +892,12 @@ start: case SbxBYREF | SbxSALINT64: if( n > SbxMAXSALINT64 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pnInt64 = (sal_Int64) n; break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } } diff --git a/basic/source/sbx/sbxlng.cxx b/basic/source/sbx/sbxlng.cxx index 0eadecb07423..c1436d5aa09e 100644 --- a/basic/source/sbx/sbxlng.cxx +++ b/basic/source/sbx/sbxlng.cxx @@ -32,7 +32,7 @@ start: switch( +p->eType ) { case SbxNULL: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); SAL_FALLTHROUGH; case SbxEMPTY: nRes = 0; break; @@ -51,7 +51,7 @@ start: case SbxULONG: if( p->nULong > SbxMAXLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXLNG; } else nRes = (sal_Int32) p->nULong; @@ -59,11 +59,11 @@ start: case SbxSINGLE: if( p->nSingle > SbxMAXLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXLNG; } else if( p->nSingle < SbxMINLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMINLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMINLNG; } else nRes = (sal_Int32) rtl::math::round( p->nSingle ); @@ -78,7 +78,7 @@ start: { sal_Int64 tstVal = p->nInt64 / CURRENCY_FACTOR; nRes = (sal_Int32) tstVal; - if( tstVal < SbxMINLNG || SbxMAXLNG < tstVal ) SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + if( tstVal < SbxMINLNG || SbxMAXLNG < tstVal ) SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); if( SbxMAXLNG < tstVal ) nRes = SbxMAXLNG; if( tstVal < SbxMINLNG ) nRes = SbxMINLNG; break; @@ -100,11 +100,11 @@ start: if( dVal > SbxMAXLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXLNG; } else if( dVal < SbxMINLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMINLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMINLNG; } else nRes = (sal_Int32) rtl::math::round( dVal ); @@ -123,11 +123,11 @@ start: nRes = 0; else if( d > SbxMAXLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXLNG; } else if( d < SbxMINLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMINLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMINLNG; } else nRes = (sal_Int32) rtl::math::round( d ); @@ -140,7 +140,7 @@ start: nRes = pVal->GetLong(); else { - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = 0; } break; } @@ -177,7 +177,7 @@ start: p = &aTmp; goto start; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0; } return nRes; } @@ -238,49 +238,49 @@ start: if( pVal ) pVal->PutLong( n ); else - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); break; } case SbxBYREF | SbxCHAR: if( n > SbxMAXCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXCHAR; } else if( n < SbxMINCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMINCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINCHAR; } *p->pChar = (sal_Unicode) n; break; case SbxBYREF | SbxBYTE: if( n > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXBYTE; } else if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: if( n > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXINT; } else if( n < SbxMININT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMININT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMININT; } *p->pInteger = (sal_Int16) n; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: if( n > SbxMAXUINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXUINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXUINT; } else if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: @@ -288,7 +288,7 @@ start: case SbxBYREF | SbxULONG: if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pULong = (sal_uInt32) n; break; case SbxBYREF | SbxSALINT64: @@ -296,7 +296,7 @@ start: case SbxBYREF | SbxSALUINT64: if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); *p->puInt64 = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); *p->puInt64 = 0; } else *p->puInt64 = n; @@ -309,7 +309,7 @@ start: case SbxBYREF | SbxCURRENCY: *p->pnInt64 = (sal_Int64)n * (sal_Int64)CURRENCY_FACTOR; break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } } diff --git a/basic/source/sbx/sbxobj.cxx b/basic/source/sbx/sbxobj.cxx index 9e331905f73b..4bdc64e86c1f 100644 --- a/basic/source/sbx/sbxobj.cxx +++ b/basic/source/sbx/sbxobj.cxx @@ -300,7 +300,7 @@ bool SbxObject::Call( const OUString& rName, SbxArray* pParam ) pMeth->SetParameters( nullptr ); return true; } - SetError( ERRCODE_SBX_NO_METHOD ); + SetError( ERRCODE_BASIC_NO_METHOD ); return false; } diff --git a/basic/source/sbx/sbxscan.cxx b/basic/source/sbx/sbxscan.cxx index 59b1c7b61e29..2e2cb082ac57 100644 --- a/basic/source/sbx/sbxscan.cxx +++ b/basic/source/sbx/sbxscan.cxx @@ -257,13 +257,13 @@ ErrCode ImpScan( const OUString& rWSrc, double& nVal, SbxDataType& rType, else if ( SbiRuntime::isVBAEnabled() ) { SAL_WARN("basic", "Reporting error converting"); - return ERRCODE_SBX_CONVERSION; + return ERRCODE_BASIC_CONVERSION; } #endif if( pLen ) *pLen = (sal_uInt16) ( p - pStart ); if( !bRes ) - return ERRCODE_SBX_CONVERSION; + return ERRCODE_BASIC_CONVERSION; if( bMinus ) nVal = -nVal; rType = eScanType; @@ -280,7 +280,7 @@ ErrCode SbxValue::ScanNumIntnl( const OUString& rSrc, double& nVal, bool bSingle // read completely? if( nRetError == ERRCODE_NONE && nLen != rSrc.getLength() ) { - nRetError = ERRCODE_SBX_CONVERSION; + nRetError = ERRCODE_BASIC_CONVERSION; } if( bSingle ) { @@ -552,7 +552,7 @@ bool SbxValue::Scan( const OUString& rSrc, sal_uInt16* pLen ) ErrCode eRes = ERRCODE_NONE; if( !CanWrite() ) { - eRes = ERRCODE_SBX_PROP_READONLY; + eRes = ERRCODE_BASIC_PROP_READONLY; } else { diff --git a/basic/source/sbx/sbxsng.cxx b/basic/source/sbx/sbxsng.cxx index fc972379f133..7406077852c1 100644 --- a/basic/source/sbx/sbxsng.cxx +++ b/basic/source/sbx/sbxsng.cxx @@ -30,7 +30,7 @@ start: switch( +p->eType ) { case SbxNULL: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); SAL_FALLTHROUGH; case SbxEMPTY: nRes = 0; break; @@ -75,23 +75,23 @@ start: if( dVal > SbxMAXSNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = static_cast< float >(SbxMAXSNG); } else if( dVal < SbxMINSNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = static_cast< float >(SbxMINSNG); } // tests for underflow - storing value too small for precision of single else if( dVal > 0 && dVal < SbxMAXSNG2 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = static_cast< float >(SbxMAXSNG2); } else if( dVal < 0 && dVal > SbxMINSNG2 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = static_cast< float >(SbxMINSNG2); } else @@ -111,12 +111,12 @@ start: nRes = 0; else if( d > SbxMAXSNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = static_cast< float >(SbxMAXSNG); } else if( d < SbxMINSNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = static_cast< float >(SbxMINSNG); } else @@ -130,7 +130,7 @@ start: nRes = pVal->GetSingle(); else { - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = 0; } break; } @@ -165,7 +165,7 @@ start: p = &aTmp; goto start; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0; } return nRes; } @@ -200,7 +200,7 @@ start: { SbxDecimal* pDec = ImpCreateDecimal( p ); if( !pDec->setSingle( n ) ) - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); break; } direct: @@ -229,49 +229,49 @@ start: if( pVal ) pVal->PutSingle( n ); else - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); break; } case SbxBYREF | SbxCHAR: if( n > SbxMAXCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXCHAR; } else if( n < SbxMINCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMINCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMINCHAR; } *p->pChar = (sal_Unicode) n; break; case SbxBYREF | SbxBYTE: if( n > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXBYTE; } else if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: if( n > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXINT; } else if( n < SbxMININT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMININT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMININT; } *p->pInteger = (sal_Int16) n; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: if( n > SbxMAXUINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXUINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXUINT; } else if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = 0; } *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: @@ -279,11 +279,11 @@ start: sal_Int32 i; if( n > SbxMAXLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); i = SbxMAXLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); i = SbxMAXLNG; } else if( n < SbxMINLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); i = SbxMINLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); i = SbxMINLNG; } else { @@ -296,11 +296,11 @@ start: sal_uInt32 i; if( n > SbxMAXULNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); i = SbxMAXULNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); i = SbxMAXULNG; } else if( n < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); i = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); i = 0; } else { @@ -321,11 +321,11 @@ start: double d; if( n > SbxMAXCURR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); d = SbxMAXCURR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); d = SbxMAXCURR; } else if( n < SbxMINCURR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); d = SbxMINCURR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); d = SbxMINCURR; } else { @@ -334,7 +334,7 @@ start: *p->pnInt64 = ImpDoubleToCurrency( d ); break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } } diff --git a/basic/source/sbx/sbxstr.cxx b/basic/source/sbx/sbxstr.cxx index 1a448c3a95d6..61c85fcd2f88 100644 --- a/basic/source/sbx/sbxstr.cxx +++ b/basic/source/sbx/sbxstr.cxx @@ -39,7 +39,7 @@ OUString ImpGetString( const SbxValues* p ) switch( +p->eType ) { case SbxNULL: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); SAL_FALLTHROUGH; case SbxEMPTY: break; @@ -97,7 +97,7 @@ OUString ImpGetString( const SbxValues* p ) } else { - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); } break; } @@ -134,7 +134,7 @@ OUString ImpGetString( const SbxValues* p ) case SbxBYREF | SbxSALUINT64: ImpPutUInt64( &aTmp, *p->puInt64 ); break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } return aRes; } @@ -226,7 +226,7 @@ void ImpPutString( SbxValues* p, const OUString* n ) if( pVal ) pVal->PutString( *n ); else - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); break; } case SbxBYREF | SbxCHAR: @@ -258,7 +258,7 @@ void ImpPutString( SbxValues* p, const OUString* n ) case SbxBYREF | SbxSALUINT64: *p->puInt64 = ImpGetUInt64( p ); break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } } diff --git a/basic/source/sbx/sbxuint.cxx b/basic/source/sbx/sbxuint.cxx index d093b5d4b2da..fb366d91afa3 100644 --- a/basic/source/sbx/sbxuint.cxx +++ b/basic/source/sbx/sbxuint.cxx @@ -30,7 +30,7 @@ start: switch( +p->eType ) { case SbxNULL: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); SAL_FALLTHROUGH; case SbxEMPTY: nRes = 0; break; @@ -43,7 +43,7 @@ start: case SbxBOOL: if( p->nInteger < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = p->nInteger; @@ -55,11 +55,11 @@ start: case SbxLONG: if( p->nLong > SbxMAXUINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXUINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXUINT; } else if( p->nLong < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt16) p->nLong; @@ -67,7 +67,7 @@ start: case SbxULONG: if( p->nULong > SbxMAXUINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXUINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXUINT; } else nRes = (sal_uInt16) p->nULong; @@ -75,11 +75,11 @@ start: case SbxCURRENCY: if( p->nInt64 / CURRENCY_FACTOR > SbxMAXUINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXUINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXUINT; } else if( p->nInt64 < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt16) (p->nInt64 / CURRENCY_FACTOR); @@ -87,11 +87,11 @@ start: case SbxSALINT64: if( p->nInt64 > SbxMAXUINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXUINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXUINT; } else if( p->nInt64 < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt16) p->nInt64; @@ -99,7 +99,7 @@ start: case SbxSALUINT64: if( p->uInt64 > SbxMAXUINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXUINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXUINT; } else nRes = (sal_uInt16) p->uInt64; @@ -107,11 +107,11 @@ start: case SbxSINGLE: if( p->nSingle > SbxMAXUINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXUINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXUINT; } else if( p->nSingle < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt16) ( p->nSingle + 0.5 ); @@ -133,11 +133,11 @@ start: if( dVal > SbxMAXUINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXUINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXUINT; } else if( dVal < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt16) ( dVal + 0.5 ); @@ -156,11 +156,11 @@ start: nRes = 0; else if( d > SbxMAXUINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXUINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXUINT; } else if( d < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt16) ( d + 0.5 ); @@ -173,7 +173,7 @@ start: nRes = pVal->GetUShort(); else { - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = 0; } break; } @@ -209,7 +209,7 @@ start: p = &aTmp; goto start; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0; } return nRes; } @@ -269,7 +269,7 @@ start: if( pVal ) pVal->PutUShort( n ); else - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); break; } @@ -278,14 +278,14 @@ start: case SbxBYREF | SbxBYTE: if( n > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXBYTE; } *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: if( n > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXINT; } *p->pInteger = (sal_Int16) n; break; case SbxBYREF | SbxERROR: @@ -308,7 +308,7 @@ start: *p->puInt64 = n; break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } } diff --git a/basic/source/sbx/sbxulng.cxx b/basic/source/sbx/sbxulng.cxx index 0db10aff19d5..5204eb45cc60 100644 --- a/basic/source/sbx/sbxulng.cxx +++ b/basic/source/sbx/sbxulng.cxx @@ -30,7 +30,7 @@ start: switch( +p->eType ) { case SbxNULL: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); SAL_FALLTHROUGH; case SbxEMPTY: nRes = 0; break; @@ -43,7 +43,7 @@ start: case SbxBOOL: if( p->nInteger < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = p->nInteger; @@ -55,7 +55,7 @@ start: case SbxLONG: if( p->nLong < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = p->nLong; @@ -65,11 +65,11 @@ start: case SbxSINGLE: if( p->nSingle > SbxMAXULNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXULNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXULNG; } else if( p->nSingle < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt32) ( p->nSingle + 0.5 ); @@ -100,11 +100,11 @@ start: if( dVal > SbxMAXULNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXULNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXULNG; } else if( dVal < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt32) ( dVal + 0.5 ); @@ -123,11 +123,11 @@ start: nRes = 0; else if( d > SbxMAXULNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = SbxMAXULNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = SbxMAXULNG; } else if( d < 0 ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); nRes = 0; } else nRes = (sal_uInt32) ( d + 0.5 ); @@ -140,7 +140,7 @@ start: nRes = pVal->GetULong(); else { - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); nRes = 0; } break; } @@ -176,7 +176,7 @@ start: p = &aTmp; goto start; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); nRes = 0; + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); nRes = 0; } return nRes; } @@ -234,39 +234,39 @@ start: if( pVal ) pVal->PutULong( n ); else - SbxBase::SetError( ERRCODE_SBX_NO_OBJECT ); + SbxBase::SetError( ERRCODE_BASIC_NO_OBJECT ); break; } case SbxBYREF | SbxCHAR: if( n > SbxMAXCHAR ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXCHAR; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXCHAR; } *p->pChar = (sal_Unicode) n; break; case SbxBYREF | SbxBYTE: if( n > SbxMAXBYTE ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXBYTE; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXBYTE; } *p->pByte = (sal_uInt8) n; break; case SbxBYREF | SbxINTEGER: case SbxBYREF | SbxBOOL: if( n > SbxMAXINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXINT; } *p->pInteger = (sal_Int16) n; break; case SbxBYREF | SbxERROR: case SbxBYREF | SbxUSHORT: if( n > SbxMAXUINT ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXUINT; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXUINT; } *p->pUShort = (sal_uInt16) n; break; case SbxBYREF | SbxLONG: if( n > SbxMAXLNG ) { - SbxBase::SetError( ERRCODE_SBX_OVERFLOW ); n = SbxMAXLNG; + SbxBase::SetError( ERRCODE_BASIC_MATH_OVERFLOW ); n = SbxMAXLNG; } *p->pLong = (sal_Int32) n; break; case SbxBYREF | SbxULONG: @@ -284,7 +284,7 @@ start: *p->puInt64 = n; break; default: - SbxBase::SetError( ERRCODE_SBX_CONVERSION ); + SbxBase::SetError( ERRCODE_BASIC_CONVERSION ); } } diff --git a/basic/source/sbx/sbxvalue.cxx b/basic/source/sbx/sbxvalue.cxx index 687f7293517c..fb52f2e3f0d1 100644 --- a/basic/source/sbx/sbxvalue.cxx +++ b/basic/source/sbx/sbxvalue.cxx @@ -53,7 +53,7 @@ SbxValue::SbxValue( const SbxValue& r ) { if( !r.CanRead() ) { - SetError( ERRCODE_SBX_PROP_WRITEONLY ); + SetError( ERRCODE_BASIC_PROP_WRITEONLY ); if( !IsFixed() ) aData.eType = SbxNULL; } @@ -86,7 +86,7 @@ SbxValue& SbxValue::operator=( const SbxValue& r ) if( &r != this ) { if( !CanWrite() ) - SetError( ERRCODE_SBX_PROP_READONLY ); + SetError( ERRCODE_BASIC_PROP_READONLY ); else { // string -> byte array @@ -224,7 +224,7 @@ SbxValue* SbxValue::TheRealValue( bool bObjInObjError ) const #endif if( !bSuccess ) { - SetError( ERRCODE_SBX_BAD_PROP_VALUE ); + SetError( ERRCODE_BASIC_BAD_PROP_VALUE ); p = nullptr; } } @@ -273,7 +273,7 @@ bool SbxValue::Get( SbxValues& rRes ) const ResetError(); if( !CanRead() ) { - SetError( ERRCODE_SBX_PROP_WRITEONLY ); + SetError( ERRCODE_BASIC_PROP_WRITEONLY ); rRes.pObj = nullptr; } else @@ -332,7 +332,7 @@ bool SbxValue::Get( SbxValues& rRes ) const rRes.pObj = p->aData.pObj; else { - SetError( ERRCODE_SBX_NO_OBJECT ); + SetError( ERRCODE_BASIC_NO_OBJECT ); rRes.pObj = nullptr; } break; @@ -341,7 +341,7 @@ bool SbxValue::Get( SbxValues& rRes ) const rRes = p->aData; else { - SetError( ERRCODE_SBX_CONVERSION ); + SetError( ERRCODE_BASIC_CONVERSION ); rRes.pObj = nullptr; } } @@ -426,9 +426,9 @@ bool SbxValue::Put( const SbxValues& rVal ) if( eOld != ERRCODE_NONE ) ResetError(); if( !CanWrite() ) - SetError( ERRCODE_SBX_PROP_READONLY ); + SetError( ERRCODE_BASIC_PROP_READONLY ); else if( rVal.eType & 0xF000 ) - SetError( ERRCODE_SBX_NOTIMP ); + SetError( ERRCODE_BASIC_BAD_ARGUMENT ); else { // If an object is requested, don't search the real values @@ -438,7 +438,7 @@ bool SbxValue::Put( const SbxValues& rVal ) if( p ) { if( !p->CanWrite() ) - SetError( ERRCODE_SBX_PROP_READONLY ); + SetError( ERRCODE_BASIC_PROP_READONLY ); else if( p->IsFixed() || p->SetType( (SbxDataType) ( rVal.eType & 0x0FFF ) ) ) switch( rVal.eType & 0x0FFF ) { @@ -504,14 +504,14 @@ bool SbxValue::Put( const SbxValues& rVal ) } } else - SetError( ERRCODE_SBX_CONVERSION ); + SetError( ERRCODE_BASIC_CONVERSION ); break; default: if( p->aData.eType == rVal.eType ) p->aData = rVal; else { - SetError( ERRCODE_SBX_CONVERSION ); + SetError( ERRCODE_BASIC_CONVERSION ); if( !p->IsFixed() ) p->aData.eType = SbxNULL; } @@ -684,7 +684,7 @@ bool SbxValue::ImpIsNumeric( bool bOnlyIntntl ) const if( !CanRead() ) { - SetError( ERRCODE_SBX_PROP_WRITEONLY ); + SetError( ERRCODE_BASIC_PROP_WRITEONLY ); return false; } // Test downcast!!! @@ -733,7 +733,7 @@ bool SbxValue::SetType( SbxDataType t ) ResetFlag( SbxFlagBits::Fixed ); if( IsFixed() ) { - SetError( ERRCODE_SBX_CONVERSION ); + SetError( ERRCODE_BASIC_CONVERSION ); return false; } t = SbxEMPTY; @@ -742,7 +742,7 @@ bool SbxValue::SetType( SbxDataType t ) { if( !CanWrite() || IsFixed() ) { - SetError( ERRCODE_SBX_CONVERSION ); + SetError( ERRCODE_BASIC_CONVERSION ); return false; } else @@ -791,7 +791,7 @@ bool SbxValue::Convert( SbxDataType eTo ) ResetFlag( SbxFlagBits::Fixed ); if( IsFixed() ) { - SetError( ERRCODE_SBX_CONVERSION ); + SetError( ERRCODE_BASIC_CONVERSION ); return false; } else @@ -800,7 +800,7 @@ bool SbxValue::Convert( SbxDataType eTo ) // Converting from null doesn't work. Once null, always null! if( aData.eType == SbxNULL ) { - SetError( ERRCODE_SBX_CONVERSION ); + SetError( ERRCODE_BASIC_CONVERSION ); return false; } @@ -838,9 +838,9 @@ bool SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp ) if( eOld != ERRCODE_NONE ) ResetError(); if( !CanWrite() ) - SetError( ERRCODE_SBX_PROP_READONLY ); + SetError( ERRCODE_BASIC_PROP_READONLY ); else if( !rOp.CanRead() ) - SetError( ERRCODE_SBX_PROP_WRITEONLY ); + SetError( ERRCODE_BASIC_PROP_WRITEONLY ); // Special rule 1: If one operand is null, the result is null else if( eThisType == SbxNULL || eOpType == SbxNULL ) SetType( SbxNULL ); @@ -880,7 +880,7 @@ bool SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp ) *aL.pOUString += *aR.pOUString; } catch (const std::bad_alloc&) { - SetError(ERRCODE_SBX_OVERFLOW); + SetError(ERRCODE_BASIC_MATH_OVERFLOW); } } // Not even Left OK? @@ -890,11 +890,11 @@ bool SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp ) } } else - SetError( ERRCODE_SBX_CONVERSION ); + SetError( ERRCODE_BASIC_CONVERSION ); } else if( eOpType == SbxSTRING && rOp.IsFixed() ) { // Numeric: there is no String allowed on the right side - SetError( ERRCODE_SBX_CONVERSION ); + SetError( ERRCODE_BASIC_CONVERSION ); // falls all the way out } else if( ( eOp >= SbxIDIV && eOp <= SbxNOT ) || eOp == SbxMOD ) @@ -923,36 +923,36 @@ bool SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp ) { case SbxIDIV: if( aL.eType == SbxCURRENCY ) - if( !aR.nInt64 ) SetError( ERRCODE_SBX_ZERODIV ); + if( !aR.nInt64 ) SetError( ERRCODE_BASIC_ZERODIV ); else { aL.nInt64 /= aR.nInt64; aL.nInt64 *= CURRENCY_FACTOR; } else if( aL.eType == SbxSALUINT64 ) - if( !aR.uInt64 ) SetError( ERRCODE_SBX_ZERODIV ); + if( !aR.uInt64 ) SetError( ERRCODE_BASIC_ZERODIV ); else aL.uInt64 /= aR.uInt64; else if( aL.eType == SbxSALINT64 ) - if( !aR.nInt64 ) SetError( ERRCODE_SBX_ZERODIV ); + if( !aR.nInt64 ) SetError( ERRCODE_BASIC_ZERODIV ); else aL.nInt64 /= aR.nInt64; else if( aL.eType == SbxLONG ) - if( !aR.nLong ) SetError( ERRCODE_SBX_ZERODIV ); + if( !aR.nLong ) SetError( ERRCODE_BASIC_ZERODIV ); else aL.nLong /= aR.nLong; else - if( !aR.nULong ) SetError( ERRCODE_SBX_ZERODIV ); + if( !aR.nULong ) SetError( ERRCODE_BASIC_ZERODIV ); else aL.nULong /= aR.nULong; break; case SbxMOD: if( aL.eType == SbxCURRENCY || aL.eType == SbxSALINT64 ) - if( !aR.nInt64 ) SetError( ERRCODE_SBX_ZERODIV ); + if( !aR.nInt64 ) SetError( ERRCODE_BASIC_ZERODIV ); else aL.nInt64 %= aR.nInt64; else if( aL.eType == SbxSALUINT64 ) - if( !aR.uInt64 ) SetError( ERRCODE_SBX_ZERODIV ); + if( !aR.uInt64 ) SetError( ERRCODE_BASIC_ZERODIV ); else aL.uInt64 %= aR.uInt64; else if( aL.eType == SbxLONG ) - if( !aR.nLong ) SetError( ERRCODE_SBX_ZERODIV ); + if( !aR.nLong ) SetError( ERRCODE_BASIC_ZERODIV ); else aL.nLong %= aR.nLong; else - if( !aR.nULong ) SetError( ERRCODE_SBX_ZERODIV ); + if( !aR.nULong ) SetError( ERRCODE_BASIC_ZERODIV ); else aL.nULong %= aR.nULong; break; case SbxAND: @@ -1024,7 +1024,7 @@ bool SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp ) break; case SbxDIV: if( aR.pDecimal->isZero() ) - SetError( ERRCODE_SBX_ZERODIV ); + SetError( ERRCODE_BASIC_ZERODIV ); else bOk = ( *(aL.pDecimal) /= *(aR.pDecimal) ); break; @@ -1038,14 +1038,14 @@ bool SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp ) bOk = ( aL.pDecimal->neg() ); break; default: - SetError( ERRCODE_SBX_NOTIMP ); + SetError( ERRCODE_BASIC_BAD_ARGUMENT ); } if( !bOk ) - SetError( ERRCODE_SBX_OVERFLOW ); + SetError( ERRCODE_BASIC_MATH_OVERFLOW ); } else { - SetError( ERRCODE_SBX_CONVERSION ); + SetError( ERRCODE_BASIC_CONVERSION ); } } } @@ -1070,7 +1070,7 @@ bool SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp ) { aL.nInt64 = SAL_MAX_INT64; if( dTest < SbxMINCURR ) aL.nInt64 = SAL_MIN_INT64; - SetError( ERRCODE_SBX_OVERFLOW ); + SetError( ERRCODE_BASIC_MATH_OVERFLOW ); break; } // second overflow check: see if unscaled product overflows - if so use doubles @@ -1088,14 +1088,14 @@ bool SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp ) case SbxDIV: if( !aR.nInt64 ) { - SetError( ERRCODE_SBX_ZERODIV ); + SetError( ERRCODE_BASIC_ZERODIV ); break; } // first overflow check: see if quotient will fit - calc real value of quotient (curr factors cancel) dTest = (double)aL.nInt64 / (double)aR.nInt64; if( dTest < SbxMINCURR || SbxMAXCURR < dTest) { - SetError( ERRCODE_SBX_OVERFLOW ); + SetError( ERRCODE_BASIC_MATH_OVERFLOW ); break; } // second overflow check: see if scaled dividend overflows - if so use doubles @@ -1114,7 +1114,7 @@ bool SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp ) dTest = ( (double)aL.nInt64 + (double)aR.nInt64 ) / (double)CURRENCY_FACTOR; if( dTest < SbxMINCURR || SbxMAXCURR < dTest) { - SetError( ERRCODE_SBX_OVERFLOW ); + SetError( ERRCODE_BASIC_MATH_OVERFLOW ); break; } aL.nInt64 += aR.nInt64; @@ -1124,7 +1124,7 @@ bool SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp ) dTest = ( (double)aL.nInt64 - (double)aR.nInt64 ) / (double)CURRENCY_FACTOR; if( dTest < SbxMINCURR || SbxMAXCURR < dTest) { - SetError( ERRCODE_SBX_OVERFLOW ); + SetError( ERRCODE_BASIC_MATH_OVERFLOW ); break; } aL.nInt64 -= aR.nInt64; @@ -1133,7 +1133,7 @@ bool SbxValue::Compute( SbxOperator eOp, const SbxValue& rOp ) aL.nInt64 = -aL.nInt64; break; default: - SetError( ERRCODE_SBX_NOTIMP ); + SetError( ERRCODE_BASIC_BAD_ARGUMENT ); } } } @@ -1158,7 +1158,7 @@ Lbl_OpIsDouble: case SbxMUL: aL.nDouble *= aR.nDouble; break; case SbxDIV: - if( !aR.nDouble ) SetError( ERRCODE_SBX_ZERODIV ); + if( !aR.nDouble ) SetError( ERRCODE_BASIC_ZERODIV ); else aL.nDouble /= aR.nDouble; break; case SbxPLUS: @@ -1168,7 +1168,7 @@ Lbl_OpIsDouble: case SbxNEG: aL.nDouble = -aL.nDouble; break; default: - SetError( ERRCODE_SBX_NOTIMP ); + SetError( ERRCODE_BASIC_BAD_ARGUMENT ); } // Date with "+" or "-" needs special handling that // forces the Date type. If the operation is '+' the @@ -1216,7 +1216,7 @@ bool SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const if( eOld != ERRCODE_NONE ) ResetError(); if( !CanRead() || !rOp.CanRead() ) - SetError( ERRCODE_SBX_PROP_WRITEONLY ); + SetError( ERRCODE_BASIC_PROP_WRITEONLY ); else if( GetType() == SbxNULL && rOp.GetType() == SbxNULL && !bVBAInterop ) { bRes = true; @@ -1260,7 +1260,7 @@ bool SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const case SbxGE: bRes = ( *aL.pOUString >= *aR.pOUString ); break; default: - SetError( ERRCODE_SBX_NOTIMP ); + SetError( ERRCODE_BASIC_BAD_ARGUMENT ); } } // From 1995-12-19: If SbxSINGLE participate, then convert to SINGLE, @@ -1284,7 +1284,7 @@ bool SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const case SbxGE: bRes = ( aL.nSingle >= aR.nSingle ); break; default: - SetError( ERRCODE_SBX_NOTIMP ); + SetError( ERRCODE_BASIC_BAD_ARGUMENT ); } } else if( GetType() == SbxDECIMAL && rOp.GetType() == SbxDECIMAL ) @@ -1310,12 +1310,12 @@ bool SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const case SbxGE: bRes = ( eRes != SbxDecimal::CmpResult::LT ); break; default: - SetError( ERRCODE_SBX_NOTIMP ); + SetError( ERRCODE_BASIC_BAD_ARGUMENT ); } } else { - SetError( ERRCODE_SBX_CONVERSION ); + SetError( ERRCODE_BASIC_CONVERSION ); } releaseDecimalPtr( aL.pDecimal ); releaseDecimalPtr( aR.pDecimal ); @@ -1342,14 +1342,14 @@ bool SbxValue::Compare( SbxOperator eOp, const SbxValue& rOp ) const case SbxGE: bRes = ( aL.nDouble >= aR.nDouble ); break; default: - SetError( ERRCODE_SBX_NOTIMP ); + SetError( ERRCODE_BASIC_BAD_ARGUMENT ); } // at least one value was got // if this is VBA then a conversion error for one // side will yield a false result of an equality test else if ( bGetR || bGetL ) { - if ( bVBAInterop && eOp == SbxEQ && GetError() == ERRCODE_SBX_CONVERSION ) + if ( bVBAInterop && eOp == SbxEQ && GetError() == ERRCODE_BASIC_CONVERSION ) { ResetError(); bRes = false; -- cgit