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, 123 insertions, 167 deletions

diff --git a/testtools/source/bridgetest/cppobj.cxx b/testtools/source/bridgetest/cppobj.cxx
index ad3fd185b97c..bda776594200 100644
--- a/testtools/source/bridgetest/cppobj.cxx
+++ b/testtools/source/bridgetest/cppobj.cxx
@@ -162,9 +162,9 @@ public:
      }
 
     // XServiceInfo
-    virtual OUString SAL_CALL getImplementationName() throw (RuntimeException, std::exception) override;
-    virtual sal_Bool SAL_CALL supportsService( const OUString & rServiceName ) throw (RuntimeException, std::exception) override;
-    virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() throw (RuntimeException, std::exception) override;
+    virtual OUString SAL_CALL getImplementationName() override;
+    virtual sal_Bool SAL_CALL supportsService( const OUString & rServiceName ) override;
+    virtual Sequence< OUString > SAL_CALL getSupportedServiceNames() override;
 
     // XLBTestBase
     virtual void SAL_CALL setValues( sal_Bool bBool, sal_Unicode cChar, sal_Int8 nByte,
@@ -176,8 +176,7 @@ public:
                                      const css::uno::Reference< css::uno::XInterface >& xTest,
                                      const css::uno::Any& rAny,
                                      const css::uno::Sequence<TestElement >& rSequence,
-                                     const TestData& rStruct )
-        throw(css::uno::RuntimeException, std::exception) override;
+                                     const TestData& rStruct ) override;
 
     virtual TestData SAL_CALL setValues2( sal_Bool& bBool, sal_Unicode& cChar, sal_Int8& nByte,
                                                 sal_Int16& nShort, sal_uInt16& nUShort,
@@ -188,8 +187,7 @@ public:
                                                 css::uno::Reference< css::uno::XInterface >& xTest,
                                                 css::uno::Any& rAny,
                                                 css::uno::Sequence<TestElement >& rSequence,
-                                                TestData& rStruct )
-        throw(css::uno::RuntimeException, std::exception) override;
+                                                TestData& rStruct ) override;
 
     virtual TestData SAL_CALL getValues( sal_Bool& bBool, sal_Unicode& cChar, sal_Int8& nByte,
                                                sal_Int16& nShort, sal_uInt16& nUShort,
@@ -200,231 +198,210 @@ public:
                                                css::uno::Reference< css::uno::XInterface >& xTest,
                                                css::uno::Any& rAny,
                                                css::uno::Sequence< TestElement >& rSequence,
-                                               TestData& rStruct )
-        throw(css::uno::RuntimeException, std::exception) override;
+                                               TestData& rStruct ) override;
 
-    virtual SmallStruct SAL_CALL echoSmallStruct(const SmallStruct& rStruct) throw(css::uno::RuntimeException, std::exception) override
+    virtual SmallStruct SAL_CALL echoSmallStruct(const SmallStruct& rStruct) override
         { return rStruct; }
-    virtual MediumStruct SAL_CALL echoMediumStruct(const MediumStruct& rStruct) throw(css::uno::RuntimeException, std::exception) override
+    virtual MediumStruct SAL_CALL echoMediumStruct(const MediumStruct& rStruct) override
         { return rStruct; }
-    virtual BigStruct SAL_CALL echoBigStruct(const BigStruct& rStruct) throw(css::uno::RuntimeException, std::exception) override
+    virtual BigStruct SAL_CALL echoBigStruct(const BigStruct& rStruct) override
         { return rStruct; }
-    virtual TwoFloats SAL_CALL echoTwoFloats(const TwoFloats& rStruct) throw(css::uno::RuntimeException, std::exception) override
+    virtual TwoFloats SAL_CALL echoTwoFloats(const TwoFloats& rStruct) override
         { return rStruct; }
-    virtual FourFloats SAL_CALL echoFourFloats(const FourFloats& rStruct) throw(css::uno::RuntimeException, std::exception) override
+    virtual FourFloats SAL_CALL echoFourFloats(const FourFloats& rStruct) override
         { return rStruct; }
-    virtual MixedFloatAndInteger SAL_CALL echoMixedFloatAndInteger(const MixedFloatAndInteger& rStruct) throw(css::uno::RuntimeException, std::exception) override
+    virtual MixedFloatAndInteger SAL_CALL echoMixedFloatAndInteger(const MixedFloatAndInteger& rStruct) override
         { return rStruct; }
-    virtual ThreeByteStruct SAL_CALL echoThreeByteStruct(const ThreeByteStruct& rStruct) throw(css::uno::RuntimeException, std::exception) override
+    virtual ThreeByteStruct SAL_CALL echoThreeByteStruct(const ThreeByteStruct& rStruct) override
         { return rStruct; }
-    virtual sal_Int32 SAL_CALL testPPCAlignment( sal_Int64, sal_Int64, sal_Int32, sal_Int64, sal_Int32 i2 ) throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL testPPCAlignment( sal_Int64, sal_Int64, sal_Int32, sal_Int64, sal_Int32 i2 ) override
         { return i2; }
-    virtual sal_Int32 SAL_CALL testPPC64Alignment( double , double , double , sal_Int32 i1 ) throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL testPPC64Alignment( double , double , double , sal_Int32 i1 ) override
         { return i1; }
-    virtual double SAL_CALL testTenDoubles( double d1, double d2, double d3, double d4, double d5, double d6, double d7, double d8, double d9, double d10 ) throw(css::uno::RuntimeException, std::exception) override
+    virtual double SAL_CALL testTenDoubles( double d1, double d2, double d3, double d4, double d5, double d6, double d7, double d8, double d9, double d10 ) override
         { return d1 + d2 + d3 + d4 + d5 + d6 + d7 + d8 + d9 + d10; }
-    virtual sal_Bool SAL_CALL getBool() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_Bool SAL_CALL getBool() override
         { return _aData.Bool; }
-    virtual sal_Int8 SAL_CALL getByte() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_Int8 SAL_CALL getByte() override
         { return _aData.Byte; }
-    virtual sal_Unicode SAL_CALL getChar() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_Unicode SAL_CALL getChar() override
         { return _aData.Char; }
-    virtual sal_Int16 SAL_CALL getShort() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_Int16 SAL_CALL getShort() override
         { return _aData.Short; }
-    virtual sal_uInt16 SAL_CALL getUShort() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_uInt16 SAL_CALL getUShort() override
         { return _aData.UShort; }
-    virtual sal_Int32 SAL_CALL getLong() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL getLong() override
         { return _aData.Long; }
-    virtual sal_uInt32 SAL_CALL getULong() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_uInt32 SAL_CALL getULong() override
         { return _aData.ULong; }
-    virtual sal_Int64 SAL_CALL getHyper() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_Int64 SAL_CALL getHyper() override
         { return _aData.Hyper; }
-    virtual sal_uInt64 SAL_CALL getUHyper() throw(css::uno::RuntimeException, std::exception) override
+    virtual sal_uInt64 SAL_CALL getUHyper() override
         { return _aData.UHyper; }
-    virtual float SAL_CALL getFloat() throw(css::uno::RuntimeException, std::exception) override
+    virtual float SAL_CALL getFloat() override
         { return _aData.Float; }
-    virtual double SAL_CALL getDouble() throw(css::uno::RuntimeException, std::exception) override
+    virtual double SAL_CALL getDouble() override
         { return _aData.Double; }
-    virtual TestEnum SAL_CALL getEnum() throw(css::uno::RuntimeException, std::exception) override
+    virtual TestEnum SAL_CALL getEnum() override
         { return _aData.Enum; }
-    virtual OUString SAL_CALL getString() throw(css::uno::RuntimeException, std::exception) override
+    virtual OUString SAL_CALL getString() override
         { return _aData.String; }
-    virtual css::uno::Reference< css::uno::XInterface > SAL_CALL getInterface(  ) throw(css::uno::RuntimeException, std::exception) override
+    virtual css::uno::Reference< css::uno::XInterface > SAL_CALL getInterface(  ) override
         { return _aData.Interface; }
-    virtual css::uno::Any SAL_CALL getAny() throw(css::uno::RuntimeException, std::exception) override
+    virtual css::uno::Any SAL_CALL getAny() override
         { return _aData.Any; }
-    virtual css::uno::Sequence< TestElement > SAL_CALL getSequence() throw(css::uno::RuntimeException, std::exception) override
+    virtual css::uno::Sequence< TestElement > SAL_CALL getSequence() override
         { return _aData.Sequence; }
-    virtual TestData SAL_CALL getStruct() throw(css::uno::RuntimeException, std::exception) override
+    virtual TestData SAL_CALL getStruct() override
         { return _aStructData; }
 
-    virtual void SAL_CALL setBool( sal_Bool _bool ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setBool( sal_Bool _bool ) override
         { _aData.Bool = _bool; }
-    virtual void SAL_CALL setByte( sal_Int8 _byte ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setByte( sal_Int8 _byte ) override
         { _aData.Byte = _byte; }
-    virtual void SAL_CALL setChar( sal_Unicode _char ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setChar( sal_Unicode _char ) override
         { _aData.Char = _char; }
-    virtual void SAL_CALL setShort( sal_Int16 _short ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setShort( sal_Int16 _short ) override
         { _aData.Short = _short; }
-    virtual void SAL_CALL setUShort( sal_uInt16 _ushort ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setUShort( sal_uInt16 _ushort ) override
         { _aData.UShort = _ushort; }
-    virtual void SAL_CALL setLong( sal_Int32 _long ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setLong( sal_Int32 _long ) override
         { _aData.Long = _long; }
-    virtual void SAL_CALL setULong( sal_uInt32 _ulong ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setULong( sal_uInt32 _ulong ) override
         { _aData.ULong = _ulong; }
-    virtual void SAL_CALL setHyper( sal_Int64 _hyper ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setHyper( sal_Int64 _hyper ) override
         { _aData.Hyper = _hyper; }
-    virtual void SAL_CALL setUHyper( sal_uInt64 _uhyper ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setUHyper( sal_uInt64 _uhyper ) override
         { _aData.UHyper = _uhyper; }
-    virtual void SAL_CALL setFloat( float _float ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setFloat( float _float ) override
         { _aData.Float = _float; }
-    virtual void SAL_CALL setDouble( double _double ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setDouble( double _double ) override
         { _aData.Double = _double; }
-    virtual void SAL_CALL setEnum( TestEnum _enum ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setEnum( TestEnum _enum ) override
         { _aData.Enum = _enum; }
-    virtual void SAL_CALL setString( const OUString& _string ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setString( const OUString& _string ) override
         { _aData.String = _string; }
-    virtual void SAL_CALL setInterface( const css::uno::Reference< css::uno::XInterface >& _interface ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setInterface( const css::uno::Reference< css::uno::XInterface >& _interface ) override
         { _aData.Interface = _interface; }
-    virtual void SAL_CALL setAny( const css::uno::Any& _any ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setAny( const css::uno::Any& _any ) override
         { _aData.Any = _any; }
-    virtual void SAL_CALL setSequence( const css::uno::Sequence<TestElement >& _sequence ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setSequence( const css::uno::Sequence<TestElement >& _sequence ) override
         { _aData.Sequence = _sequence; }
-    virtual void SAL_CALL setStruct( const TestData& _struct ) throw(css::uno::RuntimeException, std::exception) override
+    virtual void SAL_CALL setStruct( const TestData& _struct ) override
         { _aStructData = _struct; }
 
-    virtual sal_Int32 SAL_CALL getRaiseAttr1() throw (RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL getRaiseAttr1() override
     { throw RuntimeException(); }
 
-    virtual void SAL_CALL setRaiseAttr1(sal_Int32)
-        throw (IllegalArgumentException, RuntimeException, std::exception) override
+    virtual void SAL_CALL setRaiseAttr1(sal_Int32) override
     { throw IllegalArgumentException(); }
 
-    virtual sal_Int32 SAL_CALL getRaiseAttr2()
-        throw (IllegalArgumentException, RuntimeException, std::exception) override
+    virtual sal_Int32 SAL_CALL getRaiseAttr2() override
     { throw IllegalArgumentException(); }
 
     virtual TestPolyStruct< sal_Bool > SAL_CALL transportPolyBoolean(
-        TestPolyStruct< sal_Bool > const & arg) throw (RuntimeException, std::exception) override
+        TestPolyStruct< sal_Bool > const & arg) override
     { return arg; }
 
-    virtual void SAL_CALL transportPolyHyper(TestPolyStruct< sal_Int64 > &)
-        throw (RuntimeException, std::exception) override {}
+    virtual void SAL_CALL transportPolyHyper(TestPolyStruct< sal_Int64 > &) override {}
 
     virtual void SAL_CALL transportPolySequence(
         TestPolyStruct< Sequence< Any > > const & arg1,
-        TestPolyStruct< Sequence< Any > > & arg2) throw (RuntimeException, std::exception) override
+        TestPolyStruct< Sequence< Any > > & arg2) override
     { arg2 = arg1; }
 
-    virtual TestPolyStruct< sal_Int32 > SAL_CALL getNullPolyLong()
-        throw (RuntimeException, std::exception) override
+    virtual TestPolyStruct< sal_Int32 > SAL_CALL getNullPolyLong() override
     { return TestPolyStruct< sal_Int32 >(0); /* work around MS compiler bug */ }
 
-    virtual TestPolyStruct< OUString > SAL_CALL getNullPolyString()
-        throw (RuntimeException, std::exception) override
+    virtual TestPolyStruct< OUString > SAL_CALL getNullPolyString() override
     { return TestPolyStruct< OUString >(); }
 
-    virtual TestPolyStruct< Type > SAL_CALL getNullPolyType()
-        throw (RuntimeException, std::exception) override
+    virtual TestPolyStruct< Type > SAL_CALL getNullPolyType() override
     { return TestPolyStruct< Type >(); }
 
-    virtual TestPolyStruct< Any > SAL_CALL getNullPolyAny()
-        throw (RuntimeException, std::exception) override
+    virtual TestPolyStruct< Any > SAL_CALL getNullPolyAny() override
     { return TestPolyStruct< Any >(); }
 
     virtual TestPolyStruct< Sequence< sal_Bool > > SAL_CALL
-    getNullPolySequence() throw (RuntimeException, std::exception) override
+    getNullPolySequence() override
     { return TestPolyStruct< Sequence< sal_Bool > >(); }
 
-    virtual TestPolyStruct< TestEnum > SAL_CALL getNullPolyEnum()
-        throw (RuntimeException, std::exception) override
+    virtual TestPolyStruct< TestEnum > SAL_CALL getNullPolyEnum() override
     { return TestPolyStruct< TestEnum >(
         test::testtools::bridgetest::TestEnum_TEST);
           /* work around MS compiler bug */ }
 
-    virtual TestPolyStruct< TestBadEnum > SAL_CALL getNullPolyBadEnum()
-        throw (RuntimeException, std::exception) override
+    virtual TestPolyStruct< TestBadEnum > SAL_CALL getNullPolyBadEnum() override
     { return TestPolyStruct< TestBadEnum >(
         test::testtools::bridgetest::TestBadEnum_M);
           /* explicitly instantiate with default enumerator */ }
 
-    virtual TestPolyStruct< TestStruct > SAL_CALL getNullPolyStruct()
-        throw (RuntimeException, std::exception) override
+    virtual TestPolyStruct< TestStruct > SAL_CALL getNullPolyStruct() override
     { return TestPolyStruct< TestStruct >(); }
 
     virtual TestPolyStruct< Reference< XBridgeTestBase > > SAL_CALL
-    getNullPolyInterface() throw (RuntimeException, std::exception) override
+    getNullPolyInterface() override
     { return TestPolyStruct< Reference< XBridgeTestBase > >(); }
 
     virtual css::uno::Any SAL_CALL transportAny(
-        const css::uno::Any& value )
-        throw(css::uno::RuntimeException, std::exception) override;
-
-    virtual void SAL_CALL call( sal_Int32 nCallId, sal_Int32 nWaitMUSEC )
-        throw(css::uno::RuntimeException, std::exception) override;
-    virtual void SAL_CALL callOneway( sal_Int32 nCallId, sal_Int32 nWaitMUSEC )
-        throw(css::uno::RuntimeException, std::exception) override;
-    virtual sal_Bool SAL_CALL sequenceOfCallTestPassed(  )
-        throw(css::uno::RuntimeException, std::exception) override;
+        const css::uno::Any& value ) override;
+
+    virtual void SAL_CALL call( sal_Int32 nCallId, sal_Int32 nWaitMUSEC ) override;
+    virtual void SAL_CALL callOneway( sal_Int32 nCallId, sal_Int32 nWaitMUSEC ) override;
+    virtual sal_Bool SAL_CALL sequenceOfCallTestPassed(  ) override;
     virtual void SAL_CALL startRecursiveCall(
-        const css::uno::Reference< XRecursiveCall >& xCall, sal_Int32 nToCall )
-        throw(css::uno::RuntimeException, std::exception) override;
+        const css::uno::Reference< XRecursiveCall >& xCall, sal_Int32 nToCall ) override;
 
-    virtual Reference< XMulti > SAL_CALL getMulti() throw (RuntimeException, std::exception) override;
+    virtual Reference< XMulti > SAL_CALL getMulti() override;
 
-    virtual OUString SAL_CALL testMulti(Reference< XMulti > const & multi)
-        throw (RuntimeException, std::exception) override;
+    virtual OUString SAL_CALL testMulti(Reference< XMulti > const & multi) override;
 
 public: // XBridgeTest
-    virtual TestData SAL_CALL raiseException( sal_Int16 nArgumentPos, const OUString & rMsg, const Reference< XInterface > & xCOntext )
-        throw(css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception) override;
+    virtual TestData SAL_CALL raiseException( sal_Int16 nArgumentPos, const OUString & rMsg, const Reference< XInterface > & xCOntext ) override;
 
     virtual void SAL_CALL raiseRuntimeExceptionOneway(
-        const OUString& Message, const css::uno::Reference< css::uno::XInterface >& Context )
-        throw(css::uno::RuntimeException, std::exception) override;
+        const OUString& Message, const css::uno::Reference< css::uno::XInterface >& Context ) override;
 
-    virtual sal_Int32 SAL_CALL getRuntimeException() throw(css::uno::RuntimeException, std::exception) override;
-    virtual void SAL_CALL setRuntimeException( sal_Int32 _runtimeexception ) throw(css::uno::RuntimeException, std::exception) override;
+    virtual sal_Int32 SAL_CALL getRuntimeException() override;
+    virtual void SAL_CALL setRuntimeException( sal_Int32 _runtimeexception ) override;
 
     // XBridgeTest2
     virtual Sequence< sal_Bool > SAL_CALL setSequenceBool(
-        const Sequence< sal_Bool >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_Bool >& aSeq ) override;
     virtual Sequence< sal_Unicode > SAL_CALL setSequenceChar(
-        const Sequence< sal_Unicode >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_Unicode >& aSeq ) override;
     virtual Sequence< sal_Int8 > SAL_CALL setSequenceByte(
-        const Sequence< sal_Int8 >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_Int8 >& aSeq ) override;
     virtual Sequence< sal_Int16 > SAL_CALL setSequenceShort(
-        const Sequence< sal_Int16 >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_Int16 >& aSeq ) override;
     virtual Sequence< sal_uInt16 > SAL_CALL setSequenceUShort(
-        const Sequence< sal_uInt16 >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_uInt16 >& aSeq ) override;
     virtual Sequence< sal_Int32 > SAL_CALL setSequenceLong(
-        const Sequence< sal_Int32 >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_Int32 >& aSeq ) override;
     virtual Sequence< sal_uInt32 > SAL_CALL setSequenceULong(
-        const Sequence< sal_uInt32 >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_uInt32 >& aSeq ) override;
     virtual Sequence< sal_Int64 > SAL_CALL setSequenceHyper(
-        const Sequence< sal_Int64 >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_Int64 >& aSeq ) override;
     virtual Sequence< sal_uInt64 > SAL_CALL setSequenceUHyper(
-        const Sequence< sal_uInt64 >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< sal_uInt64 >& aSeq ) override;
     virtual Sequence< float > SAL_CALL setSequenceFloat(
-        const Sequence< float >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< float >& aSeq ) override;
     virtual Sequence< double > SAL_CALL setSequenceDouble(
-        const Sequence< double >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< double >& aSeq ) override;
     virtual Sequence< TestEnum > SAL_CALL setSequenceEnum(
-        const Sequence< TestEnum >& aSeq ) throw (RuntimeException, std::exception) override ;
+        const Sequence< TestEnum >& aSeq ) override ;
     virtual Sequence< OUString > SAL_CALL setSequenceString(
-        const Sequence< OUString >& aString ) throw (RuntimeException, std::exception) override;
+        const Sequence< OUString >& aString ) override;
     virtual Sequence< Reference< XInterface > > SAL_CALL setSequenceXInterface(
-        const Sequence< Reference< XInterface > >& aSeq )
-        throw (RuntimeException, std::exception) override;
+        const Sequence< Reference< XInterface > >& aSeq ) override;
     virtual Sequence<Any > SAL_CALL setSequenceAny(
-        const Sequence<Any >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence<Any >& aSeq ) override;
     virtual Sequence<TestElement > SAL_CALL setSequenceStruct(
-        const Sequence< TestElement >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence< TestElement >& aSeq ) override;
     virtual Sequence< Sequence< sal_Int32 > > SAL_CALL setDim2(
-        const Sequence<Sequence< sal_Int32 > >& aSeq ) throw (RuntimeException, std::exception) override;
+        const Sequence<Sequence< sal_Int32 > >& aSeq ) override;
     virtual Sequence< Sequence< Sequence< sal_Int32 > > > SAL_CALL setDim3(
-        const Sequence< Sequence< Sequence< sal_Int32 > > >& aSeq )
-        throw (RuntimeException, std::exception) override;
+        const Sequence< Sequence< Sequence< sal_Int32 > > >& aSeq ) override;
     virtual void SAL_CALL setSequencesInOut(Sequence< sal_Bool >& aSeqBoolean,
                                 Sequence< sal_Unicode >& aSeqChar,
                                 Sequence< sal_Int8 >& aSeqByte,
@@ -441,8 +418,7 @@ public: // XBridgeTest
                                 Sequence<Reference<XInterface > >& aSeqXInterface,
                                 Sequence< Any >& aSeqAny,
                                 Sequence< Sequence< sal_Int32 > >& aSeqDim2,
-                                Sequence< Sequence< Sequence< sal_Int32 > > >& aSeqDim3 )
-        throw (RuntimeException, std::exception) override;
+                                Sequence< Sequence< Sequence< sal_Int32 > > >& aSeqDim3 ) override;
     virtual void SAL_CALL setSequencesOut( Sequence< sal_Bool >& aSeqBoolean,
                              Sequence< sal_Unicode >& aSeqChar,
                              Sequence< sal_Int8 >& aSeqByte,
@@ -459,17 +435,14 @@ public: // XBridgeTest
                              Sequence< Reference< XInterface > >& aSeqXInterface,
                              Sequence< Any >& aSeqAny,
                              Sequence< Sequence< sal_Int32 > >& aSeqDim2,
-                             Sequence< Sequence< Sequence< sal_Int32 > > >& aSeqDim3 )
-        throw (RuntimeException, std::exception) override;
+                             Sequence< Sequence< Sequence< sal_Int32 > > >& aSeqDim3 ) override;
     virtual void SAL_CALL testConstructorsService(
-        Reference< XComponentContext > const & context)
-        throw (RuntimeException, std::exception) override;
+        Reference< XComponentContext > const & context) override;
     virtual Reference< XCurrentContextChecker > SAL_CALL
-    getCurrentContextChecker()
-        throw (RuntimeException, std::exception) override;
+    getCurrentContextChecker() override;
 
 public:
-    virtual void SAL_CALL callRecursivly( const css::uno::Reference< XRecursiveCall >& xCall, sal_Int32 nToCall ) throw(css::uno::RuntimeException, std::exception) override;
+    virtual void SAL_CALL callRecursivly( const css::uno::Reference< XRecursiveCall >& xCall, sal_Int32 nToCall ) override;
 };
 
 //Dummy class for XComponent implementation
@@ -481,7 +454,7 @@ public:
 
 };
 
-Any Test_Impl::transportAny( const Any & value ) throw ( css::uno::RuntimeException, std::exception)
+Any Test_Impl::transportAny( const Any & value )
 {
     return value;
 }
@@ -499,7 +472,7 @@ void wait(sal_Int32 microSeconds) {
 
 }
 
-void Test_Impl::call( sal_Int32 nCallId , sal_Int32 nWaitMUSEC ) throw(css::uno::RuntimeException, std::exception)
+void Test_Impl::call( sal_Int32 nCallId , sal_Int32 nWaitMUSEC )
 {
     wait(nWaitMUSEC);
     if( m_bFirstCall )
@@ -514,7 +487,7 @@ void Test_Impl::call( sal_Int32 nCallId , sal_Int32 nWaitMUSEC ) throw(css::uno:
 }
 
 
-void Test_Impl::callOneway( sal_Int32 nCallId , sal_Int32 nWaitMUSEC ) throw (css::uno::RuntimeException, std::exception)
+void Test_Impl::callOneway( sal_Int32 nCallId , sal_Int32 nWaitMUSEC )
 {
     wait(nWaitMUSEC);
     m_bSequenceOfCallTestPassed = m_bSequenceOfCallTestPassed && (nCallId > m_nLastCallId);
@@ -522,7 +495,7 @@ void Test_Impl::callOneway( sal_Int32 nCallId , sal_Int32 nWaitMUSEC ) throw (cs
 }
 
 
-sal_Bool Test_Impl::sequenceOfCallTestPassed() throw (css::uno::RuntimeException, std::exception)
+sal_Bool Test_Impl::sequenceOfCallTestPassed()
 {
     return m_bSequenceOfCallTestPassed;
 }
@@ -530,7 +503,6 @@ sal_Bool Test_Impl::sequenceOfCallTestPassed() throw (css::uno::RuntimeException
 
 void SAL_CALL Test_Impl::startRecursiveCall(
     const css::uno::Reference< XRecursiveCall >& xCall, sal_Int32 nToCall )
-    throw(css::uno::RuntimeException, std::exception)
 {
     MutexGuard guard( m_mutex );
     if( nToCall )
@@ -544,7 +516,6 @@ void SAL_CALL Test_Impl::startRecursiveCall(
 void SAL_CALL Test_Impl::callRecursivly(
     const css::uno::Reference< XRecursiveCall >& xCall,
     sal_Int32 nToCall )
-    throw(css::uno::RuntimeException, std::exception)
 {
     MutexGuard guard( m_mutex );
     if( nToCall )
@@ -554,12 +525,11 @@ void SAL_CALL Test_Impl::callRecursivly(
     }
 }
 
-Reference< XMulti > Test_Impl::getMulti() throw (RuntimeException, std::exception) {
+Reference< XMulti > Test_Impl::getMulti() {
     return new testtools::bridgetest::Multi;
 }
 
 OUString Test_Impl::testMulti(Reference< XMulti > const & multi)
-    throw (RuntimeException, std::exception)
 {
     return testtools::bridgetest::testMulti(multi);
 }
@@ -575,7 +545,6 @@ void Test_Impl::setValues( sal_Bool bBool, sal_Unicode cChar, sal_Int8 nByte,
                            const css::uno::Any& rAny,
                            const css::uno::Sequence<TestElement >& rSequence,
                            const TestData& rStruct )
-    throw(css::uno::RuntimeException, std::exception)
 {
     assign( _aData,
             bBool, cChar, nByte, nShort, nUShort, nLong, nULong, nHyper, nUHyper, fFloat, fDouble,
@@ -593,7 +562,6 @@ TestData Test_Impl::setValues2( sal_Bool& bBool, sal_Unicode& cChar, sal_Int8& n
                                 css::uno::Any& rAny,
                                 css::uno::Sequence<TestElement >& rSequence,
                                 TestData& rStruct )
-    throw(css::uno::RuntimeException, std::exception)
 {
     assign( _aData,
             bBool, cChar, nByte, nShort, nUShort, nLong, nULong, nHyper, nUHyper, fFloat, fDouble,
@@ -617,7 +585,6 @@ TestData Test_Impl::getValues( sal_Bool& bBool, sal_Unicode& cChar, sal_Int8& nB
                                css::uno::Any& rAny,
                                css::uno::Sequence<TestElement >& rSequence,
                                TestData& rStruct )
-    throw(css::uno::RuntimeException, std::exception)
 {
     bBool = _aData.Bool;
     cChar = _aData.Char;
@@ -640,7 +607,6 @@ TestData Test_Impl::getValues( sal_Bool& bBool, sal_Unicode& cChar, sal_Int8& nB
 }
 
 TestData Test_Impl::raiseException( sal_Int16 nArgumentPos, const OUString & rMsg, const Reference< XInterface > & xContext )
-    throw(css::lang::IllegalArgumentException, css::uno::RuntimeException, std::exception)
 {
     IllegalArgumentException aExc;
     aExc.ArgumentPosition = nArgumentPos;
@@ -650,7 +616,6 @@ TestData Test_Impl::raiseException( sal_Int16 nArgumentPos, const OUString & rMs
 }
 
 void Test_Impl::raiseRuntimeExceptionOneway( const OUString & rMsg, const Reference< XInterface > & xContext )
-    throw(css::uno::RuntimeException, std::exception)
 {
     RuntimeException aExc;
     aExc.Message          = _aData.String = rMsg;
@@ -691,7 +656,6 @@ void dothrow(const RuntimeException& e)
 }
 
 sal_Int32 Test_Impl::getRuntimeException()
-    throw (RuntimeException, std::exception)
 {
     try
     {
@@ -705,7 +669,7 @@ sal_Int32 Test_Impl::getRuntimeException()
     return 0; // for dummy
 }
 
-void Test_Impl::setRuntimeException( sal_Int32 ) throw(css::uno::RuntimeException, std::exception)
+void Test_Impl::setRuntimeException( sal_Int32 )
 {
     RuntimeException aExc;
     aExc.Message          = _aData.String;
@@ -715,91 +679,91 @@ void Test_Impl::setRuntimeException( sal_Int32 ) throw(css::uno::RuntimeExceptio
 
 // XBridgeTest2 -------------------------------------------------------------
 Sequence< sal_Bool > SAL_CALL Test_Impl::setSequenceBool(
-        const Sequence< sal_Bool >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_Bool >& aSeq )
 {
     _arBool = aSeq;
     return aSeq;
 }
 
 Sequence< sal_Unicode > SAL_CALL Test_Impl::setSequenceChar(
-        const Sequence< sal_Unicode >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_Unicode >& aSeq )
 {
     _arChar = aSeq;
     return aSeq;
 }
 
 Sequence< sal_Int8 > SAL_CALL Test_Impl::setSequenceByte(
-        const Sequence< sal_Int8 >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_Int8 >& aSeq )
 {
     _arByte = aSeq;
     return aSeq;
 }
 
 Sequence< sal_Int16 > SAL_CALL Test_Impl::setSequenceShort(
-        const Sequence< sal_Int16 >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_Int16 >& aSeq )
 {
     _arShort = aSeq;
     return aSeq;
 }
 
 Sequence< sal_uInt16 > SAL_CALL Test_Impl::setSequenceUShort(
-        const Sequence< sal_uInt16 >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_uInt16 >& aSeq )
 {
     _arUShort = aSeq;
     return aSeq;
 }
 
 Sequence< sal_Int32 > SAL_CALL Test_Impl::setSequenceLong(
-        const Sequence< sal_Int32 >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_Int32 >& aSeq )
 {
     _arLong = aSeq;
     return aSeq;
 }
 
 Sequence< sal_uInt32 > SAL_CALL Test_Impl::setSequenceULong(
-        const Sequence< sal_uInt32 >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_uInt32 >& aSeq )
 {
     _arULong = aSeq;
     return aSeq;
 }
 
 Sequence< sal_Int64 > SAL_CALL Test_Impl::setSequenceHyper(
-        const Sequence< sal_Int64 >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_Int64 >& aSeq )
 {
     _arHyper = aSeq;
     return aSeq;
 }
 
 Sequence< sal_uInt64 > SAL_CALL Test_Impl::setSequenceUHyper(
-        const Sequence< sal_uInt64 >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< sal_uInt64 >& aSeq )
 {
     _arUHyper = aSeq;
     return aSeq;
 }
 
 Sequence< float > SAL_CALL Test_Impl::setSequenceFloat(
-        const Sequence< float >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence< float >& aSeq )
 {
     _arFloat = aSeq;
     return aSeq;
 }
 
 Sequence< double > SAL_CALL Test_Impl::setSequenceDouble(
-    const Sequence< double >& aSeq ) throw (RuntimeException, std::exception)
+    const Sequence< double >& aSeq )
 {
     _arDouble = aSeq;
     return aSeq;
 }
 
 Sequence< TestEnum > SAL_CALL Test_Impl::setSequenceEnum(
-    const Sequence< TestEnum >& aSeq ) throw (RuntimeException, std::exception)
+    const Sequence< TestEnum >& aSeq )
 {
     _arEnum = aSeq;
     return aSeq;
 }
 
 Sequence< OUString > SAL_CALL Test_Impl::setSequenceString(
-    const Sequence< OUString >& aSeq ) throw (RuntimeException, std::exception)
+    const Sequence< OUString >& aSeq )
 {
     _arString = aSeq;
     return aSeq;
@@ -807,28 +771,27 @@ Sequence< OUString > SAL_CALL Test_Impl::setSequenceString(
 
 Sequence< Reference< XInterface > > SAL_CALL Test_Impl::setSequenceXInterface(
         const Sequence< Reference< XInterface > >& aSeq )
-        throw (RuntimeException, std::exception)
 {
     _arObject = aSeq;
     return aSeq;
 }
 
 Sequence<Any > SAL_CALL Test_Impl::setSequenceAny(
-    const Sequence<Any >& aSeq ) throw (RuntimeException, std::exception)
+    const Sequence<Any >& aSeq )
 {
     _arAny = aSeq;
     return aSeq;
 }
 
 Sequence<TestElement > SAL_CALL Test_Impl::setSequenceStruct(
-    const Sequence< TestElement >& aSeq ) throw (RuntimeException, std::exception)
+    const Sequence< TestElement >& aSeq )
 {
     _arStruct = aSeq;
     return aSeq;
 }
 
 Sequence< Sequence< sal_Int32 > > SAL_CALL Test_Impl::setDim2(
-        const Sequence<Sequence< sal_Int32 > >& aSeq ) throw (RuntimeException, std::exception)
+        const Sequence<Sequence< sal_Int32 > >& aSeq )
 {
     _arLong2 = aSeq;
     return aSeq;
@@ -836,7 +799,6 @@ Sequence< Sequence< sal_Int32 > > SAL_CALL Test_Impl::setDim2(
 
 Sequence< Sequence< Sequence< sal_Int32 > > > SAL_CALL Test_Impl::setDim3(
         const Sequence< Sequence< Sequence< sal_Int32 > > >& aSeq )
-        throw (RuntimeException, std::exception)
 {
     _arLong3 = aSeq;
     return aSeq;
@@ -859,7 +821,6 @@ void SAL_CALL Test_Impl::setSequencesInOut(Sequence< sal_Bool >& aSeqBoolean,
                                 Sequence< Any >& aSeqAny,
                                 Sequence< Sequence< sal_Int32 > >& aSeqDim2,
                                 Sequence< Sequence< Sequence< sal_Int32 > > >& aSeqDim3 )
-        throw (RuntimeException, std::exception)
 {
     _arBool = aSeqBoolean;
     _arChar = aSeqChar;
@@ -897,7 +858,6 @@ void SAL_CALL Test_Impl::setSequencesOut( Sequence< sal_Bool >& aSeqBoolean,
                              Sequence< Any >& aSeqAny,
                              Sequence< Sequence< sal_Int32 > >& aSeqDim2,
                              Sequence< Sequence< Sequence< sal_Int32 > > >& aSeqDim3 )
-        throw (RuntimeException, std::exception)
 {
     aSeqBoolean = _arBool;
     aSeqChar = _arChar;
@@ -919,7 +879,7 @@ void SAL_CALL Test_Impl::setSequencesOut( Sequence< sal_Bool >& aSeqBoolean,
 }
 
 void Test_Impl::testConstructorsService(
-    Reference< XComponentContext > const & context) throw (RuntimeException, std::exception)
+    Reference< XComponentContext > const & context)
 {
     Sequence< sal_Bool > arg14(1); arg14[0] = true;
     Sequence< sal_Int8 > arg15(1); arg15[0] = SAL_MIN_INT8;
@@ -1134,7 +1094,6 @@ void Test_Impl::testConstructorsService(
 }
 
 Reference< XCurrentContextChecker > Test_Impl::getCurrentContextChecker()
-    throw (RuntimeException, std::exception)
 {
     return new testtools::bridgetest::CurrentContextChecker;
 }
@@ -1142,19 +1101,16 @@ Reference< XCurrentContextChecker > Test_Impl::getCurrentContextChecker()
 // XServiceInfo
 
 OUString Test_Impl::getImplementationName()
-    throw (RuntimeException, std::exception)
 {
     return OUString( IMPLNAME );
 }
 
 sal_Bool Test_Impl::supportsService( const OUString & rServiceName )
-    throw (RuntimeException, std::exception)
 {
     return cppu::supportsService(this, rServiceName);
 }
 
 Sequence< OUString > Test_Impl::getSupportedServiceNames()
-    throw (RuntimeException, std::exception)
 {
     return bridge_object::getSupportedServiceNames();
 }