Code cleanup: ( () ) replaced by (())

30 files changed, 456 insertions, 456 deletions

diff --git a/cppu/inc/com/sun/star/uno/Any.h b/cppu/inc/com/sun/star/uno/Any.h
index b904d08ec356..f5f2f72be8f8 100644
--- a/cppu/inc/com/sun/star/uno/Any.h
+++ b/cppu/inc/com/sun/star/uno/Any.h
@@ -57,19 +57,19 @@ class Any : public uno_Any
 public:
     /// @cond INTERNAL
     // these are here to force memory de/allocation to sal lib.
-    inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW( () )
+    inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW(())
         { return ::rtl_allocateMemory( nSize ); }
-    inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW( () )
+    inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW(())
         { ::rtl_freeMemory( pMem ); }
-    inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW( () )
+    inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW(())
         { return pMem; }
-    inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () )
+    inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW(())
         {}
     /// @endcond
 
     /** Default constructor: Any holds no value; its type is void.
     */
-    inline Any() SAL_THROW( () );
+    inline Any() SAL_THROW(());
 
     /** Templated ctor.  Sets a copy of the given value.
 
@@ -84,51 +84,51 @@ public:
 
         @param rAny another any
     */
-    inline Any( const Any & rAny ) SAL_THROW( () );
+    inline Any( const Any & rAny ) SAL_THROW(());
 
     /** Constructor: Sets a copy of the given data.
 
         @param pData_ value
         @param rType type of value
     */
-    inline Any( const void * pData_, const Type & rType ) SAL_THROW( () );
+    inline Any( const void * pData_, const Type & rType ) SAL_THROW(());
 
     /** Constructor: Sets a copy of the given data.
 
         @param pData_ value
         @param pTypeDescr type of value
     */
-    inline Any( const void * pData_, typelib_TypeDescription * pTypeDescr ) SAL_THROW( () );
+    inline Any( const void * pData_, typelib_TypeDescription * pTypeDescr ) SAL_THROW(());
 
     /** Constructor: Sets a copy of the given data.
 
         @param pData_ value
         @param pType type of value
     */
-    inline Any( const void * pData_, typelib_TypeDescriptionReference * pType ) SAL_THROW( () );
+    inline Any( const void * pData_, typelib_TypeDescriptionReference * pType ) SAL_THROW(());
 
     /** Destructor: Destructs any content and frees memory.
     */
-    inline ~Any() SAL_THROW( () );
+    inline ~Any() SAL_THROW(());
 
     /** Assignment operator: Sets the value of the given any.
 
         @param rAny another any (right side)
         @return this any
     */
-    inline Any & SAL_CALL operator = ( const Any & rAny ) SAL_THROW( () );
+    inline Any & SAL_CALL operator = ( const Any & rAny ) SAL_THROW(());
 
     /** Gets the type of the set value.
 
         @return a Type object of the set value
      */
-    inline const Type & SAL_CALL getValueType() const SAL_THROW( () )
+    inline const Type & SAL_CALL getValueType() const SAL_THROW(())
         { return * reinterpret_cast< const Type * >( &pType ); }
     /** Gets the type of the set value.
 
         @return the UNacquired type description reference of the set value
      */
-    inline typelib_TypeDescriptionReference * SAL_CALL getValueTypeRef() const SAL_THROW( () )
+    inline typelib_TypeDescriptionReference * SAL_CALL getValueTypeRef() const SAL_THROW(())
         { return pType; }
 
     /** Gets the type description of the set value. Provides ownership of the type description!
@@ -136,34 +136,34 @@ public:
 
         @param a pointer to type description pointer
     */
-    inline void SAL_CALL getValueTypeDescription( typelib_TypeDescription ** ppTypeDescr ) const SAL_THROW( () )
+    inline void SAL_CALL getValueTypeDescription( typelib_TypeDescription ** ppTypeDescr ) const SAL_THROW(())
         { ::typelib_typedescriptionreference_getDescription( ppTypeDescr, pType ); }
 
     /** Gets the type class of the set value.
 
         @return the type class of the set value
      */
-    inline TypeClass SAL_CALL getValueTypeClass() const SAL_THROW( () )
+    inline TypeClass SAL_CALL getValueTypeClass() const SAL_THROW(())
         { return (TypeClass)pType->eTypeClass; }
 
     /** Gets the type name of the set value.
 
         @return the type name of the set value
     */
-    inline ::rtl::OUString SAL_CALL getValueTypeName() const SAL_THROW( () );
+    inline ::rtl::OUString SAL_CALL getValueTypeName() const SAL_THROW(());
 
     /** Tests if any contains a value.
 
         @return true if any has a value, false otherwise
     */
-    inline sal_Bool SAL_CALL hasValue() const SAL_THROW( () )
+    inline sal_Bool SAL_CALL hasValue() const SAL_THROW(())
         { return (typelib_TypeClass_VOID != pType->eTypeClass); }
 
     /** Gets a pointer to the set value.
 
         @return a pointer to the set value
     */
-    inline const void * SAL_CALL getValue() const SAL_THROW( () )
+    inline const void * SAL_CALL getValue() const SAL_THROW(())
         { return pData; }
 
 #if ! defined(EXCEPTIONS_OFF)
@@ -190,26 +190,26 @@ public:
         @param pData_ pointer to value
         @param rType type of value
     */
-    inline void SAL_CALL setValue( const void * pData_, const Type & rType ) SAL_THROW( () );
+    inline void SAL_CALL setValue( const void * pData_, const Type & rType ) SAL_THROW(());
     /** Sets a value. If the any already contains a value, that value will be destructed
         and its memory freed.
 
         @param pData_ pointer to value
         @param pType type of value
     */
-    inline void SAL_CALL setValue( const void * pData_, typelib_TypeDescriptionReference * pType ) SAL_THROW( () );
+    inline void SAL_CALL setValue( const void * pData_, typelib_TypeDescriptionReference * pType ) SAL_THROW(());
     /** Sets a value. If the any already contains a value, that value will be destructed
         and its memory freed.
 
         @param pData_ pointer to value
         @param pTypeDescr type description of value
     */
-    inline void SAL_CALL setValue( const void * pData_, typelib_TypeDescription * pTypeDescr ) SAL_THROW( () );
+    inline void SAL_CALL setValue( const void * pData_, typelib_TypeDescription * pTypeDescr ) SAL_THROW(());
 
     /** Clears this any. If the any already contains a value, that value will be destructed
         and its memory freed. After this has been called, the any does not contain a value.
     */
-    inline void SAL_CALL clear() SAL_THROW( () );
+    inline void SAL_CALL clear() SAL_THROW(());
 
     /** Tests whether this any is extractable to a value of given type.
         Widening conversion without data loss is taken into account.
@@ -217,7 +217,7 @@ public:
         @param rType destination type
         @return true if this any is extractable to value of given type (e.g. using >>= operator)
     */
-    inline sal_Bool SAL_CALL isExtractableTo( const Type & rType ) const SAL_THROW( () );
+    inline sal_Bool SAL_CALL isExtractableTo( const Type & rType ) const SAL_THROW(());
 
     /** Tests whether this any can provide a value of specified type.
         Widening conversion without data loss is taken into account.
@@ -234,14 +234,14 @@ public:
         @param rAny another any (right side)
         @return true if both any contains equal values
     */
-    inline sal_Bool SAL_CALL operator == ( const Any & rAny ) const SAL_THROW( () );
+    inline sal_Bool SAL_CALL operator == ( const Any & rAny ) const SAL_THROW(());
     /** Unequality operator: compares two anys.
         The values need not be of equal type, e.g. a short integer is compared to a long integer.
 
         @param rAny another any (right side)
         @return true if both any contains unequal values
     */
-    inline sal_Bool SAL_CALL operator != ( const Any & rAny ) const SAL_THROW( () );
+    inline sal_Bool SAL_CALL operator != ( const Any & rAny ) const SAL_THROW(());
 
 private:
     // not impl: forbid use with ambiguous type (sal_Unicode, sal_uInt16)
@@ -266,11 +266,11 @@ private:
     @return an any
 */
 template< class C >
-inline Any SAL_CALL makeAny( const C & value ) SAL_THROW( () );
+inline Any SAL_CALL makeAny( const C & value ) SAL_THROW(());
 
 // additionally specialized for C++ bool
 template<>
-inline Any SAL_CALL makeAny( bool const & value ) SAL_THROW( () );
+inline Any SAL_CALL makeAny( bool const & value ) SAL_THROW(());
 
 class BaseReference;
 class Type;
@@ -282,11 +282,11 @@ class Type;
     @param value source value (right side)
 */
 template< class C >
-inline void SAL_CALL operator <<= ( Any & rAny, const C & value ) SAL_THROW( () );
+inline void SAL_CALL operator <<= ( Any & rAny, const C & value ) SAL_THROW(());
 
 // additionally for C++ bool:
 inline void SAL_CALL operator <<= ( Any & rAny, bool const & value )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 /** Template binary >>= operator to assign a value from an any.
     If the any does not contain a value that can be assigned without data loss, then this
@@ -298,7 +298,7 @@ inline void SAL_CALL operator <<= ( Any & rAny, bool const & value )
     @return true if assignment was possible without data loss
 */
 template< class C >
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, C & value ) SAL_THROW( () );
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, C & value ) SAL_THROW(());
 
 /** Template equality operator: compares set value of left side any to right side value.
     The values need not be of equal type, e.g. a short integer is compared to a long integer.
@@ -311,7 +311,7 @@ inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, C & value ) SAL_THROW(
     @return true if values are equal, false otherwise
 */
 template< class C >
-inline sal_Bool SAL_CALL operator == ( const Any & rAny, const C & value ) SAL_THROW( () );
+inline sal_Bool SAL_CALL operator == ( const Any & rAny, const C & value ) SAL_THROW(());
 /** Template unequality operator: compares set value of left side any to right side value.
     The values need not be of equal type, e.g. a short integer is compared to a long integer.
     This operator can be implemented as template member function, if all supported compilers
@@ -323,43 +323,43 @@ inline sal_Bool SAL_CALL operator == ( const Any & rAny, const C & value ) SAL_T
     @return true if values are unequal, false otherwise
 */
 template< class C >
-inline sal_Bool SAL_CALL operator != ( const Any & rAny, const C & value ) SAL_THROW( () );
+inline sal_Bool SAL_CALL operator != ( const Any & rAny, const C & value ) SAL_THROW(());
 
 // additional specialized >>= and == operators
 // bool
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Bool & value ) SAL_THROW( () );
-inline sal_Bool SAL_CALL operator == ( const Any & rAny, const sal_Bool & value ) SAL_THROW( () );
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Bool & value ) SAL_THROW(());
+inline sal_Bool SAL_CALL operator == ( const Any & rAny, const sal_Bool & value ) SAL_THROW(());
 template<>
 inline sal_Bool SAL_CALL operator >>= ( Any const & rAny, bool & value )
-    SAL_THROW( () );
+    SAL_THROW(());
 template<>
 inline sal_Bool SAL_CALL operator == ( Any const & rAny, bool const & value )
-    SAL_THROW( () );
+    SAL_THROW(());
 // byte
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int8 & value ) SAL_THROW( () );
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int8 & value ) SAL_THROW(());
 // short
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int16 & value ) SAL_THROW( () );
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt16 & value ) SAL_THROW( () );
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int16 & value ) SAL_THROW(());
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt16 & value ) SAL_THROW(());
 // long
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int32 & value ) SAL_THROW( () );
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt32 & value ) SAL_THROW( () );
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int32 & value ) SAL_THROW(());
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt32 & value ) SAL_THROW(());
 // hyper
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int64 & value ) SAL_THROW( () );
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt64 & value ) SAL_THROW( () );
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int64 & value ) SAL_THROW(());
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt64 & value ) SAL_THROW(());
 // float
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, float & value ) SAL_THROW( () );
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, float & value ) SAL_THROW(());
 // double
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, double & value ) SAL_THROW( () );
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, double & value ) SAL_THROW(());
 // string
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, ::rtl::OUString & value ) SAL_THROW( () );
-inline sal_Bool SAL_CALL operator == ( const Any & rAny, const ::rtl::OUString & value ) SAL_THROW( () );
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, ::rtl::OUString & value ) SAL_THROW(());
+inline sal_Bool SAL_CALL operator == ( const Any & rAny, const ::rtl::OUString & value ) SAL_THROW(());
 // type
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, Type & value ) SAL_THROW( () );
-inline sal_Bool SAL_CALL operator == ( const Any & rAny, const Type & value ) SAL_THROW( () );
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, Type & value ) SAL_THROW(());
+inline sal_Bool SAL_CALL operator == ( const Any & rAny, const Type & value ) SAL_THROW(());
 // any
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, Any & value ) SAL_THROW( () );
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, Any & value ) SAL_THROW(());
 // interface
-inline sal_Bool SAL_CALL operator == ( const Any & rAny, const BaseReference & value ) SAL_THROW( () );
+inline sal_Bool SAL_CALL operator == ( const Any & rAny, const BaseReference & value ) SAL_THROW(());
 
 }
 }
@@ -375,7 +375,7 @@ inline sal_Bool SAL_CALL operator == ( const Any & rAny, const BaseReference & v
 
     @return type of IDL type any
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const ::com::sun::star::uno::Any * ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const ::com::sun::star::uno::Any * ) SAL_THROW(())
 {
     return ::cppu::UnoType< ::com::sun::star::uno::Any >::get();
 }
diff --git a/cppu/inc/com/sun/star/uno/Any.hxx b/cppu/inc/com/sun/star/uno/Any.hxx
index 8ea8c437dde2..56a782e37fd0 100644
--- a/cppu/inc/com/sun/star/uno/Any.hxx
+++ b/cppu/inc/com/sun/star/uno/Any.hxx
@@ -45,7 +45,7 @@ namespace uno
 {
 
 //__________________________________________________________________________________________________
-inline Any::Any() SAL_THROW( () )
+inline Any::Any() SAL_THROW(())
 {
     ::uno_any_construct( this, 0, 0, (uno_AcquireFunc)cpp_acquire );
 }
@@ -69,37 +69,37 @@ inline Any::Any( bool value )
 }
 
 //__________________________________________________________________________________________________
-inline Any::Any( const Any & rAny ) SAL_THROW( () )
+inline Any::Any( const Any & rAny ) SAL_THROW(())
 {
     ::uno_type_any_construct( this, rAny.pData, rAny.pType, (uno_AcquireFunc)cpp_acquire );
 }
 //__________________________________________________________________________________________________
-inline Any::Any( const void * pData_, const Type & rType ) SAL_THROW( () )
+inline Any::Any( const void * pData_, const Type & rType ) SAL_THROW(())
 {
     ::uno_type_any_construct(
         this, const_cast< void * >( pData_ ), rType.getTypeLibType(),
         (uno_AcquireFunc)cpp_acquire );
 }
 //__________________________________________________________________________________________________
-inline Any::Any( const void * pData_, typelib_TypeDescription * pTypeDescr ) SAL_THROW( () )
+inline Any::Any( const void * pData_, typelib_TypeDescription * pTypeDescr ) SAL_THROW(())
 {
     ::uno_any_construct(
         this, const_cast< void * >( pData_ ), pTypeDescr, (uno_AcquireFunc)cpp_acquire );
 }
 //__________________________________________________________________________________________________
-inline Any::Any( const void * pData_, typelib_TypeDescriptionReference * pType_ ) SAL_THROW( () )
+inline Any::Any( const void * pData_, typelib_TypeDescriptionReference * pType_ ) SAL_THROW(())
 {
     ::uno_type_any_construct(
         this, const_cast< void * >( pData_ ), pType_, (uno_AcquireFunc)cpp_acquire );
 }
 //__________________________________________________________________________________________________
-inline Any::~Any() SAL_THROW( () )
+inline Any::~Any() SAL_THROW(())
 {
     ::uno_any_destruct(
         this, (uno_ReleaseFunc)cpp_release );
 }
 //__________________________________________________________________________________________________
-inline Any & Any::operator = ( const Any & rAny ) SAL_THROW( () )
+inline Any & Any::operator = ( const Any & rAny ) SAL_THROW(())
 {
     if (this != &rAny)
     {
@@ -110,39 +110,39 @@ inline Any & Any::operator = ( const Any & rAny ) SAL_THROW( () )
     return *this;
 }
 //__________________________________________________________________________________________________
-inline ::rtl::OUString Any::getValueTypeName() const SAL_THROW( () )
+inline ::rtl::OUString Any::getValueTypeName() const SAL_THROW(())
 {
     return ::rtl::OUString( pType->pTypeName );
 }
 //__________________________________________________________________________________________________
-inline void Any::setValue( const void * pData_, const Type & rType ) SAL_THROW( () )
+inline void Any::setValue( const void * pData_, const Type & rType ) SAL_THROW(())
 {
     ::uno_type_any_assign(
         this, const_cast< void * >( pData_ ), rType.getTypeLibType(),
         (uno_AcquireFunc)cpp_acquire, (uno_ReleaseFunc)cpp_release );
 }
 //__________________________________________________________________________________________________
-inline void Any::setValue( const void * pData_, typelib_TypeDescriptionReference * pType_ ) SAL_THROW( () )
+inline void Any::setValue( const void * pData_, typelib_TypeDescriptionReference * pType_ ) SAL_THROW(())
 {
     ::uno_type_any_assign(
         this, const_cast< void * >( pData_ ), pType_,
         (uno_AcquireFunc)cpp_acquire, (uno_ReleaseFunc)cpp_release );
 }
 //__________________________________________________________________________________________________
-inline void Any::setValue( const void * pData_, typelib_TypeDescription * pTypeDescr ) SAL_THROW( () )
+inline void Any::setValue( const void * pData_, typelib_TypeDescription * pTypeDescr ) SAL_THROW(())
 {
     ::uno_any_assign(
         this, const_cast< void * >( pData_ ), pTypeDescr,
         (uno_AcquireFunc)cpp_acquire, (uno_ReleaseFunc)cpp_release );
 }
 //__________________________________________________________________________________________________
-inline void Any::clear() SAL_THROW( () )
+inline void Any::clear() SAL_THROW(())
 {
     ::uno_any_clear(
         this, (uno_ReleaseFunc)cpp_release );
 }
 //__________________________________________________________________________________________________
-inline sal_Bool Any::isExtractableTo( const Type & rType ) const SAL_THROW( () )
+inline sal_Bool Any::isExtractableTo( const Type & rType ) const SAL_THROW(())
 {
     return ::uno_type_isAssignableFromData(
         rType.getTypeLibType(), pData, pType,
@@ -166,14 +166,14 @@ bool Any::has<sal_uInt16>() const;
 #endif // ! defined(__SUNPRO_CC)
 
 //__________________________________________________________________________________________________
-inline sal_Bool Any::operator == ( const Any & rAny ) const SAL_THROW( () )
+inline sal_Bool Any::operator == ( const Any & rAny ) const SAL_THROW(())
 {
     return ::uno_type_equalData(
         pData, pType, rAny.pData, rAny.pType,
         (uno_QueryInterfaceFunc)cpp_queryInterface, (uno_ReleaseFunc)cpp_release );
 }
 //__________________________________________________________________________________________________
-inline sal_Bool Any::operator != ( const Any & rAny ) const SAL_THROW( () )
+inline sal_Bool Any::operator != ( const Any & rAny ) const SAL_THROW(())
 {
     return (! ::uno_type_equalData(
         pData, pType, rAny.pData, rAny.pType,
@@ -182,7 +182,7 @@ inline sal_Bool Any::operator != ( const Any & rAny ) const SAL_THROW( () )
 
 //__________________________________________________________________________________________________
 template< class C >
-inline Any SAL_CALL makeAny( const C & value ) SAL_THROW( () )
+inline Any SAL_CALL makeAny( const C & value ) SAL_THROW(())
 {
     return Any( &value, ::cppu::getTypeFavourUnsigned(&value) );
 }
@@ -190,7 +190,7 @@ inline Any SAL_CALL makeAny( const C & value ) SAL_THROW( () )
 // additionally specialized for C++ bool
 //______________________________________________________________________________
 template<>
-inline Any SAL_CALL makeAny( bool const & value ) SAL_THROW( () )
+inline Any SAL_CALL makeAny( bool const & value ) SAL_THROW(())
 {
     const sal_Bool b = value;
     return Any( &b, ::getCppuBooleanType() );
@@ -198,7 +198,7 @@ inline Any SAL_CALL makeAny( bool const & value ) SAL_THROW( () )
 
 //__________________________________________________________________________________________________
 template< class C >
-inline void SAL_CALL operator <<= ( Any & rAny, const C & value ) SAL_THROW( () )
+inline void SAL_CALL operator <<= ( Any & rAny, const C & value ) SAL_THROW(())
 {
     const Type & rType = ::cppu::getTypeFavourUnsigned(&value);
     ::uno_type_any_assign(
@@ -209,7 +209,7 @@ inline void SAL_CALL operator <<= ( Any & rAny, const C & value ) SAL_THROW( ()
 // additionally for C++ bool:
 //______________________________________________________________________________
 inline void SAL_CALL operator <<= ( Any & rAny, bool const & value )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     sal_Bool b = value;
     ::uno_type_any_assign(
@@ -219,7 +219,7 @@ inline void SAL_CALL operator <<= ( Any & rAny, bool const & value )
 
 //__________________________________________________________________________________________________
 template< class C >
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, C & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, C & value ) SAL_THROW(())
 {
     const Type & rType = ::cppu::getTypeFavourUnsigned(&value);
     return ::uno_type_assignData(
@@ -231,7 +231,7 @@ inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, C & value ) SAL_THROW(
 
 // bool
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator >>= ( const ::com::sun::star::uno::Any & rAny, sal_Bool & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator >>= ( const ::com::sun::star::uno::Any & rAny, sal_Bool & value ) SAL_THROW(())
 {
     if (typelib_TypeClass_BOOLEAN == rAny.pType->eTypeClass)
     {
@@ -241,7 +241,7 @@ inline sal_Bool SAL_CALL operator >>= ( const ::com::sun::star::uno::Any & rAny,
     return sal_False;
 }
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator == ( const Any & rAny, const sal_Bool & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator == ( const Any & rAny, const sal_Bool & value ) SAL_THROW(())
 {
     return (typelib_TypeClass_BOOLEAN == rAny.pType->eTypeClass &&
             (value != sal_False) == (* reinterpret_cast< const sal_Bool * >( rAny.pData ) != sal_False));
@@ -250,7 +250,7 @@ inline sal_Bool SAL_CALL operator == ( const Any & rAny, const sal_Bool & value
 //______________________________________________________________________________
 template<>
 inline sal_Bool SAL_CALL operator >>= ( Any const & rAny, bool & value )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (rAny.pType->eTypeClass == typelib_TypeClass_BOOLEAN)
     {
@@ -264,7 +264,7 @@ inline sal_Bool SAL_CALL operator >>= ( Any const & rAny, bool & value )
 //______________________________________________________________________________
 template<>
 inline sal_Bool SAL_CALL operator == ( Any const & rAny, bool const & value )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return (rAny.pType->eTypeClass == typelib_TypeClass_BOOLEAN &&
             (value ==
@@ -274,7 +274,7 @@ inline sal_Bool SAL_CALL operator == ( Any const & rAny, bool const & value )
 
 // byte
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator >>= ( const ::com::sun::star::uno::Any & rAny, sal_Int8 & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator >>= ( const ::com::sun::star::uno::Any & rAny, sal_Int8 & value ) SAL_THROW(())
 {
     if (typelib_TypeClass_BYTE == rAny.pType->eTypeClass)
     {
@@ -285,7 +285,7 @@ inline sal_Bool SAL_CALL operator >>= ( const ::com::sun::star::uno::Any & rAny,
 }
 // short
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int16 & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int16 & value ) SAL_THROW(())
 {
     switch (rAny.pType->eTypeClass)
     {
@@ -301,7 +301,7 @@ inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int16 & value ) SA
     }
 }
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt16 & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt16 & value ) SAL_THROW(())
 {
     switch (rAny.pType->eTypeClass)
     {
@@ -318,7 +318,7 @@ inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt16 & value ) S
 }
 // long
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int32 & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int32 & value ) SAL_THROW(())
 {
     switch (rAny.pType->eTypeClass)
     {
@@ -340,7 +340,7 @@ inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int32 & value ) SA
     }
 }
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt32 & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt32 & value ) SAL_THROW(())
 {
     switch (rAny.pType->eTypeClass)
     {
@@ -363,7 +363,7 @@ inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt32 & value ) S
 }
 // hyper
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int64 & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int64 & value ) SAL_THROW(())
 {
     switch (rAny.pType->eTypeClass)
     {
@@ -391,7 +391,7 @@ inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_Int64 & value ) SA
     }
 }
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt64 & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt64 & value ) SAL_THROW(())
 {
     switch (rAny.pType->eTypeClass)
     {
@@ -420,7 +420,7 @@ inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, sal_uInt64 & value ) S
 }
 // float
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, float & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, float & value ) SAL_THROW(())
 {
     switch (rAny.pType->eTypeClass)
     {
@@ -442,7 +442,7 @@ inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, float & value ) SAL_TH
 }
 // double
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, double & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, double & value ) SAL_THROW(())
 {
     switch (rAny.pType->eTypeClass)
     {
@@ -473,7 +473,7 @@ inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, double & value ) SAL_T
 }
 // string
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, ::rtl::OUString & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, ::rtl::OUString & value ) SAL_THROW(())
 {
     if (typelib_TypeClass_STRING == rAny.pType->eTypeClass)
     {
@@ -483,14 +483,14 @@ inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, ::rtl::OUString & valu
     return sal_False;
 }
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator == ( const Any & rAny, const ::rtl::OUString & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator == ( const Any & rAny, const ::rtl::OUString & value ) SAL_THROW(())
 {
     return (typelib_TypeClass_STRING == rAny.pType->eTypeClass &&
             value.equals( * reinterpret_cast< const ::rtl::OUString * >( rAny.pData ) ));
 }
 // type
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, Type & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, Type & value ) SAL_THROW(())
 {
     if (typelib_TypeClass_TYPE == rAny.pType->eTypeClass)
     {
@@ -500,14 +500,14 @@ inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, Type & value ) SAL_THR
     return sal_False;
 }
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator == ( const Any & rAny, const Type & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator == ( const Any & rAny, const Type & value ) SAL_THROW(())
 {
     return (typelib_TypeClass_TYPE == rAny.pType->eTypeClass &&
             value.equals( * reinterpret_cast< const Type * >( rAny.pData ) ));
 }
 // any
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, Any & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, Any & value ) SAL_THROW(())
 {
     if (&rAny != &value)
     {
@@ -519,7 +519,7 @@ inline sal_Bool SAL_CALL operator >>= ( const Any & rAny, Any & value ) SAL_THRO
 }
 // interface
 //__________________________________________________________________________________________________
-inline sal_Bool SAL_CALL operator == ( const Any & rAny, const BaseReference & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator == ( const Any & rAny, const BaseReference & value ) SAL_THROW(())
 {
     if (typelib_TypeClass_INTERFACE == rAny.pType->eTypeClass)
     {
@@ -531,7 +531,7 @@ inline sal_Bool SAL_CALL operator == ( const Any & rAny, const BaseReference & v
 // operator to compare to an any.
 //__________________________________________________________________________________________________
 template< class C >
-inline sal_Bool SAL_CALL operator == ( const Any & rAny, const C & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator == ( const Any & rAny, const C & value ) SAL_THROW(())
 {
     const Type & rType = ::cppu::getTypeFavourUnsigned(&value);
     return ::uno_type_equalData(
@@ -542,7 +542,7 @@ inline sal_Bool SAL_CALL operator == ( const Any & rAny, const C & value ) SAL_T
 // operator to compare to an any.  may use specialized operators ==.
 //__________________________________________________________________________________________________
 template< class C >
-inline sal_Bool SAL_CALL operator != ( const Any & rAny, const C & value ) SAL_THROW( () )
+inline sal_Bool SAL_CALL operator != ( const Any & rAny, const C & value ) SAL_THROW(())
 {
     return (! operator == ( rAny, value ));
 }
diff --git a/cppu/inc/com/sun/star/uno/Reference.h b/cppu/inc/com/sun/star/uno/Reference.h
index 72aecfca323b..7e75a657e66f 100644
--- a/cppu/inc/com/sun/star/uno/Reference.h
+++ b/cppu/inc/com/sun/star/uno/Reference.h
@@ -92,14 +92,14 @@ public:
 
         @return UNacquired interface pointer
     */
-    inline XInterface * SAL_CALL get() const SAL_THROW( () )
+    inline XInterface * SAL_CALL get() const SAL_THROW(())
         { return _pInterface; }
 
     /** Checks if reference is null.
 
         @return true if reference acquires an interface, i.e. true if it is not null
     */
-    inline sal_Bool SAL_CALL is() const SAL_THROW( () )
+    inline sal_Bool SAL_CALL is() const SAL_THROW(())
         { return (0 != _pInterface); }
 
     /** Equality operator: compares two interfaces
@@ -108,14 +108,14 @@ public:
         @param rRef another interface
         @return true if both references are null or refer to the same object, false otherwise
     */
-    inline sal_Bool SAL_CALL operator == ( XInterface * pInterface ) const SAL_THROW( () );
+    inline sal_Bool SAL_CALL operator == ( XInterface * pInterface ) const SAL_THROW(());
     /** Unequality operator: compares two interfaces
         Checks if both references are null or refer to the same object.
 
         @param rRef another interface
         @return false if both references are null or refer to the same object, true otherwise
     */
-    inline sal_Bool SAL_CALL operator != ( XInterface * pInterface ) const SAL_THROW( () );
+    inline sal_Bool SAL_CALL operator != ( XInterface * pInterface ) const SAL_THROW(());
 
     /** Equality operator: compares two interfaces
         Checks if both references are null or refer to the same object.
@@ -123,21 +123,21 @@ public:
         @param rRef another reference
         @return true if both references are null or refer to the same object, false otherwise
     */
-    inline sal_Bool SAL_CALL operator == ( const BaseReference & rRef ) const SAL_THROW( () );
+    inline sal_Bool SAL_CALL operator == ( const BaseReference & rRef ) const SAL_THROW(());
     /** Unequality operator: compares two interfaces
         Checks if both references are null or refer to the same object.
 
         @param rRef another reference
         @return false if both references are null or refer to the same object, true otherwise
     */
-    inline sal_Bool SAL_CALL operator != ( const BaseReference & rRef ) const SAL_THROW( () );
+    inline sal_Bool SAL_CALL operator != ( const BaseReference & rRef ) const SAL_THROW(());
 
     /** Needed by some STL containers.
 
         @param rRef another reference
         @return true, if this reference is less than rRef
     */
-    inline sal_Bool SAL_CALL operator < ( const BaseReference & rRef ) const SAL_THROW( () );
+    inline sal_Bool SAL_CALL operator < ( const BaseReference & rRef ) const SAL_THROW(());
 };
 
 /** Enum defining UNO_QUERY for implicit interface query.
@@ -234,41 +234,41 @@ class Reference : public BaseReference
 public:
     /// @cond INTERNAL
     // these are here to force memory de/allocation to sal lib.
-    inline static void * SAL_CALL operator new ( ::size_t nSize ) SAL_THROW( () )
+    inline static void * SAL_CALL operator new ( ::size_t nSize ) SAL_THROW(())
         { return ::rtl_allocateMemory( nSize ); }
-    inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW( () )
+    inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW(())
         { ::rtl_freeMemory( pMem ); }
-    inline static void * SAL_CALL operator new ( ::size_t, void * pMem ) SAL_THROW( () )
+    inline static void * SAL_CALL operator new ( ::size_t, void * pMem ) SAL_THROW(())
         { return pMem; }
-    inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () )
+    inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW(())
         {}
     /// @endcond
 
     /** Destructor: Releases interface if set.
     */
-    inline ~Reference() SAL_THROW( () );
+    inline ~Reference() SAL_THROW(());
 
     /** Default Constructor: Sets null reference.
     */
-    inline Reference() SAL_THROW( () );
+    inline Reference() SAL_THROW(());
 
     /** Copy constructor: Copies interface reference.
 
         @param rRef another reference
     */
-    inline Reference( const Reference< interface_type > & rRef ) SAL_THROW( () );
+    inline Reference( const Reference< interface_type > & rRef ) SAL_THROW(());
     /** Constructor: Sets given interface pointer.
 
         @param pInterface an interface pointer
     */
-    inline Reference( interface_type * pInterface ) SAL_THROW( () );
+    inline Reference( interface_type * pInterface ) SAL_THROW(());
 
     /** Constructor: Sets given interface pointer without acquiring it.
 
         @param pInterface another reference
         @param dummy SAL_NO_ACQUIRE to force obvious distinction to other constructors
     */
-    inline Reference( interface_type * pInterface, __sal_NoAcquire ) SAL_THROW( () );
+    inline Reference( interface_type * pInterface, __sal_NoAcquire ) SAL_THROW(());
     /** Constructor: Sets given interface pointer without acquiring it.
         Deprecated, please use SAL_NO_ACQUIRE version.
 
@@ -276,7 +276,7 @@ public:
         @param pInterface another reference
         @param dummy UNO_REF_NO_ACQUIRE to force obvious distinction to other constructors
     */
-    inline Reference( interface_type * pInterface, UnoReference_NoAcquire ) SAL_THROW( () );
+    inline Reference( interface_type * pInterface, UnoReference_NoAcquire ) SAL_THROW(());
 
     /** Constructor: Queries given interface for reference interface type (interface_type).
 
@@ -345,39 +345,39 @@ public:
         any interface must be derived from com.sun.star.uno.XInterface.
         This a useful direct cast possibility.
     */
-    inline SAL_CALL operator const Reference< XInterface > & () const SAL_THROW( () )
+    inline SAL_CALL operator const Reference< XInterface > & () const SAL_THROW(())
         { return * reinterpret_cast< const Reference< XInterface > * >( this ); }
 
     /** Dereference operator: Used to call interface methods.
 
         @return UNacquired interface pointer
     */
-    inline interface_type * SAL_CALL operator -> () const SAL_THROW( () )
+    inline interface_type * SAL_CALL operator -> () const SAL_THROW(())
         { return castFromXInterface(_pInterface); }
 
     /** Gets interface pointer. This call does not acquire the interface.
 
         @return UNacquired interface pointer
     */
-    inline interface_type * SAL_CALL get() const SAL_THROW( () )
+    inline interface_type * SAL_CALL get() const SAL_THROW(())
         { return castFromXInterface(_pInterface); }
 
     /** Clears reference, i.e. releases interface. Reference is null after clear() call.
     */
-    inline void SAL_CALL clear() SAL_THROW( () );
+    inline void SAL_CALL clear() SAL_THROW(());
 
     /** Sets the given interface. An interface already set will be released.
 
         @param rRef another reference
         @return true, if non-null interface was set
     */
-    inline sal_Bool SAL_CALL set( const Reference< interface_type > & rRef ) SAL_THROW( () );
+    inline sal_Bool SAL_CALL set( const Reference< interface_type > & rRef ) SAL_THROW(());
     /** Sets the given interface. An interface already set will be released.
 
         @param pInterface another interface
         @return true, if non-null interface was set
     */
-    inline sal_Bool SAL_CALL set( interface_type * pInterface ) SAL_THROW( () );
+    inline sal_Bool SAL_CALL set( interface_type * pInterface ) SAL_THROW(());
 
     /** Sets interface pointer without acquiring it. An interface already set will be released.
 
@@ -385,7 +385,7 @@ public:
         @param dummy SAL_NO_ACQUIRE to force obvious distinction to set methods
         @return true, if non-null interface was set
     */
-    inline sal_Bool SAL_CALL set( interface_type * pInterface, __sal_NoAcquire ) SAL_THROW( () );
+    inline sal_Bool SAL_CALL set( interface_type * pInterface, __sal_NoAcquire ) SAL_THROW(());
     /** Sets interface pointer without acquiring it. An interface already set will be released.
         Deprecated, please use SAL_NO_ACQUIRE version.
 
@@ -394,7 +394,7 @@ public:
         @param dummy UNO_REF_NO_ACQUIRE to force obvious distinction to set methods
         @return true, if non-null interface was set
     */
-    inline sal_Bool SAL_CALL set( interface_type * pInterface, UnoReference_NoAcquire ) SAL_THROW( () );
+    inline sal_Bool SAL_CALL set( interface_type * pInterface, UnoReference_NoAcquire ) SAL_THROW(());
 
     /** Queries given interface for reference interface type (interface_type) and sets it.
         An interface already set will be released.
@@ -485,14 +485,14 @@ public:
         @param pInterface an interface pointer
         @return this reference
     */
-    inline Reference< interface_type > & SAL_CALL operator = ( interface_type * pInterface ) SAL_THROW( () );
+    inline Reference< interface_type > & SAL_CALL operator = ( interface_type * pInterface ) SAL_THROW(());
     /** Assignment operator: Acquires given interface reference and sets reference.
         An interface already set will be released.
 
         @param rRef an interface reference
         @return this reference
     */
-    inline Reference< interface_type > & SAL_CALL operator = ( const Reference< interface_type > & rRef ) SAL_THROW( () );
+    inline Reference< interface_type > & SAL_CALL operator = ( const Reference< interface_type > & rRef ) SAL_THROW(());
 
     /** Queries given interface reference for type interface_type.
 
diff --git a/cppu/inc/com/sun/star/uno/Reference.hxx b/cppu/inc/com/sun/star/uno/Reference.hxx
index 39e9614f20d8..19e9fbb9f686 100644
--- a/cppu/inc/com/sun/star/uno/Reference.hxx
+++ b/cppu/inc/com/sun/star/uno/Reference.hxx
@@ -111,20 +111,20 @@ inline interface_type * Reference< interface_type >::iset_throw(
 
 //__________________________________________________________________________________________________
 template< class interface_type >
-inline Reference< interface_type >::~Reference() SAL_THROW( () )
+inline Reference< interface_type >::~Reference() SAL_THROW(())
 {
     if (_pInterface)
         _pInterface->release();
 }
 //__________________________________________________________________________________________________
 template< class interface_type >
-inline Reference< interface_type >::Reference() SAL_THROW( () )
+inline Reference< interface_type >::Reference() SAL_THROW(())
 {
     _pInterface = 0;
 }
 //__________________________________________________________________________________________________
 template< class interface_type >
-inline Reference< interface_type >::Reference( const Reference< interface_type > & rRef ) SAL_THROW( () )
+inline Reference< interface_type >::Reference( const Reference< interface_type > & rRef ) SAL_THROW(())
 {
     _pInterface = rRef._pInterface;
     if (_pInterface)
@@ -132,7 +132,7 @@ inline Reference< interface_type >::Reference( const Reference< interface_type >
 }
 //__________________________________________________________________________________________________
 template< class interface_type >
-inline Reference< interface_type >::Reference( interface_type * pInterface ) SAL_THROW( () )
+inline Reference< interface_type >::Reference( interface_type * pInterface ) SAL_THROW(())
 {
     _pInterface = castToXInterface(pInterface);
     if (_pInterface)
@@ -140,13 +140,13 @@ inline Reference< interface_type >::Reference( interface_type * pInterface ) SAL
 }
 //__________________________________________________________________________________________________
 template< class interface_type >
-inline Reference< interface_type >::Reference( interface_type * pInterface, __sal_NoAcquire ) SAL_THROW( () )
+inline Reference< interface_type >::Reference( interface_type * pInterface, __sal_NoAcquire ) SAL_THROW(())
 {
     _pInterface = castToXInterface(pInterface);
 }
 //__________________________________________________________________________________________________
 template< class interface_type >
-inline Reference< interface_type >::Reference( interface_type * pInterface, UnoReference_NoAcquire ) SAL_THROW( () )
+inline Reference< interface_type >::Reference( interface_type * pInterface, UnoReference_NoAcquire ) SAL_THROW(())
 {
     _pInterface = castToXInterface(pInterface);
 }
@@ -205,7 +205,7 @@ inline Reference< interface_type >::Reference( interface_type * pInterface, UnoR
 
 //__________________________________________________________________________________________________
 template< class interface_type >
-inline void Reference< interface_type >::clear() SAL_THROW( () )
+inline void Reference< interface_type >::clear() SAL_THROW(())
 {
     if (_pInterface)
     {
@@ -217,7 +217,7 @@ inline void Reference< interface_type >::clear() SAL_THROW( () )
 //__________________________________________________________________________________________________
 template< class interface_type >
 inline sal_Bool Reference< interface_type >::set(
-    interface_type * pInterface ) SAL_THROW( () )
+    interface_type * pInterface ) SAL_THROW(())
 {
     if (pInterface)
         castToXInterface(pInterface)->acquire();
@@ -230,7 +230,7 @@ inline sal_Bool Reference< interface_type >::set(
 //__________________________________________________________________________________________________
 template< class interface_type >
 inline sal_Bool Reference< interface_type >::set(
-    interface_type * pInterface, __sal_NoAcquire ) SAL_THROW( () )
+    interface_type * pInterface, __sal_NoAcquire ) SAL_THROW(())
 {
     XInterface * const pOld = _pInterface;
     _pInterface = castToXInterface(pInterface);
@@ -241,7 +241,7 @@ inline sal_Bool Reference< interface_type >::set(
 //__________________________________________________________________________________________________
 template< class interface_type >
 inline sal_Bool Reference< interface_type >::set(
-    interface_type * pInterface, UnoReference_NoAcquire ) SAL_THROW( () )
+    interface_type * pInterface, UnoReference_NoAcquire ) SAL_THROW(())
 {
     return set( pInterface, SAL_NO_ACQUIRE );
 }
@@ -249,7 +249,7 @@ inline sal_Bool Reference< interface_type >::set(
 //__________________________________________________________________________________________________
 template< class interface_type >
 inline sal_Bool Reference< interface_type >::set(
-    const Reference< interface_type > & rRef ) SAL_THROW( () )
+    const Reference< interface_type > & rRef ) SAL_THROW(())
 {
     return set( castFromXInterface( rRef._pInterface ) );
 }
@@ -328,7 +328,7 @@ inline void Reference< interface_type >::set(
 //__________________________________________________________________________________________________
 template< class interface_type >
 inline Reference< interface_type > & Reference< interface_type >::operator = (
-    interface_type * pInterface ) SAL_THROW( () )
+    interface_type * pInterface ) SAL_THROW(())
 {
     set( pInterface );
     return *this;
@@ -336,7 +336,7 @@ inline Reference< interface_type > & Reference< interface_type >::operator = (
 //__________________________________________________________________________________________________
 template< class interface_type >
 inline Reference< interface_type > & Reference< interface_type >::operator = (
-    const Reference< interface_type > & rRef ) SAL_THROW( () )
+    const Reference< interface_type > & rRef ) SAL_THROW(())
 {
     set( castFromXInterface( rRef._pInterface ) );
     return *this;
@@ -362,7 +362,7 @@ inline Reference< interface_type > Reference< interface_type >::query(
 //##################################################################################################
 
 //__________________________________________________________________________________________________
-inline sal_Bool BaseReference::operator == ( XInterface * pInterface ) const SAL_THROW( () )
+inline sal_Bool BaseReference::operator == ( XInterface * pInterface ) const SAL_THROW(())
 {
     if (_pInterface == pInterface)
         return sal_True;
@@ -385,7 +385,7 @@ inline sal_Bool BaseReference::operator == ( XInterface * pInterface ) const SAL
 
 //______________________________________________________________________________
 inline sal_Bool BaseReference::operator < (
-    const BaseReference & rRef ) const SAL_THROW( () )
+    const BaseReference & rRef ) const SAL_THROW(())
 {
     if (_pInterface == rRef._pInterface)
         return sal_False;
@@ -407,17 +407,17 @@ inline sal_Bool BaseReference::operator < (
 }
 
 //__________________________________________________________________________________________________
-inline sal_Bool BaseReference::operator != ( XInterface * pInterface ) const SAL_THROW( () )
+inline sal_Bool BaseReference::operator != ( XInterface * pInterface ) const SAL_THROW(())
 {
     return (! operator == ( pInterface ));
 }
 //__________________________________________________________________________________________________
-inline sal_Bool BaseReference::operator == ( const BaseReference & rRef ) const SAL_THROW( () )
+inline sal_Bool BaseReference::operator == ( const BaseReference & rRef ) const SAL_THROW(())
 {
     return operator == ( rRef._pInterface );
 }
 //__________________________________________________________________________________________________
-inline sal_Bool BaseReference::operator != ( const BaseReference & rRef ) const SAL_THROW( () )
+inline sal_Bool BaseReference::operator != ( const BaseReference & rRef ) const SAL_THROW(())
 {
     return (! operator == ( rRef._pInterface ));
 }
diff --git a/cppu/inc/com/sun/star/uno/Sequence.h b/cppu/inc/com/sun/star/uno/Sequence.h
index 13a4bf008352..f12b7c1e3b7b 100644
--- a/cppu/inc/com/sun/star/uno/Sequence.h
+++ b/cppu/inc/com/sun/star/uno/Sequence.h
@@ -71,16 +71,16 @@ public:
 
     // these are here to force memory de/allocation to sal lib.
     inline static void * SAL_CALL operator new ( ::size_t nSize )
-        SAL_THROW( () )
+        SAL_THROW(())
         { return ::rtl_allocateMemory( nSize ); }
     inline static void SAL_CALL operator delete ( void * pMem )
-        SAL_THROW( () )
+        SAL_THROW(())
         { ::rtl_freeMemory( pMem ); }
     inline static void * SAL_CALL operator new ( ::size_t, void * pMem )
-        SAL_THROW( () )
+        SAL_THROW(())
         { return pMem; }
     inline static void SAL_CALL operator delete ( void *, void * )
-        SAL_THROW( () )
+        SAL_THROW(())
         {}
 
     /** Static pointer to typelib type of sequence.
@@ -96,13 +96,13 @@ public:
 
     /** Default constructor: Creates an empty sequence.
     */
-    inline Sequence() SAL_THROW( () );
+    inline Sequence() SAL_THROW(());
 
     /** Copy constructor: Creates a copy of given sequence.
 
         @param rSeq another sequence of same type
     */
-    inline Sequence( const Sequence< E > & rSeq ) SAL_THROW( () );
+    inline Sequence( const Sequence< E > & rSeq ) SAL_THROW(());
 
     /** Constructor: Takes over ownership of given sequence.
 
@@ -111,7 +111,7 @@ public:
         constructors
     */
     inline Sequence( uno_Sequence * pSequence, __sal_NoAcquire )
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /** Constructor: Creates a copy of given elements.
 
@@ -129,7 +129,7 @@ public:
     /** Destructor: Releases sequence handle. Last handle will destruct
         elements and free memory.
     */
-    inline ~Sequence() SAL_THROW( () );
+    inline ~Sequence() SAL_THROW(());
 
     /** Assignment operator: Acquires given sequence handle and releases
         previously set handle.
@@ -138,13 +138,13 @@ public:
         @return this sequence
     */
     inline Sequence< E > & SAL_CALL operator = ( const Sequence< E > & rSeq )
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /** Gets length of the sequence.
 
         @return length of sequence
     */
-    inline sal_Int32 SAL_CALL getLength() const SAL_THROW( () )
+    inline sal_Int32 SAL_CALL getLength() const SAL_THROW(())
         { return _pSequence->nElements; }
 
     /** Tests whether the sequence has elements, i.e. elements count is
@@ -152,7 +152,7 @@ public:
 
         @return true, if elements count is greater than zero
     */
-    inline sal_Bool SAL_CALL hasElements() const SAL_THROW( () )
+    inline sal_Bool SAL_CALL hasElements() const SAL_THROW(())
         { return (_pSequence->nElements > 0); }
 
     /** Gets a pointer to elements array for reading.
@@ -161,7 +161,7 @@ public:
 
         @return pointer to elements array
     */
-    inline const E * SAL_CALL getConstArray() const SAL_THROW( () )
+    inline const E * SAL_CALL getConstArray() const SAL_THROW(())
         { return reinterpret_cast< const E * >( _pSequence->elements ); }
 
     /** Gets a pointer to elements array for reading and writing.
@@ -194,7 +194,7 @@ public:
         @return const C++ reference to element
     */
     inline const E & SAL_CALL operator [] ( sal_Int32 nIndex ) const
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /** Equality operator: Compares two sequences.
 
@@ -202,7 +202,7 @@ public:
         @return true if both sequences are equal, false otherwise
     */
     inline sal_Bool SAL_CALL operator == ( const Sequence< E > & rSeq ) const
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /** Unequality operator: Compares two sequences.
 
@@ -210,7 +210,7 @@ public:
         @return false if both sequences are equal, true otherwise
     */
     inline sal_Bool SAL_CALL operator != ( const Sequence< E > & rSeq ) const
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /** Reallocates sequence to new length.
         If the new length is smaller than the former, then upper elements will
@@ -228,7 +228,7 @@ public:
 
         @return UNacquired sequence handle
     */
-    inline uno_Sequence * SAL_CALL get() const SAL_THROW( () )
+    inline uno_Sequence * SAL_CALL get() const SAL_THROW(())
         { return _pSequence; }
 };
 
@@ -238,7 +238,7 @@ public:
     @return a UNO byte sequence
 */
 inline ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL toUnoSequence(
-    const ::rtl::ByteSequence & rByteSequence ) SAL_THROW( () );
+    const ::rtl::ByteSequence & rByteSequence ) SAL_THROW(());
 
 }
 }
@@ -258,7 +258,7 @@ inline ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL toUnoSequence(
 template< class E >
 inline const ::com::sun::star::uno::Type &
 SAL_CALL getCppuType( const ::com::sun::star::uno::Sequence< E > * )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 /** Gets the meta type of IDL sequence.
     This function has been introduced, because one cannot get the (templated)
@@ -274,7 +274,7 @@ SAL_CALL getCppuType( const ::com::sun::star::uno::Sequence< E > * )
 template< class E >
 inline const ::com::sun::star::uno::Type &
 SAL_CALL getCppuSequenceType( const ::com::sun::star::uno::Type & rElementType )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 /** Gets the meta type of IDL sequence< char >.
     This function has been introduced due to ambiguities with unsigned short.
@@ -284,7 +284,7 @@ SAL_CALL getCppuSequenceType( const ::com::sun::star::uno::Type & rElementType )
     @return type of IDL sequence< char >
 */
 inline const ::com::sun::star::uno::Type &
-SAL_CALL getCharSequenceCppuType() SAL_THROW( () );
+SAL_CALL getCharSequenceCppuType() SAL_THROW(());
 
 #endif
 
diff --git a/cppu/inc/com/sun/star/uno/Sequence.hxx b/cppu/inc/com/sun/star/uno/Sequence.hxx
index c8907d34e6bd..4d3e44a378f9 100644
--- a/cppu/inc/com/sun/star/uno/Sequence.hxx
+++ b/cppu/inc/com/sun/star/uno/Sequence.hxx
@@ -52,7 +52,7 @@ typelib_TypeDescriptionReference * Sequence< E >::s_pType = 0;
 
 //______________________________________________________________________________
 template< class E >
-inline Sequence< E >::Sequence() SAL_THROW( () )
+inline Sequence< E >::Sequence() SAL_THROW(())
 {
     const Type & rType = ::cppu::getTypeFavourUnsigned( this );
     ::uno_type_sequence_construct(
@@ -63,7 +63,7 @@ inline Sequence< E >::Sequence() SAL_THROW( () )
 
 //______________________________________________________________________________
 template< class E >
-inline Sequence< E >::Sequence( const Sequence< E > & rSeq ) SAL_THROW( () )
+inline Sequence< E >::Sequence( const Sequence< E > & rSeq ) SAL_THROW(())
 {
     ::osl_incrementInterlockedCount( &rSeq._pSequence->nRefCount );
     _pSequence = rSeq._pSequence;
@@ -72,7 +72,7 @@ inline Sequence< E >::Sequence( const Sequence< E > & rSeq ) SAL_THROW( () )
 //______________________________________________________________________________
 template< class E >
 inline Sequence< E >::Sequence(
-    uno_Sequence * pSequence, __sal_NoAcquire ) SAL_THROW( () )
+    uno_Sequence * pSequence, __sal_NoAcquire ) SAL_THROW(())
         : _pSequence( pSequence )
 {
 }
@@ -113,7 +113,7 @@ inline Sequence< E >::Sequence( sal_Int32 len )
 
 //______________________________________________________________________________
 template< class E >
-inline Sequence< E >::~Sequence() SAL_THROW( () )
+inline Sequence< E >::~Sequence() SAL_THROW(())
 {
     const Type & rType = ::cppu::getTypeFavourUnsigned( this );
     ::uno_type_destructData(
@@ -122,7 +122,7 @@ inline Sequence< E >::~Sequence() SAL_THROW( () )
 
 //______________________________________________________________________________
 template< class E >
-inline Sequence< E > & Sequence< E >::operator = ( const Sequence< E > & rSeq ) SAL_THROW( () )
+inline Sequence< E > & Sequence< E >::operator = ( const Sequence< E > & rSeq ) SAL_THROW(())
 {
     const Type & rType = ::cppu::getTypeFavourUnsigned( this );
     ::uno_type_sequence_assign(
@@ -133,7 +133,7 @@ inline Sequence< E > & Sequence< E >::operator = ( const Sequence< E > & rSeq )
 //______________________________________________________________________________
 template< class E >
 inline sal_Bool Sequence< E >::operator == ( const Sequence< E > & rSeq ) const
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (_pSequence == rSeq._pSequence)
         return sal_True;
@@ -148,7 +148,7 @@ inline sal_Bool Sequence< E >::operator == ( const Sequence< E > & rSeq ) const
 //______________________________________________________________________________
 template< class E >
 inline sal_Bool Sequence< E >::operator != ( const Sequence< E > & rSeq ) const
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return (! operator == ( rSeq ));
 }
@@ -184,7 +184,7 @@ inline E & Sequence< E >::operator [] ( sal_Int32 nIndex )
 //______________________________________________________________________________
 template< class E >
 inline const E & Sequence< E >::operator [] ( sal_Int32 nIndex ) const
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     OSL_ENSURE(
         nIndex >= 0 && nIndex < getLength(),
@@ -211,7 +211,7 @@ inline void Sequence< E >::realloc( sal_Int32 nSize )
 
 //------------------------------------------------------------------------------
 inline ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL toUnoSequence(
-    const ::rtl::ByteSequence & rByteSequence ) SAL_THROW( () )
+    const ::rtl::ByteSequence & rByteSequence ) SAL_THROW(())
 {
     return ::com::sun::star::uno::Sequence< sal_Int8 >(
         * reinterpret_cast< const ::com::sun::star::uno::Sequence< sal_Int8 > * >( &rByteSequence ) );
@@ -267,7 +267,7 @@ template< class E >
 inline const ::com::sun::star::uno::Type &
 SAL_CALL getCppuType(
     SAL_UNUSED_PARAMETER const ::com::sun::star::uno::Sequence< E > * )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return ::cppu::getTypeFavourUnsigned(
         static_cast< ::com::sun::star::uno::Sequence< E > * >(0));
@@ -277,7 +277,7 @@ SAL_CALL getCppuType(
 template< class E >
 inline const ::com::sun::star::uno::Type &
 SAL_CALL getCppuSequenceType( const ::com::sun::star::uno::Type & rElementType )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (! ::com::sun::star::uno::Sequence< E >::s_pType)
     {
@@ -295,7 +295,7 @@ static typelib_TypeDescriptionReference * s_pType_com_sun_star_uno_Sequence_Char
 
 // char sequence
 inline const ::com::sun::star::uno::Type &
-SAL_CALL getCharSequenceCppuType() SAL_THROW( () )
+SAL_CALL getCharSequenceCppuType() SAL_THROW(())
 {
 #if !( defined(__SUNPRO_CC) && (__SUNPRO_CC == 0x500))
     static typelib_TypeDescriptionReference * s_pType_com_sun_star_uno_Sequence_Char = 0;
diff --git a/cppu/inc/com/sun/star/uno/Type.h b/cppu/inc/com/sun/star/uno/Type.h
index 2072d6accc82..e11551e864d2 100644
--- a/cppu/inc/com/sun/star/uno/Type.h
+++ b/cppu/inc/com/sun/star/uno/Type.h
@@ -72,39 +72,39 @@ class Type
 public:
     /// @cond INTERNAL
     // these are here to force memory de/allocation to sal lib.
-    inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW( () )
+    inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW(())
         { return ::rtl_allocateMemory( nSize ); }
-    inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW( () )
+    inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW(())
         { ::rtl_freeMemory( pMem ); }
-    inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW( () )
+    inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW(())
         { return pMem; }
-    inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () )
+    inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW(())
         {}
     /// @endcond
 
     /** Default Constructor: Type is set to void.
     */
-    inline Type() SAL_THROW( () );
+    inline Type() SAL_THROW(());
 
     /** Constructor: Type is constructed by given name and type class.
 
         @param eTypeClass type class of type
         @param rTypeName name of type
     */
-    inline Type( TypeClass eTypeClass, const ::rtl::OUString & rTypeName ) SAL_THROW( () );
+    inline Type( TypeClass eTypeClass, const ::rtl::OUString & rTypeName ) SAL_THROW(());
 
     /** Constructor: Type is constructed by given name and type class.
 
         @param eTypeClass type class of type
         @param pTypeName name of type
     */
-    inline Type( TypeClass eTypeClass, const sal_Char * pTypeName ) SAL_THROW( () );
+    inline Type( TypeClass eTypeClass, const sal_Char * pTypeName ) SAL_THROW(());
 
     /** Constructor: Type is (copy) constructed by given C type description reference.
 
         @param pType C type description reference
     */
-    inline Type( typelib_TypeDescriptionReference * pType ) SAL_THROW( () );
+    inline Type( typelib_TypeDescriptionReference * pType ) SAL_THROW(());
 
     /** Constructor: Type is (copy) constructed by given C type description reference
         without acquiring it.
@@ -112,24 +112,24 @@ public:
         @param pType C type description reference
         @param dummy UNO_TYPE_NO_ACQUIRE to force obvious distinction to other constructors
     */
-    inline Type( typelib_TypeDescriptionReference * pType, UnoType_NoAcquire ) SAL_THROW( () );
+    inline Type( typelib_TypeDescriptionReference * pType, UnoType_NoAcquire ) SAL_THROW(());
     /** Constructor: Type is (copy) constructed by given C type description reference
         without acquiring it.
 
         @param pType C type description reference
         @param dummy SAL_NO_ACQUIRE to force obvious distinction to other constructors
     */
-    inline Type( typelib_TypeDescriptionReference * pType, __sal_NoAcquire ) SAL_THROW( () );
+    inline Type( typelib_TypeDescriptionReference * pType, __sal_NoAcquire ) SAL_THROW(());
 
     /** Copy constructor: Type is copy constructed by given type.
 
         @param rType another type
     */
-    inline Type( const Type & rType ) SAL_THROW( () );
+    inline Type( const Type & rType ) SAL_THROW(());
 
     /** Destructor: Releases acquired C type description reference.
     */
-    inline ~Type() SAL_THROW( () )
+    inline ~Type() SAL_THROW(())
         { ::typelib_typedescriptionreference_release( _pType ); }
 
     /** Assignment operator: Acquires right side type and releases previously set type.
@@ -137,33 +137,33 @@ public:
         @param rType another type (right side)
         @return this type
     */
-    inline Type & SAL_CALL operator = ( const Type & rType ) SAL_THROW( () );
+    inline Type & SAL_CALL operator = ( const Type & rType ) SAL_THROW(());
 
     /** Gets the type class of set type.
 
         @return type class of set type
     */
-    inline TypeClass SAL_CALL getTypeClass() const SAL_THROW( () )
+    inline TypeClass SAL_CALL getTypeClass() const SAL_THROW(())
         { return (TypeClass)_pType->eTypeClass; }
 
     /** Gets the name of the set type.
 
         @return name of the set type
     */
-    inline ::rtl::OUString SAL_CALL getTypeName() const SAL_THROW( () );
+    inline ::rtl::OUString SAL_CALL getTypeName() const SAL_THROW(());
 
     /** Obtains a full type description of set type.
 
         @param ppDescr [inout] type description
     */
-    inline void SAL_CALL getDescription( typelib_TypeDescription ** ppDescr ) const SAL_THROW( () )
+    inline void SAL_CALL getDescription( typelib_TypeDescription ** ppDescr ) const SAL_THROW(())
         { ::typelib_typedescriptionreference_getDescription( ppDescr, _pType ); }
 
     /** Gets the C typelib type description reference pointer. Does not acquire the reference!
 
         @return UNacquired type description reference
     */
-    inline typelib_TypeDescriptionReference * SAL_CALL getTypeLibType() const SAL_THROW( () )
+    inline typelib_TypeDescriptionReference * SAL_CALL getTypeLibType() const SAL_THROW(())
         { return _pType; }
 
     /** Tests if values of this reflected type can be assigned by values of given type.
@@ -174,7 +174,7 @@ public:
         @return true if values of this type can be assigned from values of given type,
                 false otherwise
     */
-    inline sal_Bool SAL_CALL isAssignableFrom( const Type & rType ) const SAL_THROW( () )
+    inline sal_Bool SAL_CALL isAssignableFrom( const Type & rType ) const SAL_THROW(())
         { return ::typelib_typedescriptionreference_isAssignableFrom( _pType, rType._pType ); }
 
     /** Compares two types.
@@ -182,21 +182,21 @@ public:
         @param rType another type
         @return true if both types refer the same type, false otherwise
     */
-    inline sal_Bool SAL_CALL equals( const Type & rType ) const SAL_THROW( () )
+    inline sal_Bool SAL_CALL equals( const Type & rType ) const SAL_THROW(())
         { return ::typelib_typedescriptionreference_equals( _pType, rType._pType ); }
     /** Equality operator: Compares two types.
 
         @param rType another type
         @return true if both types refer the same type, false otherwise
     */
-    inline sal_Bool SAL_CALL operator == ( const Type & rType ) const SAL_THROW( () )
+    inline sal_Bool SAL_CALL operator == ( const Type & rType ) const SAL_THROW(())
         { return ::typelib_typedescriptionreference_equals( _pType, rType._pType ); }
     /** Unequality operator: Compares two types.
 
         @param rType another type
         @return false if both types refer the same type, true otherwise
     */
-    inline sal_Bool SAL_CALL operator != ( const Type & rType ) const SAL_THROW( () )
+    inline sal_Bool SAL_CALL operator != ( const Type & rType ) const SAL_THROW(())
         { return (! ::typelib_typedescriptionreference_equals( _pType, rType._pType )); }
 };
 
@@ -223,28 +223,28 @@ public:
 
     @return type of IDL type "type"
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const ::com::sun::star::uno::Type * ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const ::com::sun::star::uno::Type * ) SAL_THROW(());
 
 /** Gets the meta type of IDL type void.
     @return type of IDL type void
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuVoidType() SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuVoidType() SAL_THROW(());
 /** Gets the meta type of IDL type void.
 
     @return type of IDL type void
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getVoidCppuType() SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getVoidCppuType() SAL_THROW(());
 
 /** Gets the meta type of IDL type boolean.
 
     @return type of IDL type boolean
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuBooleanType() SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuBooleanType() SAL_THROW(());
 /** Gets the meta type of IDL type boolean.
 
     @return type of IDL type boolean
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getBooleanCppuType() SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getBooleanCppuType() SAL_THROW(());
 /** Gets the meta type of IDL type boolean.
 
     There are cases (involving templates) where uses of getCppuType are known to
@@ -254,7 +254,7 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getBooleanCppuType() SAL_THR
 
     @return type of IDL type boolean
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Bool * ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Bool * ) SAL_THROW(());
 /** Gets the meta type of IDL type boolean.
 
     There are cases (involving templates) where uses of getCppuType are known to
@@ -265,18 +265,18 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Bool
     @return type of IDL type boolean
 */
 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType(
-    bool const * ) SAL_THROW( () );
+    bool const * ) SAL_THROW(());
 
 /** Gets the meta type of IDL type char.
 
     @return type of IDL type char
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCharCppuType() SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCharCppuType() SAL_THROW(());
 /** Gets the meta type of IDL type char.
 
     @return type of IDL type char
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuCharType() SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuCharType() SAL_THROW(());
 
 /** Gets the meta type of IDL type byte.
 
@@ -287,7 +287,7 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuCharType() SAL_THROW(
 
     @return type of IDL type byte
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int8 * ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int8 * ) SAL_THROW(());
 
 /** Gets the meta type of IDL type string.
 
@@ -298,7 +298,7 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int8
 
     @return type of IDL type string
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const ::rtl::OUString * ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const ::rtl::OUString * ) SAL_THROW(());
 
 /** Gets the meta type of IDL type short.
 
@@ -309,7 +309,7 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const ::rtl::OU
 
     @return type of IDL type short
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int16 * ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int16 * ) SAL_THROW(());
 
 /** Gets the meta type of IDL type unsigned short.
 
@@ -320,7 +320,7 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int16
 
     @return type of IDL type unsigned short
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_uInt16 * ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_uInt16 * ) SAL_THROW(());
 
 /** Gets the meta type of IDL type long.
 
@@ -331,7 +331,7 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_uInt1
 
     @return type of IDL type long
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int32 * ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int32 * ) SAL_THROW(());
 
 /** Gets the meta type of IDL type unsigned long.
 
@@ -342,7 +342,7 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int32
 
     @return type of IDL type unsigned long
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_uInt32 * ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_uInt32 * ) SAL_THROW(());
 
 /** Gets the meta type of IDL type hyper.
 
@@ -353,7 +353,7 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_uInt3
 
     @return type of IDL type hyper
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int64 * ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int64 * ) SAL_THROW(());
 
 /** Gets the meta type of IDL type unsigned hyper.
 
@@ -364,7 +364,7 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_Int64
 
     @return type of IDL type unsigned hyper
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_uInt64 * ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_uInt64 * ) SAL_THROW(());
 
 /** Gets the meta type of IDL type float.
 
@@ -375,7 +375,7 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const sal_uInt6
 
     @return type of IDL type float
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const float * ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const float * ) SAL_THROW(());
 
 /** Gets the meta type of IDL type double.
 
@@ -386,7 +386,7 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const float * )
 
     @return type of IDL type double
 */
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const double * ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const double * ) SAL_THROW(());
 
 /** Array template function to get meta type for one-dimensional arrays.
 
@@ -394,42 +394,42 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( const double *
     @return type of array
 */
 template< class T >
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType1( T * pT ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType1( T * pT ) SAL_THROW(());
 /** Array template function to get meta type for two-dimensional arrays.
 
     @param pT array pointer
     @return type of array
 */
 template< class T >
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType2( T * pT ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType2( T * pT ) SAL_THROW(());
 /** Array template function to get meta type for three-dimensional arrays.
 
     @param pT array pointer
     @return type of array
 */
 template< class T >
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType3( T * pT ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType3( T * pT ) SAL_THROW(());
 /** Array template function to get meta type for four-dimensional arrays.
 
     @param pT array pointer
     @return type of array
 */
 template< class T >
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType4( T * pT ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType4( T * pT ) SAL_THROW(());
 /** Array template function to get meta type for five-dimensional arrays.
 
     @param pT array pointer
     @return type of array
 */
 template< class T >
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType5( T * pT ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType5( T * pT ) SAL_THROW(());
 /** Array template function to get meta type for six-dimensional arrays.
 
     @param pT array pointer
     @return type of array
 */
 template< class T >
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType6( T * pT ) SAL_THROW( () );
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType6( T * pT ) SAL_THROW(());
 
 /** Gets the meta type of an IDL type.
 
diff --git a/cppu/inc/com/sun/star/uno/Type.hxx b/cppu/inc/com/sun/star/uno/Type.hxx
index 6b53d8192931..2313f6fc9af9 100644
--- a/cppu/inc/com/sun/star/uno/Type.hxx
+++ b/cppu/inc/com/sun/star/uno/Type.hxx
@@ -42,53 +42,53 @@ namespace uno
 {
 
 //__________________________________________________________________________________________________
-inline Type::Type() SAL_THROW( () )
+inline Type::Type() SAL_THROW(())
 {
     _pType = reinterpret_cast< const ::com::sun::star::uno::Type * >(
         ::typelib_static_type_getByTypeClass( typelib_TypeClass_VOID ) )->getTypeLibType();
     ::typelib_typedescriptionreference_acquire( _pType );
 }
 //__________________________________________________________________________________________________
-inline Type::Type( TypeClass eTypeClass, const ::rtl::OUString & rTypeName ) SAL_THROW( () )
+inline Type::Type( TypeClass eTypeClass, const ::rtl::OUString & rTypeName ) SAL_THROW(())
     : _pType( 0 )
 {
     ::typelib_typedescriptionreference_new( &_pType, (typelib_TypeClass)eTypeClass, rTypeName.pData );
 }
 //__________________________________________________________________________________________________
-inline Type::Type( TypeClass eTypeClass, const sal_Char * pTypeName ) SAL_THROW( () )
+inline Type::Type( TypeClass eTypeClass, const sal_Char * pTypeName ) SAL_THROW(())
     : _pType( 0 )
 {
     ::typelib_typedescriptionreference_newByAsciiName( &_pType, (typelib_TypeClass)eTypeClass, pTypeName );
 }
 //__________________________________________________________________________________________________
-inline Type::Type( typelib_TypeDescriptionReference * pType ) SAL_THROW( () )
+inline Type::Type( typelib_TypeDescriptionReference * pType ) SAL_THROW(())
     : _pType( pType )
 {
     ::typelib_typedescriptionreference_acquire( _pType );
 }
 //__________________________________________________________________________________________________
-inline Type::Type( typelib_TypeDescriptionReference * pType, UnoType_NoAcquire ) SAL_THROW( () )
+inline Type::Type( typelib_TypeDescriptionReference * pType, UnoType_NoAcquire ) SAL_THROW(())
     : _pType( pType )
 {
 }
 //__________________________________________________________________________________________________
-inline Type::Type( typelib_TypeDescriptionReference * pType, __sal_NoAcquire ) SAL_THROW( () )
+inline Type::Type( typelib_TypeDescriptionReference * pType, __sal_NoAcquire ) SAL_THROW(())
     : _pType( pType )
 {
 }
 //__________________________________________________________________________________________________
-inline Type::Type( const Type & rType ) SAL_THROW( () )
+inline Type::Type( const Type & rType ) SAL_THROW(())
     : _pType( rType._pType )
 {
     ::typelib_typedescriptionreference_acquire( _pType );
 }
 //__________________________________________________________________________________________________
-inline ::rtl::OUString Type::getTypeName() const SAL_THROW( () )
+inline ::rtl::OUString Type::getTypeName() const SAL_THROW(())
 {
     return ::rtl::OUString( _pType->pTypeName );
 }
 //__________________________________________________________________________________________________
-inline Type & Type::operator = ( const Type & rType ) SAL_THROW( () )
+inline Type & Type::operator = ( const Type & rType ) SAL_THROW(())
 {
     ::typelib_typedescriptionreference_assign( &_pType, rType._pType );
     return *this;
@@ -103,100 +103,100 @@ typelib_TypeDescriptionReference * Array< T >::s_pType = 0;
 }
 }
 
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const ::com::sun::star::uno::Type * ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const ::com::sun::star::uno::Type * ) SAL_THROW(())
 {
     return ::cppu::UnoType< ::com::sun::star::uno::Type >::get();
 }
 
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuVoidType() SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuVoidType() SAL_THROW(())
 {
     return ::cppu::UnoType< ::cppu::UnoVoidType >::get();
 }
-inline const ::com::sun::star::uno::Type & SAL_CALL getVoidCppuType() SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getVoidCppuType() SAL_THROW(())
 {
     return ::cppu::UnoType< ::cppu::UnoVoidType >::get();
 }
 
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuBooleanType() SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuBooleanType() SAL_THROW(())
 {
     return ::cppu::UnoType< bool >::get();
 }
-inline const ::com::sun::star::uno::Type & SAL_CALL getBooleanCppuType() SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getBooleanCppuType() SAL_THROW(())
 {
     return ::cppu::UnoType< bool >::get();
 }
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const sal_Bool * ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const sal_Bool * ) SAL_THROW(())
 {
     return ::cppu::UnoType< bool >::get();
 }
 
 inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType(
-    SAL_UNUSED_PARAMETER bool const * ) SAL_THROW( () )
+    SAL_UNUSED_PARAMETER bool const * ) SAL_THROW(())
 {
     return ::cppu::UnoType< bool >::get();
 }
 
-inline const ::com::sun::star::uno::Type & SAL_CALL getCharCppuType() SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCharCppuType() SAL_THROW(())
 {
     return ::cppu::UnoType< ::cppu::UnoCharType >::get();
 }
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuCharType() SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuCharType() SAL_THROW(())
 {
     return ::cppu::UnoType< ::cppu::UnoCharType >::get();
 }
 
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const sal_Int8 * ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const sal_Int8 * ) SAL_THROW(())
 {
     return ::cppu::UnoType< ::sal_Int8 >::get();
 }
 
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const ::rtl::OUString * ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const ::rtl::OUString * ) SAL_THROW(())
 {
     return ::cppu::UnoType< ::rtl::OUString >::get();
 }
 
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const sal_Int16 * ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const sal_Int16 * ) SAL_THROW(())
 {
     return ::cppu::UnoType< ::sal_Int16 >::get();
 }
 
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const sal_uInt16 * ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const sal_uInt16 * ) SAL_THROW(())
 {
     return ::cppu::UnoType< ::cppu::UnoUnsignedShortType >::get();
 }
 
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const sal_Int32 * ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const sal_Int32 * ) SAL_THROW(())
 {
     return ::cppu::UnoType< ::sal_Int32 >::get();
 }
 
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const sal_uInt32 * ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const sal_uInt32 * ) SAL_THROW(())
 {
     return ::cppu::UnoType< ::sal_uInt32 >::get();
 }
 
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const sal_Int64 * ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const sal_Int64 * ) SAL_THROW(())
 {
     return ::cppu::UnoType< ::sal_Int64 >::get();
 }
 
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const sal_uInt64 * ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const sal_uInt64 * ) SAL_THROW(())
 {
     return ::cppu::UnoType< ::sal_uInt64 >::get();
 }
 
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const float * ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const float * ) SAL_THROW(())
 {
     return ::cppu::UnoType< float >::get();
 }
 
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const double * ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuType( SAL_UNUSED_PARAMETER const double * ) SAL_THROW(())
 {
     return ::cppu::UnoType< double >::get();
 }
 
 template< class T >
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType1( T * pT ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType1( T * pT ) SAL_THROW(())
 {
     if (! ::com::sun::star::uno::Array< T >::s_pType)
     {
@@ -213,7 +213,7 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType1( T * pT )
 }
 
 template< class T >
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType2( T * pT ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType2( T * pT ) SAL_THROW(())
 {
     if (! ::com::sun::star::uno::Array< T >::s_pType)
     {
@@ -231,7 +231,7 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType2( T * pT )
 }
 
 template< class T >
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType3( T * pT ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType3( T * pT ) SAL_THROW(())
 {
     if (! ::com::sun::star::uno::Array< T >::s_pType)
     {
@@ -250,7 +250,7 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType3( T * pT )
 }
 
 template< class T >
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType4( T * pT ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType4( T * pT ) SAL_THROW(())
 {
     if (! ::com::sun::star::uno::Array< T >::s_pType)
     {
@@ -270,7 +270,7 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType4( T * pT )
 }
 
 template< class T >
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType5( T * pT ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType5( T * pT ) SAL_THROW(())
 {
     if (! ::com::sun::star::uno::Array< T >::s_pType)
     {
@@ -291,7 +291,7 @@ inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType5( T * pT )
 }
 
 template< class T >
-inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType6( T * pT ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & SAL_CALL getCppuArrayType6( T * pT ) SAL_THROW(())
 {
     if (! ::com::sun::star::uno::Array< T >::s_pType)
     {
diff --git a/cppu/inc/com/sun/star/uno/genfunc.h b/cppu/inc/com/sun/star/uno/genfunc.h
index 1b0dbd2c4cce..0deb536f512e 100644
--- a/cppu/inc/com/sun/star/uno/genfunc.h
+++ b/cppu/inc/com/sun/star/uno/genfunc.h
@@ -46,13 +46,13 @@ namespace uno
     @param pCppI C++ interface pointer
 */
 inline void SAL_CALL cpp_acquire( void * pCppI )
-    SAL_THROW( () );
+    SAL_THROW(());
 /** Function to release a C++ interface.
 
     @param pCppI C++ interface pointer
 */
 inline void SAL_CALL cpp_release( void * pCppI )
-    SAL_THROW( () );
+    SAL_THROW(());
 /** Function to query for a C++ interface.
 
     @param pCppI C++ interface pointer
@@ -60,7 +60,7 @@ inline void SAL_CALL cpp_release( void * pCppI )
     @return acquired C++ interface pointer or null
 */
 inline void * SAL_CALL cpp_queryInterface( void * pCppI, typelib_TypeDescriptionReference * pType )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 }
 }
diff --git a/cppu/inc/com/sun/star/uno/genfunc.hxx b/cppu/inc/com/sun/star/uno/genfunc.hxx
index 88234bd81389..ab9928de7632 100644
--- a/cppu/inc/com/sun/star/uno/genfunc.hxx
+++ b/cppu/inc/com/sun/star/uno/genfunc.hxx
@@ -43,19 +43,19 @@ namespace uno
 
 //==================================================================================================
 inline void SAL_CALL cpp_acquire( void * pCppI )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     reinterpret_cast< XInterface * >( pCppI )->acquire();
 }
 //==================================================================================================
 inline void SAL_CALL cpp_release( void * pCppI )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     reinterpret_cast< XInterface * >( pCppI )->release();
 }
 //==================================================================================================
 inline void * SAL_CALL cpp_queryInterface( void * pCppI, typelib_TypeDescriptionReference * pType )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (pCppI)
     {
diff --git a/cppu/inc/cppu/EnvGuards.hxx b/cppu/inc/cppu/EnvGuards.hxx
index 07f65b2aced9..9279948e06b0 100644
--- a/cppu/inc/cppu/EnvGuards.hxx
+++ b/cppu/inc/cppu/EnvGuards.hxx
@@ -68,7 +68,7 @@ namespace cppu
 
             @return  0 == empty, 1 == non empty
         */
-        sal_Bool SAL_CALL is() const SAL_THROW( () )
+        sal_Bool SAL_CALL is() const SAL_THROW(())
         {
             return m_env.is();
         }
diff --git a/cppu/inc/typelib/typedescription.hxx b/cppu/inc/typelib/typedescription.hxx
index 2e3e72f5491d..dddea422116b 100644
--- a/cppu/inc/typelib/typedescription.hxx
+++ b/cppu/inc/typelib/typedescription.hxx
@@ -57,13 +57,13 @@ class TypeDescription
 public:
     /// @cond INTERNAL
     // these are here to force memory de/allocation to sal lib.
-    inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW( () )
+    inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW(())
         { return ::rtl_allocateMemory( nSize ); }
-    inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW( () )
+    inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW(())
         { ::rtl_freeMemory( pMem ); }
-    inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW( () )
+    inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW(())
         { return pMem; }
-    inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () )
+    inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW(())
         {}
     /// @endcond
 
@@ -71,48 +71,48 @@ public:
 
         @param pTypeDescr a type description
     */
-    inline TypeDescription( typelib_TypeDescription * pTypeDescr = 0 ) SAL_THROW( () );
+    inline TypeDescription( typelib_TypeDescription * pTypeDescr = 0 ) SAL_THROW(());
     /** Constructor:
 
         @param pTypeDescrRef a type description reference
     */
-    inline TypeDescription( typelib_TypeDescriptionReference * pTypeDescrRef ) SAL_THROW( () );
+    inline TypeDescription( typelib_TypeDescriptionReference * pTypeDescrRef ) SAL_THROW(());
     /** Constructor:
 
         @param rType a type
     */
-    inline TypeDescription( const ::com::sun::star::uno::Type & rType ) SAL_THROW( () );
+    inline TypeDescription( const ::com::sun::star::uno::Type & rType ) SAL_THROW(());
     /** Copy constructor:
 
         @param rDescr another TypeDescription
     */
-    inline TypeDescription( const TypeDescription & rDescr ) SAL_THROW( () );
+    inline TypeDescription( const TypeDescription & rDescr ) SAL_THROW(());
     /** Constructor:
 
         @param pTypeName a type name
     */
-    inline TypeDescription( rtl_uString * pTypeName ) SAL_THROW( () );
+    inline TypeDescription( rtl_uString * pTypeName ) SAL_THROW(());
     /** Constructor:
 
         @param rTypeName a type name
     */
-    inline TypeDescription( const ::rtl::OUString & rTypeName ) SAL_THROW( () );
+    inline TypeDescription( const ::rtl::OUString & rTypeName ) SAL_THROW(());
     /** Destructor: releases type description
     */
-    inline ~TypeDescription() SAL_THROW( () );
+    inline ~TypeDescription() SAL_THROW(());
 
     /** Assignment operator: acquires given type description and releases a set one.
 
         @param pTypeDescr another type description
         @return this TypeDescription
     */
-    inline TypeDescription & SAL_CALL operator = ( typelib_TypeDescription * pTypeDescr ) SAL_THROW( () );
+    inline TypeDescription & SAL_CALL operator = ( typelib_TypeDescription * pTypeDescr ) SAL_THROW(());
     /** Assignment operator: acquires given type description and releases a set one.
 
         @param rTypeDescr another type description
         @return this TypeDescription
     */
-    inline TypeDescription & SAL_CALL operator =( const TypeDescription & rTypeDescr ) SAL_THROW( () )
+    inline TypeDescription & SAL_CALL operator =( const TypeDescription & rTypeDescr ) SAL_THROW(())
         { return this->operator =( rTypeDescr.get() ); }
 
     /** Tests whether two type descriptions are equal.
@@ -120,80 +120,80 @@ public:
         @param pTypeDescr another type description
         @return true, if both type descriptions are equal, false otherwise
     */
-    inline sal_Bool SAL_CALL equals( const typelib_TypeDescription * pTypeDescr ) const SAL_THROW( () );
+    inline sal_Bool SAL_CALL equals( const typelib_TypeDescription * pTypeDescr ) const SAL_THROW(());
     /** Tests whether two type descriptions are equal.
 
         @param rTypeDescr another type description
         @return true, if both type descriptions are equal, false otherwise
     */
-    inline sal_Bool SAL_CALL equals( const TypeDescription & rTypeDescr ) const SAL_THROW( () )
+    inline sal_Bool SAL_CALL equals( const TypeDescription & rTypeDescr ) const SAL_THROW(())
         { return equals( rTypeDescr._pTypeDescr ); }
 
     /** Makes stored type description complete.
     */
-    inline void SAL_CALL makeComplete() const SAL_THROW( () );
+    inline void SAL_CALL makeComplete() const SAL_THROW(());
 
     /** Gets the UNacquired type description pointer.
 
         @return stored pointer of type description
     */
-    inline typelib_TypeDescription * SAL_CALL get() const SAL_THROW( () )
+    inline typelib_TypeDescription * SAL_CALL get() const SAL_THROW(())
         { return _pTypeDescr; }
     /** Tests if a type description is set.
 
         @return true, if a type description is set, false otherwise
     */
-    inline sal_Bool SAL_CALL is() const SAL_THROW( () )
+    inline sal_Bool SAL_CALL is() const SAL_THROW(())
         { return (_pTypeDescr != 0); }
 };
 //__________________________________________________________________________________________________
-inline TypeDescription::TypeDescription( typelib_TypeDescription * pTypeDescr ) SAL_THROW( () )
+inline TypeDescription::TypeDescription( typelib_TypeDescription * pTypeDescr ) SAL_THROW(())
     : _pTypeDescr( pTypeDescr )
 {
     if (_pTypeDescr)
         typelib_typedescription_acquire( _pTypeDescr );
 }
 //__________________________________________________________________________________________________
-inline TypeDescription::TypeDescription( typelib_TypeDescriptionReference * pTypeDescrRef ) SAL_THROW( () )
+inline TypeDescription::TypeDescription( typelib_TypeDescriptionReference * pTypeDescrRef ) SAL_THROW(())
     : _pTypeDescr( 0 )
 {
     if (pTypeDescrRef)
         typelib_typedescriptionreference_getDescription( &_pTypeDescr, pTypeDescrRef );
 }
 //__________________________________________________________________________________________________
-inline TypeDescription::TypeDescription( const ::com::sun::star::uno::Type & rType ) SAL_THROW( () )
+inline TypeDescription::TypeDescription( const ::com::sun::star::uno::Type & rType ) SAL_THROW(())
     : _pTypeDescr( 0 )
 {
     if (rType.getTypeLibType())
         typelib_typedescriptionreference_getDescription( &_pTypeDescr, rType.getTypeLibType() );
 }
 //__________________________________________________________________________________________________
-inline TypeDescription::TypeDescription( const TypeDescription & rTypeDescr ) SAL_THROW( () )
+inline TypeDescription::TypeDescription( const TypeDescription & rTypeDescr ) SAL_THROW(())
     : _pTypeDescr( rTypeDescr._pTypeDescr )
 {
     if (_pTypeDescr)
         typelib_typedescription_acquire( _pTypeDescr );
 }
 //__________________________________________________________________________________________________
-inline TypeDescription::TypeDescription( rtl_uString * pTypeName ) SAL_THROW( () )
+inline TypeDescription::TypeDescription( rtl_uString * pTypeName ) SAL_THROW(())
     : _pTypeDescr( 0 )
 {
     typelib_typedescription_getByName( &_pTypeDescr , pTypeName );
 }
 //__________________________________________________________________________________________________
-inline TypeDescription::TypeDescription( const ::rtl::OUString & rTypeName ) SAL_THROW( () )
+inline TypeDescription::TypeDescription( const ::rtl::OUString & rTypeName ) SAL_THROW(())
     : _pTypeDescr( 0 )
 {
     typelib_typedescription_getByName( &_pTypeDescr , rTypeName.pData );
 }
 //__________________________________________________________________________________________________
-inline TypeDescription::~TypeDescription() SAL_THROW( () )
+inline TypeDescription::~TypeDescription() SAL_THROW(())
 {
     if (_pTypeDescr)
         typelib_typedescription_release( _pTypeDescr );
 }
 //__________________________________________________________________________________________________
-inline TypeDescription & TypeDescription::operator = ( typelib_TypeDescription * pTypeDescr ) SAL_THROW( () )
+inline TypeDescription & TypeDescription::operator = ( typelib_TypeDescription * pTypeDescr ) SAL_THROW(())
 {
     if (pTypeDescr)
         typelib_typedescription_acquire( pTypeDescr );
@@ -203,13 +203,13 @@ inline TypeDescription & TypeDescription::operator = ( typelib_TypeDescription *
     return *this;
 }
 //__________________________________________________________________________________________________
-inline sal_Bool TypeDescription::equals( const typelib_TypeDescription * pTypeDescr ) const SAL_THROW( () )
+inline sal_Bool TypeDescription::equals( const typelib_TypeDescription * pTypeDescr ) const SAL_THROW(())
 {
     return (_pTypeDescr && pTypeDescr &&
             typelib_typedescription_equals( _pTypeDescr, pTypeDescr ));
 }
 //__________________________________________________________________________________________________
-inline void TypeDescription::makeComplete() const SAL_THROW( () )
+inline void TypeDescription::makeComplete() const SAL_THROW(())
 {
     if (_pTypeDescr && !_pTypeDescr->bComplete)
         ::typelib_typedescription_complete( &_pTypeDescr );
diff --git a/cppu/inc/uno/current_context.hxx b/cppu/inc/uno/current_context.hxx
index 80a7ad8d56b3..f1326e8108c3 100644
--- a/cppu/inc/uno/current_context.hxx
+++ b/cppu/inc/uno/current_context.hxx
@@ -50,7 +50,7 @@ namespace uno
     @return current context or null ref, if none is set
 */
 inline Reference< XCurrentContext > SAL_CALL getCurrentContext()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     Reference< XCurrentContext > xRet;
     ::rtl::OUString aEnvTypeName( RTL_CONSTASCII_USTRINGPARAM(CPPU_CURRENT_LANGUAGE_BINDING_NAME) );
@@ -64,7 +64,7 @@ inline Reference< XCurrentContext > SAL_CALL getCurrentContext()
 */
 inline bool SAL_CALL setCurrentContext(
     Reference< XCurrentContext > const & xContext )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     ::rtl::OUString aEnvTypeName( RTL_CONSTASCII_USTRINGPARAM(CPPU_CURRENT_LANGUAGE_BINDING_NAME) );
     return (::uno_setCurrentContext( xContext.get(), aEnvTypeName.pData, 0 ) != sal_False);
@@ -90,22 +90,22 @@ public:
     */
     inline ContextLayer(
         Reference< XCurrentContext > const & xNewContext = Reference< XCurrentContext >() )
-        SAL_THROW( () );
+        SAL_THROW(());
     /** Destructor: restores the previous context.
     */
-    inline ~ContextLayer() SAL_THROW( () );
+    inline ~ContextLayer() SAL_THROW(());
 
     /** Gets the previously set context.
 
         @return the previously set context
     */
     inline Reference< XCurrentContext > SAL_CALL getPreviousContext() const
-        SAL_THROW( () )
+        SAL_THROW(())
         { return m_xPreviousContext; }
 };
 //__________________________________________________________________________________________________
 inline ContextLayer::ContextLayer( Reference< XCurrentContext > const & xNewContext )
-    SAL_THROW( () )
+    SAL_THROW(())
     : m_aEnvTypeName( RTL_CONSTASCII_USTRINGPARAM(CPPU_CURRENT_LANGUAGE_BINDING_NAME) )
 {
     ::uno_getCurrentContext( (void **)&m_xPreviousContext, m_aEnvTypeName.pData, 0 );
@@ -113,7 +113,7 @@ inline ContextLayer::ContextLayer( Reference< XCurrentContext > const & xNewCont
 }
 //__________________________________________________________________________________________________
 inline ContextLayer::~ContextLayer()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     ::uno_setCurrentContext( m_xPreviousContext.get(), m_aEnvTypeName.pData, 0 );
 }
diff --git a/cppu/inc/uno/environment.hxx b/cppu/inc/uno/environment.hxx
index 61b6b7aa275e..9acbe39f5dd4 100644
--- a/cppu/inc/uno/environment.hxx
+++ b/cppu/inc/uno/environment.hxx
@@ -64,17 +64,17 @@ public:
                           respectively to current C++ Environment.
         @since UDK 3.2.7
     */
-    inline static Environment getCurrent(rtl::OUString const & typeName = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(CPPU_STRINGIFY(CPPU_ENV)))) SAL_THROW( () );
+    inline static Environment getCurrent(rtl::OUString const & typeName = rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(CPPU_STRINGIFY(CPPU_ENV)))) SAL_THROW(());
 
     /// @cond INTERNAL
     // these are here to force memory de/allocation to sal lib.
-    inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW( () )
+    inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW(())
         { return ::rtl_allocateMemory( nSize ); }
-    inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW( () )
+    inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW(())
         { ::rtl_freeMemory( pMem ); }
-    inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW( () )
+    inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW(())
         { return pMem; }
-    inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () )
+    inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW(())
         {}
     /// @endcond
 
@@ -82,7 +82,7 @@ public:
 
         @param pEnv environment
     */
-    inline Environment( uno_Environment * pEnv = 0 ) SAL_THROW( () );
+    inline Environment( uno_Environment * pEnv = 0 ) SAL_THROW(());
 
     /** Gets a specific environment. If the specified environment does not exist, then a default one
         is created and registered.
@@ -90,64 +90,64 @@ public:
         @param envDcp           descriptor of the environment
         @param pContext         context pointer
     */
-    inline explicit Environment( rtl::OUString const & envDcp, void * pContext = NULL ) SAL_THROW( () );
+    inline explicit Environment( rtl::OUString const & envDcp, void * pContext = NULL ) SAL_THROW(());
 
 
     /** Copy constructor: acquires given environment
 
         @param rEnv another environment
     */
-    inline Environment( const Environment & rEnv ) SAL_THROW( () );
+    inline Environment( const Environment & rEnv ) SAL_THROW(());
 
     /** Destructor: releases a set environment.
     */
-    inline ~Environment() SAL_THROW( () );
+    inline ~Environment() SAL_THROW(());
 
     /** Sets a given environment, i.e. acquires given one and releases a set one.
 
         @param pEnv another environment
         @return this environment
     */
-    inline Environment & SAL_CALL operator = ( uno_Environment * pEnv ) SAL_THROW( () );
+    inline Environment & SAL_CALL operator = ( uno_Environment * pEnv ) SAL_THROW(());
     /** Sets a given environment, i.e. acquires given one and releases a set one.
 
         @param rEnv another environment
         @return this environment
     */
-    inline Environment & SAL_CALL operator = ( const Environment & rEnv ) SAL_THROW( () )
+    inline Environment & SAL_CALL operator = ( const Environment & rEnv ) SAL_THROW(())
         { return operator = ( rEnv._pEnv ); }
 
     /** Provides UNacquired pointer to the set C environment.
 
         @return UNacquired pointer to the C environment struct
     */
-    inline uno_Environment * SAL_CALL get() const SAL_THROW( () )
+    inline uno_Environment * SAL_CALL get() const SAL_THROW(())
         { return _pEnv; }
 
     /** Gets type name of set environment.
 
         @return type name of set environment
     */
-    inline ::rtl::OUString SAL_CALL getTypeName() const SAL_THROW( () )
+    inline ::rtl::OUString SAL_CALL getTypeName() const SAL_THROW(())
         { return _pEnv->pTypeName; }
 
     /** Gets free context pointer of set environment.
 
         @return free context pointer of set environment
     */
-    inline void * SAL_CALL getContext() const SAL_THROW( () )
+    inline void * SAL_CALL getContext() const SAL_THROW(())
         { return _pEnv->pContext; }
 
     /** Tests if a environment is set.
 
         @return true, if a environment is set, false otherwise
     */
-    inline sal_Bool SAL_CALL is() const SAL_THROW( () )
+    inline sal_Bool SAL_CALL is() const SAL_THROW(())
         { return (_pEnv != 0); }
 
     /** Releases a set environment.
     */
-    inline void SAL_CALL clear() SAL_THROW( () );
+    inline void SAL_CALL clear() SAL_THROW(());
 
     /** Invoke the passed function in this environment.
 
@@ -155,7 +155,7 @@ public:
         @param pParam   the parameter pointer to be passed to the function
         @since UDK 3.2.7
     */
-    inline void SAL_CALL invoke_v(uno_EnvCallee * pCallee, va_list * pParam) const SAL_THROW( () );
+    inline void SAL_CALL invoke_v(uno_EnvCallee * pCallee, va_list * pParam) const SAL_THROW(());
 
     /** Invoke the passed function in this environment.
 
@@ -163,49 +163,49 @@ public:
         @param ...      the parameters to be passed to the function
         @since UDK 3.2.7
     */
-    inline void SAL_CALL invoke(uno_EnvCallee * pCallee, ...) const SAL_THROW( () );
+    inline void SAL_CALL invoke(uno_EnvCallee * pCallee, ...) const SAL_THROW(());
 
     /** Enter this environment explicitly.
 
         @since UDK 3.2.7
     */
-    inline void SAL_CALL enter() const SAL_THROW( () );
+    inline void SAL_CALL enter() const SAL_THROW(());
 
     /** Checks, if it is valid to currently call objects
         belonging to this environment.
 
         @since UDK 3.2.7
     */
-    inline int  SAL_CALL isValid(rtl::OUString * pReason) const SAL_THROW( () );
+    inline int  SAL_CALL isValid(rtl::OUString * pReason) const SAL_THROW(());
 };
 //__________________________________________________________________________________________________
-inline Environment::Environment( uno_Environment * pEnv ) SAL_THROW( () )
+inline Environment::Environment( uno_Environment * pEnv ) SAL_THROW(())
     : _pEnv( pEnv )
 {
     if (_pEnv)
         (*_pEnv->acquire)( _pEnv );
 }
 //__________________________________________________________________________________________________
-inline Environment::Environment( rtl::OUString const & rEnvDcp, void * pContext ) SAL_THROW( () )
+inline Environment::Environment( rtl::OUString const & rEnvDcp, void * pContext ) SAL_THROW(())
     : _pEnv(NULL)
 {
     uno_getEnvironment(&_pEnv, rEnvDcp.pData, pContext);
 }
 //__________________________________________________________________________________________________
-inline Environment::Environment( const Environment & rEnv ) SAL_THROW( () )
+inline Environment::Environment( const Environment & rEnv ) SAL_THROW(())
     : _pEnv( rEnv._pEnv )
 {
     if (_pEnv)
         (*_pEnv->acquire)( _pEnv );
 }
 //__________________________________________________________________________________________________
-inline Environment::~Environment() SAL_THROW( () )
+inline Environment::~Environment() SAL_THROW(())
 {
     if (_pEnv)
         (*_pEnv->release)( _pEnv );
 }
 //__________________________________________________________________________________________________
-inline void Environment::clear() SAL_THROW( () )
+inline void Environment::clear() SAL_THROW(())
 {
     if (_pEnv)
     {
@@ -214,7 +214,7 @@ inline void Environment::clear() SAL_THROW( () )
     }
 }
 //__________________________________________________________________________________________________
-inline Environment & Environment::operator = ( uno_Environment * pEnv ) SAL_THROW( () )
+inline Environment & Environment::operator = ( uno_Environment * pEnv ) SAL_THROW(())
 {
     if (pEnv != _pEnv)
     {
@@ -227,13 +227,13 @@ inline Environment & Environment::operator = ( uno_Environment * pEnv ) SAL_THRO
     return *this;
 }
 //__________________________________________________________________________________________________
-inline void SAL_CALL Environment::invoke_v(uno_EnvCallee * pCallee, va_list * pParam) const SAL_THROW( () )
+inline void SAL_CALL Environment::invoke_v(uno_EnvCallee * pCallee, va_list * pParam) const SAL_THROW(())
 {
     if (_pEnv)
         uno_Environment_invoke_v(_pEnv, pCallee, pParam);
 }
 //__________________________________________________________________________________________________
-inline void SAL_CALL Environment::invoke(uno_EnvCallee * pCallee, ...) const SAL_THROW( () )
+inline void SAL_CALL Environment::invoke(uno_EnvCallee * pCallee, ...) const SAL_THROW(())
 {
     if (_pEnv)
     {
@@ -246,17 +246,17 @@ inline void SAL_CALL Environment::invoke(uno_EnvCallee * pCallee, ...) const SAL
 
 }
 //__________________________________________________________________________________________________
-inline void SAL_CALL Environment::enter() const SAL_THROW( () )
+inline void SAL_CALL Environment::enter() const SAL_THROW(())
 {
     uno_Environment_enter(_pEnv);
 }
 //__________________________________________________________________________________________________
-inline int  SAL_CALL Environment::isValid(rtl::OUString * pReason) const SAL_THROW( () )
+inline int  SAL_CALL Environment::isValid(rtl::OUString * pReason) const SAL_THROW(())
 {
     return uno_Environment_isValid(_pEnv, (rtl_uString **)pReason);
 }
 //__________________________________________________________________________________________________
-inline Environment Environment::getCurrent(rtl::OUString const & typeName) SAL_THROW( () )
+inline Environment Environment::getCurrent(rtl::OUString const & typeName) SAL_THROW(())
 {
     Environment environment;
 
diff --git a/cppu/inc/uno/mapping.hxx b/cppu/inc/uno/mapping.hxx
index 2e50164d1c14..72f8b6cc9922 100644
--- a/cppu/inc/uno/mapping.hxx
+++ b/cppu/inc/uno/mapping.hxx
@@ -61,13 +61,13 @@ class Mapping
 public:
     // these are here to force memory de/allocation to sal lib.
     /// @cond INTERNAL
-    inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW( () )
+    inline static void * SAL_CALL operator new ( size_t nSize ) SAL_THROW(())
         { return ::rtl_allocateMemory( nSize ); }
-    inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW( () )
+    inline static void SAL_CALL operator delete ( void * pMem ) SAL_THROW(())
         { ::rtl_freeMemory( pMem ); }
-    inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW( () )
+    inline static void * SAL_CALL operator new ( size_t, void * pMem ) SAL_THROW(())
         { return pMem; }
-    inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW( () )
+    inline static void SAL_CALL operator delete ( void *, void * ) SAL_THROW(())
         {}
     /// @endcond
 
@@ -81,7 +81,7 @@ public:
     inline Mapping(
         const ::rtl::OUString & rFrom, const ::rtl::OUString & rTo,
         const ::rtl::OUString & rAddPurpose = ::rtl::OUString() )
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /** Holds a mapping from the specified source to the specified destination.
 
@@ -92,7 +92,7 @@ public:
     inline Mapping(
         uno_Environment * pFrom, uno_Environment * pTo,
         const ::rtl::OUString & rAddPurpose = ::rtl::OUString() )
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /** Holds a mapping from the specified source to the specified destination
         environment.
@@ -103,55 +103,55 @@ public:
     */
     inline Mapping(const Environment & rFrom, const Environment & rTo,
                    const ::rtl::OUString & rAddPurpose = ::rtl::OUString() )
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /** Constructor.
 
         @param pMapping another mapping
     */
-    inline Mapping( uno_Mapping * pMapping = 0 ) SAL_THROW( () );
+    inline Mapping( uno_Mapping * pMapping = 0 ) SAL_THROW(());
 
     /** Copy constructor.
 
         @param rMapping another mapping
     */
-    inline Mapping( const Mapping & rMapping ) SAL_THROW( () );
+    inline Mapping( const Mapping & rMapping ) SAL_THROW(());
 
     /** Destructor.
     */
-    inline ~Mapping() SAL_THROW( () );
+    inline ~Mapping() SAL_THROW(());
 
     /** Sets a given mapping.
 
         @param pMapping another mapping
         @return this mapping
     */
-    inline Mapping & SAL_CALL operator = ( uno_Mapping * pMapping ) SAL_THROW( () );
+    inline Mapping & SAL_CALL operator = ( uno_Mapping * pMapping ) SAL_THROW(());
     /** Sets a given mapping.
 
         @param rMapping another mapping
         @return this mapping
     */
-    inline Mapping & SAL_CALL operator = ( const Mapping & rMapping ) SAL_THROW( () )
+    inline Mapping & SAL_CALL operator = ( const Mapping & rMapping ) SAL_THROW(())
         { return operator = ( rMapping._pMapping ); }
 
     /** Provides a pointer to the C mapping. The returned mapping is NOT acquired!
 
         @return UNacquired C mapping
     */
-    inline uno_Mapping * SAL_CALL get() const SAL_THROW( () )
+    inline uno_Mapping * SAL_CALL get() const SAL_THROW(())
         { return _pMapping; }
 
     /** Tests if a mapping is set.
 
         @return true if a mapping is set
     */
-    inline sal_Bool SAL_CALL is() const SAL_THROW( () )
+    inline sal_Bool SAL_CALL is() const SAL_THROW(())
         { return (_pMapping != 0); }
 
     /** Releases a set mapping.
     */
-    inline void SAL_CALL clear() SAL_THROW( () );
+    inline void SAL_CALL clear() SAL_THROW(());
 
     /** Maps an interface from one environment to another.
 
@@ -159,14 +159,14 @@ public:
         @param pTypeDescr       type description of interface
         @return                 mapped interface
     */
-    inline void * SAL_CALL mapInterface( void * pInterface, typelib_InterfaceTypeDescription * pTypeDescr ) const SAL_THROW( () );
+    inline void * SAL_CALL mapInterface( void * pInterface, typelib_InterfaceTypeDescription * pTypeDescr ) const SAL_THROW(());
     /** Maps an interface from one environment to another.
 
         @param pInterface       source interface
         @param pTypeDescr       type description of interface
         @return                 mapped interface
     */
-    inline void * SAL_CALL mapInterface( void * pInterface, typelib_TypeDescription * pTypeDescr ) const SAL_THROW( () )
+    inline void * SAL_CALL mapInterface( void * pInterface, typelib_TypeDescription * pTypeDescr ) const SAL_THROW(())
         { return mapInterface( pInterface, (typelib_InterfaceTypeDescription *)pTypeDescr ); }
 
     /** Maps an interface from one environment to another.
@@ -176,7 +176,7 @@ public:
         @return                 mapped interface
     */
     inline void * SAL_CALL mapInterface(
-        void * pInterface, const ::com::sun::star::uno::Type & rType ) const SAL_THROW( () );
+        void * pInterface, const ::com::sun::star::uno::Type & rType ) const SAL_THROW(());
 
     /** Maps an interface from one environment to another.
 
@@ -184,7 +184,7 @@ public:
         @param pInterface       source interface
         @param pTypeDescr       type description of interface
     */
-    inline void SAL_CALL mapInterface( void ** ppOut, void * pInterface, typelib_InterfaceTypeDescription * pTypeDescr ) const SAL_THROW( () )
+    inline void SAL_CALL mapInterface( void ** ppOut, void * pInterface, typelib_InterfaceTypeDescription * pTypeDescr ) const SAL_THROW(())
         { (*_pMapping->mapInterface)( _pMapping, ppOut, pInterface, pTypeDescr ); }
     /** Maps an interface from one environment to another.
 
@@ -192,7 +192,7 @@ public:
         @param pInterface       source interface
         @param pTypeDescr       type description of interface
     */
-    inline void SAL_CALL mapInterface( void ** ppOut, void * pInterface, typelib_TypeDescription * pTypeDescr ) const SAL_THROW( () )
+    inline void SAL_CALL mapInterface( void ** ppOut, void * pInterface, typelib_TypeDescription * pTypeDescr ) const SAL_THROW(())
         { (*_pMapping->mapInterface)( _pMapping, ppOut, pInterface, (typelib_InterfaceTypeDescription *)pTypeDescr ); }
 
     /** Maps an interface from one environment to another.
@@ -201,12 +201,12 @@ public:
         @param pInterface       source interface
         @param rType            type of interface to be mapped
      */
-    inline void SAL_CALL mapInterface( void ** ppOut, void * pInterface, const ::com::sun::star::uno::Type & rType ) const SAL_THROW( () );
+    inline void SAL_CALL mapInterface( void ** ppOut, void * pInterface, const ::com::sun::star::uno::Type & rType ) const SAL_THROW(());
 };
 //__________________________________________________________________________________________________
 inline Mapping::Mapping(
     const ::rtl::OUString & rFrom, const ::rtl::OUString & rTo, const ::rtl::OUString & rAddPurpose )
-    SAL_THROW( () )
+    SAL_THROW(())
     : _pMapping( 0 )
 {
     uno_getMappingByName( &_pMapping, rFrom.pData, rTo.pData, rAddPurpose.pData );
@@ -214,7 +214,7 @@ inline Mapping::Mapping(
 //__________________________________________________________________________________________________
 inline Mapping::Mapping(
     uno_Environment * pFrom, uno_Environment * pTo, const ::rtl::OUString & rAddPurpose )
-    SAL_THROW( () )
+    SAL_THROW(())
     : _pMapping( 0 )
 {
     uno_getMapping( &_pMapping, pFrom, pTo, rAddPurpose.pData );
@@ -222,33 +222,33 @@ inline Mapping::Mapping(
 //__________________________________________________________________________________________________
 inline Mapping::Mapping(
     const Environment & rFrom, const Environment & rTo, const ::rtl::OUString & rAddPurpose )
-    SAL_THROW( () )
+    SAL_THROW(())
         : _pMapping(0)
 {
     uno_getMapping( &_pMapping, rFrom.get(), rTo.get(), rAddPurpose.pData );
 }
 //__________________________________________________________________________________________________
-inline Mapping::Mapping( uno_Mapping * pMapping ) SAL_THROW( () )
+inline Mapping::Mapping( uno_Mapping * pMapping ) SAL_THROW(())
     : _pMapping( pMapping )
 {
     if (_pMapping)
         (*_pMapping->acquire)( _pMapping );
 }
 //__________________________________________________________________________________________________
-inline Mapping::Mapping( const Mapping & rMapping ) SAL_THROW( () )
+inline Mapping::Mapping( const Mapping & rMapping ) SAL_THROW(())
     : _pMapping( rMapping._pMapping )
 {
     if (_pMapping)
         (*_pMapping->acquire)( _pMapping );
 }
 //__________________________________________________________________________________________________
-inline Mapping::~Mapping() SAL_THROW( () )
+inline Mapping::~Mapping() SAL_THROW(())
 {
     if (_pMapping)
         (*_pMapping->release)( _pMapping );
 }
 //__________________________________________________________________________________________________
-inline void Mapping::clear() SAL_THROW( () )
+inline void Mapping::clear() SAL_THROW(())
 {
     if (_pMapping)
     {
@@ -257,7 +257,7 @@ inline void Mapping::clear() SAL_THROW( () )
     }
 }
 //__________________________________________________________________________________________________
-inline Mapping & Mapping::operator = ( uno_Mapping * pMapping ) SAL_THROW( () )
+inline Mapping & Mapping::operator = ( uno_Mapping * pMapping ) SAL_THROW(())
 {
     if (pMapping)
         (*pMapping->acquire)( pMapping );
@@ -269,7 +269,7 @@ inline Mapping & Mapping::operator = ( uno_Mapping * pMapping ) SAL_THROW( () )
 //__________________________________________________________________________________________________
 inline void Mapping::mapInterface(
     void ** ppOut, void * pInterface, const ::com::sun::star::uno::Type & rType ) const
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     typelib_TypeDescription * pTD = 0;
     TYPELIB_DANGER_GET( &pTD, rType.getTypeLibType() );
@@ -282,7 +282,7 @@ inline void Mapping::mapInterface(
 //__________________________________________________________________________________________________
 inline void * Mapping::mapInterface(
     void * pInterface, typelib_InterfaceTypeDescription * pTypeDescr ) const
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     void * pOut = 0;
     (*_pMapping->mapInterface)( _pMapping, &pOut, pInterface, pTypeDescr );
@@ -291,7 +291,7 @@ inline void * Mapping::mapInterface(
 //__________________________________________________________________________________________________
 inline void * Mapping::mapInterface(
     void * pInterface, const ::com::sun::star::uno::Type & rType ) const
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     void * pOut = 0;
     mapInterface( &pOut, pInterface, rType );
@@ -311,7 +311,7 @@ inline void * Mapping::mapInterface(
     @deprecated
 */
 template< class C >
-inline sal_Bool mapToCpp( Reference< C > * ppRet, uno_Interface * pUnoI ) SAL_THROW( () )
+inline sal_Bool mapToCpp( Reference< C > * ppRet, uno_Interface * pUnoI ) SAL_THROW(())
 {
     Mapping aMapping(
         ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(UNO_LB_UNO) ),
@@ -334,7 +334,7 @@ inline sal_Bool mapToCpp( Reference< C > * ppRet, uno_Interface * pUnoI ) SAL_TH
     @deprecated
 */
 template< class C >
-inline sal_Bool mapToUno( uno_Interface ** ppRet, const Reference< C > & x ) SAL_THROW( () )
+inline sal_Bool mapToUno( uno_Interface ** ppRet, const Reference< C > & x ) SAL_THROW(())
 {
     Mapping aMapping(
         ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(CPPU_CURRENT_LANGUAGE_BINDING_NAME) ),
diff --git a/cppu/source/helper/purpenv/Proxy.hxx b/cppu/source/helper/purpenv/Proxy.hxx
index 9db0182c2edc..7316623cb4be 100644
--- a/cppu/source/helper/purpenv/Proxy.hxx
+++ b/cppu/source/helper/purpenv/Proxy.hxx
@@ -68,7 +68,7 @@ public:
                    rtl::OUString                    const & rOId,
                    cppu::helper::purpenv::ProbeFun        * probeFun,
                    void                                   * pProbeContext)
-        SAL_THROW( () );
+        SAL_THROW(());
     ~Proxy(void);
 
     void acquire(void);
diff --git a/cppu/source/helper/purpenv/helper_purpenv_Mapping.cxx b/cppu/source/helper/purpenv/helper_purpenv_Mapping.cxx
index ab110761bde1..2657e788e7de 100644
--- a/cppu/source/helper/purpenv/helper_purpenv_Mapping.cxx
+++ b/cppu/source/helper/purpenv/helper_purpenv_Mapping.cxx
@@ -128,14 +128,14 @@ Mapping::Mapping(uno_Environment                 * pFrom,
                  uno_Environment                 * pTo,
                  cppu::helper::purpenv::ProbeFun * probeFun,
                  void                            * pProbeContext
-) SAL_THROW( () )
+) SAL_THROW(())
     : m_from    (pFrom),
       m_to      (pTo),
       m_nCount  (1),
       m_probeFun(probeFun),
       m_pContext(pProbeContext)
 {
-    LOG_LIFECYCLE_cppu_helper_purpenv_Mapping_emit(fprintf(stderr, "LIFE: %s -> %p\n", "Mapping::Mapping(uno_Environment * pFrom, uno_Environment * pTo) SAL_THROW( () )", this));
+    LOG_LIFECYCLE_cppu_helper_purpenv_Mapping_emit(fprintf(stderr, "LIFE: %s -> %p\n", "Mapping::Mapping(uno_Environment * pFrom, uno_Environment * pTo) SAL_THROW(())", this));
 
     uno_Mapping::acquire      = s_acquire;
     uno_Mapping::release      = s_release;
diff --git a/cppu/source/helper/purpenv/helper_purpenv_Proxy.cxx b/cppu/source/helper/purpenv/helper_purpenv_Proxy.cxx
index 5d334be5cfad..1ff7eb95199e 100644
--- a/cppu/source/helper/purpenv/helper_purpenv_Proxy.cxx
+++ b/cppu/source/helper/purpenv/helper_purpenv_Proxy.cxx
@@ -50,7 +50,7 @@ using namespace com::sun::star;
 
 
 static bool relatesToInterface(typelib_TypeDescription * pTypeDescr)
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     switch (pTypeDescr->eTypeClass)
     {
diff --git a/cppu/source/threadpool/current.cxx b/cppu/source/threadpool/current.cxx
index 2839406ea172..f1194c91003e 100644
--- a/cppu/source/threadpool/current.cxx
+++ b/cppu/source/threadpool/current.cxx
@@ -124,19 +124,19 @@ class ThreadKey
     oslThreadKeyCallbackFunction _pCallback;
 
 public:
-    inline oslThreadKey getThreadKey() SAL_THROW( () );
+    inline oslThreadKey getThreadKey() SAL_THROW(());
 
-    inline ThreadKey( oslThreadKeyCallbackFunction pCallback ) SAL_THROW( () );
-    inline ~ThreadKey() SAL_THROW( () );
+    inline ThreadKey( oslThreadKeyCallbackFunction pCallback ) SAL_THROW(());
+    inline ~ThreadKey() SAL_THROW(());
 };
 //__________________________________________________________________________________________________
-inline ThreadKey::ThreadKey( oslThreadKeyCallbackFunction pCallback ) SAL_THROW( () )
+inline ThreadKey::ThreadKey( oslThreadKeyCallbackFunction pCallback ) SAL_THROW(())
     : _bInit( sal_False )
     , _pCallback( pCallback )
 {
 }
 //__________________________________________________________________________________________________
-inline ThreadKey::~ThreadKey() SAL_THROW( () )
+inline ThreadKey::~ThreadKey() SAL_THROW(())
 {
     if (_bInit)
     {
@@ -144,7 +144,7 @@ inline ThreadKey::~ThreadKey() SAL_THROW( () )
     }
 }
 //__________________________________________________________________________________________________
-inline oslThreadKey ThreadKey::getThreadKey() SAL_THROW( () )
+inline oslThreadKey ThreadKey::getThreadKey() SAL_THROW(())
 {
     if (! _bInit)
     {
@@ -180,7 +180,7 @@ extern "C" void SAL_CALL delete_IdContainer( void * p )
     }
 }
 //==================================================================================================
-IdContainer * getIdContainer() SAL_THROW( () )
+IdContainer * getIdContainer() SAL_THROW(())
 {
     static ThreadKey s_key( delete_IdContainer );
     oslThreadKey aKey = s_key.getThreadKey();
diff --git a/cppu/source/threadpool/current.hxx b/cppu/source/threadpool/current.hxx
index 45640220116d..8d19a51c125a 100644
--- a/cppu/source/threadpool/current.hxx
+++ b/cppu/source/threadpool/current.hxx
@@ -45,7 +45,7 @@ struct IdContainer
     sal_Sequence *      pCurrentId;
 };
 
-IdContainer * getIdContainer() SAL_THROW( () );
+IdContainer * getIdContainer() SAL_THROW(());
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/cppu/source/typelib/static_types.cxx b/cppu/source/typelib/static_types.cxx
index f415c884463c..d19f7ba35d49 100644
--- a/cppu/source/typelib/static_types.cxx
+++ b/cppu/source/typelib/static_types.cxx
@@ -99,7 +99,7 @@ struct AlignSize_Impl
 static sal_Int32 nMaxAlignment = (sal_Int32)( (sal_Size)(&((AlignSize_Impl *) 16)->dDouble) - 16);
 
 static inline sal_Int32 adjustAlignment( sal_Int32 nRequestedAlignment )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if( nRequestedAlignment > nMaxAlignment )
         nRequestedAlignment = nMaxAlignment;
@@ -111,7 +111,7 @@ static inline sal_Int32 adjustAlignment( sal_Int32 nRequestedAlignment )
  */
 static inline sal_Int32 newAlignedSize(
     sal_Int32 OldSize, sal_Int32 ElementSize, sal_Int32 NeededAlignment )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     NeededAlignment = adjustAlignment( NeededAlignment );
     return (OldSize + NeededAlignment -1) / NeededAlignment * NeededAlignment + ElementSize;
@@ -126,7 +126,7 @@ namespace
 
 // !for NOT REALLY WEAK TYPES only!
 static inline typelib_TypeDescriptionReference * igetTypeByName( rtl_uString * pTypeName )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     typelib_TypeDescriptionReference * pRef = 0;
     ::typelib_typedescriptionreference_getByName( &pRef, pTypeName );
diff --git a/cppu/source/typelib/typelib.cxx b/cppu/source/typelib/typelib.cxx
index 169d29da3fcc..42489df0a9c1 100644
--- a/cppu/source/typelib/typelib.cxx
+++ b/cppu/source/typelib/typelib.cxx
@@ -89,7 +89,7 @@ struct AlignSize_Impl
 static sal_Int32 nMaxAlignment = (sal_Int32)( (sal_Size)(&((AlignSize_Impl *) 16)->dDouble) - 16);
 
 static inline sal_Int32 adjustAlignment( sal_Int32 nRequestedAlignment )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if( nRequestedAlignment > nMaxAlignment )
         nRequestedAlignment = nMaxAlignment;
@@ -101,20 +101,20 @@ static inline sal_Int32 adjustAlignment( sal_Int32 nRequestedAlignment )
  */
 static inline sal_Int32 newAlignedSize(
     sal_Int32 OldSize, sal_Int32 ElementSize, sal_Int32 NeededAlignment )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     NeededAlignment = adjustAlignment( NeededAlignment );
     return (OldSize + NeededAlignment -1) / NeededAlignment * NeededAlignment + ElementSize;
 }
 
 static inline sal_Bool reallyWeak( typelib_TypeClass eTypeClass )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return TYPELIB_TYPEDESCRIPTIONREFERENCE_ISREALLYWEAK( eTypeClass );
 }
 
 static inline sal_Int32 getDescriptionSize( typelib_TypeClass eTypeClass )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     OSL_ASSERT( typelib_TypeClass_TYPEDEF != eTypeClass );
 
@@ -175,14 +175,14 @@ extern "C" void SAL_CALL typelib_typedescriptionreference_getByName(
 //-----------------------------------------------------------------------------
 struct equalStr_Impl
 {
-    sal_Bool operator()(const sal_Unicode * const & s1, const sal_Unicode * const & s2) const SAL_THROW( () )
+    sal_Bool operator()(const sal_Unicode * const & s1, const sal_Unicode * const & s2) const SAL_THROW(())
         { return 0 == rtl_ustr_compare( s1, s2 ); }
 };
 
 //-----------------------------------------------------------------------------
 struct hashStr_Impl
 {
-    size_t operator()(const sal_Unicode * const & s) const SAL_THROW( () )
+    size_t operator()(const sal_Unicode * const & s) const SAL_THROW(())
         { return rtl_ustr_hashCode( s ); }
 };
 
@@ -211,9 +211,9 @@ struct TypeDescriptor_Init_Impl
     // The mutex to guard all type library accesses
     Mutex *                     pMutex;
 
-    inline Mutex & getMutex() SAL_THROW( () );
+    inline Mutex & getMutex() SAL_THROW(());
 
-    inline void callChain( typelib_TypeDescription ** ppRet, rtl_uString * pName ) SAL_THROW( () );
+    inline void callChain( typelib_TypeDescription ** ppRet, rtl_uString * pName ) SAL_THROW(());
 
 #if OSL_DEBUG_LEVEL > 1
     // only for debugging
@@ -241,10 +241,10 @@ struct TypeDescriptor_Init_Impl
 #endif
     {}
 
-    ~TypeDescriptor_Init_Impl() SAL_THROW( () );
+    ~TypeDescriptor_Init_Impl() SAL_THROW(());
 };
 //__________________________________________________________________________________________________
-inline Mutex & TypeDescriptor_Init_Impl::getMutex() SAL_THROW( () )
+inline Mutex & TypeDescriptor_Init_Impl::getMutex() SAL_THROW(())
 {
     if( !pMutex )
     {
@@ -257,7 +257,7 @@ inline Mutex & TypeDescriptor_Init_Impl::getMutex() SAL_THROW( () )
 //__________________________________________________________________________________________________
 inline void TypeDescriptor_Init_Impl::callChain(
     typelib_TypeDescription ** ppRet, rtl_uString * pName )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (pCallbacks)
     {
@@ -279,7 +279,7 @@ inline void TypeDescriptor_Init_Impl::callChain(
 }
 
 //__________________________________________________________________________________________________
-TypeDescriptor_Init_Impl::~TypeDescriptor_Init_Impl() SAL_THROW( () )
+TypeDescriptor_Init_Impl::~TypeDescriptor_Init_Impl() SAL_THROW(())
 {
     if( pCache )
     {
@@ -425,7 +425,7 @@ extern "C" sal_Int32 SAL_CALL typelib_typedescription_getAlignedUnoSize(
 //------------------------------------------------------------------------
 static inline void typelib_typedescription_initTables(
     typelib_TypeDescription * pTD )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     typelib_InterfaceTypeDescription * pITD = (typelib_InterfaceTypeDescription *)pTD;
 
@@ -1467,7 +1467,7 @@ void deleteExceptions(
 // frees anything except typelib_TypeDescription base!
 static inline void typelib_typedescription_destructExtendedMembers(
     typelib_TypeDescription * pTD )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     OSL_ASSERT( typelib_TypeClass_TYPEDEF != pTD->eTypeClass );
 
@@ -1810,7 +1810,7 @@ extern "C" CPPU_DLLPUBLIC void SAL_CALL typelib_typedescription_register(
 //------------------------------------------------------------------------
 static inline sal_Bool type_equals(
     typelib_TypeDescriptionReference * p1, typelib_TypeDescriptionReference * p2 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return (p1 == p2 ||
             (p1->eTypeClass == p2->eTypeClass &&
diff --git a/cppu/source/uno/assign.hxx b/cppu/source/uno/assign.hxx
index 42375832ab09..f4f126d701c3 100644
--- a/cppu/source/uno/assign.hxx
+++ b/cppu/source/uno/assign.hxx
@@ -46,7 +46,7 @@ namespace cppu
 inline void _assignInterface(
     void ** ppDest, void * pSource,
     uno_AcquireFunc acquire, uno_ReleaseFunc release )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     _acquire( pSource, acquire );
     void * const pToBeReleased = *ppDest;
@@ -58,7 +58,7 @@ inline void * _queryInterface(
     void * pSource,
     typelib_TypeDescriptionReference * pDestType,
     uno_QueryInterfaceFunc queryInterface )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (pSource)
     {
@@ -73,13 +73,13 @@ sal_Bool assignStruct(
     void * pDest, void * pSource,
     typelib_CompoundTypeDescription * pTypeDescr,
     uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release )
-    SAL_THROW( () );
+    SAL_THROW(());
 //--------------------------------------------------------------------------------------------------
 inline sal_Bool _assignStruct(
     void * pDest, void * pSource,
     typelib_CompoundTypeDescription * pTypeDescr,
     uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (pTypeDescr->pBaseTypeDescription)
     {
@@ -237,7 +237,7 @@ inline sal_Bool _assignData(
     void * pSource,
     typelib_TypeDescriptionReference * pSourceType, typelib_TypeDescription * pSourceTypeDescr,
     uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (pDest == pSource)
         return _type_equals( pDestType, pSourceType );
diff --git a/cppu/source/uno/constr.hxx b/cppu/source/uno/constr.hxx
index b8eb9b5cc5ce..c735051f9f48 100644
--- a/cppu/source/uno/constr.hxx
+++ b/cppu/source/uno/constr.hxx
@@ -42,7 +42,7 @@ namespace cppu
 inline void _defaultConstructUnion(
     void * pMem,
     typelib_TypeDescription * pTypeDescr )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     ::uno_type_constructData(
         (char *)pMem + ((typelib_UnionTypeDescription *)pTypeDescr)->nValueOffset,
@@ -53,12 +53,12 @@ inline void _defaultConstructUnion(
 void defaultConstructStruct(
     void * pMem,
     typelib_CompoundTypeDescription * pCompType )
-    SAL_THROW( () );
+    SAL_THROW(());
 //--------------------------------------------------------------------------------------------------
 inline void _defaultConstructStruct(
     void * pMem,
     typelib_CompoundTypeDescription * pTypeDescr )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (pTypeDescr->pBaseTypeDescription)
     {
@@ -161,7 +161,7 @@ inline void _defaultConstructData(
     void * pMem,
     typelib_TypeDescriptionReference * pType,
     typelib_TypeDescription * pTypeDescr )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     switch (pType->eTypeClass)
     {
diff --git a/cppu/source/uno/copy.hxx b/cppu/source/uno/copy.hxx
index 6416c22fb02c..07b9bca0e0a2 100644
--- a/cppu/source/uno/copy.hxx
+++ b/cppu/source/uno/copy.hxx
@@ -64,13 +64,13 @@ void copyConstructStruct(
     void * pDest, void * pSource,
     typelib_CompoundTypeDescription * pTypeDescr,
     uno_AcquireFunc acquire, uno_Mapping * mapping )
-    SAL_THROW ( () );
+    SAL_THROW (());
 //--------------------------------------------------------------------------------------------------
 inline void _copyConstructStruct(
     void * pDest, void * pSource,
     typelib_CompoundTypeDescription * pTypeDescr,
     uno_AcquireFunc acquire, uno_Mapping * mapping )
-    SAL_THROW ( () )
+    SAL_THROW (())
 {
     if (pTypeDescr->pBaseTypeDescription)
     {
@@ -143,7 +143,7 @@ inline void _copyConstructUnion(
     void * pDest, void * pSource,
     typelib_TypeDescription * pTypeDescr,
     uno_AcquireFunc acquire, uno_Mapping * mapping )
-    SAL_THROW ( () )
+    SAL_THROW (())
 {
     typelib_TypeDescriptionReference * pSetType = _unionGetSetType( pSource, pTypeDescr );
     if (mapping)
@@ -175,7 +175,7 @@ inline void _copyConstructAnyFromData(
     uno_Any * pDestAny, void * pSource,
     typelib_TypeDescriptionReference * pType, typelib_TypeDescription * pTypeDescr,
     uno_AcquireFunc acquire, uno_Mapping * mapping )
-    SAL_THROW ( () )
+    SAL_THROW (())
 {
     TYPE_ACQUIRE( pType );
     pDestAny->pType = pType;
@@ -339,7 +339,7 @@ inline void _copyConstructAny(
     uno_Any * pDestAny, void * pSource,
     typelib_TypeDescriptionReference * pType, typelib_TypeDescription * pTypeDescr,
     uno_AcquireFunc acquire, uno_Mapping * mapping )
-    SAL_THROW ( () )
+    SAL_THROW (())
 {
     if (typelib_TypeClass_VOID == pType->eTypeClass)
     {
@@ -718,7 +718,7 @@ inline void _copyConstructData(
     void * pDest, void * pSource,
     typelib_TypeDescriptionReference * pType, typelib_TypeDescription * pTypeDescr,
     uno_AcquireFunc acquire, uno_Mapping * mapping )
-    SAL_THROW ( () )
+    SAL_THROW (())
 {
     switch (pType->eTypeClass)
     {
diff --git a/cppu/source/uno/data.cxx b/cppu/source/uno/data.cxx
index 88634494b83c..1336a9b9132b 100644
--- a/cppu/source/uno/data.cxx
+++ b/cppu/source/uno/data.cxx
@@ -127,7 +127,7 @@ void * binuno_queryInterface( void * pUnoI, typelib_TypeDescriptionReference * p
 void defaultConstructStruct(
     void * pMem,
     typelib_CompoundTypeDescription * pCompType )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     _defaultConstructStruct( pMem, pCompType );
 }
@@ -136,7 +136,7 @@ void copyConstructStruct(
     void * pDest, void * pSource,
     typelib_CompoundTypeDescription * pTypeDescr,
     uno_AcquireFunc acquire, uno_Mapping * mapping )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     _copyConstructStruct( pDest, pSource, pTypeDescr, acquire, mapping );
 }
@@ -145,7 +145,7 @@ void destructStruct(
     void * pValue,
     typelib_CompoundTypeDescription * pTypeDescr,
     uno_ReleaseFunc release )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     _destructStruct( pValue, pTypeDescr, release );
 }
@@ -154,7 +154,7 @@ sal_Bool equalStruct(
     void * pDest, void *pSource,
     typelib_CompoundTypeDescription * pTypeDescr,
     uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return _equalStruct( pDest, pSource, pTypeDescr, queryInterface, release );
 }
@@ -163,7 +163,7 @@ sal_Bool assignStruct(
     void * pDest, void * pSource,
     typelib_CompoundTypeDescription * pTypeDescr,
     uno_QueryInterfaceFunc queryInterface, uno_AcquireFunc acquire, uno_ReleaseFunc release )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return _assignStruct( pDest, pSource, pTypeDescr, queryInterface, acquire, release );
 }
@@ -192,7 +192,7 @@ sal_Bool equalSequence(
     uno_Sequence * pDest, uno_Sequence * pSource,
     typelib_TypeDescriptionReference * pElementType,
     uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return _equalSequence( pDest, pSource, pElementType, queryInterface, release );
 }
diff --git a/cppu/source/uno/destr.hxx b/cppu/source/uno/destr.hxx
index 92da095f1ac1..0afd01163049 100644
--- a/cppu/source/uno/destr.hxx
+++ b/cppu/source/uno/destr.hxx
@@ -43,7 +43,7 @@ inline void _destructUnion(
     void * pValue,
     typelib_TypeDescription * pTypeDescr,
     uno_ReleaseFunc release )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     typelib_TypeDescriptionReference * pType = _unionGetSetType( pValue, pTypeDescr );
     ::uno_type_destructData(
@@ -56,13 +56,13 @@ void destructStruct(
     void * pValue,
     typelib_CompoundTypeDescription * pTypeDescr,
     uno_ReleaseFunc release )
-    SAL_THROW( () );
+    SAL_THROW(());
 //--------------------------------------------------------------------------------------------------
 inline void _destructStruct(
     void * pValue,
     typelib_CompoundTypeDescription * pTypeDescr,
     uno_ReleaseFunc release )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (pTypeDescr->pBaseTypeDescription)
     {
@@ -114,7 +114,7 @@ void destructSequence(
 inline void _destructAny(
     uno_Any * pAny,
     uno_ReleaseFunc release )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     typelib_TypeDescriptionReference * pType = pAny->pType;
 
@@ -196,7 +196,7 @@ inline sal_Int32 idestructElements(
     void * pElements, typelib_TypeDescriptionReference * pElementType,
     sal_Int32 nStartIndex, sal_Int32 nStopIndex,
     uno_ReleaseFunc release )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     switch (pElementType->eTypeClass)
     {
@@ -367,7 +367,7 @@ inline void _destructData(
     typelib_TypeDescriptionReference * pType,
     typelib_TypeDescription * pTypeDescr,
     uno_ReleaseFunc release )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     switch (pType->eTypeClass)
     {
diff --git a/cppu/source/uno/eq.hxx b/cppu/source/uno/eq.hxx
index fef81033cfa5..6fed374abd5e 100644
--- a/cppu/source/uno/eq.hxx
+++ b/cppu/source/uno/eq.hxx
@@ -46,7 +46,7 @@ namespace cppu
 inline sal_Bool _equalObject(
     void * pI1, void * pI2,
     uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (pI1 == pI2)
         return sal_True;
@@ -77,13 +77,13 @@ sal_Bool equalStruct(
     void * pDest, void *pSource,
     typelib_CompoundTypeDescription * pTypeDescr,
     uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
-    SAL_THROW( () );
+    SAL_THROW(());
 //--------------------------------------------------------------------------------------------------
 inline sal_Bool _equalStruct(
     void * pDest, void *pSource,
     typelib_CompoundTypeDescription * pTypeDescr,
     uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (pTypeDescr->pBaseTypeDescription &&
         !equalStruct( pDest, pSource, pTypeDescr->pBaseTypeDescription, queryInterface, release ))
@@ -114,13 +114,13 @@ sal_Bool equalSequence(
     uno_Sequence * pDest, uno_Sequence * pSource,
     typelib_TypeDescriptionReference * pElementType,
     uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
-    SAL_THROW( () );
+    SAL_THROW(());
 //--------------------------------------------------------------------------------------------------
 inline sal_Bool _equalSequence(
     uno_Sequence * pDest, uno_Sequence * pSource,
     typelib_TypeDescriptionReference * pElementType,
     uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (pDest == pSource)
         return sal_True;
@@ -305,7 +305,7 @@ inline sal_Bool _equalData(
     void * pSource,
     typelib_TypeDescriptionReference * pSourceType,
     uno_QueryInterfaceFunc queryInterface, uno_ReleaseFunc release )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     typelib_TypeClass eSourceTypeClass, eDestTypeClass;
     while (typelib_TypeClass_ANY == (eDestTypeClass = pDestType->eTypeClass))
diff --git a/cppu/source/uno/lbmap.cxx b/cppu/source/uno/lbmap.cxx
index 41add2c5276f..070e2dde8367 100644
--- a/cppu/source/uno/lbmap.cxx
+++ b/cppu/source/uno/lbmap.cxx
@@ -69,39 +69,39 @@ class Mapping
     uno_Mapping * _pMapping;
 
 public:
-    inline explicit Mapping( uno_Mapping * pMapping = 0 ) SAL_THROW( () );
-    inline Mapping( const Mapping & rMapping ) SAL_THROW( () );
-    inline ~Mapping() SAL_THROW( () );
-    inline Mapping & SAL_CALL operator = ( uno_Mapping * pMapping ) SAL_THROW( () );
-    inline Mapping & SAL_CALL operator = ( const Mapping & rMapping ) SAL_THROW( () )
+    inline explicit Mapping( uno_Mapping * pMapping = 0 ) SAL_THROW(());
+    inline Mapping( const Mapping & rMapping ) SAL_THROW(());
+    inline ~Mapping() SAL_THROW(());
+    inline Mapping & SAL_CALL operator = ( uno_Mapping * pMapping ) SAL_THROW(());
+    inline Mapping & SAL_CALL operator = ( const Mapping & rMapping ) SAL_THROW(())
         { return operator = ( rMapping._pMapping ); }
-    inline uno_Mapping * SAL_CALL get() const SAL_THROW( () )
+    inline uno_Mapping * SAL_CALL get() const SAL_THROW(())
         { return _pMapping; }
-    inline sal_Bool SAL_CALL is() const SAL_THROW( () )
+    inline sal_Bool SAL_CALL is() const SAL_THROW(())
         { return (_pMapping != 0); }
 };
 //__________________________________________________________________________________________________
-inline Mapping::Mapping( uno_Mapping * pMapping ) SAL_THROW( () )
+inline Mapping::Mapping( uno_Mapping * pMapping ) SAL_THROW(())
     : _pMapping( pMapping )
 {
     if (_pMapping)
         (*_pMapping->acquire)( _pMapping );
 }
 //__________________________________________________________________________________________________
-inline Mapping::Mapping( const Mapping & rMapping ) SAL_THROW( () )
+inline Mapping::Mapping( const Mapping & rMapping ) SAL_THROW(())
     : _pMapping( rMapping._pMapping )
 {
     if (_pMapping)
         (*_pMapping->acquire)( _pMapping );
 }
 //__________________________________________________________________________________________________
-inline Mapping::~Mapping() SAL_THROW( () )
+inline Mapping::~Mapping() SAL_THROW(())
 {
     if (_pMapping)
         (*_pMapping->release)( _pMapping );
 }
 //__________________________________________________________________________________________________
-inline Mapping & Mapping::operator = ( uno_Mapping * pMapping ) SAL_THROW( () )
+inline Mapping & Mapping::operator = ( uno_Mapping * pMapping ) SAL_THROW(())
 {
     if (pMapping)
         (*pMapping->acquire)( pMapping );
@@ -122,7 +122,7 @@ struct MappingEntry
     MappingEntry(
         uno_Mapping * pMapping_, uno_freeMappingFunc freeMapping_,
         const OUString & rMappingName_ )
-        SAL_THROW( () )
+        SAL_THROW(())
         : nRef( 1 )
         , pMapping( pMapping_ )
         , freeMapping( freeMapping_ )
@@ -132,13 +132,13 @@ struct MappingEntry
 //--------------------------------------------------------------------------------------------------
 struct FctOUStringHash : public std::unary_function< const OUString &, size_t >
 {
-    size_t operator()( const OUString & rKey ) const SAL_THROW( () )
+    size_t operator()( const OUString & rKey ) const SAL_THROW(())
         { return (size_t)rKey.hashCode(); }
 };
 //--------------------------------------------------------------------------------------------------
 struct FctPtrHash : public std::unary_function< uno_Mapping *, size_t >
 {
-    size_t operator()( uno_Mapping * pKey ) const SAL_THROW( () )
+    size_t operator()( uno_Mapping * pKey ) const SAL_THROW(())
         { return (size_t)pKey; }
 };
 
@@ -164,7 +164,7 @@ struct MappingsData
     t_OUStringSet       aNegativeLibs;
 };
 //--------------------------------------------------------------------------------------------------
-static MappingsData & getMappingsData() SAL_THROW( () )
+static MappingsData & getMappingsData() SAL_THROW(())
 {
     static MappingsData * s_p = 0;
     if (! s_p)
@@ -200,19 +200,19 @@ struct uno_Mediate_Mapping : public uno_Mapping
         const Environment & rFrom_, const Environment & rTo_,
         const Mapping & rFrom2Uno_, const Mapping & rUno2To_,
         const OUString & rAddPurpose )
-        SAL_THROW( () );
+        SAL_THROW(());
 };
 extern "C"
 {
 //--------------------------------------------------------------------------------------------------
 static void SAL_CALL mediate_free( uno_Mapping * pMapping )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     delete static_cast< uno_Mediate_Mapping * >( pMapping );
 }
 //--------------------------------------------------------------------------------------------------
 static void SAL_CALL mediate_acquire( uno_Mapping * pMapping )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (1 == ::osl_incrementInterlockedCount(
         & static_cast< uno_Mediate_Mapping * >( pMapping )->nRef ))
@@ -226,7 +226,7 @@ static void SAL_CALL mediate_acquire( uno_Mapping * pMapping )
 }
 //--------------------------------------------------------------------------------------------------
 static void SAL_CALL mediate_release( uno_Mapping * pMapping )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (! ::osl_decrementInterlockedCount(
         & static_cast< uno_Mediate_Mapping * >( pMapping )->nRef ))
@@ -239,7 +239,7 @@ static void SAL_CALL mediate_mapInterface(
     uno_Mapping * pMapping,
     void ** ppOut, void * pInterface,
     typelib_InterfaceTypeDescription * pInterfaceTypeDescr )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     OSL_ENSURE( pMapping && ppOut, "### null ptr!" );
     if (pMapping && ppOut)
@@ -275,7 +275,7 @@ uno_Mediate_Mapping::uno_Mediate_Mapping(
     const Environment & rFrom_, const Environment & rTo_,
     const Mapping & rFrom2Uno_, const Mapping & rUno2To_,
     const OUString & rAddPurpose_ )
-    SAL_THROW( () )
+    SAL_THROW(())
     : nRef( 1 )
     , aFrom( rFrom_ )
     , aTo( rTo_ )
@@ -291,7 +291,7 @@ uno_Mediate_Mapping::uno_Mediate_Mapping(
 //==================================================================================================
 static inline OUString getMappingName(
     const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     OUStringBuffer aKey( 64 );
     aKey.append( rAddPurpose );
@@ -309,7 +309,7 @@ static inline OUString getMappingName(
 //==================================================================================================
 static inline OUString getBridgeName(
     const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     OUStringBuffer aBridgeName( 16 );
     if (!rAddPurpose.isEmpty())
@@ -324,7 +324,7 @@ static inline OUString getBridgeName(
 }
 //==================================================================================================
 static inline void setNegativeBridge( const OUString & rBridgeName )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     MappingsData & rData = getMappingsData();
     MutexGuard aGuard( rData.aNegativeLibsMutex );
@@ -332,7 +332,7 @@ static inline void setNegativeBridge( const OUString & rBridgeName )
 }
 //==================================================================================================
 static inline oslModule loadModule( const OUString & rBridgeName )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     sal_Bool bNeg;
     {
@@ -356,7 +356,7 @@ static inline oslModule loadModule( const OUString & rBridgeName )
 //==================================================================================================
 static Mapping loadExternalMapping(
     const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     OSL_ASSERT( rFrom.is() && rTo.is() );
     if (rFrom.is() && rTo.is())
@@ -400,7 +400,7 @@ static Mapping loadExternalMapping(
 //==================================================================================================
 static Mapping getDirectMapping(
     const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose = OUString() )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     OSL_ASSERT( rFrom.is() && rTo.is() );
     if (rFrom.is() && rTo.is())
@@ -430,7 +430,7 @@ static inline Mapping createMediateMapping(
     const Environment & rFrom, const Environment & rTo,
     const Mapping & rFrom2Uno, const Mapping & rUno2To,
     const OUString & rAddPurpose )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     uno_Mapping * pRet = new uno_Mediate_Mapping(
         rFrom, rTo, rFrom2Uno, rUno2To, rAddPurpose ); // ref count initially 1
@@ -443,7 +443,7 @@ static inline Mapping createMediateMapping(
 //==================================================================================================
 static Mapping getMediateMapping(
     const Environment & rFrom, const Environment & rTo, const OUString & rAddPurpose )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     Environment aUno;
     Mapping aUno2To;
diff --git a/cppu/source/uno/prim.hxx b/cppu/source/uno/prim.hxx
index 81f6f3148173..b7871b078202 100644
--- a/cppu/source/uno/prim.hxx
+++ b/cppu/source/uno/prim.hxx
@@ -58,7 +58,7 @@ inline void * _map(
     void * p,
     typelib_TypeDescriptionReference * pType, typelib_TypeDescription * pTypeDescr,
     uno_Mapping * mapping )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     void * pRet = 0;
     if (p)
@@ -79,7 +79,7 @@ inline void * _map(
     return pRet;
 }
 //--------------------------------------------------------------------------------------------------
-inline void _acquire( void * p, uno_AcquireFunc acquire ) SAL_THROW( () )
+inline void _acquire( void * p, uno_AcquireFunc acquire ) SAL_THROW(())
 {
     if (p)
     {
@@ -94,7 +94,7 @@ inline void _acquire( void * p, uno_AcquireFunc acquire ) SAL_THROW( () )
     }
 }
 //--------------------------------------------------------------------------------------------------
-inline void _release( void * p, uno_ReleaseFunc release ) SAL_THROW( () )
+inline void _release( void * p, uno_ReleaseFunc release ) SAL_THROW(())
 {
     if (p)
     {
@@ -123,14 +123,14 @@ inline sal_uInt32 calcSeqMemSize(
 }
 
 //--------------------------------------------------------------------------------------------------
-inline uno_Sequence * createEmptySequence() SAL_THROW( () )
+inline uno_Sequence * createEmptySequence() SAL_THROW(())
 {
     ::osl_incrementInterlockedCount( &g_emptySeq.nRefCount );
     return &g_emptySeq;
 }
 //--------------------------------------------------------------------------------------------------
 inline typelib_TypeDescriptionReference * _getVoidType()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (! g_pVoidType)
     {
@@ -162,7 +162,7 @@ extern "C" void * binuno_queryInterface(
 //--------------------------------------------------------------------------------------------------
 inline typelib_TypeDescriptionReference * _unionGetSetType(
     void * pUnion, typelib_TypeDescription * pTD )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     typelib_TypeDescriptionReference * pRet = 0;
     sal_Int32 nPos;
@@ -188,7 +188,7 @@ inline typelib_TypeDescriptionReference * _unionGetSetType(
 //--------------------------------------------------------------------------------------------------
 inline sal_Bool _type_equals(
     typelib_TypeDescriptionReference * pType1, typelib_TypeDescriptionReference * pType2 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return (pType1 == pType2 ||
             (pType1->eTypeClass == pType2->eTypeClass &&