CWS-TOOLING: integrate CWS sb119

6 files changed, 60 insertions, 57 deletions

diff --git a/sal/inc/osl/diagnose.hxx b/sal/inc/osl/diagnose.hxx
index 72883d994d4a..e7360e93349e 100644
--- a/sal/inc/osl/diagnose.hxx
+++ b/sal/inc/osl/diagnose.hxx
@@ -125,19 +125,17 @@ public:
             VoidPointerSet::const_iterator iPos(m_data.m_addresses.begin());
             VoidPointerSet::const_iterator const iEnd(m_data.m_addresses.end());
             for ( ; iPos != iEnd; ++iPos ) {
-                T const* pLeakingObj = static_cast<T const*>(*iPos);
-                OSL_ASSERT( pLeakingObj != 0 );
-                static_cast<void>(pLeakingObj);
+                OSL_ASSERT( *iPos != 0 );
             }
         }
         return bRet;
     }
 
-    void registerObject( T const* pObj ) {
+    void registerObject( void const* pObj ) {
         osl_detail_ObjectRegistry_registerObject(m_data, pObj);
     }
 
-    void revokeObject( T const* pObj ) {
+    void revokeObject( void const* pObj ) {
         osl_detail_ObjectRegistry_revokeObject(m_data, pObj);
     }
 
@@ -188,12 +186,10 @@ public:
 
 protected:
     DebugBase() {
-        StaticObjectRegistry::get().registerObject(
-            static_cast<InheritingClassT const*>(this) );
+        StaticObjectRegistry::get().registerObject( this );
     }
     ~DebugBase() {
-        StaticObjectRegistry::get().revokeObject(
-            static_cast<InheritingClassT const*>(this) );
+        StaticObjectRegistry::get().revokeObject( this );
     }
 
 private:
diff --git a/sal/osl/unx/signal.c b/sal/osl/unx/signal.c
index df9ad8f27515..c5141fa02260 100644
--- a/sal/osl/unx/signal.c
+++ b/sal/osl/unx/signal.c
@@ -199,6 +199,7 @@ static sal_Bool InitSignal()
     int i;
     struct sigaction act;
     struct sigaction oact;
+    sigset_t unset;
 
     if (is_soffice_Impl())
     {
@@ -280,6 +281,16 @@ static sal_Bool InitSignal()
         }
     }
 
+    /* Clear signal mask inherited from parent process (on Mac OS X, upon a
+       crash soffice re-execs itself from within the signal handler, so the
+       second soffice would have the guilty signal blocked and would freeze upon
+       encountering a similar crash again): */
+    if (sigemptyset(&unset) < 0 ||
+        pthread_sigmask(SIG_SETMASK, &unset, NULL) < 0)
+    {
+        OSL_TRACE("sigemptyset or pthread_sigmask failed");
+    }
+
     return sal_True;
 }
 
diff --git a/sal/osl/unx/socket.c b/sal/osl/unx/socket.c
index c901aa7b505d..c8faf6c028f5 100644
--- a/sal/osl/unx/socket.c
+++ b/sal/osl/unx/socket.c
@@ -1858,6 +1858,9 @@ void SAL_CALL osl_closeSocket(oslSocket pSocket)
     pSocket->m_nLastError=0;
     nFD = pSocket->m_Socket;
 
+    if (nFD == OSL_INVALID_SOCKET)
+        return;
+
     pSocket->m_Socket = OSL_INVALID_SOCKET;
 
 #if defined(LINUX)
@@ -1904,6 +1907,7 @@ void SAL_CALL osl_closeSocket(oslSocket pSocket)
 #endif /* OSL_DEBUG_LEVEL */
             close(nConnFD);
         }
+        pSocket->m_bIsAccepting = sal_False;
     }
 #endif /* LINUX */
 
diff --git a/sal/rtl/source/hash.cxx b/sal/rtl/source/hash.cxx
index ec5229002c4b..7caa2341ca11 100644
--- a/sal/rtl/source/hash.cxx
+++ b/sal/rtl/source/hash.cxx
@@ -36,52 +36,51 @@
 #include <hash_set>
 
 namespace {
-    struct UStringHash
-    {
-        size_t operator()(rtl_uString * const &rString) const
-            { return (size_t)rtl_ustr_hashCode_WithLength( rString->buffer, rString->length ); }
-    };
-    struct UStringEqual
-    {
-        sal_Bool operator() ( rtl_uString * const &pStringA,
-                              rtl_uString * const &pStringB) const
-        {
-            if (pStringA == pStringB)
-                return true;
-            if (pStringA->length != pStringB->length)
-                return false;
-            return !rtl_ustr_compare_WithLength( pStringA->buffer, pStringA->length,
-                                                 pStringB->buffer, pStringB->length);
-        }
-    };
-}
 
-typedef std::hash_set< rtl_uString *, UStringHash, UStringEqual,
-                       rtl::Allocator<rtl_uString *> > UniqueHash;
+struct UStringHash
+{
+    size_t operator()(rtl_uString * const &rString) const
+    { return (size_t)rtl_ustr_hashCode_WithLength( rString->buffer, rString->length ); }
+};
 
-struct StringHashTableImpl : public UniqueHash
+struct UStringEqual
 {
-    StringHashTableImpl(sal_uInt32 nSize) : UniqueHash( nSize ) {}
+    sal_Bool operator() ( rtl_uString * const &pStringA,
+                          rtl_uString * const &pStringB) const
+    {
+        if (pStringA == pStringB)
+            return true;
+        if (pStringA->length != pStringB->length)
+            return false;
+        return !rtl_ustr_compare_WithLength( pStringA->buffer, pStringA->length,
+                                             pStringB->buffer, pStringB->length);
+    }
 };
 
+typedef std::hash_set< rtl_uString *, UStringHash, UStringEqual,
+                       rtl::Allocator<rtl_uString *> > StringHashTable;
+
 StringHashTable *
-rtl_str_hash_new (sal_uInt32 nSize)
+getHashTable ()
 {
-    return new StringHashTableImpl (nSize);
+    static StringHashTable *pInternPool = NULL;
+    if (pInternPool == NULL) {
+        static StringHashTable aImpl(1024);
+        pInternPool = &aImpl;
+    }
+    return pInternPool;
 }
 
-void
-rtl_str_hash_free (StringHashTable *pHash)
-{
-    delete pHash;
 }
 
+extern "C" {
+
 rtl_uString *
-rtl_str_hash_intern (StringHashTable   *pHash,
-                     rtl_uString       *pString,
+rtl_str_hash_intern (rtl_uString       *pString,
                      int                can_return)
 {
-    UniqueHash::iterator aIter;
+    StringHashTable *pHash = getHashTable();
+    StringHashTable::iterator aIter;
     aIter = pHash->find(pString);
     if (aIter != pHash->end())
     {
@@ -106,8 +105,9 @@ rtl_str_hash_intern (StringHashTable   *pHash,
 }
 
 void
-rtl_str_hash_remove (StringHashTable   *pHash,
-                     rtl_uString       *pString)
+rtl_str_hash_remove (rtl_uString       *pString)
 {
-    pHash->erase(pString);
+    getHashTable()->erase(pString);
+}
+
 }
diff --git a/sal/rtl/source/hash.h b/sal/rtl/source/hash.h
index 63f3e99c8495..2aadfb33efcd 100644
--- a/sal/rtl/source/hash.h
+++ b/sal/rtl/source/hash.h
@@ -8,15 +8,11 @@
 extern "C" {
 #endif /* __cplusplus */
 
-typedef struct StringHashTableImpl StringHashTable;
+/* These functions are not multi-thread safe: */
 
-StringHashTable *rtl_str_hash_new    (sal_uInt32         nSize);
-void             rtl_str_hash_free   (StringHashTable   *pHash);
-rtl_uString     *rtl_str_hash_intern (StringHashTable   *pHash,
-                                      rtl_uString       *pString,
+rtl_uString     *rtl_str_hash_intern (rtl_uString       *pString,
                                       int                can_return);
-void             rtl_str_hash_remove (StringHashTable   *pHash,
-                                      rtl_uString       *pString);
+void             rtl_str_hash_remove (rtl_uString       *pString);
 
 #if defined __cplusplus
 }
diff --git a/sal/rtl/source/ustring.c b/sal/rtl/source/ustring.c
index aebd0684a50a..b0bdd2d98e73 100644
--- a/sal/rtl/source/ustring.c
+++ b/sal/rtl/source/ustring.c
@@ -761,8 +761,6 @@ getInternMutex()
     return pPoolGuard;
 }
 
-static StringHashTable *pInternPool = NULL;
-
 /* returns true if we found a dup in the pool */
 static void rtl_ustring_intern_internal( rtl_uString ** newStr,
                                          rtl_uString  * str,
@@ -774,9 +772,7 @@ static void rtl_ustring_intern_internal( rtl_uString ** newStr,
 
     osl_acquireMutex( pPoolMutex );
 
-    if (!pInternPool)
-        pInternPool = rtl_str_hash_new (1024);
-    *newStr = rtl_str_hash_intern (pInternPool, str, can_return);
+    *newStr = rtl_str_hash_intern (str, can_return);
 
     osl_releaseMutex( pPoolMutex );
 
@@ -864,7 +860,7 @@ internRelease (rtl_uString *pThis)
         pPoolMutex = getInternMutex();
         osl_acquireMutex( pPoolMutex );
 
-        rtl_str_hash_remove (pInternPool, pThis);
+        rtl_str_hash_remove (pThis);
 
         /* May have been separately acquired */
         if ( SAL_STRING_REFCOUNT(