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

5 files changed, 97 insertions, 97 deletions

diff --git a/stoc/source/security/access_controller.cxx b/stoc/source/security/access_controller.cxx
index 1924db097c24..f2b029bcdaa4 100644
--- a/stoc/source/security/access_controller.cxx
+++ b/stoc/source/security/access_controller.cxx
@@ -94,16 +94,16 @@ class acc_Intersection
     inline acc_Intersection(
         Reference< security::XAccessControlContext > const & x1,
         Reference< security::XAccessControlContext > const & x2 )
-        SAL_THROW( () );
+        SAL_THROW(());
 
 public:
     virtual ~acc_Intersection()
-        SAL_THROW( () );
+        SAL_THROW(());
 
     static inline Reference< security::XAccessControlContext > create(
         Reference< security::XAccessControlContext > const & x1,
         Reference< security::XAccessControlContext > const & x2 )
-        SAL_THROW( () );
+        SAL_THROW(());
 
     // XAccessControlContext impl
     virtual void SAL_CALL checkPermission(
@@ -114,7 +114,7 @@ public:
 inline acc_Intersection::acc_Intersection(
     Reference< security::XAccessControlContext > const & x1,
     Reference< security::XAccessControlContext > const & x2 )
-    SAL_THROW( () )
+    SAL_THROW(())
     : m_x1( x1 )
     , m_x2( x2 )
 {
@@ -122,7 +122,7 @@ inline acc_Intersection::acc_Intersection(
 }
 //__________________________________________________________________________________________________
 acc_Intersection::~acc_Intersection()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     g_moduleCount.modCnt.release( &g_moduleCount.modCnt );
 }
@@ -130,7 +130,7 @@ acc_Intersection::~acc_Intersection()
 inline Reference< security::XAccessControlContext > acc_Intersection::create(
     Reference< security::XAccessControlContext > const & x1,
     Reference< security::XAccessControlContext > const & x2 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (! x1.is())
         return x2;
@@ -157,16 +157,16 @@ class acc_Union
     inline acc_Union(
         Reference< security::XAccessControlContext > const & x1,
         Reference< security::XAccessControlContext > const & x2 )
-        SAL_THROW( () );
+        SAL_THROW(());
 
 public:
     virtual ~acc_Union()
-        SAL_THROW( () );
+        SAL_THROW(());
 
     static inline Reference< security::XAccessControlContext > create(
         Reference< security::XAccessControlContext > const & x1,
         Reference< security::XAccessControlContext > const & x2 )
-        SAL_THROW( () );
+        SAL_THROW(());
 
     // XAccessControlContext impl
     virtual void SAL_CALL checkPermission(
@@ -177,7 +177,7 @@ public:
 inline acc_Union::acc_Union(
     Reference< security::XAccessControlContext > const & x1,
     Reference< security::XAccessControlContext > const & x2 )
-    SAL_THROW( () )
+    SAL_THROW(())
     : m_x1( x1 )
     , m_x2( x2 )
 {
@@ -185,7 +185,7 @@ inline acc_Union::acc_Union(
 }
 //__________________________________________________________________________________________________
 acc_Union::~acc_Union()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     g_moduleCount.modCnt.release( &g_moduleCount.modCnt );
 }
@@ -193,7 +193,7 @@ acc_Union::~acc_Union()
 inline Reference< security::XAccessControlContext > acc_Union::create(
     Reference< security::XAccessControlContext > const & x1,
     Reference< security::XAccessControlContext > const & x2 )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if (! x1.is())
         return Reference< security::XAccessControlContext >(); // unrestricted
@@ -226,9 +226,9 @@ class acc_Policy
 public:
     inline acc_Policy(
         PermissionCollection const & permissions )
-        SAL_THROW( () );
+        SAL_THROW(());
     virtual ~acc_Policy()
-        SAL_THROW( () );
+        SAL_THROW(());
 
     // XAccessControlContext impl
     virtual void SAL_CALL checkPermission(
@@ -238,14 +238,14 @@ public:
 //__________________________________________________________________________________________________
 inline acc_Policy::acc_Policy(
     PermissionCollection const & permissions )
-    SAL_THROW( () )
+    SAL_THROW(())
     : m_permissions( permissions )
 {
     g_moduleCount.modCnt.acquire( &g_moduleCount.modCnt );
 }
 //__________________________________________________________________________________________________
 acc_Policy::~acc_Policy()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     g_moduleCount.modCnt.release( &g_moduleCount.modCnt );
 }
@@ -271,8 +271,8 @@ public:
     inline acc_CurrentContext(
         Reference< XCurrentContext > const & xDelegate,
         Reference< security::XAccessControlContext > const & xRestriction )
-        SAL_THROW( () );
-    virtual ~acc_CurrentContext() SAL_THROW( () );
+        SAL_THROW(());
+    virtual ~acc_CurrentContext() SAL_THROW(());
 
     // XInterface impl
     virtual void SAL_CALL acquire()
@@ -288,7 +288,7 @@ public:
 inline acc_CurrentContext::acc_CurrentContext(
     Reference< XCurrentContext > const & xDelegate,
     Reference< security::XAccessControlContext > const & xRestriction )
-    SAL_THROW( () )
+    SAL_THROW(())
     : m_refcount( 0 )
     , m_xDelegate( xDelegate )
 {
@@ -302,7 +302,7 @@ inline acc_CurrentContext::acc_CurrentContext(
 }
 //__________________________________________________________________________________________________
 acc_CurrentContext::~acc_CurrentContext()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     g_moduleCount.modCnt.release( &g_moduleCount.modCnt );
 }
@@ -384,9 +384,9 @@ class cc_reset
 {
     void * m_cc;
 public:
-    inline cc_reset( void * cc ) SAL_THROW( () )
+    inline cc_reset( void * cc ) SAL_THROW(())
         : m_cc( cc ) {}
-    inline ~cc_reset() SAL_THROW( () )
+    inline ~cc_reset() SAL_THROW(())
         { ::uno_setCurrentContext( m_cc, s_envType.pData, 0 ); }
 };
 
@@ -425,7 +425,7 @@ class AccessController
 
     ThreadData m_rec;
     typedef vector< pair< OUString, Any > > t_rec_vec;
-    inline void clearPostPoned() SAL_THROW( () );
+    inline void clearPostPoned() SAL_THROW(());
     void checkAndClearPostPoned() SAL_THROW( (RuntimeException) );
 
     PermissionCollection getEffectivePermissions(
@@ -440,7 +440,7 @@ public:
     AccessController( Reference< XComponentContext > const & xComponentContext )
         SAL_THROW( (RuntimeException) );
     virtual ~AccessController()
-        SAL_THROW( () );
+        SAL_THROW(());
 
     //  XInitialization impl
     virtual void SAL_CALL initialize(
@@ -533,7 +533,7 @@ AccessController::AccessController( Reference< XComponentContext > const & xComp
 }
 //__________________________________________________________________________________________________
 AccessController::~AccessController()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     g_moduleCount.modCnt.release( &g_moduleCount.modCnt );
 }
@@ -599,7 +599,7 @@ Reference< security::XPolicy > const & AccessController::getPolicy()
 
 #ifdef __DIAGNOSE
 static void dumpPermissions(
-    PermissionCollection const & collection, OUString const & userId = OUString() ) SAL_THROW( () )
+    PermissionCollection const & collection, OUString const & userId = OUString() ) SAL_THROW(())
 {
     OUStringBuffer buf( 48 );
     if (!userId.isEmpty())
@@ -628,7 +628,7 @@ static void dumpPermissions(
 
 
 //__________________________________________________________________________________________________
-inline void AccessController::clearPostPoned() SAL_THROW( () )
+inline void AccessController::clearPostPoned() SAL_THROW(())
 {
     delete reinterpret_cast< t_rec_vec * >( m_rec.getData() );
     m_rec.setData( 0 );
@@ -1039,14 +1039,14 @@ Reference< XInterface > SAL_CALL ac_create(
     return (OWeakObject *)new stoc_sec::AccessController( xComponentContext );
 }
 //--------------------------------------------------------------------------------------------------
-Sequence< OUString > ac_getSupportedServiceNames() SAL_THROW( () )
+Sequence< OUString > ac_getSupportedServiceNames() SAL_THROW(())
 {
     Sequence< OUString > aSNS( 1 );
     aSNS.getArray()[0] = OUString(RTL_CONSTASCII_USTRINGPARAM(SERVICE_NAME));
     return aSNS;
 }
 //--------------------------------------------------------------------------------------------------
-OUString ac_getImplementationName() SAL_THROW( () )
+OUString ac_getImplementationName() SAL_THROW(())
 {
     static OUString s_implName = OUSTR(IMPL_NAME);
     return s_implName;
@@ -1056,9 +1056,9 @@ Reference< XInterface > SAL_CALL filepolicy_create(
     Reference< XComponentContext > const & xComponentContext )
     SAL_THROW( (Exception) );
 //--------------------------------------------------------------------------------------------------
-Sequence< OUString > filepolicy_getSupportedServiceNames() SAL_THROW( () );
+Sequence< OUString > filepolicy_getSupportedServiceNames() SAL_THROW(());
 //--------------------------------------------------------------------------------------------------
-OUString filepolicy_getImplementationName() SAL_THROW( () );
+OUString filepolicy_getImplementationName() SAL_THROW(());
 }
 
 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
diff --git a/stoc/source/security/file_policy.cxx b/stoc/source/security/file_policy.cxx
index 9d45741c04e6..1a48ce1d921c 100644
--- a/stoc/source/security/file_policy.cxx
+++ b/stoc/source/security/file_policy.cxx
@@ -100,9 +100,9 @@ protected:
 
 public:
     FilePolicy( Reference< XComponentContext > const & xComponentContext )
-        SAL_THROW( () );
+        SAL_THROW(());
     virtual ~FilePolicy()
-        SAL_THROW( () );
+        SAL_THROW(());
 
     // XPolicy impl
     virtual Sequence< Any > SAL_CALL getPermissions(
@@ -123,7 +123,7 @@ public:
 };
 //__________________________________________________________________________________________________
 FilePolicy::FilePolicy( Reference< XComponentContext > const & xComponentContext )
-    SAL_THROW( () )
+    SAL_THROW(())
     : t_helper( m_mutex )
     , m_xComponentContext( xComponentContext )
     , m_ac( xComponentContext )
@@ -133,7 +133,7 @@ FilePolicy::FilePolicy( Reference< XComponentContext > const & xComponentContext
 }
 //__________________________________________________________________________________________________
 FilePolicy::~FilePolicy()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     g_moduleCount.modCnt.release( &g_moduleCount.modCnt );
 }
@@ -194,22 +194,22 @@ class PolicyReader
 
     sal_Unicode get()
         SAL_THROW( (RuntimeException) );
-    inline void back( sal_Unicode c ) SAL_THROW( () )
+    inline void back( sal_Unicode c ) SAL_THROW(())
         { m_back = c; }
 
-    inline bool isWhiteSpace( sal_Unicode c ) const SAL_THROW( () )
+    inline bool isWhiteSpace( sal_Unicode c ) const SAL_THROW(())
         { return (' ' == c || '\t' == c || '\n' == c || '\r' == c); }
     void skipWhiteSpace()
         SAL_THROW( (RuntimeException) );
 
-    inline bool isCharToken( sal_Unicode c ) const SAL_THROW( () )
+    inline bool isCharToken( sal_Unicode c ) const SAL_THROW(())
         { return (';' == c || ',' == c || '{' == c || '}' == c); }
 
 public:
     PolicyReader( OUString const & file, AccessControl & ac )
         SAL_THROW( (RuntimeException) );
     ~PolicyReader()
-        SAL_THROW( () );
+        SAL_THROW(());
 
     void error( OUString const & msg )
         SAL_THROW( (RuntimeException) );
@@ -425,7 +425,7 @@ PolicyReader::PolicyReader( OUString const & fileName, AccessControl & ac )
 }
 //__________________________________________________________________________________________________
 PolicyReader::~PolicyReader()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     if ( ::osl_closeFile( m_file ) != osl_File_E_None ) {
         OSL_ASSERT( false );
@@ -585,14 +585,14 @@ Reference< XInterface > SAL_CALL filepolicy_create(
     return (OWeakObject *)new stoc_sec::FilePolicy( xComponentContext );
 }
 //--------------------------------------------------------------------------------------------------
-Sequence< OUString > filepolicy_getSupportedServiceNames() SAL_THROW( () )
+Sequence< OUString > filepolicy_getSupportedServiceNames() SAL_THROW(())
 {
     Sequence< OUString > aSNS( 1 );
     aSNS.getArray()[0] = OUString(RTL_CONSTASCII_USTRINGPARAM(SERVICE_NAME));
     return aSNS;
 }
 //--------------------------------------------------------------------------------------------------
-OUString filepolicy_getImplementationName() SAL_THROW( () )
+OUString filepolicy_getImplementationName() SAL_THROW(())
 {
     static OUString s_implName = OUSTR(IMPL_NAME);
     return s_implName;
diff --git a/stoc/source/security/lru_cache.h b/stoc/source/security/lru_cache.h
index 6853a374a186..52b53ac306ff 100644
--- a/stoc/source/security/lru_cache.h
+++ b/stoc/source/security/lru_cache.h
@@ -61,57 +61,57 @@ class lru_cache
     Entry * m_block;
     mutable Entry * m_head;
     mutable Entry * m_tail;
-    inline void toFront( Entry * entry ) const SAL_THROW( () );
+    inline void toFront( Entry * entry ) const SAL_THROW(());
 
 public:
     /** Default Ctor.  Does not cache.
     */
-    inline lru_cache() SAL_THROW( () );
+    inline lru_cache() SAL_THROW(());
     /** Ctor.
 
         @param size number of elements to be cached; default param set to 128
     */
-    inline lru_cache( ::std::size_t size ) SAL_THROW( () );
+    inline lru_cache( ::std::size_t size ) SAL_THROW(());
 
     /** Destructor: releases all cached elements and keys.
     */
-    inline ~lru_cache() SAL_THROW( () );
+    inline ~lru_cache() SAL_THROW(());
 
     /** Retrieves a pointer to value in cache.  Returns 0, if none was found.
 
         @param key a key
         @return pointer to value or 0
     */
-    inline t_val const * lookup( t_key const & key ) const SAL_THROW( () );
+    inline t_val const * lookup( t_key const & key ) const SAL_THROW(());
 
     /** Sets a value to be cached for given key.
 
         @param key a key
         @param val a value
     */
-    inline void set( t_key const & key, t_val const & val ) SAL_THROW( () );
+    inline void set( t_key const & key, t_val const & val ) SAL_THROW(());
 
     /** Tests whether a value is cached for given key.
 
         @param key a key
         @return true, if value is cached
     */
-    inline bool has( t_key const & key ) const SAL_THROW( () );
+    inline bool has( t_key const & key ) const SAL_THROW(());
 
     /** Clears the cache, releasing all cached elements and keys.
     */
-    inline void clear() SAL_THROW( () );
+    inline void clear() SAL_THROW(());
 
     /** Sets the number of elements to be cached.  This will clear previous entries.
 
         @param cacheSize number of elements to be cached
     */
-    inline void setSize( ::std::size_t size ) SAL_THROW( () );
+    inline void setSize( ::std::size_t size ) SAL_THROW(());
 };
 //__________________________________________________________________________________________________
 template< typename t_key, typename t_val, typename t_hashKey, typename t_equalKey >
 inline void lru_cache< t_key, t_val, t_hashKey, t_equalKey >::setSize(
-    ::std::size_t size ) SAL_THROW( () )
+    ::std::size_t size ) SAL_THROW(())
 {
     m_key2element.clear();
     delete [] m_block;
@@ -133,7 +133,7 @@ inline void lru_cache< t_key, t_val, t_hashKey, t_equalKey >::setSize(
 //__________________________________________________________________________________________________
 template< typename t_key, typename t_val, typename t_hashKey, typename t_equalKey >
 inline lru_cache< t_key, t_val, t_hashKey, t_equalKey >::lru_cache(
-    ::std::size_t size ) SAL_THROW( () )
+    ::std::size_t size ) SAL_THROW(())
     : m_size( 0 )
     , m_block( 0 )
 {
@@ -141,7 +141,7 @@ inline lru_cache< t_key, t_val, t_hashKey, t_equalKey >::lru_cache(
 }
 //__________________________________________________________________________________________________
 template< typename t_key, typename t_val, typename t_hashKey, typename t_equalKey >
-inline lru_cache< t_key, t_val, t_hashKey, t_equalKey >::lru_cache() SAL_THROW( () )
+inline lru_cache< t_key, t_val, t_hashKey, t_equalKey >::lru_cache() SAL_THROW(())
     : m_size( 0 )
     , m_block( 0 )
 {
@@ -149,14 +149,14 @@ inline lru_cache< t_key, t_val, t_hashKey, t_equalKey >::lru_cache() SAL_THROW(
 //__________________________________________________________________________________________________
 template< typename t_key, typename t_val, typename t_hashKey, typename t_equalKey >
 inline lru_cache< t_key, t_val, t_hashKey, t_equalKey >::~lru_cache()
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     delete [] m_block;
 }
 //__________________________________________________________________________________________________
 template< typename t_key, typename t_val, typename t_hashKey, typename t_equalKey >
 inline void lru_cache< t_key, t_val, t_hashKey, t_equalKey >::toFront(
-    Entry * entry ) const SAL_THROW( () )
+    Entry * entry ) const SAL_THROW(())
 {
     if (entry != m_head)
     {
@@ -179,7 +179,7 @@ inline void lru_cache< t_key, t_val, t_hashKey, t_equalKey >::toFront(
 //__________________________________________________________________________________________________
 template< typename t_key, typename t_val, typename t_hashKey, typename t_equalKey >
 inline bool lru_cache< t_key, t_val, t_hashKey, t_equalKey >::has(
-    t_key const & key ) const SAL_THROW( () )
+    t_key const & key ) const SAL_THROW(())
 {
     typename t_key2element::const_iterator const iFind( m_key2element.find( key ) );
     return (iFind != m_key2element.end());
@@ -187,7 +187,7 @@ inline bool lru_cache< t_key, t_val, t_hashKey, t_equalKey >::has(
 //__________________________________________________________________________________________________
 template< typename t_key, typename t_val, typename t_hashKey, typename t_equalKey >
 inline t_val const * lru_cache< t_key, t_val, t_hashKey, t_equalKey >::lookup(
-    t_key const & key ) const SAL_THROW( () )
+    t_key const & key ) const SAL_THROW(())
 {
     if (0 < m_size)
     {
@@ -213,7 +213,7 @@ inline t_val const * lru_cache< t_key, t_val, t_hashKey, t_equalKey >::lookup(
 //__________________________________________________________________________________________________
 template< typename t_key, typename t_val, typename t_hashKey, typename t_equalKey >
 inline void lru_cache< t_key, t_val, t_hashKey, t_equalKey >::set(
-    t_key const & key, t_val const & val ) SAL_THROW( () )
+    t_key const & key, t_val const & val ) SAL_THROW(())
 {
     if (0 < m_size)
     {
@@ -263,7 +263,7 @@ inline void lru_cache< t_key, t_val, t_hashKey, t_equalKey >::set(
 }
 //__________________________________________________________________________________________________
 template< typename t_key, typename t_val, typename t_hashKey, typename t_equalKey >
-inline void lru_cache< t_key, t_val, t_hashKey, t_equalKey >::clear() SAL_THROW( () )
+inline void lru_cache< t_key, t_val, t_hashKey, t_equalKey >::clear() SAL_THROW(())
 {
     m_key2element.clear();
     for ( ::std::size_t nPos = m_size; nPos--; )
diff --git a/stoc/source/security/permissions.cxx b/stoc/source/security/permissions.cxx
index 6b065ede2eb8..93715e8c48b3 100644
--- a/stoc/source/security/permissions.cxx
+++ b/stoc/source/security/permissions.cxx
@@ -59,7 +59,7 @@ namespace stoc_sec
 
 //--------------------------------------------------------------------------------------------------
 static inline sal_Int32 makeMask(
-    OUString const & items, char const * const * strings ) SAL_THROW( () )
+    OUString const & items, char const * const * strings ) SAL_THROW(())
 {
     sal_Int32 mask = 0;
 
@@ -96,7 +96,7 @@ static inline sal_Int32 makeMask(
 }
 //--------------------------------------------------------------------------------------------------
 static inline OUString makeStrings(
-    sal_Int32 mask, char const * const * strings ) SAL_THROW( () )
+    sal_Int32 mask, char const * const * strings ) SAL_THROW(())
 {
     OUStringBuffer buf( 48 );
     while (mask)
@@ -129,15 +129,15 @@ class SocketPermission : public Permission
     mutable bool m_resolvedHost;
     bool m_wildCardHost;
 
-    inline bool resolveHost() const SAL_THROW( () );
+    inline bool resolveHost() const SAL_THROW(());
 
 public:
     SocketPermission(
         connection::SocketPermission const & perm,
         ::rtl::Reference< Permission > const & next = ::rtl::Reference< Permission >() )
-        SAL_THROW( () );
-    virtual bool implies( Permission const & perm ) const SAL_THROW( () );
-    virtual OUString toString() const SAL_THROW( () );
+        SAL_THROW(());
+    virtual bool implies( Permission const & perm ) const SAL_THROW(());
+    virtual OUString toString() const SAL_THROW(());
 };
 //__________________________________________________________________________________________________
 char const * SocketPermission::s_actions [] = { "accept", "connect", "listen", "resolve", 0 };
@@ -145,7 +145,7 @@ char const * SocketPermission::s_actions [] = { "accept", "connect", "listen", "
 SocketPermission::SocketPermission(
     connection::SocketPermission const & perm,
     ::rtl::Reference< Permission > const & next )
-    SAL_THROW( () )
+    SAL_THROW(())
     : Permission( SOCKET, next )
     , m_actions( makeMask( perm.Actions, s_actions ) )
     , m_host( perm.Host )
@@ -184,7 +184,7 @@ SocketPermission::SocketPermission(
     }
 }
 //__________________________________________________________________________________________________
-inline bool SocketPermission::resolveHost() const SAL_THROW( () )
+inline bool SocketPermission::resolveHost() const SAL_THROW(())
 {
     if (m_resolveErr)
         return false;
@@ -210,7 +210,7 @@ inline bool SocketPermission::resolveHost() const SAL_THROW( () )
     return m_resolvedHost;
 }
 //__________________________________________________________________________________________________
-bool SocketPermission::implies( Permission const & perm ) const SAL_THROW( () )
+bool SocketPermission::implies( Permission const & perm ) const SAL_THROW(())
 {
     // check type
     if (SOCKET != perm.m_type)
@@ -252,7 +252,7 @@ bool SocketPermission::implies( Permission const & perm ) const SAL_THROW( () )
     return (sal_False != m_ip.equals( demanded.m_ip ));
 }
 //__________________________________________________________________________________________________
-OUString SocketPermission::toString() const SAL_THROW( () )
+OUString SocketPermission::toString() const SAL_THROW(())
 {
     OUStringBuffer buf( 48 );
     // host
@@ -300,14 +300,14 @@ public:
     FilePermission(
         io::FilePermission const & perm,
         ::rtl::Reference< Permission > const & next = ::rtl::Reference< Permission >() )
-        SAL_THROW( () );
-    virtual bool implies( Permission const & perm ) const SAL_THROW( () );
-    virtual OUString toString() const SAL_THROW( () );
+        SAL_THROW(());
+    virtual bool implies( Permission const & perm ) const SAL_THROW(());
+    virtual OUString toString() const SAL_THROW(());
 };
 //__________________________________________________________________________________________________
 char const * FilePermission::s_actions [] = { "read", "write", "execute", "delete", 0 };
 //--------------------------------------------------------------------------------------------------
-static OUString const & getWorkingDir() SAL_THROW( () )
+static OUString const & getWorkingDir() SAL_THROW(())
 {
     static OUString * s_workingDir = 0;
     if (! s_workingDir)
@@ -328,7 +328,7 @@ static OUString const & getWorkingDir() SAL_THROW( () )
 FilePermission::FilePermission(
     io::FilePermission const & perm,
     ::rtl::Reference< Permission > const & next )
-    SAL_THROW( () )
+    SAL_THROW(())
     : Permission( FILE, next )
     , m_actions( makeMask( perm.Actions, s_actions ) )
     , m_url( perm.URL )
@@ -370,7 +370,7 @@ FilePermission::FilePermission(
     }
 }
 //__________________________________________________________________________________________________
-bool FilePermission::implies( Permission const & perm ) const SAL_THROW( () )
+bool FilePermission::implies( Permission const & perm ) const SAL_THROW(())
 {
     // check type
     if (FILE != perm.m_type)
@@ -429,7 +429,7 @@ bool FilePermission::implies( Permission const & perm ) const SAL_THROW( () )
     return false;
 }
 //__________________________________________________________________________________________________
-OUString FilePermission::toString() const SAL_THROW( () )
+OUString FilePermission::toString() const SAL_THROW(())
 {
     OUStringBuffer buf( 48 );
     // url
@@ -453,15 +453,15 @@ public:
     inline RuntimePermission(
         security::RuntimePermission const & perm,
         ::rtl::Reference< Permission > const & next = ::rtl::Reference< Permission >() )
-        SAL_THROW( () )
+        SAL_THROW(())
         : Permission( RUNTIME, next )
         , m_name( perm.Name )
         {}
-    virtual bool implies( Permission const & perm ) const SAL_THROW( () );
-    virtual OUString toString() const SAL_THROW( () );
+    virtual bool implies( Permission const & perm ) const SAL_THROW(());
+    virtual OUString toString() const SAL_THROW(());
 };
 //__________________________________________________________________________________________________
-bool RuntimePermission::implies( Permission const & perm ) const SAL_THROW( () )
+bool RuntimePermission::implies( Permission const & perm ) const SAL_THROW(())
 {
     // check type
     if (RUNTIME != perm.m_type)
@@ -472,7 +472,7 @@ bool RuntimePermission::implies( Permission const & perm ) const SAL_THROW( () )
     return (sal_False != m_name.equals( demanded.m_name ));
 }
 //__________________________________________________________________________________________________
-OUString RuntimePermission::toString() const SAL_THROW( () )
+OUString RuntimePermission::toString() const SAL_THROW(())
 {
     OUStringBuffer buf( 48 );
     buf.appendAscii(
@@ -485,12 +485,12 @@ OUString RuntimePermission::toString() const SAL_THROW( () )
 //##################################################################################################
 
 //__________________________________________________________________________________________________
-bool AllPermission::implies( Permission const & ) const SAL_THROW( () )
+bool AllPermission::implies( Permission const & ) const SAL_THROW(())
 {
     return true;
 }
 //__________________________________________________________________________________________________
-OUString AllPermission::toString() const SAL_THROW( () )
+OUString AllPermission::toString() const SAL_THROW(())
 {
     return OUSTR("com.sun.star.security.AllPermission");
 }
@@ -542,7 +542,7 @@ PermissionCollection::PermissionCollection(
 }
 #ifdef __DIAGNOSE
 //__________________________________________________________________________________________________
-Sequence< OUString > PermissionCollection::toStrings() const SAL_THROW( () )
+Sequence< OUString > PermissionCollection::toStrings() const SAL_THROW(())
 {
     vector< OUString > strings;
     strings.reserve( 8 );
@@ -556,7 +556,7 @@ Sequence< OUString > PermissionCollection::toStrings() const SAL_THROW( () )
 #endif
 //__________________________________________________________________________________________________
 inline static bool __implies(
-    ::rtl::Reference< Permission > const & head, Permission const & demanded ) SAL_THROW( () )
+    ::rtl::Reference< Permission > const & head, Permission const & demanded ) SAL_THROW(())
 {
     for ( Permission * perm = head.get(); perm; perm = perm->m_next.get() )
     {
@@ -570,7 +570,7 @@ inline static bool __implies(
 //--------------------------------------------------------------------------------------------------
 static void demanded_diag(
     Permission const & perm )
-    SAL_THROW( () )
+    SAL_THROW(())
 {
     OUStringBuffer buf( 48 );
     buf.appendAscii( RTL_CONSTASCII_STRINGPARAM("demanding ") );
diff --git a/stoc/source/security/permissions.h b/stoc/source/security/permissions.h
index 898759482a6e..28f80d04a660 100644
--- a/stoc/source/security/permissions.h
+++ b/stoc/source/security/permissions.h
@@ -52,13 +52,13 @@ public:
     inline Permission(
         t_type type,
         ::rtl::Reference< Permission > const & next = ::rtl::Reference< Permission >() )
-        SAL_THROW( () )
+        SAL_THROW(())
         : m_next( next )
         , m_type( type )
         {}
 
-    virtual bool implies( Permission const & perm ) const SAL_THROW( () ) = 0;
-    virtual ::rtl::OUString toString() const SAL_THROW( () ) = 0;
+    virtual bool implies( Permission const & perm ) const SAL_THROW(()) = 0;
+    virtual ::rtl::OUString toString() const SAL_THROW(()) = 0;
 };
 //==================================================================================================
 class AllPermission : public Permission
@@ -66,12 +66,12 @@ class AllPermission : public Permission
 public:
     inline AllPermission(
         ::rtl::Reference< Permission > const & next = ::rtl::Reference< Permission >() )
-        SAL_THROW( () )
+        SAL_THROW(())
         : Permission( ALL, next )
         {}
 
-    virtual bool implies( Permission const & ) const SAL_THROW( () );
-    virtual ::rtl::OUString toString() const SAL_THROW( () );
+    virtual bool implies( Permission const & ) const SAL_THROW(());
+    virtual ::rtl::OUString toString() const SAL_THROW(());
 };
 
 //==================================================================================================
@@ -79,12 +79,12 @@ class PermissionCollection
 {
     ::rtl::Reference< Permission > m_head;
 public:
-    inline PermissionCollection() SAL_THROW( () )
+    inline PermissionCollection() SAL_THROW(())
         {}
-    inline PermissionCollection( PermissionCollection const & collection ) SAL_THROW( () )
+    inline PermissionCollection( PermissionCollection const & collection ) SAL_THROW(())
         : m_head( collection.m_head )
         {}
-    inline PermissionCollection( ::rtl::Reference< Permission > const & single ) SAL_THROW( () )
+    inline PermissionCollection( ::rtl::Reference< Permission > const & single ) SAL_THROW(())
         : m_head( single )
         {}
     PermissionCollection(
@@ -92,7 +92,7 @@ public:
         PermissionCollection const & addition = PermissionCollection() )
         SAL_THROW( (::com::sun::star::uno::RuntimeException) );
 #ifdef __DIAGNOSE
-    ::com::sun::star::uno::Sequence< ::rtl::OUString > toStrings() const SAL_THROW( () );
+    ::com::sun::star::uno::Sequence< ::rtl::OUString > toStrings() const SAL_THROW(());
 #endif
     void checkPermission( ::com::sun::star::uno::Any const & perm ) const
         SAL_THROW( (::com::sun::star::uno::RuntimeException) );