Remove dynamic exception specifications

...(for now, from LIBO_INTERNAL_CODE only).  See the mail thread starting at
<https://lists.freedesktop.org/archives/libreoffice/2017-January/076665.html>
"Dynamic Exception Specifications" for details.

Most changes have been done automatically by the rewriting loplugin:dynexcspec
(after enabling the rewriting mode, to be committed shortly).  The way it only
removes exception specs from declarations if it also sees a definition, it
identified some dead declarations-w/o-definitions (that have been removed
manually) and some cases where a definition appeared in multiple include files
(which have also been cleaned up manually).  There's also been cases of macro
paramters (that were used to abstract over exception specs) that have become
unused now (and been removed).

Furthermore, some code needed to be cleaned up manually
(avmedia/source/quicktime/ and connectivity/source/drivers/kab/), as I had no
configurations available that would actually build that code.  Missing @throws
documentation has not been applied in such manual clean-up.

Change-Id: I3408691256c9b0c12bc5332de976743626e13960
Reviewed-on: https://gerrit.libreoffice.org/33574
Tested-by: Jenkins <ci@libreoffice.org>
Reviewed-by: Stephan Bergmann <sbergman@redhat.com>

1 files changed, 175 insertions, 182 deletions

diff --git a/sc/source/ui/vba/vbarange.cxx b/sc/source/ui/vba/vbarange.cxx
index 8599c4450e44..4d444f2aaebc 100644
--- a/sc/source/ui/vba/vbarange.cxx
+++ b/sc/source/ui/vba/vbarange.cxx
@@ -253,7 +253,7 @@ static uno::Reference< excel::XRange > lcl_makeXRangeFromSheetCellRanges( const
     return xRange;
 }
 
-ScCellRangesBase* ScVbaRange::getCellRangesBase() throw ( uno::RuntimeException )
+ScCellRangesBase* ScVbaRange::getCellRangesBase()
 {
     if( mxRanges.is() )
         return ScCellRangesBase::getImplementation( mxRanges );
@@ -262,12 +262,12 @@ ScCellRangesBase* ScVbaRange::getCellRangesBase() throw ( uno::RuntimeException
     throw uno::RuntimeException("General Error creating range - Unknown" );
 }
 
-ScCellRangeObj* ScVbaRange::getCellRangeObj() throw ( uno::RuntimeException )
+ScCellRangeObj* ScVbaRange::getCellRangeObj()
 {
     return dynamic_cast< ScCellRangeObj* >( getCellRangesBase() );
 }
 
-SfxItemSet*  ScVbaRange::getCurrentDataSet( ) throw (uno::RuntimeException, std::exception)
+SfxItemSet*  ScVbaRange::getCurrentDataSet( )
 {
     SfxItemSet* pDataSet = excel::ScVbaCellRangeAccess::GetDataSet( getCellRangesBase() );
     if ( !pDataSet )
@@ -299,9 +299,9 @@ class SingleRangeEnumeration : public EnumerationHelper_BASE
     bool bHasMore;
 public:
     /// @throws uno::RuntimeException
-    explicit SingleRangeEnumeration( const uno::Reference< table::XCellRange >& xRange ) throw ( uno::RuntimeException ) : m_xRange( xRange ), bHasMore( true ) { }
-    virtual sal_Bool SAL_CALL hasMoreElements(  ) throw (uno::RuntimeException, std::exception) override { return bHasMore; }
-    virtual uno::Any SAL_CALL nextElement(  ) throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException, std::exception) override
+    explicit SingleRangeEnumeration( const uno::Reference< table::XCellRange >& xRange ) : m_xRange( xRange ), bHasMore( true ) { }
+    virtual sal_Bool SAL_CALL hasMoreElements(  ) override { return bHasMore; }
+    virtual uno::Any SAL_CALL nextElement(  ) override
     {
         if ( !bHasMore )
             throw container::NoSuchElementException();
@@ -322,18 +322,18 @@ private:
 public:
     explicit SingleRangeIndexAccess( const uno::Reference< table::XCellRange >& xRange ) : m_xRange( xRange ) {}
     // XIndexAccess
-    virtual ::sal_Int32 SAL_CALL getCount() throw (::uno::RuntimeException, std::exception) override { return 1; }
-    virtual uno::Any SAL_CALL getByIndex( ::sal_Int32 Index ) throw (lang::IndexOutOfBoundsException, lang::WrappedTargetException, uno::RuntimeException, std::exception) override
+    virtual ::sal_Int32 SAL_CALL getCount() override { return 1; }
+    virtual uno::Any SAL_CALL getByIndex( ::sal_Int32 Index ) override
     {
         if ( Index != 0 )
             throw lang::IndexOutOfBoundsException();
         return uno::makeAny( m_xRange );
     }
     // XElementAccess
-    virtual uno::Type SAL_CALL getElementType() throw (uno::RuntimeException, std::exception) override { return cppu::UnoType<table::XCellRange>::get(); }
-    virtual sal_Bool SAL_CALL hasElements() throw (uno::RuntimeException, std::exception) override { return true; }
+    virtual uno::Type SAL_CALL getElementType() override { return cppu::UnoType<table::XCellRange>::get(); }
+    virtual sal_Bool SAL_CALL hasElements() override { return true; }
     // XEnumerationAccess
-    virtual uno::Reference< container::XEnumeration > SAL_CALL createEnumeration() throw (uno::RuntimeException, std::exception) override { return new SingleRangeEnumeration( m_xRange ); }
+    virtual uno::Reference< container::XEnumeration > SAL_CALL createEnumeration() override { return new SingleRangeEnumeration( m_xRange ); }
 
 };
 
@@ -343,8 +343,8 @@ class RangesEnumerationImpl : public EnumerationHelperImpl
     bool mbIsColumns;
 public:
     /// @throws uno::RuntimeException
-    RangesEnumerationImpl( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XEnumeration >& xEnumeration, bool bIsRows, bool bIsColumns ) throw ( uno::RuntimeException ) : EnumerationHelperImpl( xParent, xContext, xEnumeration ), mbIsRows( bIsRows ), mbIsColumns( bIsColumns ) {}
-    virtual uno::Any SAL_CALL nextElement(  ) throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException, std::exception) override
+    RangesEnumerationImpl( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XEnumeration >& xEnumeration, bool bIsRows, bool bIsColumns ) : EnumerationHelperImpl( xParent, xContext, xEnumeration ), mbIsRows( bIsRows ), mbIsColumns( bIsColumns ) {}
+    virtual uno::Any SAL_CALL nextElement(  ) override
     {
         return lcl_makeRange( m_xParent, m_xContext, m_xEnumeration->nextElement(), mbIsRows, mbIsColumns );
     }
@@ -358,10 +358,10 @@ public:
     ScVbaRangeAreas( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< container::XIndexAccess >& xIndexAccess, bool bIsRows, bool bIsColumns ) : ScVbaCollectionBaseImpl( xParent, xContext, xIndexAccess ), mbIsRows( bIsRows ), mbIsColumns( bIsColumns ) {}
 
     // XEnumerationAccess
-    virtual uno::Reference< container::XEnumeration > SAL_CALL createEnumeration() throw (uno::RuntimeException) override;
+    virtual uno::Reference< container::XEnumeration > SAL_CALL createEnumeration() override;
 
     // XElementAccess
-    virtual uno::Type SAL_CALL getElementType() throw (uno::RuntimeException) override { return cppu::UnoType<excel::XRange>::get(); }
+    virtual uno::Type SAL_CALL getElementType() override { return cppu::UnoType<excel::XRange>::get(); }
 
     virtual uno::Any createCollectionObject( const uno::Any& aSource ) override;
 
@@ -372,7 +372,7 @@ public:
 };
 
 uno::Reference< container::XEnumeration > SAL_CALL
-ScVbaRangeAreas::createEnumeration() throw (uno::RuntimeException)
+ScVbaRangeAreas::createEnumeration()
 {
     uno::Reference< container::XEnumerationAccess > xEnumAccess( m_xIndexAccess, uno::UNO_QUERY_THROW );
     return new RangesEnumerationImpl( mxParent, mxContext, xEnumAccess->createEnumeration(), mbIsRows, mbIsColumns );
@@ -387,7 +387,7 @@ ScVbaRangeAreas::createCollectionObject( const uno::Any& aSource )
 // assume that xIf is infact a ScCellRangesBase
 /// @throws uno::RuntimeException
 ScDocShell*
-getDocShellFromIf( const uno::Reference< uno::XInterface >& xIf ) throw ( uno::RuntimeException )
+getDocShellFromIf( const uno::Reference< uno::XInterface >& xIf )
 {
     ScCellRangesBase* pUno = ScCellRangesBase::getImplementation( xIf );
     if ( !pUno )
@@ -397,7 +397,7 @@ getDocShellFromIf( const uno::Reference< uno::XInterface >& xIf ) throw ( uno::R
 
 /// @throws uno::RuntimeException
 ScDocShell*
-getDocShellFromRange( const uno::Reference< table::XCellRange >& xRange ) throw ( uno::RuntimeException )
+getDocShellFromRange( const uno::Reference< table::XCellRange >& xRange )
 {
     // need the ScCellRangesBase to get docshell
     uno::Reference< uno::XInterface > xIf( xRange );
@@ -406,7 +406,7 @@ getDocShellFromRange( const uno::Reference< table::XCellRange >& xRange ) throw
 
 /// @throws uno::RuntimeException
 ScDocShell*
-getDocShellFromRanges( const uno::Reference< sheet::XSheetCellRangeContainer >& xRanges ) throw ( uno::RuntimeException )
+getDocShellFromRanges( const uno::Reference< sheet::XSheetCellRangeContainer >& xRanges )
 {
     // need the ScCellRangesBase to get docshell
     uno::Reference< uno::XInterface > xIf( xRanges );
@@ -414,14 +414,14 @@ getDocShellFromRanges( const uno::Reference< sheet::XSheetCellRangeContainer >&
 }
 
 /// @throws uno::RuntimeException
-uno::Reference< frame::XModel > getModelFromXIf( const uno::Reference< uno::XInterface >& xIf ) throw ( uno::RuntimeException )
+uno::Reference< frame::XModel > getModelFromXIf( const uno::Reference< uno::XInterface >& xIf )
 {
     ScDocShell* pDocShell = getDocShellFromIf(xIf );
     return pDocShell->GetModel();
 }
 
 /// @throws uno::RuntimeException
-uno::Reference< frame::XModel > getModelFromRange( const uno::Reference< table::XCellRange >& xRange ) throw ( uno::RuntimeException )
+uno::Reference< frame::XModel > getModelFromRange( const uno::Reference< table::XCellRange >& xRange )
 {
     // the XInterface for getImplementation can be any derived interface, no need for queryInterface
     uno::Reference< uno::XInterface > xIf( xRange );
@@ -439,7 +439,7 @@ getDocumentFromRange( const uno::Reference< table::XCellRange >& xRange )
 }
 
 ScDocument&
-ScVbaRange::getScDocument() throw (uno::RuntimeException)
+ScVbaRange::getScDocument()
 {
     if ( mxRanges.is() )
     {
@@ -451,7 +451,7 @@ ScVbaRange::getScDocument() throw (uno::RuntimeException)
 }
 
 ScDocShell*
-ScVbaRange::getScDocShell() throw (uno::RuntimeException)
+ScVbaRange::getScDocShell()
 {
     if ( mxRanges.is() )
     {
@@ -468,28 +468,28 @@ ScVbaRange* ScVbaRange::getImplementation( const uno::Reference< excel::XRange >
     return dynamic_cast< ScVbaRange* >( rxRange.get() );
 }
 
-uno::Reference< frame::XModel > ScVbaRange::getUnoModel() throw (uno::RuntimeException)
+uno::Reference< frame::XModel > ScVbaRange::getUnoModel()
 {
     if( ScDocShell* pDocShell = getScDocShell() )
         return pDocShell->GetModel();
     throw uno::RuntimeException();
 }
 
-uno::Reference< frame::XModel > ScVbaRange::getUnoModel( const uno::Reference< excel::XRange >& rxRange ) throw (uno::RuntimeException)
+uno::Reference< frame::XModel > ScVbaRange::getUnoModel( const uno::Reference< excel::XRange >& rxRange )
 {
     if( ScVbaRange* pScVbaRange = getImplementation( rxRange ) )
         return pScVbaRange->getUnoModel();
     throw uno::RuntimeException();
 }
 
-const ScRangeList& ScVbaRange::getScRangeList() throw (uno::RuntimeException)
+const ScRangeList& ScVbaRange::getScRangeList()
 {
     if( ScCellRangesBase* pScRangesBase = getCellRangesBase() )
         return pScRangesBase->GetRangeList();
     throw uno::RuntimeException("Cannot obtain UNO range implementation object" );
 }
 
-const ScRangeList& ScVbaRange::getScRangeList( const uno::Reference< excel::XRange >& rxRange ) throw (uno::RuntimeException)
+const ScRangeList& ScVbaRange::getScRangeList( const uno::Reference< excel::XRange >& rxRange )
 {
     if( ScVbaRange* pScVbaRange = getImplementation( rxRange ) )
         return pScVbaRange->getScRangeList();
@@ -626,9 +626,9 @@ public:
     {
     }
 
-    virtual sal_Bool SAL_CALL hasMoreElements() throw (::uno::RuntimeException, std::exception) override { return mCurElem < mMaxElems; }
+    virtual sal_Bool SAL_CALL hasMoreElements() override { return mCurElem < mMaxElems; }
 
-    virtual uno::Any SAL_CALL nextElement() throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException, std::exception) override
+    virtual uno::Any SAL_CALL nextElement() override
     {
         if ( !hasMoreElements() )
             throw container::NoSuchElementException();
@@ -646,7 +646,7 @@ class CellsEnumeration : public CellsEnumeration_BASE
     vCellPos::const_iterator m_it;
 
     /// @throws uno::RuntimeException
-    uno::Reference< table::XCellRange > getArea( sal_Int32 nVBAIndex ) throw ( uno::RuntimeException )
+    uno::Reference< table::XCellRange > getArea( sal_Int32 nVBAIndex )
     {
         if ( nVBAIndex < 1 || nVBAIndex > m_xAreas->getCount() )
             throw uno::RuntimeException();
@@ -677,9 +677,9 @@ public:
         }
         m_it = m_CellPositions.begin();
     }
-    virtual sal_Bool SAL_CALL hasMoreElements() throw (::uno::RuntimeException, std::exception) override { return m_it != m_CellPositions.end(); }
+    virtual sal_Bool SAL_CALL hasMoreElements() override { return m_it != m_CellPositions.end(); }
 
-    virtual uno::Any SAL_CALL nextElement() throw (container::NoSuchElementException, lang::WrappedTargetException, uno::RuntimeException, std::exception) override
+    virtual uno::Any SAL_CALL nextElement() override
     {
         if ( !hasMoreElements() )
             throw container::NoSuchElementException();
@@ -1097,42 +1097,42 @@ class RangeHelper
 
 public:
     /// @throws uno::RuntimeException
-    explicit RangeHelper( const uno::Reference< table::XCellRange >& xCellRange ) throw (uno::RuntimeException) : m_xCellRange( xCellRange )
+    explicit RangeHelper( const uno::Reference< table::XCellRange >& xCellRange ) : m_xCellRange( xCellRange )
     {
         if ( !m_xCellRange.is() )
             throw uno::RuntimeException();
     }
     /// @throws uno::RuntimeException
-    explicit RangeHelper( const uno::Any& rCellRange ) throw (uno::RuntimeException)
+    explicit RangeHelper( const uno::Any& rCellRange )
     {
         m_xCellRange.set(rCellRange, uno::UNO_QUERY_THROW);
     }
     /// @throws uno::RuntimeException
-    uno::Reference< sheet::XSheetCellRange > getSheetCellRange() throw (uno::RuntimeException)
+    uno::Reference< sheet::XSheetCellRange > getSheetCellRange()
     {
         return uno::Reference< sheet::XSheetCellRange >(m_xCellRange, uno::UNO_QUERY_THROW);
     }
     /// @throws uno::RuntimeException
-    uno::Reference< sheet::XSpreadsheet >  getSpreadSheet() throw (uno::RuntimeException)
+    uno::Reference< sheet::XSpreadsheet >  getSpreadSheet()
     {
         return getSheetCellRange()->getSpreadsheet();
     }
 
     /// @throws uno::RuntimeException
-    uno::Reference< table::XCellRange > getCellRangeFromSheet() throw (uno::RuntimeException)
+    uno::Reference< table::XCellRange > getCellRangeFromSheet()
     {
         return uno::Reference< table::XCellRange >(getSpreadSheet(), uno::UNO_QUERY_THROW );
     }
 
     /// @throws uno::RuntimeException
-    uno::Reference< sheet::XCellRangeAddressable >  getCellRangeAddressable() throw (uno::RuntimeException)
+    uno::Reference< sheet::XCellRangeAddressable >  getCellRangeAddressable()
     {
         return uno::Reference< sheet::XCellRangeAddressable >(m_xCellRange, ::uno::UNO_QUERY_THROW);
 
     }
 
     /// @throws uno::RuntimeException
-    uno::Reference< sheet::XSheetCellCursor > getSheetCellCursor() throw ( uno::RuntimeException )
+    uno::Reference< sheet::XSheetCellCursor > getSheetCellCursor()
     {
         return  uno::Reference< sheet::XSheetCellCursor >( getSpreadSheet()->createCursorByRange( getSheetCellRange() ), uno::UNO_QUERY_THROW );
     }
@@ -1167,7 +1167,7 @@ ScVbaRange::getCellRangesForAddress( ScRefFlags& rResFlags, const OUString& sAdd
     return false;
 }
 
-bool getScRangeListForAddress( const OUString& sName, ScDocShell* pDocSh, ScRange& refRange, ScRangeList& aCellRanges, formula::FormulaGrammar::AddressConvention aConv ) throw ( uno::RuntimeException )
+bool getScRangeListForAddress( const OUString& sName, ScDocShell* pDocSh, ScRange& refRange, ScRangeList& aCellRanges, formula::FormulaGrammar::AddressConvention aConv )
 {
     // see if there is a match with a named range
     uno::Reference< beans::XPropertySet > xProps( pDocSh->GetModel(), uno::UNO_QUERY_THROW );
@@ -1241,7 +1241,7 @@ bool getScRangeListForAddress( const OUString& sName, ScDocShell* pDocSh, ScRang
 
 /// @throws uno::RuntimeException
 ScVbaRange*
-getRangeForName( const uno::Reference< uno::XComponentContext >& xContext, const OUString& sName, ScDocShell* pDocSh, table::CellRangeAddress& pAddr, formula::FormulaGrammar::AddressConvention eConv = formula::FormulaGrammar::CONV_XL_A1 ) throw ( uno::RuntimeException, std::exception )
+getRangeForName( const uno::Reference< uno::XComponentContext >& xContext, const OUString& sName, ScDocShell* pDocSh, table::CellRangeAddress& pAddr, formula::FormulaGrammar::AddressConvention eConv = formula::FormulaGrammar::CONV_XL_A1 )
 {
     ScRangeList aCellRanges;
     ScRange refRange;
@@ -1265,13 +1265,13 @@ namespace {
 
 /// @throws uno::RuntimeException
 template< typename RangeType >
-inline table::CellRangeAddress lclGetRangeAddress( const uno::Reference< RangeType >& rxCellRange ) throw (uno::RuntimeException)
+inline table::CellRangeAddress lclGetRangeAddress( const uno::Reference< RangeType >& rxCellRange )
 {
     return uno::Reference< sheet::XCellRangeAddressable >( rxCellRange, uno::UNO_QUERY_THROW )->getRangeAddress();
 }
 
 /// @throws uno::RuntimeException
-void lclClearRange( const uno::Reference< table::XCellRange >& rxCellRange ) throw (uno::RuntimeException)
+void lclClearRange( const uno::Reference< table::XCellRange >& rxCellRange )
 {
     using namespace ::com::sun::star::sheet::CellFlags;
     sal_Int32 nFlags = VALUE | DATETIME | STRING | ANNOTATION | FORMULA | HARDATTR | STYLES | EDITATTR | FORMATTED;
@@ -1280,7 +1280,7 @@ void lclClearRange( const uno::Reference< table::XCellRange >& rxCellRange ) thr
 }
 
 /// @throws uno::RuntimeException
-uno::Reference< sheet::XSheetCellRange > lclExpandToMerged( const uno::Reference< table::XCellRange >& rxCellRange, bool bRecursive ) throw (uno::RuntimeException)
+uno::Reference< sheet::XSheetCellRange > lclExpandToMerged( const uno::Reference< table::XCellRange >& rxCellRange, bool bRecursive )
 {
     uno::Reference< sheet::XSheetCellRange > xNewCellRange( rxCellRange, uno::UNO_QUERY_THROW );
     uno::Reference< sheet::XSpreadsheet > xSheet( xNewCellRange->getSpreadsheet(), uno::UNO_SET_THROW );
@@ -1300,7 +1300,7 @@ uno::Reference< sheet::XSheetCellRange > lclExpandToMerged( const uno::Reference
 }
 
 /// @throws uno::RuntimeException
-uno::Reference< sheet::XSheetCellRangeContainer > lclExpandToMerged( const uno::Reference< sheet::XSheetCellRangeContainer >& rxCellRanges, bool bRecursive ) throw (uno::RuntimeException)
+uno::Reference< sheet::XSheetCellRangeContainer > lclExpandToMerged( const uno::Reference< sheet::XSheetCellRangeContainer >& rxCellRanges, bool bRecursive )
 {
     if( !rxCellRanges.is() )
         throw uno::RuntimeException("Missing cell ranges object" );
@@ -1321,7 +1321,7 @@ uno::Reference< sheet::XSheetCellRangeContainer > lclExpandToMerged( const uno::
 }
 
 /// @throws uno::RuntimeException
-void lclExpandAndMerge( const uno::Reference< table::XCellRange >& rxCellRange, bool bMerge ) throw (uno::RuntimeException)
+void lclExpandAndMerge( const uno::Reference< table::XCellRange >& rxCellRange, bool bMerge )
 {
     uno::Reference< util::XMergeable > xMerge( lclExpandToMerged( rxCellRange, true ), uno::UNO_QUERY_THROW );
     // Calc cannot merge over merged ranges, always unmerge first
@@ -1344,7 +1344,7 @@ void lclExpandAndMerge( const uno::Reference< table::XCellRange >& rxCellRange,
 }
 
 /// @throws uno::RuntimeException
-util::TriState lclGetMergedState( const uno::Reference< table::XCellRange >& rxCellRange ) throw (uno::RuntimeException)
+util::TriState lclGetMergedState( const uno::Reference< table::XCellRange >& rxCellRange )
 {
     /*  1) Check if range is completely inside one single merged range. To do
         this, try to extend from top-left cell only (not from entire range).
@@ -1374,14 +1374,14 @@ util::TriState lclGetMergedState( const uno::Reference< table::XCellRange >& rxC
 css::uno::Reference< excel::XRange >
 ScVbaRange::getRangeObjectForName(
         const uno::Reference< uno::XComponentContext >& xContext, const OUString& sRangeName,
-        ScDocShell* pDocSh, formula::FormulaGrammar::AddressConvention eConv ) throw ( uno::RuntimeException, std::exception )
+        ScDocShell* pDocSh, formula::FormulaGrammar::AddressConvention eConv )
 {
     table::CellRangeAddress refAddr;
     return getRangeForName( xContext, sRangeName, pDocSh, refAddr, eConv );
 }
 
 /// @throws uno::RuntimeException
-table::CellRangeAddress getCellRangeAddressForVBARange( const uno::Any& aParam, ScDocShell* pDocSh ) throw ( uno::RuntimeException )
+table::CellRangeAddress getCellRangeAddressForVBARange( const uno::Any& aParam, ScDocShell* pDocSh )
 {
     uno::Reference< table::XCellRange > xRangeParam;
     switch ( aParam.getValueTypeClass() )
@@ -1421,7 +1421,7 @@ table::CellRangeAddress getCellRangeAddressForVBARange( const uno::Any& aParam,
 
 /// @throws uno::RuntimeException
 static uno::Reference< XCollection >
-lcl_setupBorders( const uno::Reference< excel::XRange >& xParentRange, const uno::Reference<uno::XComponentContext>& xContext,  const uno::Reference< table::XCellRange >& xRange  ) throw( uno::RuntimeException )
+lcl_setupBorders( const uno::Reference< excel::XRange >& xParentRange, const uno::Reference<uno::XComponentContext>& xContext,  const uno::Reference< table::XCellRange >& xRange  )
 {
     uno::Reference< XHelperInterface > xParent( xParentRange, uno::UNO_QUERY_THROW );
     ScDocument& rDoc = getDocumentFromRange(xRange);
@@ -1431,7 +1431,7 @@ lcl_setupBorders( const uno::Reference< excel::XRange >& xParentRange, const uno
 }
 
 ScVbaRange::ScVbaRange( uno::Sequence< uno::Any> const & args,
-    uno::Reference< uno::XComponentContext> const & xContext )  throw ( lang::IllegalArgumentException, uno::RuntimeException ) : ScVbaRange_BASE( getXSomethingFromArgs< XHelperInterface >( args, 0 ), xContext, getXSomethingFromArgs< beans::XPropertySet >( args, 1, false ), getModelFromXIf( getXSomethingFromArgs< uno::XInterface >( args, 1 ) ), true ), mbIsRows( false ), mbIsColumns( false )
+    uno::Reference< uno::XComponentContext> const & xContext ) : ScVbaRange_BASE( getXSomethingFromArgs< XHelperInterface >( args, 0 ), xContext, getXSomethingFromArgs< beans::XPropertySet >( args, 1, false ), getModelFromXIf( getXSomethingFromArgs< uno::XInterface >( args, 1 ) ), true ), mbIsRows( false ), mbIsColumns( false )
 {
     mxRange.set( mxPropertySet, uno::UNO_QUERY );
     mxRanges.set( mxPropertySet, uno::UNO_QUERY );
@@ -1447,7 +1447,7 @@ ScVbaRange::ScVbaRange( uno::Sequence< uno::Any> const & args,
     m_Areas = new ScVbaRangeAreas( mxParent, mxContext, xIndex, mbIsRows, mbIsColumns );
 }
 
-ScVbaRange::ScVbaRange( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< table::XCellRange >& xRange, bool bIsRows, bool bIsColumns ) throw( lang::IllegalArgumentException )
+ScVbaRange::ScVbaRange( const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< table::XCellRange >& xRange, bool bIsRows, bool bIsColumns )
 : ScVbaRange_BASE( xParent, xContext, uno::Reference< beans::XPropertySet >( xRange, uno::UNO_QUERY_THROW ), getModelFromRange( xRange), true ), mxRange( xRange ),
                 mbIsRows( bIsRows ),
                 mbIsColumns( bIsColumns )
@@ -1463,7 +1463,6 @@ ScVbaRange::ScVbaRange( const uno::Reference< XHelperInterface >& xParent, const
 }
 
 ScVbaRange::ScVbaRange(const uno::Reference< XHelperInterface >& xParent, const uno::Reference< uno::XComponentContext >& xContext, const uno::Reference< sheet::XSheetCellRangeContainer >& xRanges, bool bIsRows, bool bIsColumns)
-    throw (lang::IllegalArgumentException, uno::RuntimeException)
 : ScVbaRange_BASE( xParent, xContext, uno::Reference< beans::XPropertySet >( xRanges, uno::UNO_QUERY_THROW ), getModelFromXIf( uno::Reference< uno::XInterface >( xRanges, uno::UNO_QUERY_THROW ) ), true ), mxRanges( xRanges ),mbIsRows( bIsRows ), mbIsColumns( bIsColumns )
 
 {
@@ -1504,7 +1503,7 @@ ScVbaRange::visitArray( ArrayVisitor& visitor )
 }
 
 uno::Any
-ScVbaRange::getValue( ValueGetter& valueGetter) throw (uno::RuntimeException)
+ScVbaRange::getValue( ValueGetter& valueGetter)
 {
     uno::Reference< table::XColumnRowRange > xColumnRowRange(mxRange, uno::UNO_QUERY_THROW );
     // single cell range
@@ -1522,7 +1521,7 @@ ScVbaRange::getValue( ValueGetter& valueGetter) throw (uno::RuntimeException)
 }
 
 uno::Any SAL_CALL
-ScVbaRange::getValue() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getValue()
 {
     // #TODO code within the test below "if ( m_Areas.... " can be removed
     // Test is performed only because m_xRange is NOT set to be
@@ -1540,7 +1539,7 @@ ScVbaRange::getValue() throw (uno::RuntimeException, std::exception)
 }
 
 void
-ScVbaRange::setValue( const uno::Any& aValue, ValueSetter& valueSetter ) throw (uno::RuntimeException)
+ScVbaRange::setValue( const uno::Any& aValue, ValueSetter& valueSetter )
 {
     uno::TypeClass aClass = aValue.getValueTypeClass();
     if ( aClass == uno::TypeClass_SEQUENCE )
@@ -1577,7 +1576,7 @@ ScVbaRange::setValue( const uno::Any& aValue, ValueSetter& valueSetter ) throw (
 }
 
 void SAL_CALL
-ScVbaRange::setValue( const uno::Any  &aValue ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::setValue( const uno::Any  &aValue )
 {
     // If this is a multiple selection apply setValue over all areas
     if ( m_Areas->getCount() > 1 )
@@ -1592,7 +1591,7 @@ ScVbaRange::setValue( const uno::Any  &aValue ) throw (uno::RuntimeException, st
 }
 
 void SAL_CALL
-ScVbaRange::Clear() throw (uno::RuntimeException, std::exception)
+ScVbaRange::Clear()
 {
     using namespace ::com::sun::star::sheet::CellFlags;
     sal_Int32 nFlags = VALUE | DATETIME | STRING | FORMULA | HARDATTR | EDITATTR | FORMATTED;
@@ -1601,7 +1600,7 @@ ScVbaRange::Clear() throw (uno::RuntimeException, std::exception)
 
 //helper ClearContent
 void
-ScVbaRange::ClearContents( sal_Int32 nFlags, bool bFireEvent ) throw (uno::RuntimeException)
+ScVbaRange::ClearContents( sal_Int32 nFlags, bool bFireEvent )
 {
     // #TODO code within the test below "if ( m_Areas.... " can be removed
     // Test is performed only because m_xRange is NOT set to be
@@ -1628,13 +1627,13 @@ ScVbaRange::ClearContents( sal_Int32 nFlags, bool bFireEvent ) throw (uno::Runti
 }
 
 void SAL_CALL
-ScVbaRange::ClearComments() throw (uno::RuntimeException, std::exception)
+ScVbaRange::ClearComments()
 {
     ClearContents( sheet::CellFlags::ANNOTATION, false );
 }
 
 void SAL_CALL
-ScVbaRange::ClearContents() throw (uno::RuntimeException, std::exception)
+ScVbaRange::ClearContents()
 {
     using namespace ::com::sun::star::sheet::CellFlags;
     sal_Int32 nFlags = VALUE | DATETIME | STRING | FORMULA;
@@ -1642,7 +1641,7 @@ ScVbaRange::ClearContents() throw (uno::RuntimeException, std::exception)
 }
 
 void SAL_CALL
-ScVbaRange::ClearFormats() throw (uno::RuntimeException, std::exception)
+ScVbaRange::ClearFormats()
 {
     // FIXME: need to check if we need to combine FORMATTED
     using namespace ::com::sun::star::sheet::CellFlags;
@@ -1651,7 +1650,7 @@ ScVbaRange::ClearFormats() throw (uno::RuntimeException, std::exception)
 }
 
 void
-ScVbaRange::setFormulaValue( const uno::Any& rFormula, formula::FormulaGrammar::Grammar eGram ) throw (uno::RuntimeException)
+ScVbaRange::setFormulaValue( const uno::Any& rFormula, formula::FormulaGrammar::Grammar eGram )
 {
     // If this is a multiple selection apply setFormula over all areas
     if ( m_Areas->getCount() > 1 )
@@ -1666,7 +1665,7 @@ ScVbaRange::setFormulaValue( const uno::Any& rFormula, formula::FormulaGrammar::
 }
 
 uno::Any
-ScVbaRange::getFormulaValue( formula::FormulaGrammar::Grammar eGram ) throw (uno::RuntimeException)
+ScVbaRange::getFormulaValue( formula::FormulaGrammar::Grammar eGram )
 {
     // #TODO code within the test below "if ( m_Areas.... " can be removed
     // Test is performed only because m_xRange is NOT set to be
@@ -1683,32 +1682,32 @@ ScVbaRange::getFormulaValue( formula::FormulaGrammar::Grammar eGram ) throw (uno
 }
 
 void
-ScVbaRange::setFormula(const uno::Any &rFormula ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::setFormula(const uno::Any &rFormula )
 {
     // #FIXME converting "=$a$1" e.g. CONV_XL_A1 -> CONV_OOO                            // results in "=$a$1:a1", temporalily disable conversion
     setFormulaValue( rFormula,formula::FormulaGrammar::GRAM_NATIVE_XL_A1 );
 }
 
 uno::Any
-ScVbaRange::getFormulaR1C1() throw (css::uno::RuntimeException, std::exception)
+ScVbaRange::getFormulaR1C1()
 {
     return getFormulaValue( formula::FormulaGrammar::GRAM_NATIVE_XL_R1C1 );
 }
 
 void
-ScVbaRange::setFormulaR1C1(const uno::Any& rFormula ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::setFormulaR1C1(const uno::Any& rFormula )
 {
     setFormulaValue( rFormula,formula::FormulaGrammar::GRAM_NATIVE_XL_R1C1 );
 }
 
 uno::Any
-ScVbaRange::getFormula() throw (css::uno::RuntimeException, std::exception)
+ScVbaRange::getFormula()
 {
     return getFormulaValue( formula::FormulaGrammar::GRAM_NATIVE_XL_A1 );
 }
 
 sal_Int32
-ScVbaRange::getCount() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getCount()
 {
     // If this is a multiple selection apply setValue over all areas
     if ( m_Areas->getCount() > 1 )
@@ -1732,7 +1731,7 @@ ScVbaRange::getCount() throw (uno::RuntimeException, std::exception)
 }
 
 sal_Int32
-ScVbaRange::getRow() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getRow()
 {
     // #TODO code within the test below "if ( m_Areas.... " can be removed
     // Test is performed only because m_xRange is NOT set to be
@@ -1748,7 +1747,7 @@ ScVbaRange::getRow() throw (uno::RuntimeException, std::exception)
 }
 
 sal_Int32
-ScVbaRange::getColumn() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getColumn()
 {
     // #TODO code within the test below "if ( m_Areas.... " can be removed
     // Test is performed only because m_xRange is NOT set to be
@@ -1764,7 +1763,7 @@ ScVbaRange::getColumn() throw (uno::RuntimeException, std::exception)
 }
 
 uno::Any
-ScVbaRange::HasFormula() throw (uno::RuntimeException, std::exception)
+ScVbaRange::HasFormula()
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -1805,7 +1804,7 @@ ScVbaRange::HasFormula() throw (uno::RuntimeException, std::exception)
     return uno::makeAny( true );
 }
 void
-ScVbaRange::fillSeries( sheet::FillDirection nFillDirection, sheet::FillMode nFillMode, sheet::FillDateMode nFillDateMode, double fStep, double fEndValue ) throw( uno::RuntimeException )
+ScVbaRange::fillSeries( sheet::FillDirection nFillDirection, sheet::FillMode nFillMode, sheet::FillDateMode nFillDateMode, double fStep, double fEndValue )
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -1827,35 +1826,35 @@ ScVbaRange::fillSeries( sheet::FillDirection nFillDirection, sheet::FillMode nFi
 }
 
 void
-ScVbaRange::FillLeft() throw (uno::RuntimeException, std::exception)
+ScVbaRange::FillLeft()
 {
     fillSeries(sheet::FillDirection_TO_LEFT,
         sheet::FillMode_SIMPLE, sheet::FillDateMode_FILL_DATE_DAY, 0, 0x7FFFFFFF);
 }
 
 void
-ScVbaRange::FillRight() throw (uno::RuntimeException, std::exception)
+ScVbaRange::FillRight()
 {
     fillSeries(sheet::FillDirection_TO_RIGHT,
         sheet::FillMode_SIMPLE, sheet::FillDateMode_FILL_DATE_DAY, 0, 0x7FFFFFFF);
 }
 
 void
-ScVbaRange::FillUp() throw (uno::RuntimeException, std::exception)
+ScVbaRange::FillUp()
 {
     fillSeries(sheet::FillDirection_TO_TOP,
         sheet::FillMode_SIMPLE, sheet::FillDateMode_FILL_DATE_DAY, 0, 0x7FFFFFFF);
 }
 
 void
-ScVbaRange::FillDown() throw (uno::RuntimeException, std::exception)
+ScVbaRange::FillDown()
 {
     fillSeries(sheet::FillDirection_TO_BOTTOM,
         sheet::FillMode_SIMPLE, sheet::FillDateMode_FILL_DATE_DAY, 0, 0x7FFFFFFF);
 }
 
 OUString
-ScVbaRange::getText() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getText()
 {
     // #TODO code within the test below "if ( m_Areas.... " can be removed
     // Test is performed only because m_xRange is NOT set to be
@@ -1871,7 +1870,7 @@ ScVbaRange::getText() throw (uno::RuntimeException, std::exception)
 }
 
 uno::Reference< excel::XRange >
-ScVbaRange::Offset( const ::uno::Any &nRowOff, const uno::Any &nColOff ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Offset( const ::uno::Any &nRowOff, const uno::Any &nColOff )
 {
     SCROW nRowOffset = 0;
     SCCOL nColOffset = 0;
@@ -1907,7 +1906,7 @@ ScVbaRange::Offset( const ::uno::Any &nRowOff, const uno::Any &nColOff ) throw (
 }
 
 uno::Reference< excel::XRange >
-ScVbaRange::CurrentRegion() throw (uno::RuntimeException, std::exception)
+ScVbaRange::CurrentRegion()
 {
     // #TODO code within the test below "if ( m_Areas.... " can be removed
     // Test is performed only because m_xRange is NOT set to be
@@ -1928,7 +1927,7 @@ ScVbaRange::CurrentRegion() throw (uno::RuntimeException, std::exception)
 }
 
 uno::Reference< excel::XRange >
-ScVbaRange::CurrentArray() throw (uno::RuntimeException, std::exception)
+ScVbaRange::CurrentArray()
 {
     // #TODO code within the test below "if ( m_Areas.... " can be removed
     // Test is performed only because m_xRange is NOT set to be
@@ -1948,7 +1947,7 @@ ScVbaRange::CurrentArray() throw (uno::RuntimeException, std::exception)
 }
 
 uno::Any
-ScVbaRange::getFormulaArray() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getFormulaArray()
 {
     // #TODO code within the test below "if ( m_Areas.... " can be removed
     // Test is performed only because m_xRange is NOT set to be
@@ -1986,7 +1985,7 @@ ScVbaRange::getFormulaArray() throw (uno::RuntimeException, std::exception)
 }
 
 void
-ScVbaRange::setFormulaArray(const uno::Any& rFormula) throw (uno::RuntimeException, std::exception)
+ScVbaRange::setFormulaArray(const uno::Any& rFormula)
 {
     // #TODO code within the test below "if ( m_Areas.... " can be removed
     // Test is performed only because m_xRange is NOT set to be
@@ -2022,7 +2021,7 @@ ScVbaRange::setFormulaArray(const uno::Any& rFormula) throw (uno::RuntimeExcepti
 }
 
 OUString
-ScVbaRange::Characters(const uno::Any& Start, const uno::Any& Length) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Characters(const uno::Any& Start, const uno::Any& Length)
 {
     // #TODO code within the test below "if ( m_Areas.... " can be removed
     // Test is performed only because m_xRange is NOT set to be
@@ -2048,7 +2047,7 @@ ScVbaRange::Characters(const uno::Any& Start, const uno::Any& Length) throw (uno
 }
 
 OUString
-ScVbaRange::Address(  const uno::Any& RowAbsolute, const uno::Any& ColumnAbsolute, const uno::Any& ReferenceStyle, const uno::Any& External, const uno::Any& RelativeTo ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Address(  const uno::Any& RowAbsolute, const uno::Any& ColumnAbsolute, const uno::Any& ReferenceStyle, const uno::Any& External, const uno::Any& RelativeTo )
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -2123,7 +2122,7 @@ ScVbaRange::Address(  const uno::Any& RowAbsolute, const uno::Any& ColumnAbsolut
 }
 
 uno::Reference < excel::XFont >
-ScVbaRange::Font() throw ( script::BasicErrorException, uno::RuntimeException)
+ScVbaRange::Font()
 {
     uno::Reference< beans::XPropertySet > xProps(mxRange, ::uno::UNO_QUERY );
     ScDocument& rDoc = getScDocument();
@@ -2145,7 +2144,7 @@ ScVbaRange::Font() throw ( script::BasicErrorException, uno::RuntimeException)
 }
 
 uno::Reference< excel::XRange >
-ScVbaRange::Cells( const uno::Any &nRowIndex, const uno::Any &nColumnIndex ) throw(uno::RuntimeException, std::exception)
+ScVbaRange::Cells( const uno::Any &nRowIndex, const uno::Any &nColumnIndex )
 {
     // #TODO code within the test below "if ( m_Areas.... " can be removed
     // Test is performed only because m_xRange is NOT set to be
@@ -2167,7 +2166,7 @@ uno::Reference< excel::XRange >
 ScVbaRange::CellsHelper( const uno::Reference< ov::XHelperInterface >& xParent,
                          const uno::Reference< uno::XComponentContext >& xContext,
                          const uno::Reference< css::table::XCellRange >& xRange,
-                         const uno::Any &nRowIndex, const uno::Any &nColumnIndex ) throw(uno::RuntimeException)
+                         const uno::Any &nRowIndex, const uno::Any &nColumnIndex )
 {
     sal_Int32 nRow = 0, nColumn = 0;
 
@@ -2245,7 +2244,7 @@ ScVbaRange::CellsHelper( const uno::Reference< ov::XHelperInterface >& xParent,
 }
 
 void
-ScVbaRange::Select() throw (uno::RuntimeException, std::exception)
+ScVbaRange::Select()
 {
     ScCellRangesBase* pUnoRangesBase = getCellRangesBase();
     if ( !pUnoRangesBase )
@@ -2295,7 +2294,7 @@ void setCursor( SCCOL nCol, SCROW nRow, const uno::Reference< frame::XModel >& x
 }
 
 void
-ScVbaRange::Activate() throw (uno::RuntimeException, std::exception)
+ScVbaRange::Activate()
 {
     // get first cell of current range
     uno::Reference< table::XCellRange > xCellRange;
@@ -2355,7 +2354,7 @@ ScVbaRange::Activate() throw (uno::RuntimeException, std::exception)
 }
 
 uno::Reference< excel::XRange >
-ScVbaRange::Rows(const uno::Any& aIndex ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Rows(const uno::Any& aIndex )
 {
     OUString sAddress;
 
@@ -2398,7 +2397,7 @@ ScVbaRange::Rows(const uno::Any& aIndex ) throw (uno::RuntimeException, std::exc
 }
 
 uno::Reference< excel::XRange >
-ScVbaRange::Columns(const uno::Any& aIndex ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Columns(const uno::Any& aIndex )
 {
     OUString sAddress;
 
@@ -2438,7 +2437,7 @@ ScVbaRange::Columns(const uno::Any& aIndex ) throw (uno::RuntimeException, std::
 }
 
 void
-ScVbaRange::setMergeCells( const uno::Any& aIsMerged ) throw (script::BasicErrorException, uno::RuntimeException)
+ScVbaRange::setMergeCells( const uno::Any& aIsMerged )
 {
     bool bMerge = extractBoolFromAny( aIsMerged );
 
@@ -2472,7 +2471,7 @@ ScVbaRange::setMergeCells( const uno::Any& aIsMerged ) throw (script::BasicError
 }
 
 uno::Any
-ScVbaRange::getMergeCells() throw (script::BasicErrorException, uno::RuntimeException)
+ScVbaRange::getMergeCells()
 {
     if( mxRanges.is() )
     {
@@ -2501,7 +2500,7 @@ ScVbaRange::getMergeCells() throw (script::BasicErrorException, uno::RuntimeExce
 }
 
 void
-ScVbaRange::Copy(const ::uno::Any& Destination) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Copy(const ::uno::Any& Destination)
 {
     if ( m_Areas->getCount() > 1 )
         throw uno::RuntimeException("That command cannot be used on multiple selections" );
@@ -2531,7 +2530,7 @@ ScVbaRange::Copy(const ::uno::Any& Destination) throw (uno::RuntimeException, st
 }
 
 void
-ScVbaRange::Cut(const ::uno::Any& Destination) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Cut(const ::uno::Any& Destination)
 {
     if ( m_Areas->getCount() > 1 )
         throw uno::RuntimeException("That command cannot be used on multiple selections" );
@@ -2557,7 +2556,7 @@ ScVbaRange::Cut(const ::uno::Any& Destination) throw (uno::RuntimeException, std
 }
 
 void
-ScVbaRange::setNumberFormat( const uno::Any& aFormat ) throw ( script::BasicErrorException, uno::RuntimeException)
+ScVbaRange::setNumberFormat( const uno::Any& aFormat )
 {
     OUString sFormat;
     aFormat >>= sFormat;
@@ -2576,7 +2575,7 @@ ScVbaRange::setNumberFormat( const uno::Any& aFormat ) throw ( script::BasicErro
 }
 
 uno::Any
-ScVbaRange::getNumberFormat() throw (script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange::getNumberFormat()
 {
 
     if ( m_Areas->getCount() > 1 )
@@ -2605,7 +2604,7 @@ ScVbaRange::getNumberFormat() throw (script::BasicErrorException, uno::RuntimeEx
 }
 
 uno::Reference< excel::XRange >
-ScVbaRange::Resize( const uno::Any &RowSize, const uno::Any &ColumnSize ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Resize( const uno::Any &RowSize, const uno::Any &ColumnSize )
 {
     long nRowSize = 0, nColumnSize = 0;
     bool bIsRowChanged = ( RowSize >>= nRowSize ), bIsColumnChanged = ( ColumnSize >>= nColumnSize );
@@ -2629,7 +2628,7 @@ ScVbaRange::Resize( const uno::Any &RowSize, const uno::Any &ColumnSize ) throw
 }
 
 void
-ScVbaRange::setWrapText( const uno::Any& aIsWrapped ) throw (script::BasicErrorException, uno::RuntimeException)
+ScVbaRange::setWrapText( const uno::Any& aIsWrapped )
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -2648,7 +2647,7 @@ ScVbaRange::setWrapText( const uno::Any& aIsWrapped ) throw (script::BasicErrorE
 }
 
 uno::Any
-ScVbaRange::getWrapText() throw (script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange::getWrapText()
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -2676,18 +2675,18 @@ ScVbaRange::getWrapText() throw (script::BasicErrorException, uno::RuntimeExcept
     return aValue;
 }
 
-uno::Reference< excel::XInterior > ScVbaRange::Interior( ) throw ( script::BasicErrorException, uno::RuntimeException)
+uno::Reference< excel::XInterior > ScVbaRange::Interior( )
 {
     uno::Reference< beans::XPropertySet > xProps( mxRange, uno::UNO_QUERY_THROW );
         return new ScVbaInterior ( this, mxContext, xProps, &getScDocument() );
 }
 uno::Reference< excel::XRange >
-ScVbaRange::Range( const uno::Any &Cell1, const uno::Any &Cell2 ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Range( const uno::Any &Cell1, const uno::Any &Cell2 )
 {
     return Range( Cell1, Cell2, false );
 }
 uno::Reference< excel::XRange >
-ScVbaRange::Range( const uno::Any &Cell1, const uno::Any &Cell2, bool bForceUseInpuRangeTab ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Range( const uno::Any &Cell1, const uno::Any &Cell2, bool bForceUseInpuRangeTab )
 
 {
     uno::Reference< table::XCellRange > xCellRange = mxRange;
@@ -2788,7 +2787,7 @@ ScVbaRange::Range( const uno::Any &Cell1, const uno::Any &Cell2, bool bForceUseI
 
 // Allow access to underlying openoffice uno api ( useful for debugging
 // with openoffice basic )
-uno::Any SAL_CALL ScVbaRange::getCellRange(  ) throw (uno::RuntimeException, std::exception)
+uno::Any SAL_CALL ScVbaRange::getCellRange(  )
 {
     uno::Any aAny;
     if ( mxRanges.is() )
@@ -2798,7 +2797,7 @@ uno::Any SAL_CALL ScVbaRange::getCellRange(  ) throw (uno::RuntimeException, std
     return aAny;
 }
 
-uno::Any ScVbaRange::getCellRange( const uno::Reference< excel::XRange >& rxRange ) throw (uno::RuntimeException)
+uno::Any ScVbaRange::getCellRange( const uno::Reference< excel::XRange >& rxRange )
 {
     if( ScVbaRange* pVbaRange = getImplementation( rxRange ) )
         return pVbaRange->getCellRange();
@@ -2854,7 +2853,7 @@ getPasteFormulaBits( sal_Int32 Operation)
     return nFormulaBits;
 }
 void SAL_CALL
-ScVbaRange::PasteSpecial( const uno::Any& Paste, const uno::Any& Operation, const uno::Any& SkipBlanks, const uno::Any& Transpose ) throw (css::uno::RuntimeException, std::exception)
+ScVbaRange::PasteSpecial( const uno::Any& Paste, const uno::Any& Operation, const uno::Any& SkipBlanks, const uno::Any& Transpose )
 {
     if ( m_Areas->getCount() > 1 )
         throw uno::RuntimeException("That command cannot be used on multiple selections" );
@@ -2888,7 +2887,7 @@ ScVbaRange::PasteSpecial( const uno::Any& Paste, const uno::Any& Operation, cons
 }
 
 uno::Reference< excel::XRange >
-ScVbaRange::getEntireColumnOrRow( bool bColumn ) throw (uno::RuntimeException)
+ScVbaRange::getEntireColumnOrRow( bool bColumn )
 {
     ScCellRangesBase* pUnoRangesBase = getCellRangesBase();
     // copy the range list
@@ -2919,19 +2918,19 @@ ScVbaRange::getEntireColumnOrRow( bool bColumn ) throw (uno::RuntimeException)
 }
 
 uno::Reference< excel::XRange > SAL_CALL
-ScVbaRange::getEntireRow() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getEntireRow()
 {
     return getEntireColumnOrRow(false);
 }
 
 uno::Reference< excel::XRange > SAL_CALL
-ScVbaRange::getEntireColumn() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getEntireColumn()
 {
     return getEntireColumnOrRow(true);
 }
 
 uno::Reference< excel::XComment > SAL_CALL
-ScVbaRange::AddComment( const uno::Any& Text ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::AddComment( const uno::Any& Text )
 {
     // if there is already a comment in the top-left cell then throw
     if( getComment().is() )
@@ -2955,7 +2954,7 @@ ScVbaRange::AddComment( const uno::Any& Text ) throw (uno::RuntimeException, std
 }
 
 uno::Reference< excel::XComment > SAL_CALL
-ScVbaRange::getComment() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getComment()
 {
     // intentional behavior to return a null object if no
     // comment defined
@@ -2968,7 +2967,7 @@ ScVbaRange::getComment() throw (uno::RuntimeException, std::exception)
 
 /// @throws uno::RuntimeException
 uno::Reference< beans::XPropertySet >
-getRowOrColumnProps( const uno::Reference< table::XCellRange >& xCellRange, bool bRows ) throw ( uno::RuntimeException )
+getRowOrColumnProps( const uno::Reference< table::XCellRange >& xCellRange, bool bRows )
 {
     uno::Reference< table::XColumnRowRange > xColRow( xCellRange, uno::UNO_QUERY_THROW );
     uno::Reference< beans::XPropertySet > xProps;
@@ -2980,7 +2979,7 @@ getRowOrColumnProps( const uno::Reference< table::XCellRange >& xCellRange, bool
 }
 
 uno::Any SAL_CALL
-ScVbaRange::getHidden() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getHidden()
 {
     // if multi-area result is the result of the
     // first area
@@ -3004,7 +3003,7 @@ ScVbaRange::getHidden() throw (uno::RuntimeException, std::exception)
 }
 
 void SAL_CALL
-ScVbaRange::setHidden( const uno::Any& _hidden ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::setHidden( const uno::Any& _hidden )
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -3030,7 +3029,7 @@ ScVbaRange::setHidden( const uno::Any& _hidden ) throw (uno::RuntimeException, s
 }
 
 sal_Bool SAL_CALL
-ScVbaRange::Replace( const OUString& What, const OUString& Replacement, const uno::Any& LookAt, const uno::Any& SearchOrder, const uno::Any& MatchCase, const uno::Any& MatchByte, const uno::Any& SearchFormat, const uno::Any& ReplaceFormat  ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Replace( const OUString& What, const OUString& Replacement, const uno::Any& LookAt, const uno::Any& SearchOrder, const uno::Any& MatchCase, const uno::Any& MatchByte, const uno::Any& SearchFormat, const uno::Any& ReplaceFormat  )
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -3132,7 +3131,7 @@ ScVbaRange::Replace( const OUString& What, const OUString& Replacement, const un
 }
 
 uno::Reference< excel::XRange > SAL_CALL
-ScVbaRange::Find( const uno::Any& What, const uno::Any& After, const uno::Any& LookIn, const uno::Any& LookAt, const uno::Any& SearchOrder, const uno::Any& SearchDirection, const uno::Any& MatchCase, const uno::Any& /*MatchByte*/, const uno::Any& /*SearchFormat*/ ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Find( const uno::Any& What, const uno::Any& After, const uno::Any& LookIn, const uno::Any& LookAt, const uno::Any& SearchOrder, const uno::Any& SearchDirection, const uno::Any& MatchCase, const uno::Any& /*MatchByte*/, const uno::Any& /*SearchFormat*/ )
 {
     // return a Range object that represents the first cell where that information is found.
     OUString sWhat;
@@ -3321,7 +3320,7 @@ uno::Reference< table::XCellRange > processKey( const uno::Any& Key, uno::Refere
 // helper method for Sort
 /// @throws uno::RuntimeException
 sal_Int32 findSortPropertyIndex( const uno::Sequence< beans::PropertyValue >& props,
-const OUString& sPropName ) throw( uno::RuntimeException )
+const OUString& sPropName )
 {
     const beans::PropertyValue* pProp = props.getConstArray();
     sal_Int32 nItems = props.getLength();
@@ -3339,7 +3338,7 @@ const OUString& sPropName ) throw( uno::RuntimeException )
 /// @throws uno::RuntimeException
 void updateTableSortField( const uno::Reference< table::XCellRange >& xParentRange,
     const uno::Reference< table::XCellRange >& xColRowKey, sal_Int16 nOrder,
-    table::TableSortField& aTableField, bool bIsSortColumn, bool bMatchCase ) throw ( uno::RuntimeException )
+    table::TableSortField& aTableField, bool bIsSortColumn, bool bMatchCase )
 {
         RangeHelper parentRange( xParentRange );
         RangeHelper colRowRange( xColRowKey );
@@ -3373,7 +3372,7 @@ void updateTableSortField( const uno::Reference< table::XCellRange >& xParentRan
 }
 
 void SAL_CALL
-ScVbaRange::Sort( const uno::Any& Key1, const uno::Any& Order1, const uno::Any& Key2, const uno::Any& /*Type*/, const uno::Any& Order2, const uno::Any& Key3, const uno::Any& Order3, const uno::Any& Header, const uno::Any& OrderCustom, const uno::Any& MatchCase, const uno::Any& Orientation, const uno::Any& SortMethod,  const uno::Any& DataOption1, const uno::Any& DataOption2, const uno::Any& DataOption3  ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Sort( const uno::Any& Key1, const uno::Any& Order1, const uno::Any& Key2, const uno::Any& /*Type*/, const uno::Any& Order2, const uno::Any& Key3, const uno::Any& Order3, const uno::Any& Header, const uno::Any& OrderCustom, const uno::Any& MatchCase, const uno::Any& Orientation, const uno::Any& SortMethod,  const uno::Any& DataOption1, const uno::Any& DataOption2, const uno::Any& DataOption3  )
 {
     // #TODO# #FIXME# can we do something with Type
     if ( m_Areas->getCount() > 1 )
@@ -3549,7 +3548,7 @@ ScVbaRange::Sort( const uno::Any& Key1, const uno::Any& Order1, const uno::Any&
 }
 
 uno::Reference< excel::XRange > SAL_CALL
-ScVbaRange::End( ::sal_Int32 Direction )  throw (uno::RuntimeException, std::exception)
+ScVbaRange::End( ::sal_Int32 Direction )
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -3640,7 +3639,7 @@ ScVbaRange::isSingleCellRange()
 }
 
 uno::Reference< excel::XCharacters > SAL_CALL
-ScVbaRange::characters( const uno::Any& Start, const uno::Any& Length ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::characters( const uno::Any& Start, const uno::Any& Length )
 {
     if ( !isSingleCellRange() )
         throw uno::RuntimeException("Can't create Characters property for multicell range " );
@@ -3652,7 +3651,7 @@ ScVbaRange::characters( const uno::Any& Start, const uno::Any& Length ) throw (u
 }
 
  void SAL_CALL
-ScVbaRange::Delete( const uno::Any& Shift ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Delete( const uno::Any& Shift )
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -3700,7 +3699,7 @@ ScVbaRange::Delete( const uno::Any& Shift ) throw (uno::RuntimeException, std::e
 
 //XElementAccess
 sal_Bool SAL_CALL
-ScVbaRange::hasElements() throw (uno::RuntimeException, std::exception)
+ScVbaRange::hasElements()
 {
     uno::Reference< table::XColumnRowRange > xColumnRowRange(mxRange, uno::UNO_QUERY );
     if ( xColumnRowRange.is() )
@@ -3712,7 +3711,7 @@ ScVbaRange::hasElements() throw (uno::RuntimeException, std::exception)
 
 // XEnumerationAccess
 uno::Reference< container::XEnumeration > SAL_CALL
-ScVbaRange::createEnumeration() throw (uno::RuntimeException, std::exception)
+ScVbaRange::createEnumeration()
 {
     if ( mbIsColumns || mbIsRows )
     {
@@ -3730,7 +3729,7 @@ ScVbaRange::createEnumeration() throw (uno::RuntimeException, std::exception)
 }
 
 OUString SAL_CALL
-ScVbaRange::getDefaultMethodName(  ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::getDefaultMethodName(  )
 {
     return OUString( "Item" );
 }
@@ -3738,7 +3737,6 @@ ScVbaRange::getDefaultMethodName(  ) throw (uno::RuntimeException, std::exceptio
 // returns calc internal col. width ( in points )
 double
 ScVbaRange::getCalcColWidth(const table::CellRangeAddress& rAddress)
-    throw (uno::RuntimeException, std::exception)
 {
     ScDocument& rDoc = getScDocument();
     sal_uInt16 nWidth = rDoc.GetOriginalWidth( static_cast< SCCOL >( rAddress.StartColumn ), static_cast< SCTAB >( rAddress.Sheet ) );
@@ -3749,7 +3747,6 @@ ScVbaRange::getCalcColWidth(const table::CellRangeAddress& rAddress)
 
 double
 ScVbaRange::getCalcRowHeight(const table::CellRangeAddress& rAddress)
-    throw (uno::RuntimeException, std::exception)
 {
     ScDocument& rDoc = getDocumentFromRange( mxRange );
     sal_uInt16 nWidth = rDoc.GetOriginalHeight( rAddress.StartRow, rAddress.Sheet );
@@ -3772,7 +3769,7 @@ double getDefaultCharWidth( ScDocShell* pDocShell )
 }
 
 uno::Any SAL_CALL
-ScVbaRange::getColumnWidth() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getColumnWidth()
 {
     sal_Int32 nLen = m_Areas->getCount();
     if ( nLen > 1 )
@@ -3809,7 +3806,7 @@ ScVbaRange::getColumnWidth() throw (uno::RuntimeException, std::exception)
 }
 
 void SAL_CALL
-ScVbaRange::setColumnWidth( const uno::Any& _columnwidth ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::setColumnWidth( const uno::Any& _columnwidth )
 {
     sal_Int32 nLen = m_Areas->getCount();
     if ( nLen > 1 )
@@ -3841,7 +3838,7 @@ ScVbaRange::setColumnWidth( const uno::Any& _columnwidth ) throw (uno::RuntimeEx
 }
 
 uno::Any SAL_CALL
-ScVbaRange::getWidth() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getWidth()
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -3862,7 +3859,7 @@ ScVbaRange::getWidth() throw (uno::RuntimeException, std::exception)
 }
 
 uno::Any SAL_CALL
-ScVbaRange::Areas( const uno::Any& item) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Areas( const uno::Any& item)
 {
     if ( !item.hasValue() )
         return uno::makeAny( m_Areas );
@@ -3870,7 +3867,7 @@ ScVbaRange::Areas( const uno::Any& item) throw (uno::RuntimeException, std::exce
 }
 
 uno::Reference< excel::XRange >
-ScVbaRange::getArea( sal_Int32 nIndex ) throw( css::uno::RuntimeException )
+ScVbaRange::getArea( sal_Int32 nIndex )
 {
     if ( !m_Areas.is() )
         throw uno::RuntimeException("No areas available" );
@@ -3879,7 +3876,7 @@ ScVbaRange::getArea( sal_Int32 nIndex ) throw( css::uno::RuntimeException )
 }
 
 uno::Any
-ScVbaRange::Borders( const uno::Any& item ) throw( script::BasicErrorException, uno::RuntimeException )
+ScVbaRange::Borders( const uno::Any& item )
 {
     if ( !item.hasValue() )
         return uno::makeAny( getBorders() );
@@ -3888,7 +3885,7 @@ ScVbaRange::Borders( const uno::Any& item ) throw( script::BasicErrorException,
 
 uno::Any SAL_CALL
 ScVbaRange::BorderAround( const css::uno::Any& LineStyle, const css::uno::Any& Weight,
-                const css::uno::Any& ColorIndex, const css::uno::Any& Color ) throw (css::uno::RuntimeException, std::exception)
+                const css::uno::Any& ColorIndex, const css::uno::Any& Color )
 {
     sal_Int32 nCount = getBorders()->getCount();
 
@@ -3935,7 +3932,6 @@ ScVbaRange::BorderAround( const css::uno::Any& LineStyle, const css::uno::Any& W
 
 uno::Any SAL_CALL
 ScVbaRange::getRowHeight()
-    throw (uno::RuntimeException, std::exception)
 {
     sal_Int32 nLen = m_Areas->getCount();
     if ( nLen > 1 )
@@ -3974,7 +3970,7 @@ ScVbaRange::getRowHeight()
 }
 
 void SAL_CALL
-ScVbaRange::setRowHeight( const uno::Any& _rowheight) throw (uno::RuntimeException, std::exception)
+ScVbaRange::setRowHeight( const uno::Any& _rowheight)
 {
     sal_Int32 nLen = m_Areas->getCount();
     if ( nLen > 1 )
@@ -4000,7 +3996,7 @@ ScVbaRange::setRowHeight( const uno::Any& _rowheight) throw (uno::RuntimeExcepti
 }
 
 uno::Any SAL_CALL
-ScVbaRange::getPageBreak() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getPageBreak()
 {
     sal_Int32 nPageBreak = excel::XlPageBreak::xlPageBreakNone;
     ScDocShell* pShell = getDocShellFromRange( mxRange );
@@ -4036,7 +4032,7 @@ ScVbaRange::getPageBreak() throw (uno::RuntimeException, std::exception)
 }
 
 void SAL_CALL
-ScVbaRange::setPageBreak( const uno::Any& _pagebreak) throw (uno::RuntimeException, std::exception)
+ScVbaRange::setPageBreak( const uno::Any& _pagebreak)
 {
     sal_Int32 nPageBreak = 0;
     _pagebreak >>= nPageBreak;
@@ -4067,7 +4063,7 @@ ScVbaRange::setPageBreak( const uno::Any& _pagebreak) throw (uno::RuntimeExcepti
 }
 
 uno::Any SAL_CALL
-ScVbaRange::getHeight() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getHeight()
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -4088,7 +4084,7 @@ ScVbaRange::getHeight() throw (uno::RuntimeException, std::exception)
 }
 
 awt::Point
-ScVbaRange::getPosition() throw ( uno::RuntimeException )
+ScVbaRange::getPosition()
 {
     awt::Point aPoint;
     uno::Reference< beans::XPropertySet > xProps;
@@ -4100,7 +4096,7 @@ ScVbaRange::getPosition() throw ( uno::RuntimeException )
     return aPoint;
 }
 uno::Any SAL_CALL
-ScVbaRange::getLeft() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getLeft()
 {
     // helperapi returns the first ranges left ( and top below )
     if ( m_Areas->getCount() > 1 )
@@ -4110,7 +4106,7 @@ ScVbaRange::getLeft() throw (uno::RuntimeException, std::exception)
 }
 
 uno::Any SAL_CALL
-ScVbaRange::getTop() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getTop()
 {
     // helperapi returns the first ranges top
     if ( m_Areas->getCount() > 1 )
@@ -4143,7 +4139,7 @@ uno::Reference< sheet::XCellRangeReferrer > getNamedRange( const uno::Reference<
 }
 
 uno::Reference< excel::XName >
-ScVbaRange::getName() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getName()
 {
     uno::Reference< beans::XPropertySet > xProps( getUnoModel(), uno::UNO_QUERY );
     uno::Reference< table::XCellRange > thisRange( getCellRange(), uno::UNO_QUERY_THROW );
@@ -4170,7 +4166,7 @@ ScVbaRange::getName() throw (uno::RuntimeException, std::exception)
 }
 
 uno::Reference< excel::XWorksheet >
-ScVbaRange::getWorksheet() throw (uno::RuntimeException, std::exception)
+ScVbaRange::getWorksheet()
 {
     // #TODO #FIXME parent should always be set up ( currently thats not
     // the case )
@@ -4195,7 +4191,7 @@ ScVbaRange::getWorksheet() throw (uno::RuntimeException, std::exception)
 // #TODO remove this ugly application processing
 // Process an application Range request e.g. 'Range("a1,b2,a4:b6")
 uno::Reference< excel::XRange >
-ScVbaRange::ApplicationRange( const uno::Reference< uno::XComponentContext >& xContext, const css::uno::Any &Cell1, const css::uno::Any &Cell2 ) throw (css::uno::RuntimeException, std::exception)
+ScVbaRange::ApplicationRange( const uno::Reference< uno::XComponentContext >& xContext, const css::uno::Any &Cell1, const css::uno::Any &Cell2 )
 {
     // Although the documentation seems clear that Range without a
     // qualifier then it's a shortcut for ActiveSheet.Range
@@ -4376,7 +4372,6 @@ static void lcl_setTableFieldsFromCriteria( OUString& sCriteria1, uno::Reference
 
 void SAL_CALL
 ScVbaRange::AutoFilter( const uno::Any& aField, const uno::Any& Criteria1, const uno::Any& Operator, const uno::Any& Criteria2, const uno::Any& /*VisibleDropDown*/ )
-    throw (uno::RuntimeException, std::exception)
 {
     // Is there an existing autofilter
     RangeHelper thisRange( mxRange );
@@ -4621,7 +4616,7 @@ ScVbaRange::AutoFilter( const uno::Any& aField, const uno::Any& Criteria1, const
 }
 
 void SAL_CALL
-ScVbaRange::Insert( const uno::Any& Shift, const uno::Any& /*CopyOrigin*/ ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Insert( const uno::Any& Shift, const uno::Any& /*CopyOrigin*/ )
 {
     // It appears ( from the web ) that the undocumented CopyOrigin
     // param should contain member of enum XlInsertFormatOrigin
@@ -4672,7 +4667,7 @@ ScVbaRange::Insert( const uno::Any& Shift, const uno::Any& /*CopyOrigin*/ ) thro
 }
 
 void SAL_CALL
-ScVbaRange::Autofit() throw (script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange::Autofit()
 {
     sal_Int32 nLen = m_Areas->getCount();
     if ( nLen > 1 )
@@ -4709,7 +4704,7 @@ ScVbaRange::Autofit() throw (script::BasicErrorException, uno::RuntimeException,
 }
 
 uno::Any SAL_CALL
-ScVbaRange::Hyperlinks( const uno::Any& aIndex ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::Hyperlinks( const uno::Any& aIndex )
 {
     /*  The range object always returns a new Hyperlinks object containing a
         fixed list of existing hyperlinks in the range.
@@ -4730,7 +4725,7 @@ ScVbaRange::Hyperlinks( const uno::Any& aIndex ) throw (uno::RuntimeException, s
 }
 
 css::uno::Reference< excel::XValidation > SAL_CALL
-ScVbaRange::getValidation() throw (css::uno::RuntimeException, std::exception)
+ScVbaRange::getValidation()
 {
     if ( !m_xValidation.is() )
         m_xValidation = new ScVbaValidation( this, mxContext, mxRange );
@@ -4740,7 +4735,7 @@ ScVbaRange::getValidation() throw (css::uno::RuntimeException, std::exception)
 namespace {
 
 /// @throws uno::RuntimeException
-sal_Unicode lclGetPrefixChar( const uno::Reference< table::XCell >& rxCell ) throw (uno::RuntimeException)
+sal_Unicode lclGetPrefixChar( const uno::Reference< table::XCell >& rxCell )
 {
     /*  TODO/FIXME: We need an apostroph-prefix property at the cell to
         implement this correctly. For now, return an apostroph for every text
@@ -4754,7 +4749,7 @@ sal_Unicode lclGetPrefixChar( const uno::Reference< table::XCell >& rxCell ) thr
 }
 
 /// @throws uno::RuntimeException
-sal_Unicode lclGetPrefixChar( const uno::Reference< table::XCellRange >& rxRange ) throw (uno::RuntimeException)
+sal_Unicode lclGetPrefixChar( const uno::Reference< table::XCellRange >& rxRange )
 {
     /*  This implementation is able to handle different prefixes (needed if
         Application.TransitionNavigKeys is true). The function lclGetPrefixChar
@@ -4782,7 +4777,7 @@ sal_Unicode lclGetPrefixChar( const uno::Reference< table::XCellRange >& rxRange
 }
 
 /// @throws uno::RuntimeException
-sal_Unicode lclGetPrefixChar( const uno::Reference< sheet::XSheetCellRangeContainer >& rxRanges ) throw (uno::RuntimeException)
+sal_Unicode lclGetPrefixChar( const uno::Reference< sheet::XSheetCellRangeContainer >& rxRanges )
 {
     sal_Unicode cCurrPrefix = 0;
     uno::Reference< container::XEnumerationAccess > xRangesEA( rxRanges, uno::UNO_QUERY_THROW );
@@ -4806,7 +4801,7 @@ inline uno::Any lclGetPrefixVariant( sal_Unicode cPrefixChar )
 
 } // namespace
 
-uno::Any SAL_CALL ScVbaRange::getPrefixCharacter() throw (uno::RuntimeException, std::exception)
+uno::Any SAL_CALL ScVbaRange::getPrefixCharacter()
 {
     /*  (1) If Application.TransitionNavigKeys is false, this function returns
         an apostroph character if the text cell begins with an apostroph
@@ -4831,7 +4826,7 @@ uno::Any SAL_CALL ScVbaRange::getPrefixCharacter() throw (uno::RuntimeException,
     throw uno::RuntimeException("Unexpected empty Range object" );
 }
 
-uno::Any ScVbaRange::getShowDetail() throw ( css::uno::RuntimeException, std::exception)
+uno::Any ScVbaRange::getShowDetail()
 {
     // #FIXME, If the specified range is in a PivotTable report
 
@@ -4869,7 +4864,7 @@ uno::Any ScVbaRange::getShowDetail() throw ( css::uno::RuntimeException, std::ex
     return aNULL();
 }
 
-void ScVbaRange::setShowDetail(const uno::Any& aShowDetail) throw ( css::uno::RuntimeException, std::exception)
+void ScVbaRange::setShowDetail(const uno::Any& aShowDetail)
 {
     // #FIXME, If the specified range is in a PivotTable report
 
@@ -4905,7 +4900,7 @@ void ScVbaRange::setShowDetail(const uno::Any& aShowDetail) throw ( css::uno::Ru
 }
 
 uno::Reference< excel::XRange > SAL_CALL
-ScVbaRange::MergeArea() throw (script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange::MergeArea()
 {
     uno::Reference< sheet::XSheetCellRange > xMergeShellCellRange(mxRange->getCellRangeByPosition(0,0,0,0), uno::UNO_QUERY_THROW);
     uno::Reference< sheet::XSheetCellCursor > xMergeSheetCursor(xMergeShellCellRange->getSpreadsheet()->createCursorByRange( xMergeShellCellRange ), uno::UNO_QUERY_THROW);
@@ -4934,7 +4929,7 @@ ScVbaRange::MergeArea() throw (script::BasicErrorException, uno::RuntimeExceptio
 }
 
 void SAL_CALL
-ScVbaRange::PrintOut( const uno::Any& From, const uno::Any& To, const uno::Any& Copies, const uno::Any& Preview, const uno::Any& ActivePrinter, const uno::Any& PrintToFile, const uno::Any& Collate, const uno::Any& PrToFileName ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::PrintOut( const uno::Any& From, const uno::Any& To, const uno::Any& Copies, const uno::Any& Preview, const uno::Any& ActivePrinter, const uno::Any& PrintToFile, const uno::Any& Collate, const uno::Any& PrToFileName )
 {
     ScDocShell* pShell = nullptr;
 
@@ -4968,7 +4963,7 @@ ScVbaRange::PrintOut( const uno::Any& From, const uno::Any& To, const uno::Any&
 }
 
 void SAL_CALL
-ScVbaRange::AutoFill(  const uno::Reference< excel::XRange >& Destination, const uno::Any& Type ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::AutoFill(  const uno::Reference< excel::XRange >& Destination, const uno::Any& Type )
 {
     uno::Reference< excel::XRange > xDest( Destination, uno::UNO_QUERY_THROW );
     ScVbaRange* pRange = getImplementation( xDest );
@@ -5083,7 +5078,7 @@ ScVbaRange::AutoFill(  const uno::Reference< excel::XRange >& Destination, const
                                    nCount, fStep, fEndValue, true, true );
 }
 sal_Bool SAL_CALL
-ScVbaRange::GoalSeek( const uno::Any& Goal, const uno::Reference< excel::XRange >& ChangingCell ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::GoalSeek( const uno::Any& Goal, const uno::Reference< excel::XRange >& ChangingCell )
 {
     ScDocShell* pDocShell = getScDocShell();
     bool bRes = true;
@@ -5113,13 +5108,13 @@ ScVbaRange::GoalSeek( const uno::Any& Goal, const uno::Reference< excel::XRange
 }
 
 void
-ScVbaRange::Calculate(  ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange::Calculate(  )
 {
     getWorksheet()->Calculate();
 }
 
 uno::Reference< excel::XRange > SAL_CALL
-ScVbaRange::Item( const uno::Any& row, const uno::Any& column ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange::Item( const uno::Any& row, const uno::Any& column )
 {
     if ( mbIsRows || mbIsColumns )
     {
@@ -5136,7 +5131,7 @@ ScVbaRange::Item( const uno::Any& row, const uno::Any& column ) throw (script::B
 }
 
 void
-ScVbaRange::AutoOutline(  ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange::AutoOutline(  )
 {
     // #TODO #FIXME needs to check for summary row/col ( whatever they are )
     // not valid for multi Area Addresses
@@ -5160,7 +5155,7 @@ ScVbaRange::AutoOutline(  ) throw (script::BasicErrorException, uno::RuntimeExce
 }
 
 void SAL_CALL
-ScVbaRange:: ClearOutline(  ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange:: ClearOutline(  )
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -5178,7 +5173,7 @@ ScVbaRange:: ClearOutline(  ) throw (script::BasicErrorException, uno::RuntimeEx
 }
 
 void
-ScVbaRange::groupUnGroup( bool bUnGroup ) throw ( script::BasicErrorException, uno::RuntimeException )
+ScVbaRange::groupUnGroup( bool bUnGroup )
 {
     if ( m_Areas->getCount() > 1 )
          DebugHelper::basicexception(ERRCODE_BASIC_METHOD_FAILED, STR_ERRORMESSAGE_APPLIESTOSINGLERANGEONLY);
@@ -5195,24 +5190,24 @@ ScVbaRange::groupUnGroup( bool bUnGroup ) throw ( script::BasicErrorException, u
 }
 
 void SAL_CALL
-ScVbaRange::Group(  ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange::Group(  )
 {
     groupUnGroup(false);
 }
 void SAL_CALL
-ScVbaRange::Ungroup(  ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange::Ungroup(  )
 {
     groupUnGroup(true);
 }
 
 /// @throws uno::RuntimeException
-static void lcl_mergeCellsOfRange( const uno::Reference< table::XCellRange >& xCellRange, bool _bMerge ) throw ( uno::RuntimeException )
+static void lcl_mergeCellsOfRange( const uno::Reference< table::XCellRange >& xCellRange, bool _bMerge )
 {
         uno::Reference< util::XMergeable > xMergeable( xCellRange, uno::UNO_QUERY_THROW );
         xMergeable->merge(_bMerge);
 }
 void SAL_CALL
-ScVbaRange::Merge( const uno::Any& Across ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange::Merge( const uno::Any& Across )
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -5241,7 +5236,7 @@ ScVbaRange::Merge( const uno::Any& Across ) throw (script::BasicErrorException,
 }
 
 void SAL_CALL
-ScVbaRange::UnMerge(  ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange::UnMerge(  )
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -5257,7 +5252,7 @@ ScVbaRange::UnMerge(  ) throw (script::BasicErrorException, uno::RuntimeExceptio
 }
 
 uno::Any SAL_CALL
-ScVbaRange::getStyle() throw (css::script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange::getStyle()
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -5273,7 +5268,7 @@ ScVbaRange::getStyle() throw (css::script::BasicErrorException, uno::RuntimeExce
     return uno::makeAny( xStyle );
 }
 void SAL_CALL
-ScVbaRange::setStyle( const uno::Any& _style ) throw (uno::RuntimeException, std::exception)
+ScVbaRange::setStyle( const uno::Any& _style )
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -5317,7 +5312,7 @@ ScVbaRange::PreviousNext( bool bIsPrevious )
 }
 
 uno::Reference< excel::XRange > SAL_CALL
-ScVbaRange::Next() throw (script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange::Next()
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -5328,7 +5323,7 @@ ScVbaRange::Next() throw (script::BasicErrorException, uno::RuntimeException, st
 }
 
 uno::Reference< excel::XRange > SAL_CALL
-ScVbaRange::Previous() throw (script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange::Previous()
 {
     if ( m_Areas->getCount() > 1 )
     {
@@ -5340,8 +5335,6 @@ ScVbaRange::Previous() throw (script::BasicErrorException, uno::RuntimeException
 
 uno::Reference< excel::XRange > SAL_CALL
 ScVbaRange::SpecialCells( const uno::Any& _oType, const uno::Any& _oValue)
-    throw (script::BasicErrorException, uno::RuntimeException,
-           std::exception)
 {
     bool bIsSingleCell = isSingleCellRange();
     bool bIsMultiArea = ( m_Areas->getCount() > 1 );
@@ -5422,7 +5415,7 @@ ScVbaRange::SpecialCells( const uno::Any& _oType, const uno::Any& _oValue)
 }
 
 /// @throws script::BasicErrorException
-static sal_Int32 lcl_getFormulaResultFlags(const uno::Any& aType) throw ( script::BasicErrorException )
+static sal_Int32 lcl_getFormulaResultFlags(const uno::Any& aType)
 {
     sal_Int32 nType = excel::XlSpecialCellsValue::xlNumbers;
     aType >>= nType;
@@ -5450,7 +5443,7 @@ static sal_Int32 lcl_getFormulaResultFlags(const uno::Any& aType) throw ( script
 }
 
 uno::Reference< excel::XRange >
-ScVbaRange::SpecialCellsImpl( sal_Int32 nType, const uno::Any& _oValue) throw ( script::BasicErrorException )
+ScVbaRange::SpecialCellsImpl( sal_Int32 nType, const uno::Any& _oValue)
 {
     uno::Reference< excel::XRange > xRange;
     try
@@ -5506,14 +5499,14 @@ ScVbaRange::SpecialCellsImpl( sal_Int32 nType, const uno::Any& _oValue) throw (
 }
 
 void SAL_CALL
-ScVbaRange::RemoveSubtotal(  ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange::RemoveSubtotal(  )
 {
     uno::Reference< sheet::XSubTotalCalculatable > xSub( mxRange, uno::UNO_QUERY_THROW );
     xSub->removeSubTotals();
 }
 
 void SAL_CALL
-ScVbaRange::Subtotal( ::sal_Int32 _nGroupBy, ::sal_Int32 _nFunction, const uno::Sequence< ::sal_Int32 >& _nTotalList, const uno::Any& aReplace, const uno::Any& PageBreaks, const uno::Any& /*SummaryBelowData*/ ) throw (script::BasicErrorException, uno::RuntimeException, std::exception)
+ScVbaRange::Subtotal( ::sal_Int32 _nGroupBy, ::sal_Int32 _nFunction, const uno::Sequence< ::sal_Int32 >& _nTotalList, const uno::Any& aReplace, const uno::Any& PageBreaks, const uno::Any& /*SummaryBelowData*/ )
 {
     try
     {
@@ -5602,7 +5595,7 @@ ScVbaRange::getServiceNames()
 }
 
 sal_Bool SAL_CALL
-ScVbaRange::hasError() throw (uno::RuntimeException, std::exception)
+ScVbaRange::hasError()
 {
     double dResult = 0.0;
     uno::Reference< excel::XApplication > xApplication( Application(), uno::UNO_QUERY_THROW );