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

author: Alexander Bergmann <myaddons@gmx.de> 2012-01-26 16:00:09 +0100
committer: Michael Meeks <michael.meeks@suse.com> 2012-01-26 17:41:07 +0000
commit: 0439af27e1f37b19d4409f34f974d6ade49f99bf (patch)
tree: 13bbb2549319d74a1a109bf2727aab37dca5b8c7 /cppuhelper
parent: f1cb0a4ab4f11dc015be1696c7c7751802171915 (diff)
34 files changed, 352 insertions, 352 deletions
diff --git a/cppuhelper/inc/cppuhelper/access_control.hxx b/cppuhelper/inc/cppuhelper/access_control.hxx
index 4910adb57261..518f45d594a7 100644
--- a/cppuhelper/inc/cppuhelper/access_control.hxx
+++ b/cppuhelper/inc/cppuhelper/access_control.hxx
@@ -68,7 +68,7 @@ public:
 
     /** Clears the access controller reference being used.
     */
-    inline void SAL_CALL clear() SAL_THROW( () )
+    inline void SAL_CALL clear() SAL_THROW(())
         { m_xController.clear(); }
 
     /** Returns access to the access controller reference being used.
@@ -76,14 +76,14 @@ public:
         @return access controller
     */
     inline ::com::sun::star::uno::Reference<
-        ::com::sun::star::security::XAccessController > const & SAL_CALL get() const SAL_THROW( () )
+        ::com::sun::star::security::XAccessController > const & SAL_CALL get() const SAL_THROW(())
         { return m_xController; }
 
     /** Returns access to the access controller reference being used.
 
         @return access controller
     */
-    inline ::com::sun::star::security::XAccessController * SAL_CALL operator -> () const SAL_THROW( () )
+    inline ::com::sun::star::security::XAccessController * SAL_CALL operator -> () const SAL_THROW(())
         { return m_xController.get(); }
 
 
diff --git a/cppuhelper/inc/cppuhelper/bootstrap.hxx b/cppuhelper/inc/cppuhelper/bootstrap.hxx
index 41c69ad3cc0e..319854a14960 100644
--- a/cppuhelper/inc/cppuhelper/bootstrap.hxx
+++ b/cppuhelper/inc/cppuhelper/bootstrap.hxx
@@ -52,7 +52,7 @@ namespace cppu
 CPPUHELPER_DLLPUBLIC ::com::sun::star::uno::Reference< ::com::sun::star::registry::XSimpleRegistry >
 SAL_CALL createSimpleRegistry(
     const ::rtl::OUString & rBootstrapPath = ::rtl::OUString() )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 /** Creates a nested registry service instance.
 
@@ -62,7 +62,7 @@ SAL_CALL createSimpleRegistry(
 CPPUHELPER_DLLPUBLIC ::com::sun::star::uno::Reference< ::com::sun::star::registry::XSimpleRegistry >
 SAL_CALL createNestedRegistry(
     const ::rtl::OUString & rBootstrapPath = ::rtl::OUString() )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 /** Installs type description manager instance, i.e. registers a callback at cppu core.
 
@@ -71,7 +71,7 @@ SAL_CALL createNestedRegistry(
 */
 CPPUHELPER_DLLPUBLIC sal_Bool SAL_CALL installTypeDescriptionManager(
     ::com::sun::star::uno::Reference< ::com::sun::star::container::XHierarchicalNameAccess > const & xTDMgr )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 /** Bootstraps an initial component context with service manager upon a given registry.
     This includes insertion of initial services:
diff --git a/cppuhelper/inc/cppuhelper/compbase.hxx b/cppuhelper/inc/cppuhelper/compbase.hxx
index eb57e18fd4b7..60e99eef3840 100644
--- a/cppuhelper/inc/cppuhelper/compbase.hxx
+++ b/cppuhelper/inc/cppuhelper/compbase.hxx
@@ -47,7 +47,7 @@ class SAL_NO_VTABLE WeakComponentImplHelper##N \
 { \
     static ClassData##N s_aCD; \
 public: \
-    WeakComponentImplHelper##N( ::osl::Mutex & rMutex ) SAL_THROW( () ) \
+    WeakComponentImplHelper##N( ::osl::Mutex & rMutex ) SAL_THROW(()) \
         : WeakComponentImplHelperBase( rMutex ) \
         {} \
     virtual ::com::sun::star::uno::Any SAL_CALL queryInterface( ::com::sun::star::uno::Type const & rType ) throw (::com::sun::star::uno::RuntimeException) \
@@ -73,7 +73,7 @@ class SAL_NO_VTABLE WeakAggComponentImplHelper##N \
 { \
     static ClassData##N s_aCD; \
 public: \
-    WeakAggComponentImplHelper##N( ::osl::Mutex & rMutex ) SAL_THROW( () ) \
+    WeakAggComponentImplHelper##N( ::osl::Mutex & rMutex ) SAL_THROW(()) \
         : WeakAggComponentImplHelperBase( rMutex ) \
         {} \
     virtual ::com::sun::star::uno::Any SAL_CALL queryInterface( ::com::sun::star::uno::Type const & rType ) throw (::com::sun::star::uno::RuntimeException) \
diff --git a/cppuhelper/inc/cppuhelper/compbase_ex.hxx b/cppuhelper/inc/cppuhelper/compbase_ex.hxx
index ca7e0ccfdefa..0eff32185105 100644
--- a/cppuhelper/inc/cppuhelper/compbase_ex.hxx
+++ b/cppuhelper/inc/cppuhelper/compbase_ex.hxx
@@ -59,20 +59,20 @@ protected:
 
         @param rMutex mutex to sync upon disposing
     */
-    WeakComponentImplHelperBase( ::osl::Mutex & rMutex ) SAL_THROW( () );
+    WeakComponentImplHelperBase( ::osl::Mutex & rMutex ) SAL_THROW(());
 public:
     /** Destructor
     */
-    virtual ~WeakComponentImplHelperBase() SAL_THROW( () );
+    virtual ~WeakComponentImplHelperBase() SAL_THROW(());
 
     // 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(())
         {}
 
     virtual ::com::sun::star::uno::Any SAL_CALL queryInterface(
@@ -106,18 +106,18 @@ protected:
     */
     virtual void SAL_CALL disposing();
 
-    WeakAggComponentImplHelperBase( ::osl::Mutex & rMutex ) SAL_THROW( () );
+    WeakAggComponentImplHelperBase( ::osl::Mutex & rMutex ) SAL_THROW(());
 public:
-    virtual ~WeakAggComponentImplHelperBase() SAL_THROW( () );
+    virtual ~WeakAggComponentImplHelperBase() SAL_THROW(());
 
     // 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(())
         {}
 
     virtual ::com::sun::star::uno::Any SAL_CALL queryInterface(
diff --git a/cppuhelper/inc/cppuhelper/component.hxx b/cppuhelper/inc/cppuhelper/component.hxx
index ccbddc0e0aae..64c6a63693c5 100644
--- a/cppuhelper/inc/cppuhelper/component.hxx
+++ b/cppuhelper/inc/cppuhelper/component.hxx
@@ -63,7 +63,7 @@ public:
         the mutex used to protect multi-threaded access;
         lifetime must be longer than the lifetime of this object.
     */
-    OComponentHelper( ::osl::Mutex & rMutex ) SAL_THROW( () );
+    OComponentHelper( ::osl::Mutex & rMutex ) SAL_THROW(());
     /** Destructor. If this object was not disposed previously, object will be disposed manually.
     */
     virtual ~OComponentHelper() SAL_THROW( (::com::sun::star::uno::RuntimeException) );
@@ -111,8 +111,8 @@ protected:
     /// @endcond
 
 private:
-    inline OComponentHelper( const OComponentHelper & ) SAL_THROW( () );
-    inline OComponentHelper & operator = ( const OComponentHelper & ) SAL_THROW( () );
+    inline OComponentHelper( const OComponentHelper & ) SAL_THROW(());
+    inline OComponentHelper & operator = ( const OComponentHelper & ) SAL_THROW(());
 };
 
 }
diff --git a/cppuhelper/inc/cppuhelper/component_context.hxx b/cppuhelper/inc/cppuhelper/component_context.hxx
index bcb02c705555..06e1f264394d 100644
--- a/cppuhelper/inc/cppuhelper/component_context.hxx
+++ b/cppuhelper/inc/cppuhelper/component_context.hxx
@@ -56,7 +56,7 @@ struct ContextEntry_Init
 
     /** Default ctor.
     */
-    inline ContextEntry_Init() SAL_THROW( () )
+    inline ContextEntry_Init() SAL_THROW(())
         : bLateInitService( false )
         {}
     /** Ctor.
@@ -72,7 +72,7 @@ struct ContextEntry_Init
     inline ContextEntry_Init(
         ::rtl::OUString const & name_,
         ::com::sun::star::uno::Any const & value_,
-        bool bLateInitService_ = false ) SAL_THROW( () )
+        bool bLateInitService_ = false ) SAL_THROW(())
             : bLateInitService( bLateInitService_ ),
               name( name_ ),
               value( value_ )
@@ -91,7 +91,7 @@ SAL_CALL createComponentContext(
     ContextEntry_Init const * pEntries, sal_Int32 nEntries,
     ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext > const & xDelegate =
     ::com::sun::star::uno::Reference< ::com::sun::star::uno::XComponentContext >() )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 }
 
diff --git a/cppuhelper/inc/cppuhelper/factory.hxx b/cppuhelper/inc/cppuhelper/factory.hxx
index 2653908c9ba2..c100eab61d55 100644
--- a/cppuhelper/inc/cppuhelper/factory.hxx
+++ b/cppuhelper/inc/cppuhelper/factory.hxx
@@ -150,7 +150,7 @@ SAL_CALL createSingleComponentFactory(
     ::rtl::OUString const & rImplementationName,
     ::com::sun::star::uno::Sequence< ::rtl::OUString > const & rServiceNames,
     rtl_ModuleCount * pModCount = 0 )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 /** Creates a single service factory which holds the instance created only once.
 
@@ -167,7 +167,7 @@ createOneInstanceComponentFactory(
     ::rtl::OUString const & rImplementationName,
     ::com::sun::star::uno::Sequence< ::rtl::OUString > const & rServiceNames,
     rtl_ModuleCount * pModCount = 0 )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 /** Deprecated.  The type of the instanciate function used as argument of the create*Fcatory functions.
 
@@ -198,7 +198,7 @@ createSingleFactory(
     ComponentInstantiation pCreateFunction,
     const ::com::sun::star::uno::Sequence< ::rtl::OUString > & rServiceNames,
     rtl_ModuleCount * pModCount = 0  )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 /** Deprecated.  Creates a factory wrapping another one.
     This means the methods of the interfaces XServiceProvider, XServiceInfo and
@@ -218,7 +218,7 @@ CPPUHELPER_DLLPUBLIC ::com::sun::star::uno::Reference< ::com::sun::star::lang::X
 createFactoryProxy(
     const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > & rServiceManager,
     const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XSingleServiceFactory > & rFactory )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 /** Deprecated.  Creates a single service factory which holds the instance created only once.
 
@@ -240,7 +240,7 @@ createOneInstanceFactory(
     ComponentInstantiation pCreateFunction,
     const ::com::sun::star::uno::Sequence< ::rtl::OUString > & rServiceNames,
     rtl_ModuleCount * pModCount = 0  )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 /** Deprecated.  Creates a single service factory based on a registry.
 
@@ -256,7 +256,7 @@ createSingleRegistryFactory(
     const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > & rServiceManager,
     const ::rtl::OUString & rImplementationName,
     const ::com::sun::star::uno::Reference< ::com::sun::star::registry::XRegistryKey > & rImplementationKey )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 /** Deprecated.  Creates a single service factory which holds the instance created only once
     based on a registry.
@@ -275,7 +275,7 @@ createOneInstanceRegistryFactory(
     const ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > & rServiceManager,
     const ::rtl::OUString & rComponentName,
     const ::com::sun::star::uno::Reference< ::com::sun::star::registry::XRegistryKey > & rImplementationKey )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 }
 
diff --git a/cppuhelper/inc/cppuhelper/implbase.hxx b/cppuhelper/inc/cppuhelper/implbase.hxx
index f7fe3a228853..06506d3092a4 100644
--- a/cppuhelper/inc/cppuhelper/implbase.hxx
+++ b/cppuhelper/inc/cppuhelper/implbase.hxx
@@ -89,15 +89,15 @@ struct CPPUHELPER_DLLPUBLIC ClassDataBase
 
     /** def ctor
     */
-    ClassDataBase() SAL_THROW( () );
+    ClassDataBase() SAL_THROW(());
     /** class code ctor
 
         @param nClassCode class code, see ClassDataBase::nClassCode
     */
-    ClassDataBase( sal_Int32 nClassCode ) SAL_THROW( () );
+    ClassDataBase( sal_Int32 nClassCode ) SAL_THROW(());
     /** dtor
     */
-    ~ClassDataBase() SAL_THROW( () );
+    ~ClassDataBase() SAL_THROW(());
 };
 /** Struct used for inline template implementation helpers:
     There will be versions of this struct with varying arType2Offset[] array sizes, each of which
@@ -113,14 +113,14 @@ struct CPPUHELPER_DLLPUBLIC ClassData : public ClassDataBase
 
     /** init call for supporting com.sun.star.lang.XTypeProvider
     */
-    void SAL_CALL initTypeProvider() SAL_THROW( () );
+    void SAL_CALL initTypeProvider() SAL_THROW(());
     /** initial writing type offsets for vtables
 
         @param rType type of interface
         @param nOffset offset to vtable entry
     */
     void SAL_CALL writeTypeOffset( const ::com::sun::star::uno::Type & rType, sal_Int32 nOffset )
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /** Queries for an interface.
 
@@ -130,25 +130,25 @@ struct CPPUHELPER_DLLPUBLIC ClassData : public ClassDataBase
     */
     ::com::sun::star::uno::Any SAL_CALL query(
         const ::com::sun::star::uno::Type & rType, ::com::sun::star::lang::XTypeProvider * pBase )
-        SAL_THROW( () );
+        SAL_THROW(());
     /** Gets the types for supporting com.sun.star.lang.XTypeProvider
 
         @return sequence of types supported
     */
     ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL getTypes()
-        SAL_THROW( () );
+        SAL_THROW(());
     /** Gets the class id of implementation supporting com.sun.star.lang.XTypeProvider
 
         @return class identifier (sequence< byte >)
     */
     ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId()
-        SAL_THROW( () );
+        SAL_THROW(());
 };
 
 /** Shared mutex for implementation helper initialization.
     Not for public use.
 */
-CPPUHELPER_DLLPUBLIC ::osl::Mutex & SAL_CALL getImplHelperInitMutex(void) SAL_THROW( () );
+CPPUHELPER_DLLPUBLIC ::osl::Mutex & SAL_CALL getImplHelperInitMutex(void) SAL_THROW(());
 }
 
 //
@@ -176,7 +176,7 @@ namespace cppu \
 struct ClassData##N : public ClassDataBase \
 { \
     Type_Offset arType2Offset[ N ]; \
-    ClassData##N( sal_Int32 nInClassCode ) SAL_THROW( () ) \
+    ClassData##N( sal_Int32 nInClassCode ) SAL_THROW(()) \
         : ClassDataBase( nInClassCode ) \
         {} \
 }; \
@@ -186,7 +186,7 @@ class SAL_NO_VTABLE ImplHelperBase##N \
     , __PUBLIC_IFC##N \
 { \
 protected: \
-    ClassData & SAL_CALL getClassData( ClassDataBase & s_aCD ) SAL_THROW( () ) \
+    ClassData & SAL_CALL getClassData( ClassDataBase & s_aCD ) SAL_THROW(()) \
     { \
         ClassData & rCD = * static_cast< ClassData * >( &s_aCD ); \
         if (! rCD.bOffsetsInit) \
diff --git a/cppuhelper/inc/cppuhelper/implbase_ex.hxx b/cppuhelper/inc/cppuhelper/implbase_ex.hxx
index 55bfd28c67e5..ba70e8d103e4 100644
--- a/cppuhelper/inc/cppuhelper/implbase_ex.hxx
+++ b/cppuhelper/inc/cppuhelper/implbase_ex.hxx
@@ -55,7 +55,7 @@ namespace cppu
 
 /** function pointer signature for getCppuType
 */
-typedef ::com::sun::star::uno::Type const & (SAL_CALL * fptr_getCppuType)( void * ) SAL_THROW( () );
+typedef ::com::sun::star::uno::Type const & (SAL_CALL * fptr_getCppuType)( void * ) SAL_THROW(());
 
 /** single type + object offset
 */
diff --git a/cppuhelper/inc/cppuhelper/implbase_ex_post.hxx b/cppuhelper/inc/cppuhelper/implbase_ex_post.hxx
index eaa9280918b5..04353f451532 100644
--- a/cppuhelper/inc/cppuhelper/implbase_ex_post.hxx
+++ b/cppuhelper/inc/cppuhelper/implbase_ex_post.hxx
@@ -181,7 +181,7 @@ class SAL_NO_VTABLE WeakComponentImplHelper##N \
 { \
     static class_data##N s_cd; \
 public: \
-    inline WeakComponentImplHelper##N( ::osl::Mutex & rMutex ) SAL_THROW( () ) \
+    inline WeakComponentImplHelper##N( ::osl::Mutex & rMutex ) SAL_THROW(()) \
         : WeakComponentImplHelperBase( rMutex ) \
         {} \
     virtual ::com::sun::star::uno::Any SAL_CALL queryInterface( ::com::sun::star::uno::Type const & rType ) throw (::com::sun::star::uno::RuntimeException) \
@@ -206,7 +206,7 @@ class SAL_NO_VTABLE WeakAggComponentImplHelper##N \
 { \
     static class_data##N s_cd; \
 public: \
-    inline WeakAggComponentImplHelper##N( ::osl::Mutex & rMutex ) SAL_THROW( () ) \
+    inline WeakAggComponentImplHelper##N( ::osl::Mutex & rMutex ) SAL_THROW(()) \
         : WeakAggComponentImplHelperBase( rMutex ) \
         {} \
     virtual ::com::sun::star::uno::Any SAL_CALL queryInterface( ::com::sun::star::uno::Type const & rType ) throw (::com::sun::star::uno::RuntimeException) \
diff --git a/cppuhelper/inc/cppuhelper/interfacecontainer.h b/cppuhelper/inc/cppuhelper/interfacecontainer.h
index 454013c9c282..8282893ec851 100644
--- a/cppuhelper/inc/cppuhelper/interfacecontainer.h
+++ b/cppuhelper/inc/cppuhelper/interfacecontainer.h
@@ -82,28 +82,28 @@ public:
 
        @param rCont the container of the elements.
      */
-    OInterfaceIteratorHelper( OInterfaceContainerHelper & rCont ) SAL_THROW( () );
+    OInterfaceIteratorHelper( OInterfaceContainerHelper & rCont ) SAL_THROW(());
 
     /**
       Releases the connection to the container.
      */
-    ~OInterfaceIteratorHelper() SAL_THROW( () );
+    ~OInterfaceIteratorHelper() SAL_THROW(());
 
     /** Return sal_True, if there are more elements in the iterator. */
-    sal_Bool SAL_CALL hasMoreElements() const SAL_THROW( () )
+    sal_Bool SAL_CALL hasMoreElements() const SAL_THROW(())
         { return nRemain != 0; }
     /** Return the next element of the iterator. Calling this method if
         hasMoreElements() has returned sal_False, is an error. Cast the
         returned pointer to the
      */
-    ::com::sun::star::uno::XInterface * SAL_CALL next() SAL_THROW( () );
+    ::com::sun::star::uno::XInterface * SAL_CALL next() SAL_THROW(());
 
     /** Removes the current element (the last one returned by next())
         from the underlying container. Calling this method before
         next() has been called or calling it twice with no next()
         inbetween is an error.
     */
-    void SAL_CALL remove() SAL_THROW( () );
+    void SAL_CALL remove() SAL_THROW(());
 
 private:
     OInterfaceContainerHelper & rCont;
@@ -113,8 +113,8 @@ private:
 
     sal_Int32                   nRemain;
 
-    OInterfaceIteratorHelper( const OInterfaceIteratorHelper & ) SAL_THROW( () );
-    OInterfaceIteratorHelper &  operator = ( const OInterfaceIteratorHelper & ) SAL_THROW( () );
+    OInterfaceIteratorHelper( const OInterfaceIteratorHelper & ) SAL_THROW(());
+    OInterfaceIteratorHelper &  operator = ( const OInterfaceIteratorHelper & ) SAL_THROW(());
 };
 
 //===================================================================
@@ -128,13 +128,13 @@ class CPPUHELPER_DLLPUBLIC OInterfaceContainerHelper
 {
 public:
     // 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(())
         {}
 
     /**
@@ -144,22 +144,22 @@ public:
        The lifetime must be longer than the lifetime
        of this object.
      */
-    OInterfaceContainerHelper( ::osl::Mutex & rMutex ) SAL_THROW( () );
+    OInterfaceContainerHelper( ::osl::Mutex & rMutex ) SAL_THROW(());
     /**
       Release all interfaces. All iterators must be destroyed before
       the container is destructed.
      */
-    ~OInterfaceContainerHelper() SAL_THROW( () );
+    ~OInterfaceContainerHelper() SAL_THROW(());
     /**
       Return the number of Elements in the container. Only useful if you have acquired
       the mutex.
      */
-    sal_Int32 SAL_CALL getLength() const SAL_THROW( () );
+    sal_Int32 SAL_CALL getLength() const SAL_THROW(());
 
     /**
       Return all interfaces added to this container.
      **/
-    ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > > SAL_CALL getElements() const SAL_THROW( () );
+    ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > > SAL_CALL getElements() const SAL_THROW(());
 
     /** Inserts an element into the container.  The position is not specified, thus it is not
         specified in which order events are fired.
@@ -177,7 +177,7 @@ public:
         @return
                 the new count of elements in the container
     */
-    sal_Int32 SAL_CALL addInterface( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > & rxIFace ) SAL_THROW( () );
+    sal_Int32 SAL_CALL addInterface( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > & rxIFace ) SAL_THROW(());
     /** Removes an element from the container.  It uses interface equality to remove the interface.
 
         @param rxIFace
@@ -185,16 +185,16 @@ public:
         @return
                 the new count of elements in the container
     */
-    sal_Int32 SAL_CALL removeInterface( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > & rxIFace ) SAL_THROW( () );
+    sal_Int32 SAL_CALL removeInterface( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > & rxIFace ) SAL_THROW(());
     /**
       Call disposing on all object in the container that
       support XEventListener. Than clear the container.
      */
-    void SAL_CALL disposeAndClear( const ::com::sun::star::lang::EventObject & rEvt ) SAL_THROW( () );
+    void SAL_CALL disposeAndClear( const ::com::sun::star::lang::EventObject & rEvt ) SAL_THROW(());
     /**
       Clears the container without calling disposing().
      */
-    void SAL_CALL clear() SAL_THROW( () );
+    void SAL_CALL clear() SAL_THROW(());
 
     /** Executes a functor for each contained listener of specified type, e.g.
         <code>forEach<awt::XPaintListener>(...</code>.
@@ -247,14 +247,14 @@ friend class OInterfaceIteratorHelper;
     /** TRUE -> aData.pAsSequence is of type Sequence< XInterfaceSequence >. */
     sal_Bool                bIsList;
 
-    OInterfaceContainerHelper( const OInterfaceContainerHelper & ) SAL_THROW( () );
-    OInterfaceContainerHelper & operator = ( const OInterfaceContainerHelper & ) SAL_THROW( () );
+    OInterfaceContainerHelper( const OInterfaceContainerHelper & ) SAL_THROW(());
+    OInterfaceContainerHelper & operator = ( const OInterfaceContainerHelper & ) SAL_THROW(());
 
     /*
       Dulicate content of the conaitner and release the old one without destroying.
       The mutex must be locked and the memberbInUse must be true.
      */
-    void copyAndResetInUse() SAL_THROW( () );
+    void copyAndResetInUse() SAL_THROW(());
 
 private:
     template< typename ListenerT, typename EventT >
@@ -315,13 +315,13 @@ class OMultiTypeInterfaceContainerHelperVar
 {
 public:
     // 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(())
         {}
 
     /**
@@ -331,16 +331,16 @@ public:
                          The lifetime must be longer than the lifetime
                          of this object.
      */
-    inline OMultiTypeInterfaceContainerHelperVar( ::osl::Mutex & ) SAL_THROW( () );
+    inline OMultiTypeInterfaceContainerHelperVar( ::osl::Mutex & ) SAL_THROW(());
     /**
       Deletes all containers.
      */
-    inline ~OMultiTypeInterfaceContainerHelperVar() SAL_THROW( () );
+    inline ~OMultiTypeInterfaceContainerHelperVar() SAL_THROW(());
 
     /**
       Return all id's under which at least one interface is added.
      */
-    inline ::com::sun::star::uno::Sequence< key > SAL_CALL getContainedTypes() const SAL_THROW( () );
+    inline ::com::sun::star::uno::Sequence< key > SAL_CALL getContainedTypes() const SAL_THROW(());
 
     /**
       Return the container created under this key.
@@ -348,7 +348,7 @@ public:
       @return the container created under this key. If the container
                  was not created, null was returned.
      */
-    inline OInterfaceContainerHelper * SAL_CALL getContainer( const key & ) const SAL_THROW( () );
+    inline OInterfaceContainerHelper * SAL_CALL getContainer( const key & ) const SAL_THROW(());
 
     /** Inserts an element into the container with the specified key.
         The position is not specified, thus it is not specified in which order events are fired.
@@ -371,7 +371,7 @@ public:
     inline sal_Int32 SAL_CALL addInterface(
         const key & rKey,
         const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > & r )
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /** Removes an element from the container with the specified key.
         It uses interface equality to remove the interface.
@@ -386,18 +386,18 @@ public:
     inline sal_Int32 SAL_CALL removeInterface(
         const key & rKey,
         const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > & rxIFace )
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /**
       Call disposing on all references in the container, that
       support XEventListener. Then clears the container.
       @param rEvt the event object which is passed during disposing() call
      */
-    inline void SAL_CALL disposeAndClear( const ::com::sun::star::lang::EventObject & rEvt ) SAL_THROW( () );
+    inline void SAL_CALL disposeAndClear( const ::com::sun::star::lang::EventObject & rEvt ) SAL_THROW(());
     /**
       Remove all elements of all containers. Does not delete the container.
      */
-    inline void SAL_CALL clear() SAL_THROW( () );
+    inline void SAL_CALL clear() SAL_THROW(());
 
     typedef key keyType;
 private:
@@ -420,8 +420,8 @@ private:
         return iter;
     }
 
-    inline OMultiTypeInterfaceContainerHelperVar( const OMultiTypeInterfaceContainerHelperVar & ) SAL_THROW( () );
-    inline OMultiTypeInterfaceContainerHelperVar & operator = ( const OMultiTypeInterfaceContainerHelperVar & ) SAL_THROW( () );
+    inline OMultiTypeInterfaceContainerHelperVar( const OMultiTypeInterfaceContainerHelperVar & ) SAL_THROW(());
+    inline OMultiTypeInterfaceContainerHelperVar & operator = ( const OMultiTypeInterfaceContainerHelperVar & ) SAL_THROW(());
 };
 
 
@@ -452,7 +452,7 @@ struct OBroadcastHelperVar
       Initialize the structur. bDispose and bInDispose are set to false.
       @param rMutex the mutex reference.
      */
-    OBroadcastHelperVar( ::osl::Mutex & rMutex_ ) SAL_THROW( () )
+    OBroadcastHelperVar( ::osl::Mutex & rMutex_ ) SAL_THROW(())
         : rMutex( rMutex_ )
         , aLC( rMutex_ )
         , bDisposed( sal_False )
@@ -465,7 +465,7 @@ struct OBroadcastHelperVar
     inline void addListener(
         const keyType &key,
         const ::com::sun::star::uno::Reference < ::com::sun::star::uno::XInterface > &r )
-        SAL_THROW( () )
+        SAL_THROW(())
     {
         ::osl::MutexGuard guard( rMutex );
         OSL_ENSURE( !bInDispose, "do not add listeners in the dispose call" );
@@ -480,7 +480,7 @@ struct OBroadcastHelperVar
     inline void removeListener(
         const keyType &key,
         const ::com::sun::star::uno::Reference < ::com::sun::star::uno::XInterface > & r )
-        SAL_THROW( () )
+        SAL_THROW(())
     {
         ::osl::MutexGuard guard( rMutex );
         OSL_ENSURE( !bDisposed, "object is disposed" );
@@ -494,7 +494,7 @@ struct OBroadcastHelperVar
                 was not created, null was returned. This can be used to optimize
               performance ( construction of an event object can be avoided ).
      ***/
-    inline OInterfaceContainerHelper * SAL_CALL getContainer( const keyType &key ) const SAL_THROW( () )
+    inline OInterfaceContainerHelper * SAL_CALL getContainer( const keyType &key ) const SAL_THROW(())
         { return aLC.getContainer( key ); }
 };
 
@@ -508,7 +508,7 @@ struct OBroadcastHelperVar
 // helper function call class
 struct hashType_Impl
 {
-    size_t operator()(const ::com::sun::star::uno::Type & s) const SAL_THROW( () )
+    size_t operator()(const ::com::sun::star::uno::Type & s) const SAL_THROW(())
         { return s.getTypeName().hashCode(); }
 };
 
@@ -520,13 +520,13 @@ class CPPUHELPER_DLLPUBLIC OMultiTypeInterfaceContainerHelper
 {
 public:
     // 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(())
         {}
 
     /**
@@ -536,23 +536,23 @@ public:
                          The lifetime must be longer than the lifetime
                          of this object.
      */
-    OMultiTypeInterfaceContainerHelper( ::osl::Mutex & ) SAL_THROW( () );
+    OMultiTypeInterfaceContainerHelper( ::osl::Mutex & ) SAL_THROW(());
     /**
       Delete all containers.
      */
-    ~OMultiTypeInterfaceContainerHelper() SAL_THROW( () );
+    ~OMultiTypeInterfaceContainerHelper() SAL_THROW(());
 
     /**
       Return all id's under which at least one interface is added.
      */
-    ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL getContainedTypes() const SAL_THROW( () );
+    ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL getContainedTypes() const SAL_THROW(());
 
     /**
       Return the container created under this key.
       @return the container created under this key. If the container
                  was not created, null was returned.
      */
-    OInterfaceContainerHelper * SAL_CALL getContainer( const ::com::sun::star::uno::Type & rKey ) const SAL_THROW( () );
+    OInterfaceContainerHelper * SAL_CALL getContainer( const ::com::sun::star::uno::Type & rKey ) const SAL_THROW(());
 
     /** Inserts an element into the container with the specified key.
         The position is not specified, thus it is not specified in which order events are fired.
@@ -575,7 +575,7 @@ public:
     sal_Int32 SAL_CALL addInterface(
         const ::com::sun::star::uno::Type & rKey,
         const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > & r )
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /** Removes an element from the container with the specified key.
         It uses interface equality to remove the interface.
@@ -590,25 +590,25 @@ public:
     sal_Int32 SAL_CALL removeInterface(
         const ::com::sun::star::uno::Type & rKey,
         const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > & rxIFace )
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /**
       Call disposing on all object in the container that
       support XEventListener. Than clear the container.
      */
-    void    SAL_CALL disposeAndClear( const ::com::sun::star::lang::EventObject & rEvt ) SAL_THROW( () );
+    void    SAL_CALL disposeAndClear( const ::com::sun::star::lang::EventObject & rEvt ) SAL_THROW(());
     /**
       Remove all elements of all containers. Does not delete the container.
      */
-    void SAL_CALL clear() SAL_THROW( () );
+    void SAL_CALL clear() SAL_THROW(());
 
     typedef ::com::sun::star::uno::Type keyType;
 private:
     void *m_pMap;
     ::osl::Mutex &  rMutex;
 
-    inline OMultiTypeInterfaceContainerHelper( const OMultiTypeInterfaceContainerHelper & ) SAL_THROW( () );
-    inline OMultiTypeInterfaceContainerHelper & operator = ( const OMultiTypeInterfaceContainerHelper & ) SAL_THROW( () );
+    inline OMultiTypeInterfaceContainerHelper( const OMultiTypeInterfaceContainerHelper & ) SAL_THROW(());
+    inline OMultiTypeInterfaceContainerHelper & operator = ( const OMultiTypeInterfaceContainerHelper & ) SAL_THROW(());
 };
 
 typedef OBroadcastHelperVar< OMultiTypeInterfaceContainerHelper , OMultiTypeInterfaceContainerHelper::keyType > OBroadcastHelper;
diff --git a/cppuhelper/inc/cppuhelper/interfacecontainer.hxx b/cppuhelper/inc/cppuhelper/interfacecontainer.hxx
index d9c347ecc0cf..74c264b9fddc 100644
--- a/cppuhelper/inc/cppuhelper/interfacecontainer.hxx
+++ b/cppuhelper/inc/cppuhelper/interfacecontainer.hxx
@@ -36,7 +36,7 @@ namespace cppu
 
 template< class key , class hashImpl , class equalImpl >
 inline OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::OMultiTypeInterfaceContainerHelperVar( ::osl::Mutex & rMutex_ )
-    SAL_THROW( () )
+    SAL_THROW(())
     : rMutex( rMutex_ )
 {
     m_pMap = new InterfaceMap;
@@ -45,7 +45,7 @@ inline OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::OMul
 //===================================================================
 template< class key , class hashImpl , class equalImpl >
 inline OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::~OMultiTypeInterfaceContainerHelperVar()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     typename InterfaceMap::iterator iter = m_pMap->begin();
     typename InterfaceMap::iterator end = m_pMap->end();
@@ -62,7 +62,7 @@ inline OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::~OMu
 //===================================================================
 template< class key , class hashImpl , class equalImpl >
 inline ::com::sun::star::uno::Sequence< key > OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::getContainedTypes() const
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     ::osl::MutexGuard aGuard( rMutex );
     typename InterfaceMap::size_type nSize = m_pMap->size();
@@ -95,7 +95,7 @@ inline ::com::sun::star::uno::Sequence< key > OMultiTypeInterfaceContainerHelper
 //===================================================================
 template< class key , class hashImpl , class equalImpl >
 OInterfaceContainerHelper * OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::getContainer(
-    const key & rKey ) const SAL_THROW( () )
+    const key & rKey ) const SAL_THROW(())
 {
     ::osl::MutexGuard aGuard( rMutex );
 
@@ -110,7 +110,7 @@ template< class key , class hashImpl , class equalImpl >
 sal_Int32 OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::addInterface(
     const key & rKey,
     const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > & rListener )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     ::osl::MutexGuard aGuard( rMutex );
     typename InterfaceMap::iterator iter = find( rKey );
@@ -129,7 +129,7 @@ template< class key , class hashImpl , class equalImpl >
 inline sal_Int32 OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::removeInterface(
     const key & rKey,
     const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > & rListener )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     ::osl::MutexGuard aGuard( rMutex );
 
@@ -147,7 +147,7 @@ inline sal_Int32 OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalIm
 template< class key , class hashImpl , class equalImpl >
 void OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::disposeAndClear(
     const ::com::sun::star::lang::EventObject & rEvt )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     typename InterfaceMap::size_type nSize = 0;
     OInterfaceContainerHelper ** ppListenerContainers = NULL;
@@ -183,7 +183,7 @@ void OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::dispos
 
 //===================================================================
 template< class key , class hashImpl , class equalImpl >
-void OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::clear() SAL_THROW( () )
+void OMultiTypeInterfaceContainerHelperVar< key , hashImpl , equalImpl >::clear() SAL_THROW(())
 {
     ::osl::MutexGuard aGuard( rMutex );
     typename InterfaceMap::iterator iter = m_pMap->begin();
diff --git a/cppuhelper/inc/cppuhelper/propshlp.hxx b/cppuhelper/inc/cppuhelper/propshlp.hxx
index 00ff4d0b2f50..4b0112679f10 100644
--- a/cppuhelper/inc/cppuhelper/propshlp.hxx
+++ b/cppuhelper/inc/cppuhelper/propshlp.hxx
@@ -57,13 +57,13 @@ class CPPUHELPER_DLLPUBLIC IPropertyArrayHelper
 {
 public:
     // 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(())
         {}
 
     /**
@@ -135,7 +135,7 @@ public:
         ::com::sun::star::beans::Property *pProps,
         sal_Int32 nElements ,
         sal_Bool bSorted = sal_True )
-        SAL_THROW( () );
+        SAL_THROW(());
 
      /**
        Create an object which supports the common property interfaces.
@@ -146,12 +146,12 @@ public:
     OPropertyArrayHelper(
         const ::com::sun::star::uno::Sequence< ::com::sun::star::beans::Property > & aProps,
         sal_Bool bSorted = sal_True )
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /**
        Return the number of properties.
      */
-    sal_Int32 SAL_CALL getCount() const SAL_THROW( () );
+    sal_Int32 SAL_CALL getCount() const SAL_THROW(());
     /**
        Return the property members Name and Attribute from the handle nHandle.
        @param nHandle   the handle of a property. If the values of the handles
@@ -203,7 +203,7 @@ protected:
     void * m_pReserved;
 
 private:
-    void init( sal_Bool bSorted ) SAL_THROW( () );
+    void init( sal_Bool bSorted ) SAL_THROW(());
 
     /** The sequence generated from the pProperties array. */
     ::com::sun::star::uno::Sequence< ::com::sun::star::beans::Property > aInfos;
@@ -221,13 +221,13 @@ private:
 
 struct equalInt32_Impl
 {
-    bool operator()(const sal_Int32 & i1 , const sal_Int32 & i2) const SAL_THROW( () )
+    bool operator()(const sal_Int32 & i1 , const sal_Int32 & i2) const SAL_THROW(())
         { return i1 == i2; }
 };
 
 struct hashInt32_Impl
 {
-    size_t operator()(const sal_Int32 & i) const SAL_THROW( () )
+    size_t operator()(const sal_Int32 & i) const SAL_THROW(())
         { return i; }
 };
 /** Specialized class for key type sal_Int32,
@@ -237,13 +237,13 @@ class CPPUHELPER_DLLPUBLIC OMultiTypeInterfaceContainerHelperInt32
 {
 public:
     // 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(())
         {}
 
     /**
@@ -253,23 +253,23 @@ public:
                          The lifetime must be longer than the lifetime
                          of this object.
      */
-    OMultiTypeInterfaceContainerHelperInt32( ::osl::Mutex & ) SAL_THROW( () );
+    OMultiTypeInterfaceContainerHelperInt32( ::osl::Mutex & ) SAL_THROW(());
     /**
       Delete all containers.
      */
-    ~OMultiTypeInterfaceContainerHelperInt32() SAL_THROW( () );
+    ~OMultiTypeInterfaceContainerHelperInt32() SAL_THROW(());
 
     /**
       Return all id's under which at least one interface is added.
      */
-    ::com::sun::star::uno::Sequence< sal_Int32 > SAL_CALL getContainedTypes() const SAL_THROW( () );
+    ::com::sun::star::uno::Sequence< sal_Int32 > SAL_CALL getContainedTypes() const SAL_THROW(());
 
     /**
       Return the container created under this key.
       @return the container created under this key. If the container
                  was not created, null was returned.
      */
-    OInterfaceContainerHelper * SAL_CALL getContainer( const sal_Int32 & rKey ) const SAL_THROW( () );
+    OInterfaceContainerHelper * SAL_CALL getContainer( const sal_Int32 & rKey ) const SAL_THROW(());
 
     /**
       Insert an element in the container specified with the key. The position is not specified.
@@ -281,7 +281,7 @@ public:
     sal_Int32 SAL_CALL addInterface(
         const sal_Int32 & rKey,
         const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > & r )
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /**
       Remove an element from the container specified with the key.
@@ -293,25 +293,25 @@ public:
     sal_Int32 SAL_CALL removeInterface(
         const sal_Int32 & rKey,
         const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > & rxIFace )
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /**
       Call disposing on all objects in the container that
       support XEventListener. Then clear the container.
      */
-    void    SAL_CALL disposeAndClear( const ::com::sun::star::lang::EventObject & rEvt ) SAL_THROW( () );
+    void    SAL_CALL disposeAndClear( const ::com::sun::star::lang::EventObject & rEvt ) SAL_THROW(());
     /**
       Remove all elements of all containers. Does not delete the container.
      */
-    void SAL_CALL clear() SAL_THROW( () );
+    void SAL_CALL clear() SAL_THROW(());
 
     typedef sal_Int32 keyType;
 private:
     void *m_pMap;
     ::osl::Mutex &  rMutex;
 
-    inline OMultiTypeInterfaceContainerHelperInt32( const OMultiTypeInterfaceContainerHelperInt32 & ) SAL_THROW( () );
-    inline OMultiTypeInterfaceContainerHelperInt32 & operator = ( const OMultiTypeInterfaceContainerHelperInt32 & ) SAL_THROW( () );
+    inline OMultiTypeInterfaceContainerHelperInt32( const OMultiTypeInterfaceContainerHelperInt32 & ) SAL_THROW(());
+    inline OMultiTypeInterfaceContainerHelperInt32 & operator = ( const OMultiTypeInterfaceContainerHelperInt32 & ) SAL_THROW(());
 };
 
 
@@ -362,7 +362,7 @@ public:
                           The lifetime must be longer than the lifetime
                           of this object. Stored in the variable rBHelper.
      */
-    OPropertySetHelper( OBroadcastHelper & rBHelper ) SAL_THROW( () );
+    OPropertySetHelper( OBroadcastHelper & rBHelper ) SAL_THROW(());
 
     /** Constructor.
 
@@ -429,7 +429,7 @@ public:
 
        @see OComponentHelper
      */
-    void SAL_CALL disposing() SAL_THROW( () );
+    void SAL_CALL disposing() SAL_THROW(());
 
     /**
        Throw UnknownPropertyException or PropertyVetoException if the property with the name
@@ -513,7 +513,7 @@ public:
        The property sequence is created in the call. The interface isn't used after the call.
      */
     static ::com::sun::star::uno::Reference < ::com::sun::star::beans::XPropertySetInfo > SAL_CALL
-        createPropertySetInfo( IPropertyArrayHelper & rProperties ) SAL_THROW( () );
+        createPropertySetInfo( IPropertyArrayHelper & rProperties ) SAL_THROW(());
 protected:
     /**
        This method fire events to all registered property listeners.
@@ -643,8 +643,8 @@ protected:
     const std::auto_ptr<Impl> m_pReserved;
 
 private:
-    OPropertySetHelper( const OPropertySetHelper & ) SAL_THROW( () );
-    OPropertySetHelper &    operator = ( const OPropertySetHelper & ) SAL_THROW( () );
+    OPropertySetHelper( const OPropertySetHelper & ) SAL_THROW(());
+    OPropertySetHelper &    operator = ( const OPropertySetHelper & ) SAL_THROW(());
 
     /** notifies the given changes in property's values, <em>plus</em> all property changes collected during recent
         |setDependentFastPropertyValue| calls.
@@ -667,7 +667,7 @@ public:
     /**
        You must call disposing before destruction.
      */
-    ~OPropertySetHelper() SAL_THROW( () );
+    ~OPropertySetHelper() SAL_THROW(());
 };
 #if defined _MSC_VER
 #pragma warning(pop)
@@ -700,15 +700,15 @@ public:
 
 
 private:
-    OPropertySetHelper2( const OPropertySetHelper2 & ) SAL_THROW( () );
-    OPropertySetHelper2 &    operator = ( const OPropertySetHelper2 & ) SAL_THROW( () );
+    OPropertySetHelper2( const OPropertySetHelper2 & ) SAL_THROW(());
+    OPropertySetHelper2 &    operator = ( const OPropertySetHelper2 & ) SAL_THROW(());
 
 public:
 // Suppress warning about virtual functions but non-virtual destructor:
     /**
        You must call disposing before destruction.
      */
-    virtual ~OPropertySetHelper2() SAL_THROW( () );
+    virtual ~OPropertySetHelper2() SAL_THROW(());
 };
 
 } // end namespace cppuhelper
diff --git a/cppuhelper/inc/cppuhelper/queryinterface.hxx b/cppuhelper/inc/cppuhelper/queryinterface.hxx
index 4717eacce33c..8bbb56038051 100644
--- a/cppuhelper/inc/cppuhelper/queryinterface.hxx
+++ b/cppuhelper/inc/cppuhelper/queryinterface.hxx
@@ -48,7 +48,7 @@ template< class Interface1 >
 inline ::com::sun::star::uno::Any SAL_CALL queryInterface(
     const ::com::sun::star::uno::Type & rType,
     Interface1 * p1 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (rType == Interface1::static_type())
         return ::com::sun::star::uno::Any( &p1, rType );
@@ -68,7 +68,7 @@ template< class Interface1, class Interface2 >
 inline ::com::sun::star::uno::Any SAL_CALL queryInterface(
     const ::com::sun::star::uno::Type & rType,
     Interface1 * p1, Interface2 * p2 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (rType == Interface1::static_type())
         return ::com::sun::star::uno::Any( &p1, rType );
@@ -92,7 +92,7 @@ template< class Interface1, class Interface2, class Interface3 >
 inline ::com::sun::star::uno::Any SAL_CALL queryInterface(
     const ::com::sun::star::uno::Type & rType,
     Interface1 * p1, Interface2 * p2, Interface3 * p3 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (rType == Interface1::static_type())
         return ::com::sun::star::uno::Any( &p1, rType );
@@ -120,7 +120,7 @@ template< class Interface1, class Interface2, class Interface3, class Interface4
 inline ::com::sun::star::uno::Any SAL_CALL queryInterface(
     const ::com::sun::star::uno::Type & rType,
     Interface1 * p1, Interface2 * p2, Interface3 * p3, Interface4 * p4 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (rType == Interface1::static_type())
         return ::com::sun::star::uno::Any( &p1, rType );
@@ -152,7 +152,7 @@ template< class Interface1, class Interface2, class Interface3, class Interface4
 inline ::com::sun::star::uno::Any SAL_CALL queryInterface(
     const ::com::sun::star::uno::Type & rType,
     Interface1 * p1, Interface2 * p2, Interface3 * p3, Interface4 * p4, Interface5 * p5 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (rType == Interface1::static_type())
         return ::com::sun::star::uno::Any( &p1, rType );
@@ -190,7 +190,7 @@ inline ::com::sun::star::uno::Any SAL_CALL queryInterface(
     const ::com::sun::star::uno::Type & rType,
     Interface1 * p1, Interface2 * p2, Interface3 * p3, Interface4 * p4, Interface5 * p5,
     Interface6 * p6 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (rType == Interface1::static_type())
         return ::com::sun::star::uno::Any( &p1, rType );
@@ -232,7 +232,7 @@ inline ::com::sun::star::uno::Any SAL_CALL queryInterface(
     const ::com::sun::star::uno::Type & rType,
     Interface1 * p1, Interface2 * p2, Interface3 * p3, Interface4 * p4, Interface5 * p5,
     Interface6 * p6, Interface7 * p7 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (rType == Interface1::static_type())
         return ::com::sun::star::uno::Any( &p1, rType );
@@ -278,7 +278,7 @@ inline ::com::sun::star::uno::Any SAL_CALL queryInterface(
     const ::com::sun::star::uno::Type & rType,
     Interface1 * p1, Interface2 * p2, Interface3 * p3, Interface4 * p4, Interface5 * p5,
     Interface6 * p6, Interface7 * p7, Interface8 * p8 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (rType == Interface1::static_type())
         return ::com::sun::star::uno::Any( &p1, rType );
@@ -328,7 +328,7 @@ inline ::com::sun::star::uno::Any SAL_CALL queryInterface(
     const ::com::sun::star::uno::Type & rType,
     Interface1 * p1, Interface2 * p2, Interface3 * p3, Interface4 * p4, Interface5 * p5,
     Interface6 * p6, Interface7 * p7, Interface8 * p8, Interface9 * p9 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (rType == Interface1::static_type())
         return ::com::sun::star::uno::Any( &p1, rType );
@@ -382,7 +382,7 @@ inline ::com::sun::star::uno::Any SAL_CALL queryInterface(
     const ::com::sun::star::uno::Type & rType,
     Interface1 * p1, Interface2 * p2, Interface3 * p3, Interface4 * p4, Interface5 * p5,
     Interface6 * p6, Interface7 * p7, Interface8 * p8, Interface9 * p9, Interface10 * p10 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (rType == Interface1::static_type())
         return ::com::sun::star::uno::Any( &p1, rType );
@@ -442,7 +442,7 @@ inline ::com::sun::star::uno::Any SAL_CALL queryInterface(
     Interface1 * p1, Interface2 * p2, Interface3 * p3, Interface4 * p4, Interface5 * p5,
     Interface6 * p6, Interface7 * p7, Interface8 * p8, Interface9 * p9, Interface10 * p10,
     Interface11 * p11 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (rType == Interface1::static_type())
         return ::com::sun::star::uno::Any( &p1, rType );
@@ -506,7 +506,7 @@ inline ::com::sun::star::uno::Any SAL_CALL queryInterface(
     Interface1 * p1, Interface2 * p2, Interface3 * p3, Interface4 * p4, Interface5 * p5,
     Interface6 * p6, Interface7 * p7, Interface8 * p8, Interface9 * p9, Interface10 * p10,
     Interface11 * p11, Interface12 * p12 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (rType == Interface1::static_type())
         return ::com::sun::star::uno::Any( &p1, rType );
diff --git a/cppuhelper/inc/cppuhelper/stdidlclass.hxx b/cppuhelper/inc/cppuhelper/stdidlclass.hxx
index 6879adf6f743..750057fef12e 100644
--- a/cppuhelper/inc/cppuhelper/stdidlclass.hxx
+++ b/cppuhelper/inc/cppuhelper/stdidlclass.hxx
@@ -44,7 +44,7 @@ CPPUHELPER_DLLPUBLIC ::com::sun::star::reflection::XIdlClass * SAL_CALL createSt
     const ::rtl::OUString & sImplementationName ,
     const ::com::sun::star::uno::Reference < ::com::sun::star::reflection::XIdlClass > & rSuperClass,
     const ::com::sun::star::uno::Sequence < ::rtl::OUString > &seq )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 
 
@@ -69,7 +69,7 @@ createStandardClass(	const ::com::sun::star::uno::Reference < ::com::sun::star::
 					 	const ::com::sun::star::uno::Reference < ::com::sun::star::reflection::XIdlClass > & ,
                          const Interface1 *
                      )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return 0;
 }
@@ -85,7 +85,7 @@ createStandardClass(	const ::com::sun::star::uno::Reference < ::com::sun::star::
                          const Interface1 *,
                          const Interface2 *
                      )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return 0;
 }
@@ -104,7 +104,7 @@ createStandardClass(	const ::com::sun::star::uno::Reference < ::com::sun::star::
                          const Interface2 *,
                          const Interface3 *
                      )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return 0;
 }
@@ -124,7 +124,7 @@ createStandardClass(	const ::com::sun::star::uno::Reference < ::com::sun::star::
                          const Interface3 *,
                          const Interface4 *
                      )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return 0;
 }
@@ -147,7 +147,7 @@ createStandardClass(	const ::com::sun::star::uno::Reference < ::com::sun::star::
                          const Interface4 *,
                          const Interface5 *
                      )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return 0;
 }
@@ -169,7 +169,7 @@ createStandardClass(	const ::com::sun::star::uno::Reference < ::com::sun::star::
                          const Interface5 *,
                          const Interface6 *
                      )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return 0;
 }
@@ -193,7 +193,7 @@ createStandardClass(	const ::com::sun::star::uno::Reference < ::com::sun::star::
                          const Interface6 *,
                          const Interface7 *
                      )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return 0;
 }
@@ -219,7 +219,7 @@ createStandardClass(	const ::com::sun::star::uno::Reference < ::com::sun::star::
                          const Interface7 *,
                          const Interface8 *
                      )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return 0;
 }
@@ -244,7 +244,7 @@ createStandardClass(	const ::com::sun::star::uno::Reference < ::com::sun::star::
                          const Interface8 *,
                          const Interface9 *
                      )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return 0;
 }
@@ -268,7 +268,7 @@ createStandardClass(	const ::com::sun::star::uno::Reference < ::com::sun::star::
                          const Interface9 *,
                          const Interface10 *
                      )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return 0;
 }
diff --git a/cppuhelper/inc/cppuhelper/typeprovider.hxx b/cppuhelper/inc/cppuhelper/typeprovider.hxx
index af813e570d03..8bcf9272ceeb 100644
--- a/cppuhelper/inc/cppuhelper/typeprovider.hxx
+++ b/cppuhelper/inc/cppuhelper/typeprovider.hxx
@@ -47,42 +47,42 @@ class CPPUHELPER_DLLPUBLIC OTypeCollection
 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
 
     inline OTypeCollection( const OTypeCollection & rCollection )
-        SAL_THROW( () )
+        SAL_THROW(())
         : _aTypes( rCollection._aTypes )
         {}
     OTypeCollection(
         const ::com::sun::star::uno::Type & rType1,
         const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > & rAddTypes = ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type >() )
-        SAL_THROW( () );
+        SAL_THROW(());
     OTypeCollection(
         const ::com::sun::star::uno::Type & rType1,
         const ::com::sun::star::uno::Type & rType2,
         const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > & rAddTypes = ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type >() )
-        SAL_THROW( () );
+        SAL_THROW(());
     OTypeCollection(
         const ::com::sun::star::uno::Type & rType1,
         const ::com::sun::star::uno::Type & rType2,
         const ::com::sun::star::uno::Type & rType3,
         const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > & rAddTypes = ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type >() )
-        SAL_THROW( () );
+        SAL_THROW(());
     OTypeCollection(
         const ::com::sun::star::uno::Type & rType1,
         const ::com::sun::star::uno::Type & rType2,
         const ::com::sun::star::uno::Type & rType3,
         const ::com::sun::star::uno::Type & rType4,
         const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > & rAddTypes = ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type >() )
-        SAL_THROW( () );
+        SAL_THROW(());
     OTypeCollection(
         const ::com::sun::star::uno::Type & rType1,
         const ::com::sun::star::uno::Type & rType2,
@@ -90,7 +90,7 @@ public:
         const ::com::sun::star::uno::Type & rType4,
         const ::com::sun::star::uno::Type & rType5,
         const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > & rAddTypes = ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type >() )
-        SAL_THROW( () );
+        SAL_THROW(());
     OTypeCollection(
         const ::com::sun::star::uno::Type & rType1,
         const ::com::sun::star::uno::Type & rType2,
@@ -99,7 +99,7 @@ public:
         const ::com::sun::star::uno::Type & rType5,
         const ::com::sun::star::uno::Type & rType6,
         const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > & rAddTypes = ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type >() )
-        SAL_THROW( () );
+        SAL_THROW(());
     OTypeCollection(
         const ::com::sun::star::uno::Type & rType1,
         const ::com::sun::star::uno::Type & rType2,
@@ -109,7 +109,7 @@ public:
         const ::com::sun::star::uno::Type & rType6,
         const ::com::sun::star::uno::Type & rType7,
         const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > & rAddTypes = ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type >() )
-        SAL_THROW( () );
+        SAL_THROW(());
     OTypeCollection(
         const ::com::sun::star::uno::Type & rType1,
         const ::com::sun::star::uno::Type & rType2,
@@ -120,7 +120,7 @@ public:
         const ::com::sun::star::uno::Type & rType7,
         const ::com::sun::star::uno::Type & rType8,
         const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > & rAddTypes = ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type >() )
-        SAL_THROW( () );
+        SAL_THROW(());
     OTypeCollection(
         const ::com::sun::star::uno::Type & rType1,
         const ::com::sun::star::uno::Type & rType2,
@@ -132,7 +132,7 @@ public:
         const ::com::sun::star::uno::Type & rType8,
         const ::com::sun::star::uno::Type & rType9,
         const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > & rAddTypes = ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type >() )
-        SAL_THROW( () );
+        SAL_THROW(());
     OTypeCollection(
         const ::com::sun::star::uno::Type & rType1,
         const ::com::sun::star::uno::Type & rType2,
@@ -145,7 +145,7 @@ public:
         const ::com::sun::star::uno::Type & rType9,
         const ::com::sun::star::uno::Type & rType10,
         const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > & rAddTypes = ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type >() )
-        SAL_THROW( () );
+        SAL_THROW(());
     OTypeCollection(
         const ::com::sun::star::uno::Type & rType1,
         const ::com::sun::star::uno::Type & rType2,
@@ -159,7 +159,7 @@ public:
         const ::com::sun::star::uno::Type & rType10,
         const ::com::sun::star::uno::Type & rType11,
         const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > & rAddTypes = ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type >() )
-        SAL_THROW( () );
+        SAL_THROW(());
     OTypeCollection(
         const ::com::sun::star::uno::Type & rType1,
         const ::com::sun::star::uno::Type & rType2,
@@ -174,13 +174,13 @@ public:
         const ::com::sun::star::uno::Type & rType11,
         const ::com::sun::star::uno::Type & rType12,
         const ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > & rAddTypes = ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type >() )
-        SAL_THROW( () );
+        SAL_THROW(());
 
     /** Called upon XTypeProvider::getTypes().
 
         @return type collection
     */
-    ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL getTypes() SAL_THROW( () )
+    ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Type > SAL_CALL getTypes() SAL_THROW(())
         { return _aTypes; }
 };
 
@@ -196,16 +196,16 @@ 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(())
         {}
 
-    ~OImplementationId() SAL_THROW( () );
+    ~OImplementationId() SAL_THROW(());
 
     /// @endcond
 
@@ -213,7 +213,7 @@ public:
 
         @param bUseEthernetAddress whether an ethernet mac address should be taken into account
     */
-    inline OImplementationId( sal_Bool bUseEthernetAddress = sal_True ) SAL_THROW( () )
+    inline OImplementationId( sal_Bool bUseEthernetAddress = sal_True ) SAL_THROW(())
         : _pSeq( 0 )
         , _bUseEthernetAddress( bUseEthernetAddress )
         {}
@@ -221,10 +221,10 @@ public:
 
         @param rSeq implementation id
     */
-    inline OImplementationId( const ::com::sun::star::uno::Sequence< sal_Int8 > & rSeq ) SAL_THROW( () )
+    inline OImplementationId( const ::com::sun::star::uno::Sequence< sal_Int8 > & rSeq ) SAL_THROW(())
         : _pSeq( new ::com::sun::star::uno::Sequence< sal_Int8 >( rSeq ) )
         {}
-    inline OImplementationId( const OImplementationId & rId ) SAL_THROW( () )
+    inline OImplementationId( const OImplementationId & rId ) SAL_THROW(())
         : _pSeq( new ::com::sun::star::uno::Sequence< sal_Int8 >( rId.getImplementationId() ) )
         {}
 
@@ -232,7 +232,7 @@ public:
 
         @return implementation id
     */
-    ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() const SAL_THROW( () );
+    ::com::sun::star::uno::Sequence< sal_Int8 > SAL_CALL getImplementationId() const SAL_THROW(());
 };
 
 }
diff --git a/cppuhelper/inc/cppuhelper/weak.hxx b/cppuhelper/inc/cppuhelper/weak.hxx
index ceddbda9c411..8838797dfe5d 100644
--- a/cppuhelper/inc/cppuhelper/weak.hxx
+++ b/cppuhelper/inc/cppuhelper/weak.hxx
@@ -90,13 +90,13 @@ protected:
 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
 
@@ -104,11 +104,11 @@ public:
     /** Default Constructor.  Sets the reference count to zero.
         Accidentally occurs in msvc mapfile = > had to be outlined.
     */
-    OWeakObject() SAL_THROW( () );
+    OWeakObject() SAL_THROW(());
 #else
     /** Default Constructor.  Sets the reference count to zero.
     */
-    inline OWeakObject() SAL_THROW( () )
+    inline OWeakObject() SAL_THROW(())
         : m_refCount( 0 )
         , m_pWeakConnectionPoint( 0 )
         {}
@@ -117,7 +117,7 @@ public:
 
         @param rObj dummy param
     */
-    inline OWeakObject( const OWeakObject & ) SAL_THROW( () )
+    inline OWeakObject( const OWeakObject & ) SAL_THROW(())
         : com::sun::star::uno::XWeak()
         , m_refCount( 0 )
         , m_pWeakConnectionPoint( 0 )
@@ -127,7 +127,7 @@ public:
         @return this OWeakObject
     */
     inline OWeakObject & SAL_CALL operator = ( const OWeakObject &)
-        SAL_THROW( () )
+        SAL_THROW(())
         { return *this; }
 
     /** Basic queryInterface() implementation supporting \::com::sun::star::uno::XWeak and
@@ -159,7 +159,7 @@ public:
 
         @return XInterface reference
     */
-    inline SAL_CALL operator ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > () SAL_THROW( () )
+    inline SAL_CALL operator ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > () SAL_THROW(())
         { return this; }
 };
 
diff --git a/cppuhelper/inc/cppuhelper/weakagg.hxx b/cppuhelper/inc/cppuhelper/weakagg.hxx
index 150cfd1b1aa4..094e178ec222 100644
--- a/cppuhelper/inc/cppuhelper/weakagg.hxx
+++ b/cppuhelper/inc/cppuhelper/weakagg.hxx
@@ -53,7 +53,7 @@ class CPPUHELPER_DLLPUBLIC OWeakAggObject
 public:
     /** Constructor.  No delegator set.
     */
-    inline OWeakAggObject() SAL_THROW( () )
+    inline OWeakAggObject() SAL_THROW(())
         {}
 
     /** If a delegator is set, then the delegators gets acquired.  Otherwise call is delegated to
@@ -102,8 +102,8 @@ protected:
     */
     ::com::sun::star::uno::WeakReferenceHelper xDelegator;
 private:
-    OWeakAggObject( const OWeakAggObject & rObj ) SAL_THROW( () );
-    OWeakAggObject & operator = ( const OWeakAggObject & rObj ) SAL_THROW( () );
+    OWeakAggObject( const OWeakAggObject & rObj ) SAL_THROW(());
+    OWeakAggObject & operator = ( const OWeakAggObject & rObj ) SAL_THROW(());
 };
 
 }
diff --git a/cppuhelper/inc/cppuhelper/weakref.hxx b/cppuhelper/inc/cppuhelper/weakref.hxx
index 1e8362a19b23..73c8ee24e76f 100644
--- a/cppuhelper/inc/cppuhelper/weakref.hxx
+++ b/cppuhelper/inc/cppuhelper/weakref.hxx
@@ -51,7 +51,7 @@ class CPPUHELPER_DLLPUBLIC WeakReferenceHelper
 public:
     /** Default ctor.  Creates an empty weak reference.
     */
-    inline WeakReferenceHelper() SAL_THROW( () )
+    inline WeakReferenceHelper() SAL_THROW(())
         : m_pImpl( 0 )
         {}
 
@@ -59,23 +59,23 @@ public:
 
         @param rWeakRef another weak ref
     */
-    WeakReferenceHelper( const WeakReferenceHelper & rWeakRef ) SAL_THROW( () );
+    WeakReferenceHelper( const WeakReferenceHelper & rWeakRef ) SAL_THROW(());
     /** Initialize this reference with the hard interface reference xInt. If the implementation
         behind xInt does not support XWeak or XInt is null then this reference will be null.
 
         @param xInt another hard interface reference
     */
     WeakReferenceHelper( const ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > & xInt )
-        SAL_THROW( () );
+        SAL_THROW(());
     /** Releases this reference.
     */
-    ~WeakReferenceHelper() SAL_THROW( () );
+    ~WeakReferenceHelper() SAL_THROW(());
 
     /** Releases this reference and takes over rWeakRef.
 
         @param rWeakRef another weak ref
     */
-    WeakReferenceHelper & SAL_CALL operator = ( const WeakReferenceHelper & rWeakRef ) SAL_THROW( () );
+    WeakReferenceHelper & SAL_CALL operator = ( const WeakReferenceHelper & rWeakRef ) SAL_THROW(());
 
     /** Releases this reference and takes over hard reference xInt.
         If the implementation behind xInt does not support XWeak
@@ -85,33 +85,33 @@ public:
     */
     WeakReferenceHelper & SAL_CALL operator = (
             const ::com::sun::star::uno::Reference<
-                ::com::sun::star::uno::XInterface > & xInt ) SAL_THROW( () );
+                ::com::sun::star::uno::XInterface > & xInt ) SAL_THROW(());
 
     /** Returns true if both weak refs reference to the same object.
 
         @param rObj another weak ref
         @return true, if both weak refs reference to the same object.
     */
-    inline sal_Bool SAL_CALL operator == ( const WeakReferenceHelper & rObj ) const SAL_THROW( () )
+    inline sal_Bool SAL_CALL operator == ( const WeakReferenceHelper & rObj ) const SAL_THROW(())
         { return (get() == rObj.get()); }
 
     /**  Gets a hard reference to the object.
 
          @return hard reference or null, if the weakly referenced interface has gone
     */
-    ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > SAL_CALL get() const SAL_THROW( () );
+    ::com::sun::star::uno::Reference< ::com::sun::star::uno::XInterface > SAL_CALL get() const SAL_THROW(());
     /**  Gets a hard reference to the object.
 
          @return hard reference or null, if the weakly referenced interface has gone
     */
-    inline SAL_CALL operator Reference< XInterface > () const SAL_THROW( () )
+    inline SAL_CALL operator Reference< XInterface > () const SAL_THROW(())
         { return get(); }
 
     /** Releases this reference.
 
         @since UDK 3.2.12
     */
-    void SAL_CALL clear() SAL_THROW( () );
+    void SAL_CALL clear() SAL_THROW(());
 
 protected:
     /// @cond INTERNAL
@@ -130,7 +130,7 @@ class WeakReference : public WeakReferenceHelper
 public:
     /** Default ctor.  Creates an empty weak reference.
     */
-    inline WeakReference() SAL_THROW( () )
+    inline WeakReference() SAL_THROW(())
         : WeakReferenceHelper()
         {}
 
@@ -138,7 +138,7 @@ public:
 
         @param rRef another hard ref
     */
-    inline WeakReference( const Reference< interface_type > & rRef ) SAL_THROW( () )
+    inline WeakReference( const Reference< interface_type > & rRef ) SAL_THROW(())
         : WeakReferenceHelper( rRef )
         {}
 
@@ -152,14 +152,14 @@ public:
     */
     WeakReference & SAL_CALL operator = (
             const ::com::sun::star::uno::Reference< interface_type > & xInt )
-        SAL_THROW( () )
+        SAL_THROW(())
         { WeakReferenceHelper::operator=(xInt); return *this; }
 
     /**  Gets a hard reference to the object.
 
          @return hard reference or null, if the weakly referenced interface has gone
     */
-    inline SAL_CALL operator Reference< interface_type > () const SAL_THROW( () )
+    inline SAL_CALL operator Reference< interface_type > () const SAL_THROW(())
         { return Reference< interface_type >::query( get() ); }
 };
 
diff --git a/cppuhelper/source/bootstrap.cxx b/cppuhelper/source/bootstrap.cxx
index 063bece4d8a0..39e44feda2e5 100644
--- a/cppuhelper/source/bootstrap.cxx
+++ b/cppuhelper/source/bootstrap.cxx
@@ -93,7 +93,7 @@ OUString const & get_this_libpath()
     return s_path;
 }
 
-Bootstrap const & get_unorc() SAL_THROW( () )
+Bootstrap const & get_unorc() SAL_THROW(())
 {
     static rtlBootstrapHandle s_bstrap = 0;
     if (! s_bstrap)
@@ -142,7 +142,7 @@ Reference< XComponentContext > bootstrapInitialContext(
 Reference< XComponentContext > SAL_CALL createInitialCfgComponentContext(
     ContextEntry_Init const * pEntries, sal_Int32 nEntries,
     Reference< XComponentContext > const & xDelegate )
-    SAL_THROW( () );
+    SAL_THROW(());
 
 Reference< registry::XSimpleRegistry > SAL_CALL createRegistryWrapper(
     const Reference< XComponentContext >& xContext );
@@ -152,7 +152,7 @@ namespace {
 template< class T >
 inline beans::PropertyValue createPropertyValue(
     OUString const & name, T const & value )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return beans::PropertyValue(
         name, -1, makeAny( value ), beans::PropertyState_DIRECT_VALUE );
diff --git a/cppuhelper/source/component.cxx b/cppuhelper/source/component.cxx
index a4e797706199..1cc7c2fdd79b 100644
--- a/cppuhelper/source/component.cxx
+++ b/cppuhelper/source/component.cxx
@@ -49,7 +49,7 @@ namespace cppu
 //  class OComponentHelper
 //  ----------------------------------------------------
 
-OComponentHelper::OComponentHelper( Mutex & rMutex ) SAL_THROW( () )
+OComponentHelper::OComponentHelper( Mutex & rMutex ) SAL_THROW(())
     : rBHelper( rMutex )
 {
 }
diff --git a/cppuhelper/source/component_context.cxx b/cppuhelper/source/component_context.cxx
index da60e39152b7..6c795dec88cc 100644
--- a/cppuhelper/source/component_context.cxx
+++ b/cppuhelper/source/component_context.cxx
@@ -302,7 +302,7 @@ class DisposingForwarder
     Reference< lang::XComponent > m_xTarget;
 
     inline DisposingForwarder( Reference< lang::XComponent > const & xTarget )
-        SAL_THROW( () )
+        SAL_THROW(())
         : m_xTarget( xTarget )
         { OSL_ASSERT( m_xTarget.is() ); }
 public:
@@ -375,7 +375,7 @@ public:
         ContextEntry_Init const * pEntries, sal_Int32 nEntries,
         Reference< XComponentContext > const & xDelegate );
     virtual ~ComponentContext()
-        SAL_THROW( () );
+        SAL_THROW(());
 
     // XComponentContext
     virtual Any SAL_CALL getValueByName( OUString const & rName )
@@ -676,7 +676,7 @@ Reference< lang::XMultiComponentFactory > ComponentContext::getServiceManager()
 }
 //__________________________________________________________________________________________________
 ComponentContext::~ComponentContext()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
 #ifdef CONTEXT_DIAG
     ::fprintf( stderr, "> destructed context %p\n", this );
@@ -865,7 +865,7 @@ extern "C" { static void s_createComponentContext_v(va_list * pParam)
 Reference< XComponentContext > SAL_CALL createComponentContext(
     ContextEntry_Init const * pEntries, sal_Int32 nEntries,
     Reference< XComponentContext > const & xDelegate )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     uno::Environment curr_env(Environment::getCurrent());
     uno::Environment source_env(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(CPPU_STRINGIFY(CPPU_ENV))));
diff --git a/cppuhelper/source/factory.cxx b/cppuhelper/source/factory.cxx
index 4a298d1cb188..dc46aa8a09f5 100644
--- a/cppuhelper/source/factory.cxx
+++ b/cppuhelper/source/factory.cxx
@@ -80,7 +80,7 @@ public:
         ComponentInstantiation pCreateFunction_,
         ComponentFactoryFunc fptr,
         const Sequence< OUString > * pServiceNames_ )
-        SAL_THROW( () )
+        SAL_THROW(())
         : xSMgr( rServiceManager )
         , pCreateFunction( pCreateFunction_ )
         , m_fptr( fptr )
@@ -94,7 +94,7 @@ public:
     OSingleFactoryHelper(
         const Reference<XMultiServiceFactory > & rServiceManager,
         const OUString & rImplementationName_ )
-        SAL_THROW( () )
+        SAL_THROW(())
         : xSMgr( rServiceManager )
         , pCreateFunction( NULL )
         , m_fptr( 0 )
@@ -292,7 +292,7 @@ public:
         ComponentFactoryFunc fptr,
         const Sequence< OUString > * pServiceNames_,
         sal_Bool bOneInstance_ = sal_False )
-        SAL_THROW( () )
+        SAL_THROW(())
         : OComponentHelper( aMutex )
         , OSingleFactoryHelper( rServiceManager, rImplementationName_, pCreateFunction_, fptr, pServiceNames_ )
         , bOneInstance( bOneInstance_ )
@@ -310,7 +310,7 @@ public:
         const Sequence< OUString > * pServiceNames_,
         rtl_ModuleCount * pModCount,
         sal_Bool bOneInstance_ = sal_False )
-        SAL_THROW( () )
+        SAL_THROW(())
         : OComponentHelper( aMutex )
         , OSingleFactoryHelper( rServiceManager, rImplementationName_, pCreateFunction_, fptr, pServiceNames_ )
         , bOneInstance( bOneInstance_ )
@@ -325,7 +325,7 @@ public:
         const Reference<XMultiServiceFactory > & rServiceManager,
         const OUString & rImplementationName_,
         sal_Bool bOneInstance_ = sal_False )
-        SAL_THROW( () )
+        SAL_THROW(())
         : OComponentHelper( aMutex )
         , OSingleFactoryHelper( rServiceManager, rImplementationName_ )
         , bOneInstance( bOneInstance_ )
@@ -551,7 +551,7 @@ public:
         const Reference<XMultiServiceFactory > & rServiceManager,
         const OUString & rImplementationName_,
         const Reference<XRegistryKey > & xImplementationKey_,
-        sal_Bool bOneInstance_ = sal_False ) SAL_THROW( () )
+        sal_Bool bOneInstance_ = sal_False ) SAL_THROW(())
             : OFactoryComponentHelper(
                 rServiceManager, rImplementationName_, 0, 0, 0, bOneInstance_ ),
               OPropertySetHelper( OComponentHelper::rBHelper ),
@@ -957,7 +957,7 @@ class OFactoryProxyHelper : public WeakImplHelper3< XServiceInfo, XSingleService
 public:
 
     OFactoryProxyHelper( const Reference<XSingleServiceFactory > & rFactory )
-        SAL_THROW( () )
+        SAL_THROW(())
         : xFactory( rFactory )
         {}
 
@@ -1043,7 +1043,7 @@ Reference<XSingleServiceFactory > SAL_CALL createSingleFactory(
     ComponentInstantiation pCreateFunction,
     const Sequence< OUString > & rServiceNames,
     rtl_ModuleCount *pModCount )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return new OFactoryComponentHelper(
         rServiceManager, rImplementationName, pCreateFunction, 0, &rServiceNames, pModCount, sal_False );
@@ -1053,7 +1053,7 @@ Reference<XSingleServiceFactory > SAL_CALL createSingleFactory(
 Reference<XSingleServiceFactory > SAL_CALL createFactoryProxy(
     SAL_UNUSED_PARAMETER const Reference<XMultiServiceFactory > &,
     const Reference<XSingleServiceFactory > & rFactory )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return new OFactoryProxyHelper( rFactory );
 }
@@ -1065,7 +1065,7 @@ Reference<XSingleServiceFactory > SAL_CALL createOneInstanceFactory(
     ComponentInstantiation pCreateFunction,
     const Sequence< OUString > & rServiceNames,
     rtl_ModuleCount *pModCount )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return new OFactoryComponentHelper(
         rServiceManager, rImplementationName, pCreateFunction, 0, &rServiceNames, pModCount, sal_True );
@@ -1076,7 +1076,7 @@ Reference<XSingleServiceFactory > SAL_CALL createSingleRegistryFactory(
     const Reference<XMultiServiceFactory > & rServiceManager,
     const OUString & rImplementationName,
     const Reference<XRegistryKey > & rImplementationKey )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return new ORegistryFactoryHelper(
         rServiceManager, rImplementationName, rImplementationKey, sal_False );
@@ -1087,7 +1087,7 @@ Reference<XSingleServiceFactory > SAL_CALL createOneInstanceRegistryFactory(
     const Reference<XMultiServiceFactory > & rServiceManager,
     const OUString & rImplementationName,
     const Reference<XRegistryKey > & rImplementationKey )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return new ORegistryFactoryHelper(
         rServiceManager, rImplementationName, rImplementationKey, sal_True );
@@ -1099,7 +1099,7 @@ Reference< lang::XSingleComponentFactory > SAL_CALL createSingleComponentFactory
     OUString const & rImplementationName,
     Sequence< OUString > const & rServiceNames,
     rtl_ModuleCount * pModCount)
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return new OFactoryComponentHelper(
         Reference< XMultiServiceFactory >(), rImplementationName, 0, fptr, &rServiceNames, pModCount, sal_False );
@@ -1110,7 +1110,7 @@ Reference< lang::XSingleComponentFactory > SAL_CALL createOneInstanceComponentFa
     OUString const & rImplementationName,
     Sequence< OUString > const & rServiceNames,
     rtl_ModuleCount * pModCount)
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return new OFactoryComponentHelper(
         Reference< XMultiServiceFactory >(), rImplementationName, 0, fptr, &rServiceNames, pModCount, sal_True );
diff --git a/cppuhelper/source/implbase.cxx b/cppuhelper/source/implbase.cxx
index 4738870b69e5..fbe7ed69b79c 100644
--- a/cppuhelper/source/implbase.cxx
+++ b/cppuhelper/source/implbase.cxx
@@ -48,14 +48,14 @@ namespace
 namespace cppu
 {
 //==================================================================================================
-Mutex & SAL_CALL getImplHelperInitMutex(void) SAL_THROW( () )
+Mutex & SAL_CALL getImplHelperInitMutex(void) SAL_THROW(())
 {
     return theImplHelperInitMutex::get();
 }
 
 // ClassDataBase
 //__________________________________________________________________________________________________
-ClassDataBase::ClassDataBase() SAL_THROW( () )
+ClassDataBase::ClassDataBase() SAL_THROW(())
     : bOffsetsInit( sal_False )
     , nType2Offset( 0 )
     , nClassCode( 0 )
@@ -64,7 +64,7 @@ ClassDataBase::ClassDataBase() SAL_THROW( () )
 {
 }
 //__________________________________________________________________________________________________
-ClassDataBase::ClassDataBase( sal_Int32 nClassCode_ ) SAL_THROW( () )
+ClassDataBase::ClassDataBase( sal_Int32 nClassCode_ ) SAL_THROW(())
     : bOffsetsInit( sal_False )
     , nType2Offset( 0 )
     , nClassCode( nClassCode_ )
@@ -73,7 +73,7 @@ ClassDataBase::ClassDataBase( sal_Int32 nClassCode_ ) SAL_THROW( () )
 {
 }
 //__________________________________________________________________________________________________
-ClassDataBase::~ClassDataBase() SAL_THROW( () )
+ClassDataBase::~ClassDataBase() SAL_THROW(())
 {
     delete pTypes;
     delete pId;
@@ -87,7 +87,7 @@ ClassDataBase::~ClassDataBase() SAL_THROW( () )
 
 // ClassData
 //__________________________________________________________________________________________________
-void ClassData::writeTypeOffset( const Type & rType, sal_Int32 nOffset ) SAL_THROW( () )
+void ClassData::writeTypeOffset( const Type & rType, sal_Int32 nOffset ) SAL_THROW(())
 {
     arType2Offset[nType2Offset].nOffset = nOffset;
 
@@ -107,7 +107,7 @@ void ClassData::writeTypeOffset( const Type & rType, sal_Int32 nOffset ) SAL_THR
 #endif
 }
 //__________________________________________________________________________________________________
-void ClassData::initTypeProvider() SAL_THROW( () )
+void ClassData::initTypeProvider() SAL_THROW(())
 {
     ::osl::MutexGuard aGuard( ::osl::Mutex::getGlobalMutex() );
     if (! pTypes)
@@ -148,14 +148,14 @@ void ClassData::initTypeProvider() SAL_THROW( () )
     }
 }
 //__________________________________________________________________________________________________
-Sequence< Type > ClassData::getTypes() SAL_THROW( () )
+Sequence< Type > ClassData::getTypes() SAL_THROW(())
 {
     if (! pTypes)
         initTypeProvider();
     return *pTypes;
 }
 //__________________________________________________________________________________________________
-Sequence< sal_Int8 > ClassData::getImplementationId() SAL_THROW( () )
+Sequence< sal_Int8 > ClassData::getImplementationId() SAL_THROW(())
 {
     if (! pTypes)
         initTypeProvider();
@@ -165,14 +165,14 @@ Sequence< sal_Int8 > ClassData::getImplementationId() SAL_THROW( () )
 //--------------------------------------------------------------------------------------------------
 static inline sal_Bool td_equals(
     typelib_TypeDescription * pTD, typelib_TypeDescriptionReference * pType )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return (pTD->pWeakRef == pType ||
             (pTD->pTypeName->length == pType->pTypeName->length &&
              rtl_ustr_compare( pTD->pTypeName->buffer, pType->pTypeName->buffer ) == 0));
 }
 //__________________________________________________________________________________________________
-Any ClassData::query( const Type & rType, lang::XTypeProvider * pBase ) SAL_THROW( () )
+Any ClassData::query( const Type & rType, lang::XTypeProvider * pBase ) SAL_THROW(())
 {
     if (rType == ::getCppuType( (const Reference< XInterface > *)0 ))
         return Any( &pBase, ::getCppuType( (const Reference< XInterface > *)0 ) );
@@ -204,13 +204,13 @@ Any ClassData::query( const Type & rType, lang::XTypeProvider * pBase ) SAL_THRO
 // WeakComponentImplHelperBase
 //__________________________________________________________________________________________________
 WeakComponentImplHelperBase::WeakComponentImplHelperBase( Mutex & rMutex )
-    SAL_THROW( () )
+    SAL_THROW(())
     : rBHelper( rMutex )
 {
 }
 //__________________________________________________________________________________________________
 WeakComponentImplHelperBase::~WeakComponentImplHelperBase()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
 }
 //__________________________________________________________________________________________________
@@ -330,13 +330,13 @@ void WeakComponentImplHelperBase::removeEventListener(
 // WeakAggComponentImplHelperBase
 //__________________________________________________________________________________________________
 WeakAggComponentImplHelperBase::WeakAggComponentImplHelperBase( Mutex & rMutex )
-    SAL_THROW( () )
+    SAL_THROW(())
     : rBHelper( rMutex )
 {
 }
 //__________________________________________________________________________________________________
 WeakAggComponentImplHelperBase::~WeakAggComponentImplHelperBase()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
 }
 //__________________________________________________________________________________________________
diff --git a/cppuhelper/source/implbase_ex.cxx b/cppuhelper/source/implbase_ex.cxx
index 720ab0d35479..2e5e9523eb3a 100644
--- a/cppuhelper/source/implbase_ex.cxx
+++ b/cppuhelper/source/implbase_ex.cxx
@@ -49,7 +49,7 @@ namespace cppu
 /** Shared mutex for implementation helper initialization.
     Not for public use.
 */
-::osl::Mutex & SAL_CALL getImplHelperInitMutex(void) SAL_THROW( () );
+::osl::Mutex & SAL_CALL getImplHelperInitMutex(void) SAL_THROW(());
 
 //--------------------------------------------------------------------------------------------------
 static inline void checkInterface( Type const & rType )
@@ -70,12 +70,12 @@ static inline void checkInterface( Type const & rType )
     }
 }
 //--------------------------------------------------------------------------------------------------
-static inline bool isXInterface( rtl_uString * pStr ) SAL_THROW( () )
+static inline bool isXInterface( rtl_uString * pStr ) SAL_THROW(())
 {
     return (((OUString const *)&pStr)->equalsAsciiL( RTL_CONSTASCII_STRINGPARAM("com.sun.star.uno.XInterface") ) != sal_False);
 }
 //--------------------------------------------------------------------------------------------------
-static inline void * makeInterface( sal_IntPtr nOffset, void * that ) SAL_THROW( () )
+static inline void * makeInterface( sal_IntPtr nOffset, void * that ) SAL_THROW(())
 {
     return (((char *)that) + nOffset);
 }
@@ -83,7 +83,7 @@ static inline void * makeInterface( sal_IntPtr nOffset, void * that ) SAL_THROW(
 static inline bool __td_equals(
     typelib_TypeDescriptionReference const * pTDR1,
     typelib_TypeDescriptionReference const * pTDR2 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     return ((pTDR1 == pTDR2) ||
             ((OUString const *)&pTDR1->pTypeName)->equals( *(OUString const *)&pTDR2->pTypeName ) != sal_False);
diff --git a/cppuhelper/source/interfacecontainer.cxx b/cppuhelper/source/interfacecontainer.cxx
index 58150c47fa3e..510d25f35c20 100644
--- a/cppuhelper/source/interfacecontainer.cxx
+++ b/cppuhelper/source/interfacecontainer.cxx
@@ -49,7 +49,7 @@ namespace cppu
  * Reallocate the sequence.
  */
 static void realloc( Sequence< Reference< XInterface > > & rSeq, sal_Int32 nNewLen )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     rSeq.realloc( nNewLen );
 }
@@ -58,7 +58,7 @@ static void realloc( Sequence< Reference< XInterface > > & rSeq, sal_Int32 nNewL
  * Remove an element from an interface sequence.
  */
 static void sequenceRemoveElementAt( Sequence< Reference< XInterface > > & rSeq, sal_Int32 index )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     sal_Int32 nNewLen = rSeq.getLength() - 1;
 
@@ -79,7 +79,7 @@ static void sequenceRemoveElementAt( Sequence< Reference< XInterface > > & rSeq,
 #endif
 
 OInterfaceIteratorHelper::OInterfaceIteratorHelper( OInterfaceContainerHelper & rCont_ )
-    SAL_THROW( () )
+    SAL_THROW(())
     : rCont( rCont_ )
 {
     MutexGuard aGuard( rCont.rMutex );
@@ -102,7 +102,7 @@ OInterfaceIteratorHelper::OInterfaceIteratorHelper( OInterfaceContainerHelper &
         nRemain = 0;
 }
 
-OInterfaceIteratorHelper::~OInterfaceIteratorHelper() SAL_THROW( () )
+OInterfaceIteratorHelper::~OInterfaceIteratorHelper() SAL_THROW(())
 {
     sal_Bool bShared;
     {
@@ -127,7 +127,7 @@ OInterfaceIteratorHelper::~OInterfaceIteratorHelper() SAL_THROW( () )
     }
 }
 
-XInterface * OInterfaceIteratorHelper::next() SAL_THROW( () )
+XInterface * OInterfaceIteratorHelper::next() SAL_THROW(())
 {
     if( nRemain )
     {
@@ -142,7 +142,7 @@ XInterface * OInterfaceIteratorHelper::next() SAL_THROW( () )
     return 0;
 }
 
-void OInterfaceIteratorHelper::remove() SAL_THROW( () )
+void OInterfaceIteratorHelper::remove() SAL_THROW(())
 {
     if( bIsList )
     {
@@ -158,14 +158,14 @@ void OInterfaceIteratorHelper::remove() SAL_THROW( () )
     }
 }
 
-OInterfaceContainerHelper::OInterfaceContainerHelper( Mutex & rMutex_ ) SAL_THROW( () )
+OInterfaceContainerHelper::OInterfaceContainerHelper( Mutex & rMutex_ ) SAL_THROW(())
     : rMutex( rMutex_ )
     , bInUse( sal_False )
     , bIsList( sal_False )
 {
 }
 
-OInterfaceContainerHelper::~OInterfaceContainerHelper() SAL_THROW( () )
+OInterfaceContainerHelper::~OInterfaceContainerHelper() SAL_THROW(())
 {
     OSL_ENSURE( !bInUse, "~OInterfaceContainerHelper but is in use" );
     if( bIsList )
@@ -174,7 +174,7 @@ OInterfaceContainerHelper::~OInterfaceContainerHelper() SAL_THROW( () )
         aData.pAsInterface->release();
 }
 
-sal_Int32 OInterfaceContainerHelper::getLength() const SAL_THROW( () )
+sal_Int32 OInterfaceContainerHelper::getLength() const SAL_THROW(())
 {
     MutexGuard aGuard( rMutex );
     if( bIsList )
@@ -184,7 +184,7 @@ sal_Int32 OInterfaceContainerHelper::getLength() const SAL_THROW( () )
     return 0;
 }
 
-Sequence< Reference<XInterface> > OInterfaceContainerHelper::getElements() const SAL_THROW( () )
+Sequence< Reference<XInterface> > OInterfaceContainerHelper::getElements() const SAL_THROW(())
 {
     MutexGuard aGuard( rMutex );
     if( bIsList )
@@ -197,7 +197,7 @@ Sequence< Reference<XInterface> > OInterfaceContainerHelper::getElements() const
     return Sequence< Reference< XInterface > >();
 }
 
-void OInterfaceContainerHelper::copyAndResetInUse() SAL_THROW( () )
+void OInterfaceContainerHelper::copyAndResetInUse() SAL_THROW(())
 {
     OSL_ENSURE( bInUse, "OInterfaceContainerHelper not in use" );
     if( bInUse )
@@ -213,7 +213,7 @@ void OInterfaceContainerHelper::copyAndResetInUse() SAL_THROW( () )
     }
 }
 
-sal_Int32 OInterfaceContainerHelper::addInterface( const Reference<XInterface> & rListener ) SAL_THROW( () )
+sal_Int32 OInterfaceContainerHelper::addInterface( const Reference<XInterface> & rListener ) SAL_THROW(())
 {
     OSL_ASSERT( rListener.is() );
     MutexGuard aGuard( rMutex );
@@ -247,7 +247,7 @@ sal_Int32 OInterfaceContainerHelper::addInterface( const Reference<XInterface> &
     }
 }
 
-sal_Int32 OInterfaceContainerHelper::removeInterface( const Reference<XInterface> & rListener ) SAL_THROW( () )
+sal_Int32 OInterfaceContainerHelper::removeInterface( const Reference<XInterface> & rListener ) SAL_THROW(())
 {
     OSL_ASSERT( rListener.is() );
     MutexGuard aGuard( rMutex );
@@ -303,7 +303,7 @@ sal_Int32 OInterfaceContainerHelper::removeInterface( const Reference<XInterface
     return aData.pAsInterface ? 1 : 0;
 }
 
-void OInterfaceContainerHelper::disposeAndClear( const EventObject & rEvt ) SAL_THROW( () )
+void OInterfaceContainerHelper::disposeAndClear( const EventObject & rEvt ) SAL_THROW(())
 {
     ClearableMutexGuard aGuard( rMutex );
     OInterfaceIteratorHelper aIt( *this );
@@ -333,7 +333,7 @@ void OInterfaceContainerHelper::disposeAndClear( const EventObject & rEvt ) SAL_
 }
 
 
-void OInterfaceContainerHelper::clear() SAL_THROW( () )
+void OInterfaceContainerHelper::clear() SAL_THROW(())
 {
     ClearableMutexGuard aGuard( rMutex );
     OInterfaceIteratorHelper aIt( *this );
@@ -354,13 +354,13 @@ void OInterfaceContainerHelper::clear() SAL_THROW( () )
 typedef ::std::vector< std::pair < Type , void* > > t_type2ptr;
 
 OMultiTypeInterfaceContainerHelper::OMultiTypeInterfaceContainerHelper( Mutex & rMutex_ )
-    SAL_THROW( () )
+    SAL_THROW(())
     : rMutex( rMutex_ )
 {
     m_pMap = new t_type2ptr();
 }
 OMultiTypeInterfaceContainerHelper::~OMultiTypeInterfaceContainerHelper()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     t_type2ptr * pMap = (t_type2ptr *)m_pMap;
     t_type2ptr::iterator iter = pMap->begin();
@@ -375,7 +375,7 @@ OMultiTypeInterfaceContainerHelper::~OMultiTypeInterfaceContainerHelper()
     delete pMap;
 }
 Sequence< Type > OMultiTypeInterfaceContainerHelper::getContainedTypes() const
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     t_type2ptr * pMap = (t_type2ptr *)m_pMap;
     t_type2ptr::size_type nSize;
@@ -423,7 +423,7 @@ static t_type2ptr::iterator findType(t_type2ptr *pMap, const Type & rKey )
 }
 
 OInterfaceContainerHelper * OMultiTypeInterfaceContainerHelper::getContainer( const Type & rKey ) const
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     ::osl::MutexGuard aGuard( rMutex );
 
@@ -435,7 +435,7 @@ OInterfaceContainerHelper * OMultiTypeInterfaceContainerHelper::getContainer( co
 }
 sal_Int32 OMultiTypeInterfaceContainerHelper::addInterface(
     const Type & rKey, const Reference< XInterface > & rListener )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     ::osl::MutexGuard aGuard( rMutex );
     t_type2ptr * pMap = (t_type2ptr *)m_pMap;
@@ -451,7 +451,7 @@ sal_Int32 OMultiTypeInterfaceContainerHelper::addInterface(
 }
 sal_Int32 OMultiTypeInterfaceContainerHelper::removeInterface(
     const Type & rKey, const Reference< XInterface > & rListener )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     ::osl::MutexGuard aGuard( rMutex );
 
@@ -466,7 +466,7 @@ sal_Int32 OMultiTypeInterfaceContainerHelper::removeInterface(
     return 0;
 }
 void OMultiTypeInterfaceContainerHelper::disposeAndClear( const EventObject & rEvt )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     t_type2ptr::size_type nSize = 0;
     OInterfaceContainerHelper ** ppListenerContainers = NULL;
@@ -503,7 +503,7 @@ void OMultiTypeInterfaceContainerHelper::disposeAndClear( const EventObject & rE
     delete [] ppListenerContainers;
 }
 void OMultiTypeInterfaceContainerHelper::clear()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     ::osl::MutexGuard aGuard( rMutex );
     t_type2ptr * pMap = (t_type2ptr *)m_pMap;
@@ -536,14 +536,14 @@ static t_long2ptr::iterator findLong(t_long2ptr *pMap, sal_Int32 nKey )
 }
 
 OMultiTypeInterfaceContainerHelperInt32::OMultiTypeInterfaceContainerHelperInt32( Mutex & rMutex_ )
-    SAL_THROW( () )
+    SAL_THROW(())
     : m_pMap( NULL )
     , rMutex( rMutex_ )
 {
     // delay pMap allocation until necessary.
 }
 OMultiTypeInterfaceContainerHelperInt32::~OMultiTypeInterfaceContainerHelperInt32()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (!m_pMap)
         return;
@@ -561,7 +561,7 @@ OMultiTypeInterfaceContainerHelperInt32::~OMultiTypeInterfaceContainerHelperInt3
     delete pMap;
 }
 Sequence< sal_Int32 > OMultiTypeInterfaceContainerHelperInt32::getContainedTypes() const
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     t_long2ptr * pMap = (t_long2ptr *)m_pMap;
     t_long2ptr::size_type nSize;
@@ -594,7 +594,7 @@ Sequence< sal_Int32 > OMultiTypeInterfaceContainerHelperInt32::getContainedTypes
     return ::com::sun::star::uno::Sequence< sal_Int32 >();
 }
 OInterfaceContainerHelper * OMultiTypeInterfaceContainerHelperInt32::getContainer( const sal_Int32 & rKey ) const
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     ::osl::MutexGuard aGuard( rMutex );
 
@@ -608,7 +608,7 @@ OInterfaceContainerHelper * OMultiTypeInterfaceContainerHelperInt32::getContaine
 }
 sal_Int32 OMultiTypeInterfaceContainerHelperInt32::addInterface(
     const sal_Int32 & rKey, const Reference< XInterface > & rListener )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     ::osl::MutexGuard aGuard( rMutex );
     if (!m_pMap)
@@ -626,7 +626,7 @@ sal_Int32 OMultiTypeInterfaceContainerHelperInt32::addInterface(
 }
 sal_Int32 OMultiTypeInterfaceContainerHelperInt32::removeInterface(
     const sal_Int32 & rKey, const Reference< XInterface > & rListener )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     ::osl::MutexGuard aGuard( rMutex );
 
@@ -643,7 +643,7 @@ sal_Int32 OMultiTypeInterfaceContainerHelperInt32::removeInterface(
     return 0;
 }
 void OMultiTypeInterfaceContainerHelperInt32::disposeAndClear( const EventObject & rEvt )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     t_long2ptr::size_type nSize = 0;
     OInterfaceContainerHelper ** ppListenerContainers = NULL;
@@ -682,7 +682,7 @@ void OMultiTypeInterfaceContainerHelperInt32::disposeAndClear( const EventObject
     delete [] ppListenerContainers;
 }
 void OMultiTypeInterfaceContainerHelperInt32::clear()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     ::osl::MutexGuard aGuard( rMutex );
     if (!m_pMap)
diff --git a/cppuhelper/source/macro_expander.cxx b/cppuhelper/source/macro_expander.cxx
index 431e24c76c01..eab09c55ab16 100644
--- a/cppuhelper/source/macro_expander.cxx
+++ b/cppuhelper/source/macro_expander.cxx
@@ -55,7 +55,7 @@ using namespace ::com::sun::star::uno;
 namespace cppu
 {
 //---- private forward -----------------------------------------------------------------------------
-Bootstrap const & get_unorc() SAL_THROW( () );
+Bootstrap const & get_unorc() SAL_THROW(());
 }
 
 namespace cppuhelper { namespace detail {
@@ -111,11 +111,11 @@ protected:
     virtual void SAL_CALL disposing();
 
 public:
-    inline Bootstrap_MacroExpander() SAL_THROW( () )
+    inline Bootstrap_MacroExpander() SAL_THROW(())
         : t_uno_impl( m_mutex )
         {}
     virtual ~Bootstrap_MacroExpander()
-        SAL_THROW( () );
+        SAL_THROW(());
 
     // XMacroExpander impl
     virtual OUString SAL_CALL expandMacros( OUString const & exp )
@@ -133,7 +133,7 @@ public:
 void Bootstrap_MacroExpander::disposing()
 {}
 //__________________________________________________________________________________________________
-Bootstrap_MacroExpander::~Bootstrap_MacroExpander() SAL_THROW( () )
+Bootstrap_MacroExpander::~Bootstrap_MacroExpander() SAL_THROW(())
 {}
 
 // XServiceInfo impl
@@ -185,7 +185,7 @@ namespace cppu
 {
 
 //##################################################################################################
-Reference< lang::XSingleComponentFactory > create_boostrap_macro_expander_factory() SAL_THROW( () )
+Reference< lang::XSingleComponentFactory > create_boostrap_macro_expander_factory() SAL_THROW(())
 {
     Reference< lang::XSingleComponentFactory > free(::cppu::createSingleComponentFactory(
                                                         service_create,
diff --git a/cppuhelper/source/propshlp.cxx b/cppuhelper/source/propshlp.cxx
index 338d9c184b24..a66f185c303a 100644
--- a/cppuhelper/source/propshlp.cxx
+++ b/cppuhelper/source/propshlp.cxx
@@ -51,15 +51,15 @@ IPropertyArrayHelper::~IPropertyArrayHelper()
 {
 }
 
-inline const ::com::sun::star::uno::Type & getPropertyTypeIdentifier( ) SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & getPropertyTypeIdentifier( ) SAL_THROW(())
 {
     return ::getCppuType( (Reference< XPropertyChangeListener > *)0 );
 }
-inline const ::com::sun::star::uno::Type & getPropertiesTypeIdentifier() SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & getPropertiesTypeIdentifier() SAL_THROW(())
 {
     return ::getCppuType( (Reference< XPropertiesChangeListener > *)0 );
 }
-inline const ::com::sun::star::uno::Type & getVetoableTypeIdentifier() SAL_THROW( () )
+inline const ::com::sun::star::uno::Type & getVetoableTypeIdentifier() SAL_THROW(())
 {
     return ::getCppuType( (Reference< XVetoableChangeListener > *)0 );
 }
@@ -84,7 +84,7 @@ class OPropertySetHelperInfo_Impl
     Sequence < Property > aInfos;
 
 public:
-    OPropertySetHelperInfo_Impl( IPropertyArrayHelper & rHelper_ ) SAL_THROW( () );
+    OPropertySetHelperInfo_Impl( IPropertyArrayHelper & rHelper_ ) SAL_THROW(());
 
     // XPropertySetInfo-Methoden
     virtual Sequence< Property > SAL_CALL getProperties(void) throw(::com::sun::star::uno::RuntimeException);
@@ -98,7 +98,7 @@ public:
  */
 OPropertySetHelperInfo_Impl::OPropertySetHelperInfo_Impl(
     IPropertyArrayHelper & rHelper_ )
-    SAL_THROW( () )
+    SAL_THROW(())
     :aInfos( rHelper_.getProperties() )
 {
 }
@@ -169,7 +169,7 @@ public:
 //  class PropertySetHelper
 //  ----------------------------------------------------
 OPropertySetHelper::OPropertySetHelper(
-    OBroadcastHelper  & rBHelper_ ) SAL_THROW( () )
+    OBroadcastHelper  & rBHelper_ ) SAL_THROW(())
     : rBHelper( rBHelper_ ),
       aBoundLC( rBHelper_.rMutex ),
       aVetoableLC( rBHelper_.rMutex ),
@@ -208,10 +208,10 @@ OPropertySetHelper2::OPropertySetHelper2(
 /**
  * You must call disposing before.
  */
-OPropertySetHelper::~OPropertySetHelper() SAL_THROW( () )
+OPropertySetHelper::~OPropertySetHelper() SAL_THROW(())
 {
 }
-OPropertySetHelper2::~OPropertySetHelper2() SAL_THROW( () )
+OPropertySetHelper2::~OPropertySetHelper2() SAL_THROW(())
 {
 }
 
@@ -251,7 +251,7 @@ Any OPropertySetHelper2::queryInterface( const ::com::sun::star::uno::Type & rTy
 }
 
 // ComponentHelper
-void OPropertySetHelper::disposing() SAL_THROW( () )
+void OPropertySetHelper::disposing() SAL_THROW(())
 {
     // Create an event with this as sender
     Reference < XPropertySet  > rSource( SAL_STATIC_CAST( XPropertySet * , this ) , UNO_QUERY );
@@ -265,7 +265,7 @@ void OPropertySetHelper::disposing() SAL_THROW( () )
 }
 
 Reference < XPropertySetInfo > OPropertySetHelper::createPropertySetInfo(
-    IPropertyArrayHelper & rProperties ) SAL_THROW( () )
+    IPropertyArrayHelper & rProperties ) SAL_THROW(())
 {
     return static_cast< XPropertySetInfo * >( new OPropertySetHelperInfo_Impl( rProperties ) );
 }
@@ -1126,7 +1126,7 @@ static int compare_Property_Impl( const void *arg1, const void *arg2 )
 
 }
 
-void OPropertyArrayHelper::init( sal_Bool bSorted ) SAL_THROW( () )
+void OPropertyArrayHelper::init( sal_Bool bSorted ) SAL_THROW(())
 {
     sal_Int32 i, nElements = aInfos.getLength();
     const Property* pProperties = aInfos.getConstArray();
@@ -1157,7 +1157,7 @@ OPropertyArrayHelper::OPropertyArrayHelper(
     Property * pProps,
     sal_Int32 nEle,
     sal_Bool bSorted )
-    SAL_THROW( () )
+    SAL_THROW(())
     : aInfos(pProps, nEle)
     , bRightOrdered( sal_False )
 {
@@ -1167,7 +1167,7 @@ OPropertyArrayHelper::OPropertyArrayHelper(
 OPropertyArrayHelper::OPropertyArrayHelper(
     const Sequence< Property > & aProps,
     sal_Bool bSorted )
-    SAL_THROW( () )
+    SAL_THROW(())
     : aInfos(aProps)
     , bRightOrdered( sal_False )
 {
diff --git a/cppuhelper/source/servicefactory.cxx b/cppuhelper/source/servicefactory.cxx
index d0dea93cf664..ff4f41769b56 100644
--- a/cppuhelper/source/servicefactory.cxx
+++ b/cppuhelper/source/servicefactory.cxx
@@ -71,10 +71,10 @@ namespace cppu
 {
 
 Reference< security::XAccessController >
-createDefaultAccessController() SAL_THROW( () );
+createDefaultAccessController() SAL_THROW(());
 
 Reference< lang::XSingleComponentFactory >
-create_boostrap_macro_expander_factory() SAL_THROW( () );
+create_boostrap_macro_expander_factory() SAL_THROW(());
 
 OUString const & get_this_libpath();
 
@@ -105,7 +105,7 @@ static Reference< XInterface > SAL_CALL createInstance(
 
 Reference< registry::XSimpleRegistry > SAL_CALL createSimpleRegistry(
     OUString const & rBootstrapPath )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     try
     {
@@ -136,7 +136,7 @@ Reference< registry::XSimpleRegistry > SAL_CALL createSimpleRegistry(
 
 Reference< registry::XSimpleRegistry > SAL_CALL createNestedRegistry(
     OUString const & rBootstrapPath )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     try
     {
diff --git a/cppuhelper/source/shlib.cxx b/cppuhelper/source/shlib.cxx
index 48596aa40a2d..068a50a27247 100644
--- a/cppuhelper/source/shlib.cxx
+++ b/cppuhelper/source/shlib.cxx
@@ -59,7 +59,7 @@ namespace cppu
 
 #if OSL_DEBUG_LEVEL > 1
 //------------------------------------------------------------------------------
-static inline void out( const char * p ) SAL_THROW( () )
+static inline void out( const char * p ) SAL_THROW(())
 {
     printf( "%s\n", p );
 }
@@ -128,7 +128,7 @@ namespace
 }
 
 //------------------------------------------------------------------------------
-static const ::std::vector< OUString > * getAccessDPath() SAL_THROW( () )
+static const ::std::vector< OUString > * getAccessDPath() SAL_THROW(())
 {
     return theAccessDPath::get().getAccessDPath();
 }
@@ -206,7 +206,7 @@ static bool checkAccessPath( OUString * pComp ) throw ()
 
 //------------------------------------------------------------------------------
 static inline sal_Int32 endsWith(
-    const OUString & rText, const OUString & rEnd ) SAL_THROW( () )
+    const OUString & rText, const OUString & rEnd ) SAL_THROW(())
 {
     if (rText.getLength() >= rEnd.getLength() &&
         rEnd.equalsIgnoreAsciiCase(
diff --git a/cppuhelper/source/tdmgr.cxx b/cppuhelper/source/tdmgr.cxx
index a63f59bedf01..8217d8eecd58 100644
--- a/cppuhelper/source/tdmgr.cxx
+++ b/cppuhelper/source/tdmgr.cxx
@@ -732,7 +732,7 @@ class EventListenerImpl
 public:
     inline EventListenerImpl(
         Reference< container::XHierarchicalNameAccess > const & xTDMgr )
-        SAL_THROW( () )
+        SAL_THROW(())
         : m_xTDMgr( xTDMgr )
         {}
 
@@ -754,7 +754,7 @@ void EventListenerImpl::disposing( lang::EventObject const & rEvt )
 //==================================================================================================
 sal_Bool SAL_CALL installTypeDescriptionManager(
     Reference< container::XHierarchicalNameAccess > const & xTDMgr_c )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     uno::Environment curr_env(Environment::getCurrent());
     uno::Environment target_env(rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(CPPU_STRINGIFY(CPPU_ENV))));
diff --git a/cppuhelper/source/typeprovider.cxx b/cppuhelper/source/typeprovider.cxx
index 3f224f0a89c7..4887669128c7 100644
--- a/cppuhelper/source/typeprovider.cxx
+++ b/cppuhelper/source/typeprovider.cxx
@@ -37,12 +37,12 @@ namespace cppu
 {
 
 //__________________________________________________________________________________________________
-OImplementationId::~OImplementationId() SAL_THROW( () )
+OImplementationId::~OImplementationId() SAL_THROW(())
 {
     delete _pSeq;
 }
 //__________________________________________________________________________________________________
-Sequence< sal_Int8 > OImplementationId::getImplementationId() const SAL_THROW( () )
+Sequence< sal_Int8 > OImplementationId::getImplementationId() const SAL_THROW(())
 {
     if (! _pSeq)
     {
@@ -59,7 +59,7 @@ Sequence< sal_Int8 > OImplementationId::getImplementationId() const SAL_THROW( (
 
 //--------------------------------------------------------------------------------------------------
 static inline void copy( Sequence< Type > & rDest, const Sequence< Type > & rSource, sal_Int32 nOffset )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     Type * pDest = rDest.getArray();
     const Type * pSource = rSource.getConstArray();
@@ -72,7 +72,7 @@ static inline void copy( Sequence< Type > & rDest, const Sequence< Type > & rSou
 OTypeCollection::OTypeCollection(
     const Type & rType1,
     const Sequence< Type > & rAddTypes )
-    SAL_THROW( () )
+    SAL_THROW(())
     : _aTypes( 1 + rAddTypes.getLength() )
 {
     _aTypes[0] = rType1;
@@ -83,7 +83,7 @@ OTypeCollection::OTypeCollection(
     const Type & rType1,
     const Type & rType2,
     const Sequence< Type > & rAddTypes )
-    SAL_THROW( () )
+    SAL_THROW(())
     : _aTypes( 2 + rAddTypes.getLength() )
 {
     _aTypes[0] = rType1;
@@ -96,7 +96,7 @@ OTypeCollection::OTypeCollection(
     const Type & rType2,
     const Type & rType3,
     const Sequence< Type > & rAddTypes )
-    SAL_THROW( () )
+    SAL_THROW(())
     : _aTypes( 3 + rAddTypes.getLength() )
 {
     _aTypes[0] = rType1;
@@ -111,7 +111,7 @@ OTypeCollection::OTypeCollection(
     const Type & rType3,
     const Type & rType4,
     const Sequence< Type > & rAddTypes )
-    SAL_THROW( () )
+    SAL_THROW(())
     : _aTypes( 4 + rAddTypes.getLength() )
 {
     _aTypes[0] = rType1;
@@ -128,7 +128,7 @@ OTypeCollection::OTypeCollection(
     const Type & rType4,
     const Type & rType5,
     const Sequence< Type > & rAddTypes )
-    SAL_THROW( () )
+    SAL_THROW(())
     : _aTypes( 5 + rAddTypes.getLength() )
 {
     _aTypes[0] = rType1;
@@ -147,7 +147,7 @@ OTypeCollection::OTypeCollection(
     const Type & rType5,
     const Type & rType6,
     const Sequence< Type > & rAddTypes )
-    SAL_THROW( () )
+    SAL_THROW(())
     : _aTypes( 6 + rAddTypes.getLength() )
 {
     _aTypes[0] = rType1;
@@ -168,7 +168,7 @@ OTypeCollection::OTypeCollection(
     const Type & rType6,
     const Type & rType7,
     const Sequence< Type > & rAddTypes )
-    SAL_THROW( () )
+    SAL_THROW(())
     : _aTypes( 7 + rAddTypes.getLength() )
 {
     _aTypes[0] = rType1;
@@ -191,7 +191,7 @@ OTypeCollection::OTypeCollection(
     const Type & rType7,
     const Type & rType8,
     const Sequence< Type > & rAddTypes )
-    SAL_THROW( () )
+    SAL_THROW(())
     : _aTypes( 8 + rAddTypes.getLength() )
 {
     _aTypes[0] = rType1;
@@ -216,7 +216,7 @@ OTypeCollection::OTypeCollection(
     const Type & rType8,
     const Type & rType9,
     const Sequence< Type > & rAddTypes )
-    SAL_THROW( () )
+    SAL_THROW(())
     : _aTypes( 9 + rAddTypes.getLength() )
 {
     _aTypes[0] = rType1;
@@ -243,7 +243,7 @@ OTypeCollection::OTypeCollection(
     const Type & rType9,
     const Type & rType10,
     const Sequence< Type > & rAddTypes )
-    SAL_THROW( () )
+    SAL_THROW(())
     : _aTypes( 10 + rAddTypes.getLength() )
 {
     _aTypes[0] = rType1;
@@ -272,7 +272,7 @@ OTypeCollection::OTypeCollection(
     const Type & rType10,
     const Type & rType11,
     const Sequence< Type > & rAddTypes )
-    SAL_THROW( () )
+    SAL_THROW(())
     : _aTypes( 11 + rAddTypes.getLength() )
 {
     _aTypes[0] = rType1;
@@ -303,7 +303,7 @@ OTypeCollection::OTypeCollection(
     const Type & rType11,
     const Type & rType12,
     const Sequence< Type > & rAddTypes )
-    SAL_THROW( () )
+    SAL_THROW(())
     : _aTypes( 12 + rAddTypes.getLength() )
 {
     _aTypes[0] = rType1;
diff --git a/cppuhelper/source/weak.cxx b/cppuhelper/source/weak.cxx
index 2e7e1832ba3c..b40cb444388d 100644
--- a/cppuhelper/source/weak.cxx
+++ b/cppuhelper/source/weak.cxx
@@ -39,7 +39,7 @@ namespace cppu
 {
 
 // due to static Reflection destruction from usr, ther must be a mutex leak (#73272#)
-inline static Mutex & getWeakMutex() SAL_THROW( () )
+inline static Mutex & getWeakMutex() SAL_THROW(())
 {
     static Mutex * s_pMutex = 0;
     if (! s_pMutex)
@@ -56,7 +56,7 @@ public:
     /**
         Hold the weak object without an acquire (only the pointer).
      */
-    OWeakConnectionPoint( OWeakObject* pObj ) SAL_THROW( () )
+    OWeakConnectionPoint( OWeakObject* pObj ) SAL_THROW(())
         : m_aRefCount( 0 )
         , m_pObject(pObj)
         , m_aReferences( getWeakMutex() )
@@ -181,7 +181,7 @@ void SAL_CALL OWeakConnectionPoint::removeReference(const Reference< XReference
 
 #ifdef _MSC_VER
 // Accidentally occurs in msvc mapfile = > had to be outlined.
-OWeakObject::OWeakObject() SAL_THROW( () )
+OWeakObject::OWeakObject() SAL_THROW(())
     : m_refCount( 0 ),
       m_pWeakConnectionPoint( 0 )
 {
@@ -328,9 +328,9 @@ namespace uno
 class OWeakRefListener : public XReference
 {
 public:
-    OWeakRefListener(const OWeakRefListener& rRef) SAL_THROW( () );
-    OWeakRefListener(const Reference< XInterface >& xInt) SAL_THROW( () );
-    virtual ~OWeakRefListener() SAL_THROW( () );
+    OWeakRefListener(const OWeakRefListener& rRef) SAL_THROW(());
+    OWeakRefListener(const Reference< XInterface >& xInt) SAL_THROW(());
+    virtual ~OWeakRefListener() SAL_THROW(());
 
     // XInterface
     Any SAL_CALL queryInterface( const Type & rType ) throw(RuntimeException);
@@ -346,10 +346,10 @@ public:
     Reference< XAdapter >       m_XWeakConnectionPoint;
 
 private:
-    OWeakRefListener& SAL_CALL operator=(const OWeakRefListener& rRef) SAL_THROW( () );
+    OWeakRefListener& SAL_CALL operator=(const OWeakRefListener& rRef) SAL_THROW(());
 };
 
-OWeakRefListener::OWeakRefListener(const OWeakRefListener& rRef) SAL_THROW( () )
+OWeakRefListener::OWeakRefListener(const OWeakRefListener& rRef) SAL_THROW(())
     : com::sun::star::uno::XReference()
     , m_aRefCount( 1 )
 {
@@ -366,7 +366,7 @@ OWeakRefListener::OWeakRefListener(const OWeakRefListener& rRef) SAL_THROW( () )
     osl_decrementInterlockedCount( &m_aRefCount );
 }
 
-OWeakRefListener::OWeakRefListener(const Reference< XInterface >& xInt) SAL_THROW( () )
+OWeakRefListener::OWeakRefListener(const Reference< XInterface >& xInt) SAL_THROW(())
     : m_aRefCount( 1 )
 {
     try
@@ -387,7 +387,7 @@ OWeakRefListener::OWeakRefListener(const Reference< XInterface >& xInt) SAL_THRO
     osl_decrementInterlockedCount( &m_aRefCount );
 }
 
-OWeakRefListener::~OWeakRefListener() SAL_THROW( () )
+OWeakRefListener::~OWeakRefListener() SAL_THROW(())
 {
     try
     {
@@ -440,7 +440,7 @@ void SAL_CALL OWeakRefListener::dispose()
 //------------------------------------------------------------------------
 //-- WeakReferenceHelper ----------------------------------------------------------
 //------------------------------------------------------------------------
-WeakReferenceHelper::WeakReferenceHelper(const Reference< XInterface >& xInt) SAL_THROW( () )
+WeakReferenceHelper::WeakReferenceHelper(const Reference< XInterface >& xInt) SAL_THROW(())
     : m_pImpl( 0 )
 {
     if (xInt.is())
@@ -450,7 +450,7 @@ WeakReferenceHelper::WeakReferenceHelper(const Reference< XInterface >& xInt) SA
     }
 }
 
-WeakReferenceHelper::WeakReferenceHelper(const WeakReferenceHelper& rWeakRef) SAL_THROW( () )
+WeakReferenceHelper::WeakReferenceHelper(const WeakReferenceHelper& rWeakRef) SAL_THROW(())
     : m_pImpl( 0 )
 {
     Reference< XInterface > xInt( rWeakRef.get() );
@@ -461,7 +461,7 @@ WeakReferenceHelper::WeakReferenceHelper(const WeakReferenceHelper& rWeakRef) SA
     }
 }
 
-void WeakReferenceHelper::clear() SAL_THROW( () )
+void WeakReferenceHelper::clear() SAL_THROW(())
 {
     try
     {
@@ -480,7 +480,7 @@ void WeakReferenceHelper::clear() SAL_THROW( () )
     catch (RuntimeException &) { OSL_ASSERT( 0 ); } // assert here, but no unexpected()
 }
 
-WeakReferenceHelper& WeakReferenceHelper::operator=(const WeakReferenceHelper& rWeakRef) SAL_THROW( () )
+WeakReferenceHelper& WeakReferenceHelper::operator=(const WeakReferenceHelper& rWeakRef) SAL_THROW(())
 {
     if (this == &rWeakRef)
     {
@@ -492,7 +492,7 @@ WeakReferenceHelper& WeakReferenceHelper::operator=(const WeakReferenceHelper& r
 
 WeakReferenceHelper & SAL_CALL
 WeakReferenceHelper::operator= (const Reference< XInterface > & xInt)
-SAL_THROW( () )
+SAL_THROW(())
 {
     try
     {
@@ -507,12 +507,12 @@ SAL_THROW( () )
     return *this;
 }
 
-WeakReferenceHelper::~WeakReferenceHelper() SAL_THROW( () )
+WeakReferenceHelper::~WeakReferenceHelper() SAL_THROW(())
 {
     clear();
 }
 
-Reference< XInterface > WeakReferenceHelper::get() const SAL_THROW( () )
+Reference< XInterface > WeakReferenceHelper::get() const SAL_THROW(())
 {
     try
     {
diff --git a/cppuhelper/test/cfg_test.cxx b/cppuhelper/test/cfg_test.cxx
index 4e30393054f3..2dd1d57b47da 100644
--- a/cppuhelper/test/cfg_test.cxx
+++ b/cppuhelper/test/cfg_test.cxx
@@ -90,7 +90,7 @@ class ServiceImpl0
     Reference< XComponentContext > m_xContext;
 
 public:
-    ServiceImpl0( Reference< XComponentContext > const & xContext ) SAL_THROW( () );
+    ServiceImpl0( Reference< XComponentContext > const & xContext ) SAL_THROW(());
 
     // XInitialization
     virtual void SAL_CALL initialize( const Sequence< Any >& rArgs ) throw (Exception, RuntimeException);
@@ -101,7 +101,7 @@ public:
     virtual sal_Bool SAL_CALL supportsService( const OUString & rServiceName ) throw (RuntimeException);
 };
 //__________________________________________________________________________________________________
-ServiceImpl0::ServiceImpl0( Reference< XComponentContext > const & xContext ) SAL_THROW( () )
+ServiceImpl0::ServiceImpl0( Reference< XComponentContext > const & xContext ) SAL_THROW(())
     : m_xContext( xContext )
 {
     sal_Int32 n;
@@ -168,7 +168,7 @@ sal_Bool ServiceImpl0::supportsService( const OUString & rServiceName )
 class ServiceImpl1 : public ServiceImpl0
 {
 public:
-    inline ServiceImpl1( Reference< XComponentContext > const & xContext ) SAL_THROW( () )
+    inline ServiceImpl1( Reference< XComponentContext > const & xContext ) SAL_THROW(())
         : ServiceImpl0( xContext )
         {}
author	Alexander Bergmann <myaddons@gmx.de>	2012-01-26 16:00:09 +0100
committer	Michael Meeks <michael.meeks@suse.com>	2012-01-26 17:41:07 +0000
commit	0439af27e1f37b19d4409f34f974d6ade49f99bf (patch)
tree	13bbb2549319d74a1a109bf2727aab37dca5b8c7 /cppuhelper
parent	f1cb0a4ab4f11dc015be1696c7c7751802171915 (diff)