rename SBX errorcodes to BASIC

Change-Id: Ia6c2d2379a2f6e9b1109e2c04edd5cdd9dcf242f Reviewed-on: https://gerrit.libreoffice.org/41706 Tested-by: Jenkins <ci@libreoffice.org> Reviewed-by: Noel Grandin <noel.grandin@collabora.co.uk>
author: Noel Grandin <noelgrandin@gmail.com> 2017-08-28 17:03:09 +0200
committer: Noel Grandin <noel.grandin@collabora.co.uk> 2017-08-29 19:50:11 +0200
commit: 4e70d0b6bf4c07734b11bc2df155ccdc9fc6874b (patch)
tree: 5d23b771cc94978a48939f675b0ebb8a12db00ae /basic
parent: ddc4c0edeb57c95c02a683fd4dae50c57578237d (diff)
22 files changed, 398 insertions, 398 deletions
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<SbxVarEntry&>(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<sal_Int32>(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<size_t>(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<const SbxObject*>(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<SbxObject*>( 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;
author	Noel Grandin <noelgrandin@gmail.com>	2017-08-28 17:03:09 +0200
committer	Noel Grandin <noel.grandin@collabora.co.uk>	2017-08-29 19:50:11 +0200
commit	4e70d0b6bf4c07734b11bc2df155ccdc9fc6874b (patch)
tree	5d23b771cc94978a48939f675b0ebb8a12db00ae /basic
parent	ddc4c0edeb57c95c02a683fd4dae50c57578237d (diff)